2.0 Python 數據結構與類型

數據類型是編程語言中的一個重要概念，它定義了數據的類型和提供了特定的操作和方法。在 python 中，數據類型的作用是將不同類型的數據進行分類和定義，例如數字、字元串、列表、元組、集合、字典等。這些數據類型不僅定義了數據的類型，還為數據提供了一些特定的操作和方法，例如字元串支持連接和分割，列表支持排序和添加元素，字典支持查找和更新等。因此，選擇合適的數據類型是 python 編程的重要組成部分。

2.1 算數類型

算數運算符在編程語言中是一種非常重要的工具，它用於執行數學運算。在 python 中，算數運算符大致可以分為 7 種類型：算術運算符、比較運算符、賦值運算符、邏輯運算符、位運算符、成員運算符和身份運算符。

除了運算符外，python 還支持多種數值類型，如int、float、bool和 complex複數等。這些數值類型的賦值和計算都是直觀易懂的，因此，它們對於初學者來說是非常友好的。

數值間的數據互換可以參考如下列表:

基本算術運算: 算數運算是任何一門編程語言中都存在的，使用算術運算可以實現對特定變數的加減乘除比較等基本功能，在Python中實現算數運算很容易。

>>> import math,os
>>>
>>> numberA = 10
>>> numberB = 20
>>> numberC = 10
>>>
>>> numberA + numberB
30
>>> numberA != numberB
True
>>> numberA += 10

位運算符號: 在程式中，位運算就是直接對整數在記憶體中的二進位位進行操作。

>>> a=60                      # 60 = 0011 1100 
>>> b=13                      # 13 = 0000 1101
>>>
>>> c= a & b                  # 12 = 0000 1100
>>> print("a與b: ",c)
a與b:  12
>>>
>>> c= a | b                  # 61 = 0011 1101 
>>> print("a或b: ",c)
a或b:  61
>>>
>>> c=a^b                     # 49 = 0011 0001
>>> print("a異或b:",c)
a異或b: 49
>>>
>>> c=a << 2                  # 240 = 1111 0000
>>> print("a左移2",c)
a左移2 240

其他運算符: 其他運算符包括常用的,邏輯運算,成員運算,身份運算等.

>>> num1 = 10
>>> num2 = 20
>>> num3 = 0
>>> list = [10,20,30,40,50]
>>>
>>> num1 and num3
0
>>> num1 in list      # 判斷num1是否在list裡面
True
>>> num1 not in list
False
>>>
>>> num1 is num3      # 判斷兩個標識符是不是引用自一個對象
True
>>> num1 is num2
False
>>> num1 is not num2
True

整數轉其他數值: 使用轉換命令將一個整數轉換為其他任意數值.

>>> number = 100
>>>
>>> float(number)
100.0
>>> complex(number)
(100+0j)
>>> str(number)
'100'
>>> chr(number)
'd'
>>> ord(chr(number))
100

實現數值之間進位轉換: 使用轉換命令實現進位轉換,bin二進位,oct八進位,hex十六進位,format也支持轉換輸出.

>>> import math
>>>
>>> number = 1024
>>> bin(number)
'0b10000000000'
>>> oct(number)
'0o2000'
>>> hex(number)
'0x400'
>>>
>>> format(number,"b")
'10000000000'
>>> format(number,"x")
'400'
>>>
>>> int("-4d2",16)
-1234

實現浮點數/負數之間運算: 複數的函數操作正弦、餘弦和平方根，可以使用cmath模塊

>>> import cmath,math
>>> numberA = complex(2,4)
>>> numberB = 3-5j
>>> numberA,numberB    # 複數相加
((2+4j), (3-5j))
>>>
>>> numberA.real       # 取實屬部分
2.0
>>> numberA.imag       # 取虛數部分
4.0
>>> math.ceil(3.14)    # 四捨五入
4
>>> round(3.14)        # 四捨五入
3
>>> cmath.sin(numberA)
(24.83130584894638-11.356612711218174j)
>>> cmath.cos(numberA)
(-11.36423470640106-24.814651485634187j)
>>> cmath.exp(numberA)
(-4.829809383269385-5.5920560936409816j)

數值格式化輸出: 針對數值做格式化,並對齊進行輸出顯示.

>>> number = 1234.56789
>>>
>>> format(number,"0.2f")
'1234.57'                                    # 格式化時精確2位小數
>>>
>>> "value = > {:>20.3f}".format(number)     # 輸出右側對齊
'value = >             1234.568'
>>> "value = > {:<20.3f}".format(number)     # 輸出左側對齊
'value = > 1234.568            '
>>> "value = > {:^20.3f}".format(number)     # 輸出居中對齊
'value = >       1234.568      '

數值類型格式化輸出: 實例化數字類型,或將其他類型轉換為數字類型,或各種進位轉換為十進位.

>>> temp = int(21)                # 實例化數字類型
>>> print(type(temp),temp)        # 列印類型,和參數值
<class 'int'> 21
>>> print(int("110101",base=2))   # 將二進位轉為十進位
53
>>> print(int("156",base=8))      # 將八進位轉為十進位
110
>>> print(int("1A2C31",base=16))  # 將十六進位轉為十進位
1715249

2.2 字元類型

字元串是字元的集合，是一種常見的數據類型。python 提供了強大的字元串處理功能，以支持各種字元串操作。例如，您可以使用字元串運算符進行字元串拼接、比較和替換；您還可以使用字元串內置函數對字元串進行搜索、切片、大小寫轉換等操作。

總的來說，字元串是 python 編程中不可或缺的一部分，它們在處理文本數據、輸入輸出、網路通信等方面都發揮了重要作用。因此，學習和掌握 python 中的字元串操作是非常必要的。

接下來我們將找出幾個比較常用的字元串函數來進行演示.

首字母大寫: 使用capitalize()函數,將一個指定字元串首字母變成大寫.

>>> str="hello lyshark"
>>>
>>> str.capitalize()
'Hello lyshark'

全部首字母大寫: 使用title()函數,將字元串中的每一個單詞的首字母大寫.

>>> str="hello lyshark"
>>>
>>> str.title()
'Hello Lyshark'

查找字元串位置: 使用index()查找字元串所在位置(不能存在則報錯),使用find()查找字元串位置(不存在返回-1).

>>> str = "hello lyshark"
>>>
>>> str.index("hello")
0
>>> str.index("lyshark")
6
>>> str.find("hello")
0

統計字元串出現次數: 使用count()函數,統計指定字元串的出現次數.

