Python之路（组合数据类型及操作）

Python之路（组合数据类型及操作）

集合类型

集合类型的定义

• 集合是多个元素的无序组合
• 集合类型与数学中的集合概念一致
• 集合类型之间无序，每个元素唯一，不存在相同元素
• 集合元素之间不可或更改，不是可变数据类型
• 集合用大括号 {} 表示，元素间用逗号分隔
• 建立集合类型用 {} 或 set()
• 建立空集合类型，必须使用set() 

集合操作符

• S | T 返回一个新集合，包括在集合S和T中的所有元素
• S - T 返回一个新集合，包括在集合S但不在T中的元素
• S & T 返回一个新集合，包括同时在集合S和T中的元素
• S ^ T 返回一个新集合，包括集合S和T中的非相同元素
• S <= T 或 S < T 返回True/False，判断S和T的子集关系
• S >= T 或 S > T 返回True/False，判断S和T的包含
• S |= T 更新集合S，包括在集合S和T中的所有元素
• S -= T 更新集合S，包括在集合S但不在T中的元素
• S &= T 更新集合S，包括同时在集合S和T中的元素
• S ^= T 更新集合S，包括集合S和T中的非相同

 1 python_l=['lcg','szw','zjw','lcg']
 2 linux_l=['lcg','szw','sb']
 3 p_s=set(python_l)
 4 l_s=set(linux_l)
 5 print(p_s,l_s)
 6 求交集
 7 print('交集',p_s&l_s)
 8 p_s&=l_s
 9 print('更新交集',p_s)
10 print(p_s.intersection(l_s))#求集
11 p_s.intersection_update(l_s)#求集并更新到左边部分
12 print(p_s,l_s)
13 求并集
14 print('并集',p_s|l_s)
15 p_s|=l_s
16 print('更新并集',p_s)
17 print(p_s.union(l_s))#求集
18 p_s.update(l_s)#求集并更新到左边部分
19 print(p_s,l_s)
20 求差集
21 print('差集',p_s-l_s)
22 p_s-=l_s
23 print('更新差集',p_s)
24 print(p_s.difference(l_s))#求集
25 p_s.difference_update(l_s)#求集并更新到左边部分
26 print(p_s,l_s)
27 求补集
28 print('补集',p_s^l_s)
29 p_s^=l_s
30 print('更新补集',p_s)
31 print(p_s.symmetric_difference(l_s))#求集
32 p_s.symmetric_difference_update(l_s)#求集并更新到左边部分
33 print(p_s,l_s)
34 判断s1是否不是s2的子集，不是就返回True，否则False
35 s1={1}
36 s2={2,3,5}
37 print(s1.isdisjoint(s2))
38 s1={1,2}
39 s2={1,2,3,4}
40 print(s1<=s2)#判断S和T的子集关系,判断S和T的包含关系
41 print(s1.issubset(s2))#判断s1是s2的子集，是就True，否则False
42 print(s2.issubset(s1))
43 print(s2.issuperset(s1))#判断s2是s1的父集，是就True，否则False
44 print(s1.issuperset(s2))

集合处理方法

操作函数或方法           　　描述
S.add(x)     　　　　  如果x不在集合S中，将x增加到S
S.discard(x)     　　　移除S中元素x，如果x不在集合S中，不报错
S.remove(x) 　　　　移除S中元素x，如果x不在集合S中，产生KeyError异常
S.clear() 　　　　　  移除S中所有元素
S.pop() 　　　　　　随机返回S的一个元素，更新S，若S为空产生KeyError异常

S.copy()　　　　　　返回集合S的一个副本
len(S) 　　　　　　  返回集合S的元素个数
x in S 　　　　　　   判断S中元素x，x在集合S中，返回True，否则返回False
x not in S 　　　　　判断S中元素x，x不在集合S中，返回False，否则返回True
set(x) 　　　　　　   将其他类型变量x转变为集合类型

 1 数据类型的相互转化
 2 s=frozenset('hello')
 3 print(s)
 4 names=['alex','alex','wupeiqi']
 5 names=list(set(names))
 6 print(names)
 7 #set建立集合
 8 s=set(['hello','hello','lz','age'])
 9 s={'hello','hello','lz','age'}
