数据类型——列表,元祖,字典和集合
列表(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)