>>> str="hello lyshark"
>>>
>>> str.count("h")
2
>>> str.count("l")
3
>>> str.count("hello")
1
>>> str.count("mk")
0

字元串文本對齊: 字元串對齊函數實現對字元串的對齊與填充,字元串方法包括ljust()、rjust()和center()

>>> str = "hello lyshark"
>>>
>>> str.ljust(30)
'hello lyshark                 '
>>> str.rjust(30)
'                 hello lyshark'
>>>
>>> str.center(30)
'        hello lyshark         '
>>>
>>> str.center(50,"-")
'------------------hello lyshark-------------------'

字元串連接: 使用join()函數,將序列中以指定的字元連接生成一個新字元串

>>> str="-"
>>> seq=("hello","lyshark","welcome")
>>>
>>> print(str.join(seq))
hello-lyshark-welcome
>>>
>>> list =['1','2','3','4','5']
>>> print(''.join(list))
12345
>>>
>>> 'kill %s' % ' '.join(['1024','2234'])
'kill 1024 2234'

切割字元串: 使用split()函數,指定分割一個字元串,並保存成列表.

>>> str="hello-lyshark-welcome"
>>>
>>> str.split("-")
['hello', 'lyshark', 'welcome']

去除字元串兩邊空格: 使用strip()函數去除兩邊的空格,而lstrip/rstrip則是分別去掉兩邊空格.

>>> str="    hello      lyshark       "
>>>
>>> str.strip()          # 去掉兩邊空格
'hello      lyshark'
>>> str.rstrip()         # 去掉右邊空格
'    hello      lyshark'
>>>
>>> str.lstrip()
'hello      lyshark       '

去除字元串中註釋行: 將一個文件中的以警號開頭的行註釋掉.

>>> import os
>>>
>>> with open("test.log","r") as fp:
...     for each in fp:
...             if each[0]== "#":
...                     continue
...             else:
...                     print(each,end="")

字元串查找並替換: 通過使用replace()函數或者是re.sub()函數,查找並替換指定字元串.

>>> string = "hello lyshark ! ?"
>>>
>>> string.replace("lyshark","world")
'hello world ! ?'
>>>
>>> string.replace("!","").replace("?","")
'hello lyshark  '
>>>
>>> string = "  <br>hello lyshark</br>  !"
>>>
>>> re.sub('[<br> | </br> | ]',"",string)
'hellolyshak!'

判斷是否為大寫: 使用isupper()函數,判斷指定字元串是否為大寫.

>>> str="LYSHARK"
>>> str1="lyshark"
>>>
>>> str.isupper()
True
>>> str1.isupper()
False

實現字元串拆分: 通過split拆分分解元素,將一個字元串拆解成多個部分.

>>> string = "python"
>>> # 拆分上面的字元串,忽略某個值使用下劃線代替
>>> x,_,_,y,_,_ = string
>>> x
'p'
>>>
>>> passwd = 'root:x:0:0:root:/root:/bin/bash'
>>> username,*_,homedir,sh = passwd.split(":")
>>> username
'root'

查找開頭結尾: 使用startswith函數,找出指定字母開頭的字元元素,endswith找出字母結尾的元素.

>>> from fnmatch import fnmatch,fnmatchcase
>>> url = "https://www.baidu.com"
>>>
>>> url.endswith(".com")
True
>>> url.startswith("http://")
False
>>> url.startswith("https://") and url.endswith(".com")
True
>>> fnmatch(url,"*.com")
True
>>> filename = ["a.py","b.zip","c.zip","d.doc","e.py","f.jpg","g.gz","h.tar.gz"]
>>>
>>> [ item for item in filename if item.endswith((".py",".jpg")) ]     # 多個結果匹配時使用元組集合
['a.py', 'e.py', 'f.jpg']
>>>
>>> any(item.endswith(".py") for item in filename)                     # 判斷目錄中是否有.py結尾的文件
True
>>> names = ['dat01.csv','dat99.csv','config.ini','foo.py']
>>>
>>> [i for i in names if fnmatch(i,'dat[0-9]*.csv')]                   # 支持正則匹配查詢
['dat01.csv', 'dat99.csv']
>>>
>>> addr = [
...     '5412 N CLARK ST',
...     '1060 W ADDISON ST',
...     '1039 W GRANVILLE AVE',
...     '2122 N CLARK ST',
...     '4802 N BROADWAY' ]
>>>
>>> [ i for i in addr if fnmatch(i,'*ST') ]
['5412 N CLARK ST', '1060 W ADDISON ST', '2122 N CLARK ST']
>>>
>>> [ i for i in addr if fnmatch(i,'*CLARK*') ]
['5412 N CLARK ST', '2122 N CLARK ST']

2.3 列表類型

列表（List）是最常用的數據結構之一，它是一個有序的、可變的、元素可以重覆的集合。列表中的每個元素都可以根據它們在列表中的位置或索引進行訪問，第一個元素的索引為0，第二個為1，以此類推。列表可以容納任意類型的對象，包括整數、浮點數、字元串、函數等。

列表操作函數來進行演示.

正向/反向輸出列表: 簡單的實現正向輸出列表元素,與反向輸出列表元素.

>>> list
[1, 2, 3, 4, 5, 6, 7, 'python']
>>>
>>> for each in list:
...     print("正向輸出: ",each)
>>>
>>> for each in reversed(list):
...     print("反向輸出: ",each)

向列表追加數據: 使用append()函數,追加寫入幾個數據到指定的列表裡.

>>> list = [1,2,3,4,5]
>>>
>>> list.append(6)
>>> list.append(7)
>>> list.append("python")
>>>
>>> list
[1, 2, 3, 4, 5, 6, 7, 'python']

向列表插入數據: 使用insert()函數,向指定的列表插入幾個數據到指定的位置.

>>> list = ["admin","lyshark"]
>>> list
['admin', 'lyshark']
>>>
>>> list.insert(1,"python")
>>> list
['admin', 'python', 'lyshark']
>>>
>>> list.insert(2,"ruby")
>>> list.insert(2,"ruby")
>>> list
['admin', 'python', 'ruby', 'ruby', 'lyshark']

修改指定數據: 使用names[]變數賦值的方式,修改指定元素的欄位值.

>>> list
['admin', 'python', 'ruby', 'ruby', 'lyshark']
>>> list[0]="mkdirs"
>>> list
['mkdirs', 'python', 'ruby', 'ruby', 'lyshark']
>>>
>>> list[3]="pip"
>>> list
['mkdirs', 'python', 'ruby', 'pip', 'lyshark']