10 print(s)    #{'hello', 'lz', 'age'}
11 
12 #s.add添加
13 s={1,2,3,4,5,6}
14 s.add('s')
15 s.add('s')
16 s.add(3)
17 s.add(3)
18 print(s)#{1, 2, 3, 4, 5, 6, 's'}
19 #移除所有元素
20 s1=s.copy()#4,返回集合s的一个副本
21 s.clear()
22 print(s)
23 print(s1)
24 
25 s={'sb',1,2,3,4,5,6}
26 #随机删除
27 s.pop()
28 print(s)
29 #指定删除
30 s.remove('sb')#元素不存在会报错
31 print(s)
32 s.discard(2)#元素不存在并不会报错
33 print(s)
34 s={1,2,3,4,5}
35 s1=[1,2,3,4,5]
36 s2=set(s1)#将其他类型变量x转变为集合类型
37 print(s2)#{1, 2, 3, 4, 5}
38 print(len(s))#返回集合S的元素个数
39 print(1 in s)#判断S中元素x，x在集合S中，返回True，否则返回False
40 print(1 not in s)#判断S中元素x，x不在集合S中，返回False，否则返回True

集合应用场景

1 # 数据去重：集合类型所有元素无重复
2 ls=['df','df','er',1,2,'er']
3 s=set(ls)
4 ls=list(s)
5 print(ls)

元组类型

元组类型定义

• 元组是序列类型的一种扩展
• 元组是一种序列类型，一旦创建就不能被修改
• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
• 可以使用或不使用小括号 def func():return 1,2
• 元组继承序列类型的全部通用操作
• 元组因为创建后不能修改，因此没有特殊操作

元组类型操作

• 创建
• 索引
• 切片
• 循环
• 长度
• 数据类型转换

 1 #---------元组类型----------
 2 #创建元组
 3 tu = (111,"me",(11,22),[(33,44)],True,33,44,)
 4 tu = [111,"me",(11,22),[(33,44)],True,33,44,]
 5 s=tuple(tu)
 6 print(s)
 7 #索引
 8 v=s[0]
 9 print(v)
10 #切片
11 v=s[0:2]
12 print(v)
13 #循环
14 for item in s:
15     print(item,end=' ')
16 长度
17 l=len(s)
18 print(l)
19 #转换
20 a='dfgtyuhj'
21 li=['dfgfgh','dghxe']
22 tup=('xvbt','hjdc')
23 
24 v=tuple(a)
25 print(v)
26 
27 v=tuple(li)
28 print(v)
29 
30 v=list(tup)
31 print(v)
32 
33 v='_'.join(tup)
34 print(v)
35 
36 li=['dfgfgh','dghxe']
37 li.extend((11,22,33,))
38 print(li)
39 其他操作
40 a=('dfg','fgh','vgfsd','fgh','vgfsd','fgh')
41 b=('uj7d','weg')
42 print(a+b)#连接两个序列s和t
43 print(2*a)#将序列s复制n次
44 print(a.index('fgh',2,-1))#返回序列s从i开始到j位置中第一次出现元素x的位置
45 print(a.count('fgh'))#返回序列s中出现x的总次数
46 print('dfg' in a)
47 print('dfg' not in a)

列表类型

列表类型定义

• 列表是序列类型的一种扩展，十分常用
• 列表是一种序列类型，创建后可以随意被修改
• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
• 列表中各元素类型可以不同，无长度限制

列表类型操作

• 按索引取值（正+反）：可存可取
• 切片
• 长度
• 追加
• 删除
• 循环

  1 import copy
  2 li=[11, 22, 33, 22, 44]
  3 追加
  4 li.append('cd')
  5 li.append(['xcg','ersx'])
  6 print(li)
  7 
  8 清空
  9 li.clear()
 10 print(li)
 11 
 12 拷贝：深、浅拷贝
 13 v=li.copy()
 14 s=copy.deepcopy(li)
 15 li[6][0]='lz'
 16 print(v)#改变
 17 print(s)#不变
 18 
 19 计算元素出现的次数
 20 print(li.count(22))
 21 
 22 扩展原列表，参数：可迭代对象
 23 li = [11, 22, 33, 22, 44]
 24 li.extend(['dfg','hjc'])
 25 print(li)
 26 
 27 根据值获取当前值索引位置（左边优先）
 28 li = [11, 22, 33, 22, 44]
 29 print(li.index(22,2,-1))
 30 
 31 在指定索引位置插入元素
 32 li.insert(1,55)
 33 print(li)
 34 
 35 删除某个值(1.指定索引；2. 默认最后一个)，并获取删除的值
 36 li.pop(0)
 37 print(li)
 38 
 39 删除列表中的指定值，左边优先
 40 li.remove(22,)
 41 print(li)
 42 
 43 将当前列表进行翻转
 44 li = [11, 22, 33, 22, 44]
 45 li.reverse()
 46 print(li)
 47 
 48 列表的排序
 49 li = [11, 22, 33, 22, 44]
 50 li.sort()#正序
 51 print(li)
 52 li.sort(reverse=True)#反序
 53 print(li)
 54 
 55 索引取值
 56 li = [11, 22, 33, 22, 44]
 57 print(li[1])
 58 
 59 切片
 60 li = [11, 22, 33, 22, 44]
 61 print(li[1:-1])
 62 
 63 循环
 64 li = [11, 22, 33, 22, 44]
 65 for item in li:
 66     print(item,end=' ')
 67 
 68 修改
 69 li = [11, 22, 33, 22, 44]
 70 li[1]=200
 71 print(li)
 72 
 73 li[1:3]=[20,30]
 74 print(li)
 75 
 76 li[0]=['df','cvb','rty']
 77 print(li)
 78 
 79 删除
 80 li = [11, 22, 33, 22, 44]
 81 del li[0]
 82 print(li)
 83 
 84 del li[1:3]
 85 print(li)
 86 
 87 enumerate操作:可以指定索引从哪个数开始
 88 tu=['me','father','mother','brother']
 89 for index,element in enumerate(tu,10):
 90     print(index,element)
 91 
 92 直接使用字符串join方法：列表中的元素只有字符串
 93 li = ["123","lzme"]
 94 v = "".join(li)
 95 print(v)
 96 
 97 补充：字符串创建后，不可修改
 98 v = "memofabo"
 99 v = v.replace('m','M')
