容器数据类型之列表、元组、字典
列表：按位置存放多个值
1、定义：l=[1,1.2,'a'] #本质：l=list([1,1.2,'a'])
2、类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
字符串list('wdad') # 结果：['w', 'd', 'a', 'd']
列表list([1,2,3]) # 结果：[1, 2, 3]
字典list({"name":"jason","age":18}) #结果：['name', 'age']
元组list((1,2,3)) # 结果：[1, 2, 3]
集合list({1,2,3,4}) # 结果：[1, 2, 3, 4]
3、内置方法
*优先掌握的操作：
（1）按索引存取值(正向存取+反向存取)：即可以取也可以改，索引存在则修改对应的，无论是取值操作还是赋值操作：索引不存在则报错。
l=[111,'egon','hello']
print(l[0]) # 正向取 111
print(l[-1]) # 反向取 hello
l[0]=222 # 修改索引对应的值
print(l) # [222, 'egon', 'hello']
（2）切片(顾头不顾尾，步长)切片等同于拷贝行为，而且相当于浅copy.
l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
print(l[0:3]) # [111, 'egon', 'hello']
print(l[0:5:2]) # 0 2 4 [111, 'hello', 'b']
（3）长度：print(len([1, 2, 3])) # 3
（4）成员运算in和not in：判断元素是否在列表里
print('aaa' in ['aaa', 1, 2])
print(1 in ['aaa', 1, 2])
（5）往列表中添加值
方法一：追加（.append()是在列表尾部追加元素）
l=[111,'egon','hello']
l.append(3333)
print(l) # [111, 'egon', 'hello', 3333]
方式二：插入值（在指定位置插入元素）
l=[111,'egon','hello']
l.insert(0,'alex')
print(l) # ['alex', 111, 'egon', 'hello']
方式三：extend（一次性在列表尾部添加多个值）
new_l=[1,2,3]
l=[111,'egon','hello']
l.append(new_l)
print(l) # [111, 'egon', 'hello', [1, 2, 3]]
（6）删除
方式一：通用的删除方法，只是单纯的删除、没有返回值
l = [111, 'egon', 'hello']
del l[1]
x =del l[1] # 抛出异常，不支持赋值语法
print(l) # [111, 'hello']
方式二：l.pop()根据索引删除，会返回删除的值
l = [111, 'egon', 'hello']
l.pop() #不指定索引默认删除最后一个
print(l) # [111, 'egon']
方式三：l.remove()根据元素删除，返回None
l = [111, 'egon', [1,2,3],'hello']
l.remove([1,2,3])
print(l) # [111, 'egon','hello']
res=l.remove('egon')
print(res) # None
（7）循环：输出列表的每个元素
l=[1,'aaa','bbb']
for x in l:
print(x)
*需要掌握操作
l = [1, 'aaa', 'bbb','aaa','aaa']
（1）l.count()：统计列表中元素的个数
print(l.count('aaa'))
（2）l.index()：查找元素在列表中的起始索引
print(l.index('aaa')) # 1
print(l.index('aaaaaaaaa')) # 找不到报错
（3）l.clear()：清空列表
l.clear()
print(l) # []
（4）l.reverse():不是排序，就是将列表倒过来
l = [1, 'egon','alex','lxx']
l.reverse()
print(l) # ['lxx', 'alex', 'egon', 1]
（5）l.sort(): 给列表内元素排序，必须是同种类型才可以排序。
l=[11,-3,9,2,3.1]
l.sort() # 默认从小到大排，称之为升序
l.sort(reverse=True) # 从大到小排，设置为降序
*了解：字符串可以比大小，按照对应的位置的字符依次pk
字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的。
# print('a'>'b') # False
# print('abz'>'abcdefg') # True
*了解：列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型。
l1=[1,'abc','zaa']
l2=[1,'abc','zb']
print(l1 < l2) # True
*补充
1、队列：FIFO,先进先出
l=[]
# # # 入队操作
l.append('first')
l.append('second')
l.append('third')
print(l) # ['first', 'second', 'third']
# # # 出队操作
print(l.pop(0)) # first
print(l.pop(0)) # second
print(l.pop(0)) # third
2、堆栈：LIFO,后进先出
l=[]
# # 入栈操作
l.append('first')
l.append('second')
l.append('third')
print(l) # ['first', 'second', 'third']
# # 出队操作
print(l.pop()) # third
print(l.pop()) # second
print(l.pop()) # first
元组就是"一个不可变的列表"，按照索引/位置存放多个值，只用于读不用于改。
1、定义:（）内用逗号分隔开多个任意类型的元素
t=(1,1.3,'aa') # 本质：t=tuple((1,1.3,'aa'))
x=(10) # 单独一个括号代表包含的意思，int类型
t=(10,) # 如果元组中只有一个元素，必须加逗号
2、类型转换：但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型。
字符串 tuple('wdad') # 结果：('w', 'd', 'a', 'd')
列表 tuple([1,2,3]) # 结果：(1, 2, 3)
字典 tuple({"name":"jason","age":18}) # 结果：('name', 'age')
元组 tuple((1,2,3)) # 结果：(1, 2, 3)
集合 tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
3、内置方法
*优先掌握的操作：
（1）按索引取值(正向取+反向取)：只能取
（2）切片(顾头不顾尾，步长)
t=('aa','bbb','cc','dd','eee')
print(t[0:3]) # ('aa', 'bbb', 'cc')
print(t[::-1]) # ('eee', 'dd', 'cc', 'bbb', 'aa')
（3）长度：计算元组中元素的总个数
t=('aa','bbb','cc','dd','eee')
print(len(t)) # 5
（4）成员运算in和not in：判断某元素是否在元组中
print('aa' in t) # True
（5）循环：输出元组中的每个元素
for x in t:
print(x)
（6）.Index():查找该元素在元组中的起始索引
t=(2,3,111,111,111,111)
print(t.index(111)) # 2
（7）.count():计算元组中该元素的个数
print(t.count(111)) # 4
字典
1、定义：{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是key必须是不可变类型,且不能重复
造字典的方式一：
d={} # 默认定义出来的是空字典
造字典的方式二：
d=dict(x=1,y=2,z=3)
print(d,type(d)) # {'x': 1, 'y': 2, 'z': 3} <class 'dict'>
2、数据类型转换
info=[
['name','egon'],
('age',18),
['gender','male']
]
造字典的方式三：
res=dict(info)
print(res) # {'name': 'egon', 'age': 18, 'gender': 'male'}
造字典的方式四:快速初始化一个字典
keys=['name','age','gender']
d={}.fromkeys(keys,None)
print(d) # {'name': None, 'age': None, 'gender': None}
3、内置方法
*优先掌握的操作：
（1）按key存取值：可存可取
d={'k1':111}
# 针对赋值操作：key存在，则修改
d['k1']=222
print(d) # {'k1': 222}
# 针对赋值操作：key不存在，则创建新值
d['k2']=3333
print(d) # {'k1': 111, 'k2': 3333}
（2）长度len
d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(d) # {'k1': 4444, 'k2': 2222}
# print(len(d)) # 2
（3）成员运算in和not in:根据key
d={'k1':111,'k2':2222}
print('k1' in d) # True
print(111 in d) # False
（4）删除
d={'k1':111,'k2':2222}
*通用删除
del d['k1']
print(d) # {'k2': 2222}
*pop删除：根据key删除元素，返回删除key对应的那个value值
res=d.pop('k2')
print(d) # {'k1': 111}
print(res) #2222
*popitem删除：随机删除，返回元组(删除的key,删除的value)
res=d.popitem()
print(d) # {'k1': 111}
print(res) # ('k2', 2222)
（5）键keys()，值values()，键值对items()
（6）for循环：默认遍历字典中的键
d={'k1':111,'k2':2222}
for k in d.keys():
print(k) # k1、k2
for k in d:
print(k) # k1、k2
for v in d.values():
print(v) # 111、2222
for k,v in d.items():
print(k,v) # k1 111 k2 2222
print(list(d.keys())) # ['k1', 'k2']
print(list(d.values())) # [111, 2222]
print(list(d.items())) # [('k1', 111), ('k2', 2222)]
*需要掌握的内置方法
d={'k1':111}
（1）d.clear()
（2）d.update():用新字典更新旧字典，有则修改，无则添加
d.update({'k2':222,'k3':333,'k1':111111111111111})
print(d) # {'k1': 111111111111111, 'k2': 222, 'k3': 333}
（3）d.get() ：根据key取值，容错性好
print(d['k2']) # key不存在则报错
print(d.get('k1')) # 111
print(d.get('k2')) # key不存在不报错，返回None
（4）d.setdefault()
*如果key有则不添加,返回字典中key对应的值
info={'name':'egon'}
res=info.setdefault('name','egon')
print(res) # egon
*如果key没有则添加，返回字典中key对应的值
info={}
res=info.setdefault('name','egon')
print(info) # {'name': 'egon'}
print(res) # egon