刪除指定數據: 使用remove()函數,刪除指定數據,或使用del()函數來刪除.

>>> list
['mkdirs', 'python', 'ruby', 'pip', 'lyshark']
>>> 
>>> del list[2]                             #通過下標刪除元素
>>> list
['mkdirs', 'python', 'pip', 'lyshark']
>>> 
>>> list.remove("python")                   #刪除指定的元素
>>> list
['mkdirs', 'pip', 'lyshark']
>>> 
>>> list.pop()                              #刪除列表的最後一個元素
'lyshark'
>>> list.pop()
'pip'
>>> list
['mkdirs']

擴展一個列表: 使用extend()函數,將一個列表追加到另一個列表的後面.

>>> list1 = ["admin","guest","lyshark"]
>>> list2 = [1,2,3]
>>>
>>> list1.extend(list2)
>>> list1
['admin', 'guest', 'lyshark', 1, 2, 3]

淺COPY列表: 使用copy()函數,實現列表的淺Copy.

>>> list1
['admin', 'guest', 'lyshark', 1, 2, 3]
>>>
>>> list1_copy = list1.copy()
>>> list1_copy
['admin', 'guest', 'lyshark', 1, 2, 3]

統計元素次數: 使用count()函數,統計列表中元素出現的次數.

>>> list = ["admin","admin","lyshark","mkdirs"]
>>>
>>> list.count("admin")
2
>>> list.count("mkdirs")
1

列表正反向排序: 使用sort()函數實現正向排序,使用reverse()函數則實現反向排序.

>>> list = ["admin","python","ruby","1","3","6","9"]
>>> list
['admin', 'python', 'ruby', '1', '3', '6', '9']
>>>
>>> list.sort()          #正向排序,必須元素類型一致
>>> list
['1', '3', '6', '9', 'admin', 'python', 'ruby']
>>>
>>> list
['1', '3', '6', '9', 'admin', 'python', 'ruby']
>>> list.reverse()          #反向排序,必須元素類型一致
>>> list
['ruby', 'python', 'admin', '9', '6', '3', '1']

獲取列表元素下標: 使用index()函數,我們可以獲取到指定元素的下標值.

>>> list
['ruby', 'python', 'admin', '9', '6', '3', '1']
>>>
>>> list.index("admin")
2
>>> list.index("1")
6

實現列表的切片: 使用[]特殊符號既可以定義列表,也可以實現列表的各種切片操作.