100 print(v)

字典类型

字典的定义

• 映射是一种键(索引)和值(数据)的对应，字典类型是“映射”的体现
• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 采用大括号{}和dict()创建，键值对用冒号: 表示

字典类型操作

• 索引
• 长度
• 新增
• 删除
• 循环
• 取键值对

  1 创建字典
  2 dic=dict()
  3 dic={"k1": 'v1',
  4     "k2": 'v2'}
  5 print(dic)
  6 
  7 根据序列，创建字典，并指定统一的值
  8 v = dict.fromkeys(["k1",123,"999"],123)
  9 print(v)
 10 
 11 dict.get(Key,b)根据Key获取值，键k存在，则返回相应值，不在则返回<default>值
 12 dic={
 13     'k1':'v1',
 14     'k2':'v2'
 15 }
 16 v = dic['k1']
 17 print(v)
 18 v = dic.get('k3',111111)
 19 print(v)
 20 
 21 dict.pop(k,<default>)删除并获取值,键k存在，则取出相应值，不在则返回<default>值
 22 dic = {
 23     "k1": 'v1',
 24     "k2": 'v2',
 25     "k3": 'v3',
 26 }
 27 v = dic.pop('k1', 90)
 28 print(dic, v)
 29 
 30 dict.popitem()随机从字典d中取出一个键值对，以元组形式返回
 31 s = dic.popitem()
 32 print(dic, s)
 33 k,v=dic.popitem()
 34 print(dic,k,v)
 35 
 36 设置值，
 37 已存在，不设置，获取当前key对应的值
 38 不存在，设置，获取当前key对应的值
 39 dic = {
 40     "k1": 'v1',
 41     "k2": 'v2',
 42     "k3": 'v3',
 43 }
 44 v = dic.setdefault('k1111', '123')
 45 print(dic, v)
 46 
 47 更新，更改或新增值
 48 dic = {
 49     "k1": 'v1',
 50     "k2": 'v2',
 51     "k3": 'v3'
 52 }
 53 dic.update({'k1': '111111', 'k3': 123})
 54 print(dic)
 55 dic.update(k1=123, k3=345, k5="asdf")
 56 print(dic)
 57 
 58 返回字典dic中元素的个数
 59 dic = {
 60     "k1": 'v1',
 61     "k2": 'v2',
 62     "k3": 'v3'
 63 }
 64 print(len(dic))
 65 
 66 删除所有的键值对
 67 dic.clear()
 68 print(dic)
 69 
 70 删除字典d中键k对应的数据值
 71 dic = {
 72     "k1": 'v1',
 73     "k2": 'v2',
 74     "k3": 'v3'
 75 }
 76 del dic['k2']
 77 print(dic)
 78 判断键k是否在字典dic中，如果在返回True，否则False
 79 print('k1' in dic)
 80 返回字典d中所有的键信息
 81 print(dic.keys())
 82 返回字典d中所有的值信息
 83 print(dic.values())
 84 返回字典d中所有的键值对信息
 85 print(dic.items())
 86 
 87 循环遍历字典
 88 dic = {
 89     "k1": 'v1',
 90     "k2": 'v2',
 91     "k3": 'v3'
 92 }
 93 for k in dic.keys():
 94     print(k)
 95 for v in dic.values():
 96     print(v)
 97 for k,v in dic.items():
 98     print(k,v)
 99 for k,v in enumerate(dic.items(),20):
100     print(k,v[0],v[1])
101 for k,v in enumerate(dic,20):
102     print(k,v,dic[v])

补充

布尔值

1 None ""  () []  {} 0 ==> False
2 print(bool(None))