(Python学习) 40. Python 常用内置数据结构部分总结-列表、元组、字典、集合
一、列表list
1. 列表的特征
1. 列表中的每个元素都可变的，意味着可以对每个元素进行修改和删除；
2. 列表是有序的，每个元素的位置是确定的，可以用索引去访问每个元素；
3. 列表中的元素可以是Python中的任何对象；
4. 可以为任意对象就意味着元素可以是字符串、整数、元组、也可以是 list 等Python中的对象。
2. 列表的数据操作
1. 直接创建列表
mylist = ['Google', 'Yahoo', 'Baidu']
2. 对列表中的指定位置进行修改
1 mylist = ['Google', 'Yahoo', 'Baidu'] #变更索引位置1Yahoo的内容为Microsoft 2 mylist[1] = 'Microsoft' #运行结果： ['Google', 'Microsoft', 'Baidu']
3. 在列表后面追加元素
mylist.append('Alibaba')
4. 在指定位置插入元素
mylist.insert(1, 'Tencent')
5. 删除元素
1 mylist = ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba'] 2 mylist.pop() # 删除尾部元素，会返回被删除元素 3 mylist.pop(1) # 删除索引为1的元素，并返回删除的元素 4 mylist.remove('Microsoft') #删除列表中的Microsoft 5 del mylist[1:3] #删除列表中索引位置1到位置 3 的数据
6. 替换元素
1 mylist[0] = 'Baidu' 2 mylist[1] = ['python', 'java', 'php'] # 列表的数据类型可以不同，也可以是列表
7. 列表排序
1 def comp(x,y): 2 return y-x 3 4 #sort 只能应用在列表list上，sort方法会在原list上直接进行排序，不会创建新的list 5 #sorted 可以对所有可迭代的对象进行排序的操作，sorted方法不会对原来的数据做任何改动，排序后的结果是新生成的 6 7 myList= [1, 2, 5, 4] 8 myList.sort(key=cmp_to_key(lambda x,y:x-y)) # 按从小到大 9 myList=sorted(myList,key=cmp_to_key(lambda x,y: x-y)) # 按从小到大 10 myList.sort(key=cmp_to_key(comp)) # 按从大到小 11 myList=sorted(myList,key=cmp_to_key(comp)) # 按从大到小
8. 获取列表长度
1 mylist = [1, 2, 5, 4] 2 len(mylist)
9. 获取列表指定位置的数据
1 mylist = ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba','Sina'] 2 mylist[1] #获取索引位置1的数据 'Tencent' 3 mylist[1:5] #获取索引位置1到5的数据，注意这里只会取到索引位置4,这里叫做取头不取尾 'Tencent', 'Microsoft', 'Baidu', 'Alibaba' 4 mylist[ :5] #获取从最头到索引位置5的数据 'Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba' 5 mylist[2:] #获取从索引位置2开始到最后的数据 'Microsoft', 'Baidu', 'Alibaba','Sina'
10. 用循环来创建列表
1 a = [1,2,3,4,5,6] 2 b = [i*10 for i in a] #在a的数据基础上每个数据乘以10生成一个列表b， 3 4 # [1, 2, 3, 4, 5, 6] 5 # [10, 20, 30, 40, 50, 60]
11. 过滤列表中的内容放入新的列表中
1 a = [x for x in range(1,20)] #生成一个从1到20的列表 2 b = [m for m in a if m % 2 == 0] #把a中所有偶数生成一个新的列表b 3 4 # 运行结果如下: 5 # b = [2, 4, 6, 8, 10, 12, 14, 16, 18]
12. 嵌套式生成列表
1 a = [i for i in range(1,4)] #生成一个列表a 2 b = [i for i in range(100,400) if i % 100 == 0] #生成一个列表b 3 c = [m+n for m in a for n in b] # 嵌套式 4 5 #运行结果： 6 # [1, 2, 3] 7 # [100, 200, 300] 8 # [101, 201, 301, 102, 202, 302, 103, 203, 303]
13. list函数：可以通过list将序列创建为列表。其实list为一种类型并非函数，但此处二者并无多大区别。下面的tuple、dict也是如此。
myList = list("Hello world") #myList=['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
二、元组tuple
注意：元组Tuple，用法与List类似，但Tuple一经初始化，就不能修改，没有List中的append(), insert(), pop()等修改的方法，只能对元素进行查询
a = ('a','b',['A','B']) print(type(a)) # 检测a的数据类型是什么 <class 'tuple'> print(a) # 打印内容 ('a', 'b', ['A', 'B']) a[2][0] = 'X' # 尝试变更数据，成功了，为什么？ a[2][1] = 'y' print(a) # 打印出变更后的内容 ('a', 'b', ['X', 'y']) print(type(a[2])) # 检测a[2]的数据类型是什么 <class 'list'
元组是固定的列表，那么元组的意义何在呢？因为tuple不可变，所以代码更安全。如果可能，能用 tuple 代替 list 就尽量用 tuple 并且需要注意元组中元素的可变性(同上)！！空的tuple可以记为()，若只有一个元素的tuple记为 (1,) 因为记为(1)的话，这个实际代表的是数字1，此时()是数学公式中的小括号。
1 t = (1,) # 如果需要是Tuple，就必须加上逗号，否则变成成了数字1了 2 # 这里如果没有“,”就变成了“(1)”
因为元组是固定的列表，所以其内置的大多数的方法和列表是差不多的。可以通过 tuple 将序列转换为元组，用法和 list 一样
mytuple=tuple('Hello,world!') # mytuple=('H', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd', '!')
三、字典dict
注意：字典dictionary 全称这个概念就是基于现实生活中的字典原型，生活中的使用名称-内容对数据进行构建，Python中使用键(key)-值(value)存储，也就是java、C++中的map。
1. 字典的特征
1. 字典中的数据必须以键值对的形式出现，即k,v。其中 key 必须是可哈希的值，比如int、string、float、tuple, 但是 list、set、dict 不行。value可以是任何值。
2. 键不可重复，值可重复。键若重复字典中只会记该键对应的最后一个值。
3. 字典中键是不可变的，即不能进行修改；而值(value)是可以修改的，可以是任何对象。在dict中是根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。
2. 字典创建
1 d = {} # 创建空字典1 2 d = dict() # 创建空字典2 3 d = {"one":1,"two":2,"three":3,"four":4} # 直接赋值方式 4 dd = {k:v for k,v in d.items()} # 常规字典生成式 5 ddd = {k:v for k,v in d.items() if v % 2 ==0} # 加限制条件的字典生成方式
3. 字典的常见操作
1 d = {"one":1,"two":2,"three":3,"four":4} 2 print(d["one"]) # 访问字典中的数据 3 d["one"] = "eins" # 变更字典里面的数据 4 del d["one"] # 删除一个数据,使用del
4. 字典中的成员检测
1 d = {"one":1,"two":2,"three":3,"four":4} 2 3 if 2 in d: 4 print("value") # 不会打印 5 6 if "two" in d: 7 print("key") # 打印 8 9 if ("two",2) in d: # 不会打印 10 print("kv")
5. 使用 for 循环访问字典
1 d = {"one":1,"two":2,"three":3,"four":4} 2 3 # 使用for循环，直接按key值访问 4 for k in d: 5 print(k,d[k]) 6 7 #上述代码也可以写成如下 8 for k in d.keys(): 9 print(k,d[k]) 10 11 #只访问字典的值 12 for v in d.values(): 13 print(v) 14 15 #以下是特殊用法 16 for k,v in d.items(): 17 print(k,'--->',v)
6. 字典相关函数
1. 通用函数：len,max,min,dict
1 d = {"one":1,"two":2,"three":3,"four":4} 2 print(max(d)) # two 3 print(min(d)) # four 4 print(len(d)) # 4
1 # dict() 函数的使用方法 2 dict0 = dict() # 传一个空字典 3 print('dict0:', dict0) 4 5 dict1 = dict({'three': 3, 'four': 4}) # 传一个字典 6 print('dict1:', dict1) 7 8 dict2 = dict(five=5, six=6) # 传关键字 9 print('dict2:', dict2) 10 11 dict3 = dict([('seven', 7), ('eight', 8)]) # 传一个包含一个或多个元祖的列表 12 print('dict3:', dict3) 13 14 dict5 = dict(zip(['eleven', 'twelve'], [11, 12])) # 传一个zip()函数 15 print('dict5:', dict5)
2. str(字典)：返回字典的字符串形式
1 d = {"one":1,"two":2,"three":3,"four":4} 2 print(str(d))
3. clear 清空字典，items 返回字典的键值对组成的元组格式
1 d = {"one":1,"two":2,"three":3,"four":4} 2 3 i = d.items() 4 print(type(i)) 5 print(i) 6 7 d.clear() 8 print(d)
4. keys：返回字典的键组成的一个结构
1 d = {"one":1,"two":2,"three":3,"four":4} 2 k = d.keys() 3 print(type(k)) 4 print(k)
5. values: 返回字典的值组成的一个结构
1 d = {"one":1,"two":2,"three":3,"four":4} 2 v = d.values() 3 print(type(v)) 4 print(v)
6. get(key, default=None) 根据指定的键返回相应的值，如果指定键的值不存在时，返回默认值或设定值。
1 d = {"one":1,"two":2,"three":3,"four":4} 2 3 print(d.get("one333")) # None 4 print(d.get("one",100)) # 1 5 print(d.get("one222",100)) # 100
7. fromkeys：使用指定的序列作为键，使用一个值作为字典的所有的键的值
1 p = ["one","two","three","four",] 2 #注意fromkeys两个参数的类型 3 #注意fromkeys的调用主体 4 d = dict.fromkeys(p,"222") 5 print(d)
四、集合set
1. 集合的特点
1. 集合更接近数学上集合的概念。集合中每个元素都是无序的、不重复的任意对象。
2. 可以通过集合去判断数据的从属关系，也可以通过集合把数据结构中重复的元素减掉。集合可做集合运算，可添加和删除元素。
3. 集合内数据无序，即无法使用索引和分片。
4. 集合内部数据元素具有唯一性，可以用来排除重复数据。
5. 集合内的数据:str,int,float,tuple,冰冻集合等，即内部只能放置可哈希数据。
2. 集合的创建
1 s = set() 2 print(type(s)) 3 print(s) 4 5 #也可以像下面这样做,大括号内一定要有值，否则定义出的将是一个dict 6 s = {1,2,3,4,5,6,7} 7 print(s)
创建集合时可以用 list 作为输入集合，可通过 add() 方法增加元素，remove() 方法删除元素：
1 s = set([1,2,3]) 2 s.add(6) 3 s.remove(2)
3. 集合的循环
1. 集合会在初始化后自动除掉重复的元素
1 s = {33,1,33,6,9,126,8,6,3,77,88,99,126} 2 print(s)
2. 集合的普通循环
1 s = {33,1,33,6,9,126,8,6,3,77,88,99,126} 2 ss = {i for i in s} 3 print(ss)
3. 带条件的集合循环
1 s = {33,1,33,6,9,126,8,6,3,77,88,99,126} 2 sss = {i for i in s if i % 2 ==0} 3 print(sss)
4. 多循环集合循环
1 s1 = {1,2} 2 s2 = {"nice","to","meet","you"} 3 4 s = {m*n for m in s2 for n in s1} 5 print(s) # {'toto', 'to', 'you', 'nicenice', 'youyou', 'meet', 'meetmeet', 'nice'}
4. 集合相关的函数
- intersection：交集
- difference：差集
- union：并集
- issubset：检查一个集合是否为另一个子集
- issuperset：检查一个集合是否为另一个超集
1 s1 = {1,2,3,4,5,6,7} 2 s2 = {5,6,7,8,9} 3 4 #交集 5 s_1 = s1.intersection(s2) 6 print("交集:",s_1) 7 8 #差集 9 s_2 = s1.difference(s2) 10 print("差集:",s_2) 11 12 #并集 13 s_3 = s1.union(s2) 14 print("并集:",s_3) 15 16 #检查一个集合是否为另一个子集 17 s_4 = s1.issubset(s2) 18 print("检查子集结果：",s_4) 19 20 #检查一个集合是否为另一个超集 21 s_5 = s1.issuperset(s2) 22 print("检查超集结果：",s_5)
1 这里是运行结果： 2 交集: {5, 6, 7} 3 差集: {1, 2, 3, 4} 4 并集: {1, 2, 3, 4, 5, 6, 7, 8, 9} 5 检查子集结果： False 6 检查超集结果： False
5. frozen set:冰冻集合：冰冻集合是不可以进行任何修改的集合，是一种特殊集合。
s = frozenset()