>>> list=[1,2,3,4,5,6,7,8,9,0]
>>>
>>> list[1:4]              #取出下標1-4的元素,不包括4
[2, 3, 4]
>>>
>>> list[1:-1]             #取出下標1至-1,不包括-1
[2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> list[1:]               #取出下標從1到最後的數據
[2, 3, 4, 5, 6, 7, 8, 9, 0]
>>>
>>> list[:]                #取出所有元素
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
>>> list[0::2]             #取元素時每次格2格
[1, 3, 5, 7, 9]

通過分片刪除數據: 通過使用分片來清除指定列表中的數據.

>>> list
[123, 111, 111, 111, 8, 7, 6, 5, 4, 3, 2, 1]
>>> list[0:3]
[123, 111, 111]
>>>
>>> list[0:3]=[]            #將下標0-3替換成空,不包括3
>>> print(list)
[111, 8, 7, 6, 5, 4, 3, 2, 1]
>>>

嵌套列表的實現: 一次性聲明兩個列表,並於數據名稱相關聯.

>>> list1,list2 = [[1,"a","b"],[2,"a","b"]]
>>>
>>> print(list1)
[1, 'a', 'b']
>>> print(list2)
[2, 'a', 'b']

從列表中隨機彈出元素: 在一個列表中隨機彈出一個元素.

>>> import random
>>> from random import randrange
>>>
>>> list = ["admin","python","ruby","1","3","6","9"]
>>>
>>> random.choice(list)
'python'
>>> random.choice(list)
'9'
>>>
>>> random_index = randrange(0,len(list))
>>> list[random_index]
'9'

列表元素查找並修改: 查找列表中的指定元素,並將列表中所有的元素1修改為88888.

>>> number = [1,2,3,4,5,1,5,6,1]
>>>
>>> def FindNumber(num_list,number,modify):
...     for item in range(num_list.count(number)):
...             ele_index = num_list.index(number)
...             num_list[ele_index] = modify
...
>>> number
[1, 2, 3, 4, 5, 1, 5, 6, 1]
>>> FindNumber(number,1,88888)
>>> number
[88888, 2, 3, 4, 5, 88888, 5, 6, 88888]

列表生成式篩選元素: 通過使用列表生成式,我們可以靈活地篩選出列表中的元素.

>>> from itertools import compress
>>>
>>> mylist = [1,2,-5,10,-8,3,-1]
>>>
>>> list(item for item in mylist if item > 0)       # 篩選出列表中大於0的數值
[1, 2, 10, 3]
>>>
>>> list(item for item in mylist if item < 0)       # 篩選出列表中小於0的數值
[-5, -8, -1]
>>>
>>> list(item if item>0 else 0 for item in mylist)  # 大於0的數值直接輸出,小於0的直接填0
[1, 2, 0, 10, 0, 3, 0]
>>>
>>> more = [item > 3 for item in mylist]            # 列表中大於3的返回真假
>>> more
[False, False, False, True, False, False, False]

統計列表中元素出現頻率: 統計出number列表中所有元素的出現頻率,並組合成字典.

>>> number = ["12:10","12:20","12:10","12:20","12:20","12:10","12:10"]
>>>
>>> def GetFrequency(item):
...     dict = {}
...     for x in item:
...             dict[x] = dict.get(x,0) + 1
...     return dict
...
>>> dict = GetFrequency(number)
>>> dict
{'12:10': 4, '12:20': 3}
>>>
>>> from collections import Counter
>>>
>>> data = [1,1,1,1,2,3,4,4,5,6,5,3,3,4,5,6,7,8,9,6,5,4,5]
>>> Counter(data)                 # 統計列表元素出現次數,以字典方式展現
Counter({5: 5, 1: 4, 4: 4, 3: 3, 6: 3, 2: 1, 7: 1, 8: 1, 9: 1})
>>>
>>> Counter(data).most_common()   # 統計列表元素出現次數,以元組方式展現
[(5, 5), (1, 4), (4, 4), (3, 3), (6, 3), (2, 1), (7, 1), (8, 1), (9, 1)]
>>>
>>> Counter(data).most_common(2)  # 統計列表元素出現次數,並取出前兩個元素
[(5, 5), (1, 4)]

定義固定長度的列表: 使用collections.deque保存有限的列表數據,deque用來創建一個固定長度的隊列.

>>> from collections import deque
>>>
>>> queue = deque(maxlen=4)       # 定義最大可存儲4個元素
>>> queue.append(1)
>>> queue.append(2)
>>> queue.append(3)
>>> queue.append(4)
>>> queue
deque([1, 2, 3, 4], maxlen=4)
>>> queue.append(5)
>>> queue                         # 超出部分會被從左側排除出去
deque([2, 3, 4, 5], maxlen=4)
>>>
>>> queue.appendleft(6)           # 從左邊加入數據到隊列,超出部分從右側排除
>>> queue
deque([6, 2, 3, 4], maxlen=4)
>>> queue.pop()                   # 從末尾取出一個數據
4
>>> queue.popleft()               # 從左側取出一個數據
6

列表中取出最大/最小值: 在heapq模塊中有兩個函數nlargest()從最大的值開始取,nsmallest()從最小的值開始取.

>>> import heapq
>>>
>>> data = [1,3,4,9,11,34,55,232,445,9812,321,45,67,434,555]
>>>
>>> heapq.heappush(data,1000)   # 追加寫入一個元素
>>> data
[1, 3, 4, 9, 11, 34, 55, 232, 445, 9812, 321, 45, 67, 434, 555, 1000]
>>> heapq.heappop(data)         # 取出第一個元素
>>> data
[3, 9, 4, 232, 11, 34, 55, 1000, 445, 9812, 321, 45, 67, 434, 555]
>>>
>>> heapq.nlargest(3,data)      # 取出最大的三個數
[9999, 9812, 1000]
>>> heapq.nsmallest(3,data)     # 取出最小的三個數
[4, 9, 11]

將二維列表橫豎顛倒: 將一個橫向排列的二維數組,以豎向排列,每一排代表一條記錄.

>>> val = \
        [
            ["/etc/system/winsss", "/proc/", "/sys", "/abc/lyshark"],
            ["1024GG", "2048GB", "111GB", "1111GB"],
            ["1024GG", "2048GB", "111GB", "22GB"],
            ["10%", "50%", "20%", "33%"]
        ]

>>> ref_xor = list ( map(list,zip(*val)) )
>>> for num in ref_xor:
...     print(num)
...
['/etc/system/winsss', '1024GG', '1024GG', '10%']
['/proc/', '2048GB', '2048GB', '50%']
['/sys', '111GB', '111GB', '20%']
['/abc/lyshark', '1111GB', '22GB', '33%']

多個列表的同步輸出: 通過使用enumerate()/zip()函數,可以實現多個列表同時遍歷輸出.

>>> data = ["C","Java","python","Shell","Ruby","Go","perl"]
>>>
# enumerate() 函數可用輸出元素序列
>>> for key,value in enumerate(data,1):
...     print(key,value)
...
1 C
2 Java
3 python
4 Shell
5 Ruby

# 迭代列印一個嵌套列表結構
>>> data = [(1,2),(3,4),(5,6)]
>>>
>>> for num,(key,value) in enumerate(data,1):
...     print("ID: {} Value: {} {}".format(num,key,value))
...
ID: 1 Value: 1 2
ID: 2 Value: 3 4
ID: 3 Value: 5 6

# 同時迭代多個序列可使用zip()函數,它將迭代對象產生出一個元組,整個迭代的長度取其中最短的序列
>>> list1 = [1,2,3,4,5]
>>> list2 = ["a","b","c","d"]
>>> list3 = ["jar","py","sh"]
>>>
>>> for x,y,z in zip(list1,list2,list3):
...     print(x,y,z)
...
1 a jar
2 b py
3 c sh
>>> from itertools import zip_longest
>>>
>>> for each in zip_longest(list1,list2,list3):
...     print(each)
...
(1, 'a', 'jar')
(2, 'b', 'py')
(3, 'c', 'sh')
(4, 'd', None)
(5, None, None)

遍歷列表的所有組合: itertools 模塊中提供了3個函數來解決枚舉所有列表元素的組合排列的可能情況.

>>> from itertools import permutations
>>>
# 第一個itertools.permutations()
>>> item = [1,2,3]
>>> for each in permutations(item):
...     print(each)
...
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)

# 如果要限定排序的長度可用指定長度參數
>>> for each in permutations(item,2):
...     print(each)
...
(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)

追加列表保持元素數: 保持列表中最多只有Size個元素,如果超出則自動shift左移或自動unshift右移,保證只有Size個元素.

>>> def shift(Array, Size, Push):
...    if len(Array) <= Size and len(Array) >= 0:
...        Array.pop(0)
...        Array.append(Push)
...        return True
...    return False
...
>>> def unshift(Array, Size, Push):
...    if len(Array) <= Size and len(Array) >= 0:
...        Array.pop(Size-1)
...        Array.insert(0,Push)
>>> 
>>> Array = [1,1,1,1,1,1,1,1,1,1]
>>> 
>>> shift(Array,10,0)
>>> shift(Array,10,0)
>>> print(Array)
[1, 1, 1, 1, 1, 1, 1, 1, 0, 0]
>>> 
>>> unshift(Array,10,0)
>>> unshift(Array,10,0)
>>> print(Array)
[0, 0, 1, 1, 1, 1, 1, 1, 1, 1]

2.4 字典類型

字典（Dictionary）是一種內置數據結構，它是一種可變的容器模型，可以存儲任意類型的對象，不僅如此，字典的一個重要特性是它可以通過任意不可變對象通常是字元串或數字來作為鍵key來存儲和檢索值value。字典是基於哈希表實現的，可以快速地根據鍵找到對應的值。

字典的定義使用大括弧{}包含鍵值對，每個鍵值對使用冒號:連接鍵和值，鍵值對之間使用逗號, 分割。例如：

d = {'name': 'Alice', 'age': 20, 'gender': 'female'}

在上面的例子中，d 是一個字典，包含三個鍵值對，'name'、'age' 和 'gender' 分別是鍵，而它們對應的值分別是 'Alice'、20 和 'female'。可以使用鍵來訪問對應的值，例如：

print(d['name'])     # 輸出 'Alice'

