列表（list）续
1.列表相关运算
数学运算：+，*
列表一+列表二：将两个列表中的元素合并（按先后顺序）产生一个新的列表（原列表不会发生变化）
列表*N：列表中的所有元素重复N次产生新的列表
比较运算
== ，!=
print([1,2] == [1,2]) #True
print([1,2] != [2,1]) #True
<,>,<=,>=
只支持相同位置上元素类型相同的两个列表进行比较
相关方法
len(列表)，sum(列表)，max(列表)，min(列表)
list(数据)：将指定数据转换为列表，只有序列可以转换：字符串，列表，字典，集合，元祖，range，迭代器，生成器等，不能是数字
转换的时候是将序列中的元素作为列表元素
print(list('abcd')) #['a','b','c','d']
print(list(range(5))) #[0,1,2,3,4]
print(list(23)) #报错
print(list(str(123))) #['1','2','3']
列表.count(元素)：计算列表中指定元素出现的次数
列表.extend(序列)：将序列中的元素添加到列表末尾，返回值为None
a = [1,2,3]
a.extend(['a','b'])
print(a) #[1,2,3,'a','b']
a.extend('45')
print(a) #[1,2,3,'a','b',4,5]
列表.index(元素)：获取指定元素在列表中的下标，如果有多个相同元素，只获取第一个，如果元素不存在会报错
列表.reverse()：将列表中的元素倒序，不会产生新列表
内置函数：reversed(序列) --将序列中的元素倒序，产生一个新的迭代器，原序列不会改变
a = [1,2,3]
result = reversed(a)
print(list(result)) #[3,2,1]
b = reversed('abc')
print(list(b)) #['c','b','a']
列表.sort()：对列表中的元素从小到大排序（列表中元素类型一致且支持比较运算符），不会产生新的列表
列表.sort(reverse=True)：从大到小排列
列表.copy()：产生一个新的列表，列表中的元素和原列表一样，相当于：列表[:]
a = [1,2,3]
b = a
c = a.copy()
d = a[:]
a.remove(1)
print(a) #[2,3]
print(b) #[2,3]
print(c) #[1,2,3]
print(d) #[1,2,3]
id(变量)：查看变量中实质存放的内存地址
python中所有变量实际保存的是数据在内存中的地址
列表删除元素
问题1：通过元素删除时可能出现删除不干净的问题
如：
#删除列表中小于60的数
a = [12,30,66,79,44]
for i in a:
if i < 60:
a.remove(i)
print(a) #[30,66,79]
解决方法：创建一个新的列表保存原始数据，从新的列表中取值 ，删除原来列表中的元素
a = [12,30,66,79,44]
for i in a[:]: #切片产生新的列表，没有指定变量名保存，那么用完后就会在内存里释放
if i < 60:
a.remove(i)
print(a) #[66,79]
问题2：通过下标删除满足要求的元素时，可能会出现下标越界的错误
a = [12,30,66,44,79]
for i in range(len(a)):
if a[i] < 60:
del a[i]
print(a) #报错：IndexError: list index out of range
解决方法：通过while循环控制下标，遇到删除操作，下标不变
a = [12,30,66,44,79]
index = 0
while index < len(a):
if a[index] < 60:
del a[index]
continue
index += 1
print(a)
元祖（tuple）
1.什么是元祖
元祖就是不可变的列表，作为序列不可变（不支持增删改）但是有序（支持下标操作）
语法：（元素1，元素2，...，元素n）
其中元素的要求和列表一样
2.查 --获取元素
tuple1 = (1,2,3)
print(tuple1[0],tuple1[-1]) #结果为对应下标元素值
print(tuple1[:]) #结果为元祖
3.数学运算，比较运算
同列表操作一样
in / not in ,len(),max(),min(),sum()操作结果同列表（list）
tuple（序列）：将序列转换为元祖，序列要求同列表
4.元祖专有特点
a.只有一个元素的元祖
需要在这个元素的后面加逗号，否则类型是他本身的类型
a = ('a')
b = (2)
c = (2,)
print(type(a)) #str
print(type(b)) #int
print(type(c)) #tuple
b.元祖的值可以去掉小括号
直接用逗号隔开各个元素即可
a = 1,2,3
b = 1, #一个时要加逗号，逗号才是决定是否为元祖的关键而非小括号
x,y,z = 2,3,4 #变量同时赋值的原理其实是元祖的运用
c.多个元素时
若变量个数和元祖中元素个数相同时，可以让变量依次取出元祖中的元素
a = (1,2)
x,y = a
print(x,y) #1 2
d.*的运用
通过多个变量去获取元祖元素时，可以在某个变量前加*来将这个变量变成列表获取不带*的变量取剩下来的数据
带*的变量只能最多存在一个
a = (1,2,3,4,5,6,7)
x,*y,z = a
print(x,y,z) #1 [2,3,4,5,6] 7
字典
1.什么是字典（dict）
字典是Python内置的一个容器型数据类型，可变（支持曾删改），无序（不支持下标操作）
语法：{键值对1，键值对2，...，键值对n} = {键1：值1，键2：值2，...，键n：值n}
键（key）：不可变且唯一（可用数字，字符串，元祖等不可变数据类型，实际开发建议用字符串）
值（value）：和列表元素要求一样
dict1 = {'a': 100,'b': 'a','c': [1,2,3]}
dict2 = {[1,2]:2} #报错，list可变不能作为键值
dict3 = {'a': 100,'b': 'a','a':99} #{'a': 99,'b': 'a'},有相同键时，只有最后的键值对保留（唯一性）
键值对必须是成对出现
2.什么时候用字典
如果同时保存的多个数据具有不同意义就使用字典
3.查 --获取字典的值
a.获取key对应的值
字典[key] ：获取字典中指定key对应的值
a = {'a':100,'b':200,'c':300}
print(a['a']) #100,若key不存在则报错
字典.get(key)：获取字典中指定key对应的值，如果key不存在则返回None
None是Python中的关键字，表示数据为空或没有的意思
字典.get(key,默认值)：获取字典中指定key对应的值，如果不存在，则返回指定默认值（不会对原字典产生修改）
b.遍历
直接遍历字典拿到的是key而不是value。
a = {'a':1,'b':2,'c':3}
for i in a:
print(i,a[i])
补充:
for i in a.values():
for i in a.keys():
for x,y in a.items():
字典不支持切片！
c.增/改
语法：
字典[key]=value --当key不存在时就增加键值对，存在就修改原key值为新value
字典.setdefault(key,value) --只能添加键值对，不能修改
d.删
语法：
del 字典[key] --删除字典中key对应的键值对，如果key不存在会报错
字典.pop(key) --从字典中取出key对应的值，结果是key对应的值，原字典中会删除key及其对应的值
4.相关运算
只支持比较运算
== ，！= ：判断多个字典中是否所有键值对都相等（无关顺序）
in / not in ：
key in 字典：判断字典中是否存在某个key对应的键值对
len(字典)：键值对的个数
max(字典)/min(字典)：取key的最大值/最小值
dict(序列)：将序列转换成字典，序列中元素要求也是小序列，且小序列必须有且只有2个元素，这两个元素的第一个元素要为不可变数据类型。
字典转列表或元祖时，是将字典的key取出来作为列表或元祖的元素
5.相关方法
a.字典.clear()
清空字典
students.clear()
b.字典.copy()
复制字典的内容，产生一个新的字典
c.dict.fromkeys(序列，值)
创建一个新的字典，将序列中的元素作为新字典的key，指定的值作为每个key对应的值
d.字典1.update(字典2)
将字典2中的键值对添加到字典1中，相同键值会更新为字典2的键值对。
