05--基本类型02：列表、元祖、字典

1 列表

1.1 基本介绍

# 1.作用：按位置存放多个值

# 2.定义：l = []  # l=list()

# 3.类型转换：凡是能够被for循环遍历的类型，都可以当做参数传递给list()转成列表
转换字典时，是将字典的键，取出来生成列表
list({'k1':111, 'k2':222, 'k3:333'}) ----->['k2', 'k3', 'k1']

1.2 内置方法

# 1.按索引存取值（正向、反向）：即可以取也可以改
l = [111, 'egon', 'hello', 'nihao', 253, 2558]

# 索引存在时，赋值就是修改操作
l[0] = 222

# 索引不存在时，会报索引错误

    
# 2.切片（顾头不顾尾，步长）
# 切片相当于浅copy
print(l[0:4:2])  # [111, 'hello'] 

# 拷贝并反转字符串
res = l[::-1]

    
# 3.长度
len(l)

    
# 4. 成员运算 in 和 not in 
111 in [111, 222]


# 5.添加值
# 5.1 追加
l.append(obj)

# 5.2 插入
l.insert(index,obj)  # (索引位置，插入对象)

# 5.3 扩展 （用新的序列扩展原来的列表）
l.extend([2, 4, 5])  # 将一个可迭代对象，依次追加到l 列表中

    
    
# 6.删除
# 6.1 del  删除，无返回值，且无法赋值操作
del l

# 6.2 .pop(index)  根据索引删除,默认为最后一位。返回值：删除的值
l.pop(0)

# 6.3 .remove(obj) 根据值删除，参数：需要删除的值。无返回值
l.remove(111)

    
# 7.需要掌握的操作
l = [111,222,333,'dadda', 'aaa']
l.count(obj)	# 返回值：对象在列表中的个数
l.index(obj)	# 返回值：对象在列表中的索引值(第一个匹配项)
l.clear()		# 清空列表，无返回值
l.reverse()		# 逆转列表，无返回值

# 排序列表，无返回值。列表内元素必须是同种类型
l.sort(key=None, reverse=False)		
# key:用来进行比较的元素，只有一个参数，
  具体的函数参数就是取自可迭代对象中，指定可迭代对象中的一个元素来比较
    
# reverse:排序规则，默认是False升序，=True 降序

l = [[111, 555], [333, 222]]

def take_second(elem):
    """返回参数的第二个元素"""
    return elem[1]

# 指定第二个元素来排
l.sort(key=take_second, reverse=False)
print(l)	# [[333, 222], [111, 555]]
        
        
"""
了解：
1.字符串可以比较大小，对应位置的字符依次，按照ASCI码表的先后顺序来区分，越往后越大 
2.列表也可以比较大小，原理同字符串一样，但是对应位置的元素必须是同一类型
"""

1.3 队列：FIFO，先进先出

l = []
# 入队操作
l.append('first')
l.append('second')
l.append('third')

print(l)
# 出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

1.4 堆栈：LIFO，后进先出

l = []
# 入栈操作
l.append('first')
l.append('second')
l.append('third')

print(l)
# 出栈操作
print(l.pop())
print(l.pop())
print(l.pop())

2 元祖

# 元祖是"一个不可变的列表"
	不可变的指的是内各个元素的内存地址不可变，并不代表各元素值不变。
# 例：元祖中有个元素是列表，并修改该列表的值，是可以的。（因为该列表的内存地址没有变）

# 1.作用：按索引/位置存放多个值，只用于读不用于改

# 2.定义：()  内用逗号分隔开任意类型的元素
	只有一个元素，后必须加逗号
    
# 3.类型转换：凡是能够被for循环遍历的类型，都可以当做参数传递给tuple()转成元祖
	
# 4.内置方法
    1.按索引取值（正向、反向）:只能取 [-1]
    2.切片（顾头不顾尾，步长） [0:2:2]
    3.长度	len
    4.成员运算 in 和 not in 
    5.t.count(obj)	# 返回值：对象在元祖中的个数
    6.t.index(obj)	# 返回值：对象在元祖中的索引值(第一个匹配项)字典

3 字典

# 1.作用：按key存放多个值，key 与 value 一一对应

# 2.定义：{}内用逗号分隔开多个key：value，
    # 其中value可以是任意类型，但key必须是不可变类型且唯一
    d = {'k1':111, (11,22):222}  # d = dict(...)
    d = {}  # 默认定义是空字典，不是集合
    
# 3.类型转换：
    info =[['name','egon'], ('age',18), ['gender','male']]
    res = dict(info)
    print(res)  # 容器类型中，每个元素再包含两个元素，就可以直接转换为字典
	
    # 快速初始化字典
    seq = ['name', 'age', 'gender']
    d = {}.fromkeys(seq,None)		# 让key都指向同一个默认值
    print(d)
	
    
# 4.内置方法
    # 1.按key存取值:可存可取
        # 针对赋值操作：key存在，则修改
        d = {'k1':'name'}
        d['k1'] ='name2'
        # 针对赋值操作：key不存在，则添加
        d['k2'] ='name2'

    # 2.长度	len  
        len(d)  # 统计字典键值对的个数

    # 3.成员运算 in 和 not in : 根据key
        d = {'k1':'name'}
        print('k1' in d)

    # 4.删除
        d = {'k1':111, 'k2':222}

        # 4.1 通用删除 del 
        del d['k1']

        # 4.2 .pop(key) ：根据key删除元素，返回值：删除k1对于的value值
        d.pop('k1')

        # 4.3 popitem() :删除字典中最后一对，返回值：元祖(删除的key，删除的value) 
        d.popitem()
	
    
# 5.键.key()  值.value()  键值对.items()
    # 在python3中，不再是列表形式，而是各自对象的生成器
    print(d.keys())		# dict_keys(['k1', 'k2'])
	
# 6.循环
    # 循环的是.key() 键
	
# 7.其他掌握方法
    d.clear()	# 清空字典内键值对。无返回值
    
    d.update(dict2)	# 用新字典更新旧字典，有就覆盖，无则添加。无返回值
    
    d.get(key,default=None) 	# 取某个key的值，若没有key，返回默认值。默认值：默认为None
    
    d.setdefault(key, default=None)  
    # 如果key不存在字典中，会添加键，并将值设为默认值。返回值：默认值
    # 如果key存在字典中，不操作。返回值：key对应的value值