需要註意的是，字典中的數據是無序存儲的，這意味著字典中的鍵值對的順序不固定，不能通過下標來訪問，只能通過鍵來訪問對應的值。

另一個字典的特性是，字典中的鍵必須是唯一的，如果多個鍵對應的值相同，後面的鍵值對會覆蓋前面的鍵值對。這是因為字典是基於哈希表實現的，每個鍵的哈希值是唯一的，如果多個鍵的哈希值相同，就會發生哈希衝突，這個衝突會被解決為一個鏈表。所以，字典中的鍵天生就是去重的。

如下是字典的幾種格式聲明:

person = {"name": "lyshark", "age": 22}
person = dict({"name": "lyshark", "age": 22})

info = {
    'stu1': "administrator",
    'stu2': "lyshark",
    'stu3': "redhat",
}

字典需要使用字典專有的操作函數,字典的常用函數有以下這幾種,後面我會使用不同的例子進行說明.

增加字典: 在info字典的基礎上,增加一個欄位info["stu4"] = "root".

>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>> info["stu4"] = "root"
>>>
>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}

修改字典: 在info字典的基礎上,修改將stu1:administrator修改為stu1:centos.

>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}
>>>
>>> info["stu1"] = "centos"
>>> info
{'stu1': 'centos', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}

刪除字典: 在info字典的基礎上,刪除幾個字典,以下提供多種刪除方法.

>>> info
{'stu1': 'centos', 'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}
>>>
>>> info.pop("stu1")        #通過pop函數刪除
'centos'
>>> info
{'stu2': 'lyshark', 'stu3': 'redhat', 'stu4': 'root'}
>>>
>>> del info["stu4"]        #通過del命令刪除
>>> info
{'stu2': 'lyshark', 'stu3': 'redhat'}
>>>
>>> info.popitem()          #隨機刪除元素
('stu3', 'redhat')

查找字典: 在info字典基礎上,完成幾個查詢任務,這裡提供幾種方法.

>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>>
>>> "stu1" in info          #標準的查詢方式
True
>>>
>>> info.get("stu1")        #使用get函數查詢
'administrator'
>>>
>>> info["stu2"]
'lyshark'

更新字典: 在info字典的基礎上,更新字典內容,將temp字典與info字典合併.

>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>>
>>> temp = {1:2,"stu4":"root"}
>>>
>>> info.update(temp)
>>> info
{'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat', 1: 2, 'stu4': 'root'}

遍歷字典: 這裡提供兩種字典遍歷方法,建議使用第二種,因為其遍歷速度最快.

>>> info = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>>
>>> for keys,values in info.items():
...     print(keys,values)
...
stu1 administrator
stu2 lyshark
stu3 redhat

>>> for keys in info:
...     print(keys,info[keys])
...
stu1 administrator
stu2 lyshark
stu3 redhat

索引字典: 字典也支持索引的方式獲取字典中的元素,只不過必須以key作為索引.

>>> info = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>>
>>> info['stu2']
'lyshark'
>>>
>>> len(info)
3
>>>
>>> dict = {"姓名":"administrator","得分":[98,99,87]}
>>>
>>> dict["姓名"]
'administrator'
>>> dict["得分"]
[98, 99, 87]
>>> dict["得分"][2:]
[87]

字典嵌套: 字典內部可繼續存放列表或新的字典,遍歷時只需要逐級輸出即可.

>>> info = {'name': 'lyshark', 'gender': 'male', 'age': 22, 'company': ['oldboy', 'beijing', 50]}
>>>
>>> info["name"]
'lyshark'
>>> info["company"][1]
'beijing'
>>>
>>> info = {'name': 'lyshark', 'gender': 'male', 'age': 22, 'company': {'c_name': 'oldboy', 'c_addr': 'shandong'}}
>>>
>>> info["company"]["c_addr"]
'shandong'

將字典解包: 將字典分解為獨立的元組並將元組賦值給其他變數.

>>> dict = {"姓名":"administrator","得分":[98,99,87]}
>>> t1,t2 = dict.items()
>>>
>>> print(t1)
('姓名', 'administrator')
>>> print(t2)
('得分', [98, 99, 87])
>>>
>>> k1,k2 = {"x":100,"y":200}
>>> print(k1)
x

根據字典的值找鍵: 通常情況下是根據key找值,但是有時需要反過來,根據值找key.

>>> Dict = { "admin":"001" , "guest":"002" , "lyshark":"003" }
>>>
>>> Dict.get("admin",0)                                     # 一般用法
'001'
>>> list(Dict.keys())[list(Dict.values()).index("001")]     # 單值返回
'admin'
>>>
>>> def get_keys(d, value):                                 # 多值返回列表
...     return [k for k,v in d.items() if v == value]
...
>>> get_keys(Dict,"002")
['guest']

列表合併為字典: 將兩個列表合成一個字典,其中list1是key,list2是values.

>>> dict = {}
>>> list = [100,200,300,400,500]
>>> head = ["MemTotal","MemFree","Cached","SwapTotal","SwapFree"]
>>>
>>> for (keys,values) in zip(head,list):
...     dict[keys] = values
...
>>> dict
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>>
>>> dict(map(lambda x,y:[x,y],head,list))
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>>
>>> dict(zip(head,list))
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}

字典鍵值對調: 將字典中的鍵與字典中的值進行位置的對調,第一個是列表對調,第二個是字典對調.

>>> list = [100,200,300,400,500]
>>> head = ["MemTotal","MemFree","Cached","SwapTotal","SwapFree"]
>>>
>>> {key:value for key,value in zip(head,list)}
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>>
>>> {value:key for key,value in zip(head,list)}
{100: 'MemTotal', 200: 'MemFree', 300: 'Cached', 400: 'SwapTotal', 500: 'SwapFree'}

