数据类型——列表，元祖，字典和集合
列表（list）
列表关键字list，[]列表具有有序性，可以根据下标查找。
lst = []
lst = [1,2,"3","abc","列表"]
列表的“增删改查”
增
追加（list.append(a)）
在列表的最后添加，a为要添加的内容。
lst1.append("abc") # 在lst1后追加字符串“abc”
print(lst1) # 结果为 >>> [1, 2, '3', 'abc', '列表', 'abc']
插入（list.insert(a,b)）
根据下标“a”，将内容“b”插入到列表中。
lst1.insert(2,"abc") # 在内容“3”（下标为2）的前边插入字符串“abc” print(lst1) # [1, 2, 'abc', '3', 'abc', '列表']
迭代添加（list.extend(a)）
将“a”迭代添加到列表中，注意“a”要有迭代性，如字符串，列表，元祖，字典，集合。
lst1.extend("abc") # 将“abc”迭代添加到lst1中
print(lst1) # [1, 2, '3', 'abc', '列表', 'a', 'b', 'c']
两个列表的加和“list1+list2”
lst2 = ["a",'b',"c"] # 声明新列表lst2 lst3 = lst1 + lst2 # 加和 print(lst3) # [1, 2, '3', 'abc', '列表', 'a', 'b', 'c']
删
删除（del）
直接删除整个列表，或根据下标查找到列表内容后删除
del lst1 #删除整个列表 del lst1[0] #删除列表lst1中下标为0的内容 [2,"3","abc","列表"]
del lst1[1:3] #[1,"abc","列表"]
提取（list. pop(a)）
根据下标“a”删除列表中的内容，并返回删除的内容。
elm = lst1.pop(2) print(elm) # "3" print(lst1) # [1, 2, 'abc', '列表']
根据内容删除（list.remove(b)）
根据列表中的元素b直接删除元素b
lst1 = [1,2,"3","abc","列表"] lst1.remove(2) print(lst1) # [1, '3', 'abc', '列表']
清空（list.clear()）
清空列表中的内容
lst1 = [1,2,"3","abc","列表"] lst1.clear() print(lst1) # []
for
lst = [1,2,4,4,5,6,7,8] for i in range(len(lst)-1,-1,-1): #倒叙循环 lst.pop(i) print(lst
改
利用下标找到要修改的内容后直接修改
lst1 = [1,2,"3","abc","列表"] lst1[3] = "ABC" print(lst1) # [1, 2, '3', 'ABC', '列表']
----------------------------------------------------
lst1 = [1,2,"3","abc","列表"]
lst1[3] = lst1[3].upper()
print(lst1) # [1, 2, '3', 'ABC', '列表']
查
利用for循环可查
lst1 = [1,2,"3","abc","列表"] for i in lst1: # 逐行打印1,2,3，abc,列表 print(i)
利用下标索引和切片
lst1 = [1,2,"3","abc","列表"] print(lst1[3]) # abc print(lst1[2:4]) # ['3', 'abc']
其他操作
获取下标（list.index(a，start，stop)）
根据内容a查找第一个位置的下标，可以根据start和stop确定搜索位置。
lst1 = [1,2,"2","3","abc","3","列表"] lst1.index("3") print(lst1.index("3")) # 3
翻转（list.reverse()）
lst1 = [1,2,"2","3","abc","3","列表"] lst1.reverse() print(lst1) # ['列表', '3', 'abc', '3', '2', 2, 1]
获取长度(=len(list))
lst1 = [1,2,"2","3","abc","3","列表"] print(len(lst1)) # 7
列表嵌套
lst1 = ["一",2,["21",'76',["he","hex","31"]],"abc","3","列表"] print(lst1[2][2][0]) # he print(lst1[-4][-1][-1]) # 31
元祖（tuple）
元祖，关键字tuple,不可变,只读列表。可以放任何数据类型的数据,可查询，可以循环，可以切片。但就是不能改。存放密码。
#只有一个元素的元祖必须加","逗号，否则会识别为元素本身类型。#
tup = ("1","2","abc")
tup = ("a") #只有一个元素的元祖必须加","逗号，否则会识别为元素本身类型。#
print(type(tup)) #<class 'str'>
tup = ("a",)
print(type(tup)) #<class 'tuple'>
元祖嵌套
同列表嵌套一样。
tup = ("一",2,("21",'76',("he","hex","31")),"abc","3","列表") print(tup[2][2][0]) #he print(tup[-4][-1][-1]) #31
字典（dict）
映射类型，以{ }括起来的键值对组成，由key-value一一对应dict = {"key1":value1,"key2":"value2"}
key必须为不可变的 (可hash),(列表，集合，字典不能作为key)
value没有要求，可任意数据类型。
dic = {"1":"a",2:"b"}
dic = {}
字典保存的数据无顺序， 是按照hash表的顺序保存的。 而hash表不是连续的。
所以不能切片，它只能通过key来获取dict中的数据。
字典操作
增
直接加
如果dict中没有出现这个key,就会将key-value组合添加到这个字典中
dic = {}
dic["1"]= "a"
print(dic) #{'1': 'a'}
dict.setdefault(“a”,"b")
如果dict有key“a”,则返回对应的值。
dic = {"1":"one","2":"twe","3":"three","4":""}
value = dic.setdefault("1") # one
print(value)
如果dict没有key"a",则返回“b”，并在dict中添加“a”:"b" 键值对。“b”处不填时返回NONE，同时也添加"a":"b"键值对。
dic = {"1":"a","2":"b","3":"c","4":""}
value = dic.setdefault("0","meiyou") # meiyou
print(value)
print(dic) #{'1': 'a', '2': 'b', '3': 'c', '4': '', '0': 'meiyou'}
dict.fromkeys(keys,value)
keys是可迭代的，value任意类型。
dic = dict.fromkeys(["1","2","3","3","4"],"随便") print(dic) #{'1': '随便', '2': '随便', '3': '随便', '4': '随便'}
dic = dict.fromkeys("1234")
print(dic) #{'1': None, '2': None, '3': None, '4': None}
dic = dict.fromkeys(range(1,5),"abc")
dic[1]="ABCD"
dic[2] = dic[2].upper()
print(dic) #{1: 'ABCD', 2: 'ABC', 3: 'abc', 4: 'abc'}
dic = dict.fromkeys("abc",[1,2,3])
print(dic) #{'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]}
dic["a"] = [4,5,6] #把key为“a”的值改为[4,5,6,]
print(dic) #{'a': [4, 5, 6], 'b': [1, 2, 3], 'c': [1, 2, 3]}
dic = dict.fromkeys("abc",[1,2,3])
print(dic) #{'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]}
dic["a"].append(5) #在key为“a”的值后边追加5，由于是列表可变，共源，所以全变
print(dic) #{'a': [1, 2, 3, 5], 'b': [1, 2, 3, 5], 'c': [1, 2, 3, 5]}
删
dict. pop(a)
pop删除有返回值。根据key“a”删除键值对.
dic = {"1":"a","2":"b","3":"c","4":""}
value = dic.pop("1")
print(value) # a
print(dic) #{'2': 'b', '3': 'c', '4': ''}
dict.popitems()
随机删除，python3.6 以后删除最后一个
dic = {"1":"a","2":"b","3":"c","4":""}
value = dic.popitem()
print(value) #('4', '')
print(dic) #{'1': 'a', '2': 'b', '3': 'c'}
改
直接改
利用key,找到值后直接改
dic = {"1":"a","2":"b","3":"c","4":""}
dic['2'] = "B"
print(dic) #{'1': 'a', '2': 'B', '3': 'c', '4': ''}
更新 dict.update(DIC)
通过字典DIC中的key对 原dict进行比较，如果存在，将值改为DIC中的，如果不存在，就添加，没有返回值。
dic = {"1":"a","2":"b","3":"c","4":""}
dic.update({"1":"one","5":"five"})
print(dic) #{'1': 'one', '2': 'b', '3': 'c', '4': '', '5': 'five'}
查
直接查
通过key 直接查看，如果存在，返回对应的值，如果不存在，报错。
dic = {"1":"a","2":"b","3":"c","4":""}
print(dic["3"]) # c
print(dic["5"]) #KeyError: '5'
dict.get("key"，“msg”)
通过key查看，如果存在返回对应值，如果不存在，返回“msg”，默认为none。
dic = {"1":"a","2":"b","3":"c","4":""}
print(dic.get("2","没有")) #"b"
print(dic.get("0","没有")) #没有
print(dic) #{'1': 'a', '2': 'b', '3': 'c', '4': ''}
其他操作
获取key列表，dict.key()
（是一个高仿列表，不能用下标，可用for循环）
dic = {"1":"a","2":"b","3":"c","4":""}
print(dic.keys()) # dict_keys(['1', '2', '3', '4'])
print(type(dic.keys())) # <class 'dict_keys'> 不是列表
获取value列表，dict.values()
（是一个高仿列表，不能用下标，可用for循环）
dic = {"1":"a","2":"b","3":"c","4":""}
print(dic.values()) # dict_values(['a', 'b', 'c', ''])
print(type(dic.values())) # <class 'dict_values'> 不是列表
获取item列表，dict.items()
是一个存放多个元祖的高仿列表，不能用下标，可用for循环
dic = {"1":"a","2":"b","3":"c","4":""}
print(dic.items()) # dict_items([('1', 'a'), ('2', 'b'), ('3', 'c'), ('4', '')])
print(type(dic.items())) # <class 'dict_items'> 不是列表
字典嵌套
dic = {"1":{"11":"a1","12":"z2"},"2":"b","3":"c","4":{"41":"d1",42:{"421":"hao"},"43":"d3"}}
print(dic["1"]["12"])
print(dic["4"][42]["421"])
列表字典嵌套
lst = {a:b}
集合（set）
set集合是基本数据类型，不是很常用，元素是不重复的无序的，元素必须是可hash的(int, str, tuple,bool)。
可认为set就是dict类型的数据但是不保存value， 只保存key。set也用{}表示。
set = {} #不能为空，否则为字典
print(type(set)) #<class 'dict'>
set = {"1","11","a1","11"} print(set) #{'a1', '1', '11'} 自动去重复
set集合中的元素必须是可hash的, 但是set本身是不可hash得.set是可变的
set1 = {'1','abc',2,True,[1,2,3]} # 报错list
set2 = {'1','abc',2,True,{1:2}} # 报错
set3 = {'1','abc',2,True,(1,2,[2,3,4])} # 报错
set3 = {'1','abc',2,True,(1,2,3)} #可行
增
添加set.add('a')
迭代添加set.update()
迭代更新重复的内容不会被添加到集合中
s = {"A", 's', "a"}
s.update("ABc") # 迭代更新{'c', 'B', 's', 'a', 'A'}
print(s)
删除
set.pop()
随机弹出一个
set.remove（A）
直接删除元素，不存在会报错
set.clear
清空set集合，打印出来的是set（）因为要和dict区别
修改
不能索引下标，不能定位元素，只能先删除在添加
查询
set是可迭代对象所以可以用for循环
常用操作
交集（&）
并集（|）
差集（-）
反交集（^）
子集（<）
超集（>）
frozenset
set集合本身是可以发生改变的。 是不可hash的。我们可以使用frozenset，返回一个冻结的集合，来保存数据。
frozenset是不可变的. 也就是一个可哈希的数据类型。
set = frozenset(["a", "b", "c, "d"]) dic = {set:'123'} # 可以正常使用了 print(dic)
