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))