>>> dict = {'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>>
>>> {key:value for key,value in dict.items()}
{'MemTotal': 100, 'MemFree': 200, 'Cached': 300, 'SwapTotal': 400, 'SwapFree': 500}
>>>
>>> {value:key for key,value in dict.items()}
{100: 'MemTotal', 200: 'MemFree', 300: 'Cached', 400: 'SwapTotal', 500: 'SwapFree'}

字典拆分為列表: 將一個完整的字典拆分為兩個列表.

>>> dict = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>> keys= dict.keys()
>>> values = dict.values()
>>>
>>> print("keys:{}".format(keys))
keys:dict_keys(['stu1', 'stu2', 'stu3'])
>>>

>>> dict = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>>
>>> keys,values = zip(*dict.items())
>>> print("Keys:",str(keys))
Keys: ('stu1', 'stu2', 'stu3')

>>> dict = {'stu1': 'administrator', 'stu2': 'lyshark', 'stu3': 'redhat'}
>>>
>>> keys = []
>>> values = []
>>> items = dict.items()
>>> for x in items:
...     keys.append(x[0]),values.append(x[1])
...
>>> print(str(keys))
['stu1', 'stu2', 'stu3']

字典合併與拷貝: 合併字典,但是在有相同的key時會覆蓋原有的key的值.

>>> dict1 = {"x":1,"y":2}
>>> dict2 = {"a":3,"b":4}
>>> dict3 = {}
>>>
>>> dict3 = {**dict1,**dict2}
>>> print(dict3)
{'x': 1, 'y': 2, 'a': 3, 'b': 4}
>>>
>>> dict3.update(dict1)
>>> dict3.update(dict2)
>>> print(dict3)
{'x': 1, 'y': 2, 'a': 3, 'b': 4}
>>>
>>> import copy
>>> n1 = {"k1": "wu", "k2": 123, "k3": ["lyshark", 456]}
>>> n2 = {}
>>>
>>> n2 = copy.deepcopy(n1)
>>> print(n2)
{'k1': 'wu', 'k2': 123, 'k3': ['lyshark', 456]}

複雜字典數據存儲: 首先定義三個字典用於存儲用戶信息,然後將其放入一個列表中,並對列表中的元素進行取值.

>>> dict1 = {"name":"admin","age":19,"salary":3000,"address":"beijing"}
>>> dict2 = {"name":"guest","age":20,"salary":4000,"address":"shanghai"}
>>> dict3 = {"name":"lyshark","age":21,"salary":5000,"address":"shenzhen"}
>>> table = [dict1,dict2,dict3]

# 用於獲取指定人的指定欄位數據
>>> print(table[1].get("name"))
guest
>>> print(table[2].get("address"))
shenzhen

# 列印表格中所有人的名字
>>> for i in range(len(table)):
...     print(table[i].get("name"))
...
admin
guest
lyshark

統計字典中的重覆記錄數: 就是統計兩個字典中key的出現頻率,並輸出.

>>> dictA = {'a': 3,'c': 2, 'b': 1, 'd': 2, 'e': 1, 'r': 1, 'w': 2}
>>> dictB = {'a': 3, 'b': 2, 'd': 1, 'c': 1, 'r': 2, 'e': 1, 's': 1, 'w': 1}
>>>
>>> def GetDict(A,B):
...     for key,value in B.items():
...             A[key] = A.get(key,0) + value
...     return A
...
>>> item = GetDict(dictA,dictB)
>>> item
{'a': 6, 'c': 3, 'b': 3, 'd': 3, 'e': 2, 'r': 3, 'w': 3, 's': 1}

讓字典保持有序存儲: 字典預設是無序排列的,使用內置模塊,當對字典做迭代時,它會嚴格按照元素初始添加的順序進行迭代.

>>> from collections import OrderedDict
>>>
>>> dict = OrderedDict()
>>>
>>> dict["one"] = 1
>>> dict["two"] = 2
>>> dict["three"] = 3
>>>
>>> for key,value in dict.items():
...     print(key,value)
...
one 1
two 2
three 3

字典中實現的列表推導: 通過使用列表推導式,對字典進行迭代操作,篩選字典元素.

>>> prices = {
...     'ACME':45.23,
...     'AAPL':612.78,
...     'IBM':205.55,
...     'HPQ':37.20,
...     'FB':10.75,
... }
>>>
>>> P1 = { key:value for key,value in prices.items() if value > 30 }
>>>
>>> print(P1)
{'ACME': 45.23, 'AAPL': 612.78, 'IBM': 205.55, 'HPQ': 37.2}
>>>
>>> tech = {'ACME','IBM','HPQ','FB'}
>>> P2 = { key:value for key,value in prices.items() if key in tech }
>>> print(P2)
{'ACME': 45.23, 'IBM': 205.55, 'HPQ': 37.2, 'FB': 10.75}
>>>
>>> P3 = dict((key,value) for key,value in prices.items() if value > 100)
>>> P3
{'AAPL': 612.78, 'IBM': 205.55}
>>>
>>> numbers = [ {'name':'GOOG','shares':50},{'name':'YHOO','shares':75} ]
>>> sumnmber = sum(item["shares"] for item in numbers)
>>> sumnmber
125

字典中元素的排序: 使用zip()將字典中的值映射為元組的迭代器,並求最大值、最小值和排序.

>>> prices = {
...     'ACME':45.23,
...     'AAPL':612.78,
...     'IBM':205.55,
...     'HPQ':10.75,
...     'FB':10.75
... }
>>>
>>> max(zip(prices.values(),prices.keys()))
(612.78, 'AAPL')
>>>
>>> min(zip(prices.values(),prices.keys()))
(10.75, 'FB')
>>>
>>> sorted(zip(prices.values(),prices.keys()))
[(10.75, 'FB'), (10.75, 'HPQ'), (45.23, 'ACME'), (205.55, 'IBM'), (612.78, 'AAPL')]

字典間差異對比與元素排除: 比較兩個字典之間存在的差異,和排除字典中指定的key並生成新字典.

>>> dictA = {"x": 1 , "y": 2 , "z": 3}
>>> dictB = {"a": 10 , "y": 11 , "z": 12}
>>>
>>> dictA.keys() & dictB.keys()      # dictA和dictB中同時都有的Key
{'y', 'z'}
>>>
>>> dictA.keys() - dictB.keys()      # dictA中的鍵不在dictB中出現的Key
{'x'}
>>>
>>> dictA.items() - dictB.items()    # dictA和dictB中鍵值都相同的元素
{('y', 2), ('x', 1), ('z', 3)}
>>>
>>> dictOld = { "admin":123 , "guest":456, "lyshark":123123, "zhangsan": 123456 }
>>>
>>> dictNew = { key:dictOld[key] for key in dictOld.keys() - {"guest","zhangsan"} }
>>> dictNew
{'lyshark': 123123, 'admin': 123}

高級字典列表的排序: operator模塊中的itemgetter函數可以對嵌套數據結構的排序會非常簡單且運行很快

>>> from operator import itemgetter
>>> data = [
...     {'fname':'Brian','lname':'Jones','uid':1003},
...     {'fname':'David','lname':'Beazley','uid':1002},
...     {'fname':'John','lname':'Cleese','uid':1001},
...     {'fname':'Big','lname':'Jones','uid':1004},
... ]
>>>
>>> sorted(data,key=itemgetter("uid"))              # 以UID欄位作為排序條件,從小到大的排列
>>> sorted(data,key=itemgetter("uid"),reverse=True) # 以UID欄位作為排序條件,從大到小的排列
>>> sorted(data,key=itemgetter("uid","fname"))      # 通過多個公共鍵排序
>>> max(data,key=itemgetter("uid"))                 # 找出UID欄位最大的一條字典

高級字典取出最大/最小值: 在heapq模塊中有兩個函數nlargest()從最大的值開始取,nsmallest()從最小的值開始取.

>>> import heapq
>>>
>>> data = [
...     {'name':'dhcp','port':67},
...     {'name':'mysql','port':3306},
...     {'name':'memcached','port':11211},
...     {'name':'nginx','port':80},
...     {'name':'ssh','port':22}]
>>>
>>> heapq.nlargest(2,data,key=lambda x:x["port"])  # 取出port欄位最大的兩個字典
[{'name': 'memcached', 'port': 11211}, {'name': 'mysql', 'port': 3306}]
>>>
>>> heapq.nsmallest(3,data,key=lambda x:x["port"]) # 取出port欄位最小的三個字典
[{'name': 'ssh', 'port': 22}, {'name': 'dhcp', 'port': 67}, {'name': 'nginx', 'port': 80}]

高級字典記錄的分組: itertools模塊中的函數groupby()可以通過掃描序列,並將相同元素進行分組排序.

>>> from operator import itemgetter
>>> from itertools import groupby
>>>
>>> rows = [
...     { "name":"c++","date": "2012/12/11" },
...     { "name":"python","date": "2016/01/12" },
...     { "name":"ruby","date": "2012/12/11" },
...     { "name":"perl","date": "2020/11/12" },
...     { "name":"c#","date": "2020/11/12" }
... ]
>>>
>>> rows.sort(key=itemgetter("date"))    # 通過date欄位對字典進行排序
>>> for date,items in groupby(rows,key=itemgetter("date")):
...     print("時間歸檔: {}".format(date))
...     for value in items:
...             print("--> {}".format(value))
...
時間歸檔: 2012/12/11
--> {'name': 'c++', 'date': '2012/12/11'}
--> {'name': 'ruby', 'date': '2012/12/11'}
時間歸檔: 2016/01/12
--> {'name': 'python', 'date': '2016/01/12'}
>>>
# 根據數據分組來構建一個一鍵多值的字典 {'2012/12/11': [{'name': 'c++', 'date': '2012/12/11'}]
>>> from collections import defaultdict
>>> rows_data = defaultdict(type(list))
>>> for row in rows:
...     rows_data[row["date"]].append(row)
>>> print(rows_data)

2.5 元組類型

元組是一種不可變的有序數據結構，由多個元素組成，每個元素可以是不同的數據類型，包括數字、字元串、元組等。元組的創建很簡單，只需要使用小括弧將元素括起來，並使用逗號隔開即可。元組一旦創建後，不能對其中的元素進行修改，所以也被稱為只讀列表。元組通常用於存儲一些固定不變的數據，如一行記錄或一組配置參數等。元組可以作為函數的參數和返回值，也可以與列表等數據類型進行相互轉換。與列表不同，元組中的元素是不可變的，這使得元組在某些場景下比列表更加安全和高效。

創建元組: 同個幾個實例看一下元組是如何被創建的.

>>> tup1 = ("google","baidu",1997,1998)
>>> tup2 = (1,2,3,4,5,6,7)
>>> tup3 = "a","b","c","d"
>>>
>>> tup1
('google', 'baidu', 1997, 1998)
>>> tup2
(1, 2, 3, 4, 5, 6, 7)
>>> tup3
('a', 'b', 'c', 'd')
>>>
>>> type(tup1)
<class 'tuple'>

訪問元組: 元組可以使用下標索引來訪問元組中的值.

>>> tup1
('google', 'baidu', 1997, 1998)
>>>
>>> print("tup1[0:]",tup1[0])
tup1[0:] google
>>> print("tup1[1:2]",tup1[1:2])
tup1[1:2] ('baidu',)

連接元組: 元組中的元素值是不允許修改的,但我們可以對元組進行連接組合.

>>> tup1 = (1,2,3,4)
>>> tup2 = ("abc","xyz")
>>>
>>> tup3 = tup1+tup2
>>> print(tup3)
(1, 2, 3, 4, 'abc', 'xyz')

刪除元組: 元組中的元素值是不允許刪除的,但我們可以使用del語句來刪除整個元組.

>>> tup = ("admin","lyshark", 1997, 2000)
>>>
>>> print(tup)
('admin', 'lyshark', 1997, 2000)
>>> del tup;
>>> print(tup)

列表轉元組: 將一個列表,強制轉換成元祖.

>>> list = ["admin","lyshark","guest"]
>>>
>>> tuple = tuple(list)
>>>
>>> tuple
('admin', 'lyshark', 'guest')

數據統計: 通過使用count(),index()函數統計元組中的其他數據.

>>> tuple
('admin', 'lyshark', 'guest')
>>>
>>> tuple.count("lyshark")    #統計lyshark出現次數
1
>>> tuple.index("lyshark")    #統計lyshark索引位置
1

元素修改: 在沒有嵌套的情況,元組是不可變對象,但是元組內的列表是可變的.

>>> tup=("lyshark",[1,2,3,4,5])
>>> tup
('lyshark', [1, 2, 3, 4, 5])
>>>
>>> tup[1].pop()
5
>>> tup
('lyshark', [1, 2, 3, 4])

元組解包: 將兩個元組,查分開,分別存儲在兩個變數中.

>>> tup1,tup2=((1,2,3),("a","b","c"))
>>> print(tup1)
(1, 2, 3)
>>>
>>> print(tup2)
('a', 'b', 'c')

創建可命名元組: 根據namedtuple可以創建一個包含tuple所有功能以及其他功能的類型.

>>> from collections import namedtuple
>>>
>>> tup = namedtuple("tup1",["x","y","z"])
>>> obj = tup(1,2,3)
>>>
>>> obj.x
1
>>> obj.y
2

任意長度對象分解元素: 從某個可迭代對象中分解出N個元素,可以使用python的*表達式.

>>> grades = (68,98,85,78,84,79,88)
>>> first,*middle,last = grades
>>> sum(middle) / len(middle)
84.8
>>>
>>> records = [
...     ('foo',1,2,3),
...     ('bar',11,22,33),
...     ('foo',4,5,6),
...     ('bar',44,55,66),
... ]
>>> for tag,*args in records:
...     if tag == "foo":
...             print(*args)
1 2 3
4 5 6

2.6 集合類型

集合是一種無序的、不重覆的數據結構。集合中的元素必須是可哈希的，因此支持數字、字元串、元組等不可變類型，不支持列表、字典等可變類型。可以通過工廠函數set()或使用花括弧{}來創建集合。將列表傳入set()中可以快速實現去重，而添加重覆元素則會被忽略。

集合可以進行並集、交集、差集等基本運算，也支持添加、刪除、清空等操作。由於集合是無序的，因此不支持索引、切片等操作，只能通過迭代遍歷來訪問集合中的元素。

值得註意的是，集合支持使用推導式（set comprehension）來創建集合，形如{expression for item in iterable}，這在創建大型集合時比使用迴圈和add()方法更為高效。另外，python中還提供了frozenset()函數，創建一個不可變集合，它可以作為字典的鍵值，而普通集合不能作為鍵值。

set(): 實例化可變集合類型,或其他類型轉換成集合類型.

(1) 實例化集合類型
>>> s = set({"fedora","geentoo","debian","centos"})
>>> print(type(s),s)
<class 'set'> {'fedora', 'centos', 'debian', 'geentoo'}

(2) 將其他類型轉換成集合set類型
>>> l = ["centos","centos","redhat","ubuntu","suse","ubuntu"]
>>> s = set(l)
>>> print(type(s),s)
<class 'set'> {'ubuntu', 'centos', 'redhat', 'suse'}

>>> d = {"kernel":"Linux","os":"ubuntu","version":"15.10"}
>>> s = set(d.keys())
>>> print(type(s),s)
<class 'set'> {'kernel', 'version', 'os'}

frozenset(): 實例化不可變集合,或類型轉換成不可變集合類型.

(1) 實例化不可變集合
>>> fs = frozenset({"redhat","centos","fedora","debian","ubuntu"})
>>> print(type(fs),fs)
<class 'frozenset'> frozenset({'fedora', 'ubuntu', 'centos', 'debian', 'redhat'})

(2) 類型轉換成不可變集合
>>> l = [1,2,3,4,4,5,5]
>>> fs1 = frozenset(l)
>>> print(type(fs1),fs1)
<class 'frozenset'> frozenset({1, 2, 3, 4, 5})

創建集合: 使用兩種方式分別創建一個集合元素.

>>> s = {"tom","cat","name","lyshark"}
>>> s = set({"tom","cat","name","lyshark"})
>>>
>>> s
{'tom', 'cat', 'name', 'lyshark'}
>>> type(s)
<class 'set'>

定義可變集合: 定義一個可變集合,集合中的元素不可重覆,都是不同的.

>>> set_test = set("hello")
>>> set_test
{'o', 'e', 'l', 'h'}

定義不可變集合: 定義一個不可變集合,集合中的元素不可重覆,都是不同的.

>>> set_test = set("hello")
>>> set_test
{'o', 'e', 'l', 'h'}
>>>
>>> no_set_test = frozenset(set_test)
>>> no_set_test
frozenset({'o', 'e', 'l', 'h'})

求子集: 子集為某個集合中一部分的集合,故亦稱部分集合.

>>> A = set('abcd')
>>> B = set("cdef")
>>> C = set("ab")
>>>
>>> C<A           #C是A的子集
True
>>> C.issubset(A) #C是A的子集
True
>>> C<B           #C不是B的子集
False

求並集: 一組集合的並集是這些集合的所有元素構成的集合,而不包含其他元素.

>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A | B
{'f', 'b', 'c', 'a', 'e', 'd'}
>>> A.union(B)
{'f', 'b', 'c', 'a', 'e', 'd'}

求交集: 兩個集合A和B的交集是含有所有既屬於A又屬於B的元素,而沒有其他元素的集合.

>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A & B
{'c', 'd'}
>>> A.intersection(B)
{'c', 'd'}

求差集: A與B的差集是,所有屬於A且不屬於B的元素構成的集合.

>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A - B
{'a', 'b'}
>>> A.difference(B)
{'a', 'b'}

對稱差: 兩個集合的對稱差是只屬於其中一個集合,而不屬於另一個集合的元素組成的集合.

>>> A
{'d', 'a', 'c', 'b'}
>>> B
{'f', 'd', 'e', 'c'}
>>>
>>> A ^ B
{'f', 'b', 'a', 'e'}
>>> A.symmetric_difference(B)
{'f', 'b', 'a', 'e'}

添加元素: 使用add()函數,向一個現有的集合添加一個元素.

>>> s = {1,2,3,4,5,6}
>>> s
{1, 2, 3, 4, 5, 6}
>>> s.add("s")
>>> s.add("e")
>>> s.add("t")
>>>
>>> s
{1, 2, 3, 4, 5, 6, 't', 's', 'e'}

清空集合: 使用clear()函數,清空一個集合中的所有元素.

>>> s
{1, 2, 3, 4, 5, 6, 't', 's', 'e'}
>>>
>>> s.clear()
>>>
>>> s
set()

刪除指定元素: 使用remove,discard函數,刪除集合中的指定元素.

>>> s = {1,2,3,4,5}
>>> s
{1, 2, 3, 4, 5}
>>>
>>> s.remove(3)
>>> s
{1, 2, 4, 5}

批量更新元素: 使用update()函數,用自己和另一個的並集來更新這個集合.

>>> s ={"p","y"}
>>> s
{'p', 'y'}
>>>
>>> s.update(["H","e"],{"1","2","3"})
>>> s
{'H', '1', 'y', 'p', '2', 'e', '3'}

2.7 序列類型

序列類型是指由索引為非負整數的有序對象集合組成的數據類型，包括字元串、列表和元組。其中字元串是由字元組成的不可變序列，列表和元組都是由任意python對象組成的序列。列表支持插入、刪除和替換元素等操作，而元組是不可變序列，對元素的操作是不支持的，但是可以嵌套包含列表和字典等可變對象進行操作。所有序列類型都支持迭代操作，可以通過for迴圈遍歷序列中的每一個元素。此外，還可以使用切片操作對序列進行分片，以獲取子序列或進行元素複製。

以下是幾個常用的序列操作函數:

您的分享是我們最大的動力!

-Advertisement-