一、元組 tuple

列表屬于可變序列，可以任意修改列表中的元素。

元組屬于不可變序列，不能修改元組中的元素。因此，元組沒有增加元素、修改元素、刪除元素相關的方法。

下面只介紹元組的創建和刪除，元組中元素的訪問和計數即可。元組支持如下操作：

• 1. 索引訪問
• 2. 切片操作
• 3. 連接操作
• 4. 成員關系操作
• 5. 比較運算操作
• 6. 計數：元組長度 len()、最大值 max()、最小值 min()、求和 sum()等。

1、元組的創建

（1） 通過()創建元組（小括號可以省略）

a = (10,20,30) 或者a = 10,20,30

注：如果元組只有一個元素，則必須后面加逗號。這是因為解釋器會把(1)解釋為整數 1，(1,)解釋為元組。

>>> a = (1) >>> type(a) <class 'int'>>>> a = (1,) #或者 a = 1, >>> type(a) <class 'tuple'>

（2） 通過 tuple()創建元組

tuple(可迭代的對象)

例如：

>>> b = tuple() #創建一個空元組對象 >>> b = tuple("abc") >>> b = tuple(range(3)) >>> b = tuple([2,3,4])

總結：

** tuple()可以接收列表、字符串、其他序列類型、迭代器等生成元組。

** list()可以接收元組、字符串、其他序列類型、迭代器等生成列表。

2、元組的元素訪問和計數

（1）元組的元素不能修改

>>> a = (20,10,30,9,8) >>> a[3]=33 Traceback (most recent call last): File "<pyshell#313>", line 1, in <module> a[3]=33 TypeError: 'tuple' object does not support item assignment

（2）元組的元素訪問和列表一樣，只不過返回的仍然是元組對象

>>> a = (20,10,30,9,8) >>> a[1] 10>>> a[1:3] (10, 30)>>> a[:4] (20, 10, 30, 9)

（3）列表關于排序的方法 list.sorted()是修改原列表對象，元組沒有該方法。如果要對元組排序，只能使用內置函數 sorted(tupleObj)，并生成新的列表對象。

>>> a = (20,10,30,9,8) >>> sorted(a) [8, 9, 10, 20, 30]

（4）元組的計數用len()函數

3、zip

zip(列表 1，列表 2，...)將多個列表對應位置的元素組合成為元組，并返回這個 zip 對象。

>>> a = [10,20,30] >>> b = [40,50,60] >>> c = [70,80,90] >>> d = zip(a,b,c) >>> list(d) [(10, 40, 70), (20, 50, 80), (30, 60, 90)]

4、生成器推導式創建元組

從形式上看，生成器推導式與列表推導式類似，只是生成器推導式使用小括號。列表推導式直接生成列表對象，生成器推導式生成的不是列表也不是元組，而是一個生成器對象。

通過生成器對象，轉化成列表或者元組。也可以使用生成器對象的__next__()方法進行遍歷，或者直接作為迭代器對象來使用。不管什么方式使用，元素訪問結束后，如果需要重新訪問其中的元素，必須重新創建該生成器對象。

【操作】生成器的使用測試

>>> s = (x*2 for x in range(5)) >>> s <generator object <genexpr> at 0x0000000002BDEB48> >>> tuple(s) (0, 2, 4, 6, 8)>>> list(s) #只能訪問一次元素，第二次就為空了，需要再生成一次 []>>> s <generator object <genexpr> at 0x0000000002BDEB48> >>> tuple(s) ()>>> s = (x*2 for x in range(5)) >>> s.__next__() 0>>> s.__next__() 2>>> s.__next__() 4

元組總結

*1. 元組的核心特點是：不可變序列。

*2. 元組的訪問和處理速度比列表快。

*3. 與整數和字符串一樣，元組可以作為字典的鍵，列表則永遠不能作為字典的鍵使用。

二、字典

字典是“鍵值對”的無序可變序列，字典中的每個元素都是一個“鍵值對”，包含：“鍵對象”和“值對象”。可以通過“鍵對象”實現快速獲取、刪除、更新對應的“值對象”。列表中通過“下標數字”找到對應的對象。字典中通過“鍵對象”找到對應的“值對象”。“鍵”是任意的不可變數據，比如：整數、浮點數、字符串、元組。但是：列表、字典、集合這些可變對象，不能作為“鍵”。并且“鍵”不可重復。“值”可以是任意的數據，并且可重復。

一個典型的字典的定義方式：

a = {'name':'xiaoxin','age':18,'job':'student'}

1、字典的創建

（1）通過{}、dict()來創建字典對象

>>> a = {'name':'xiaoxin','age':18,'job':'student'} >>> b = dict(name='xiaoxin',age=18,job='student') >>> a = dict([("name","xiaoxin"),("age",18)]) >>> c = {} #空的字典對象 >>> d = dict() #空的字典對象

（2）通過 zip()創建字典對象

>>> k = ['name','age','job'] >>> v = ['xiaoxin',18,'student'] >>> d = dict(zip(k,v)) >>> d {'name': 'xiaoxin', 'age': 18, 'job': 'student'}

（3） 通過 fromkeys 創建值為空的字典

>>> a = dict.fromkeys(['name','age','job']) >>> a {'name': None, 'age': None, 'job': None}

2、字典元素的訪問

為了測試各種訪問方法，先設定一個字典對象：

a = {'name':'xiaoxin','age':18,'job':'student'}

（1）通過 [鍵] 獲得“值”,若鍵不存在，則拋出異常

>>> a = {'name':'xiaoxin','age':18,'job':'student'} >>> a['name'] 'xiaoxin' >>> a['age'] 18 >>> a['sex'] Traceback (most recent call last): File "<pyshell#374>", line 1, in <module> a['sex'] KeyError: 'sex'

（2） 通過 get()方法獲得“值”，推薦使用。

優點是：指定鍵不存在，返回 None；也可以設定指定鍵不存在時默認返回的對象。

>>> a.get('name') 'xiaoxin'>>> a.get('sex') >>> a.get('sex','一個男人') '一個男人'

（3）列出所有的鍵值對

>>> a.items() dict_items([('name', 'xiaoxin'), ('age', 18), ('job', 'student')])

（4）列出所有的鍵，列出所有的值

>>> a.keys() dict_keys(['name', 'age', 'job']) >>> a.values() dict_values(['gaoqi', 18, 'programmer'])

（5） len() 鍵值對的個數

（6） 檢測一個“鍵”是否在字典中

>>> a = {"name":"gaoqi","age":18} >>> "name" in a True

3、字典元素添加、修改、刪除

（1） 給字典新增“鍵值對”。如果“鍵”已經存在，則覆蓋舊的鍵值對；如果“鍵”不存在，則新增“鍵值對”。

>>>a = {'name':'xiaoxin','age':18,'job':'student'} >>> a['address']='北京' >>> a['age']=16 >>> a {'name': 'xiaoxin', 'age': 16, 'job': 'student', 'address': '北京'}

（2）使用 update()將新字典中所有鍵值對全部添加到舊字典對象上。如果 key 有重復，則直接覆蓋。

>>> a = {'name':'xiaoxin','age':18,'job':'student'} >>> b = {'name':'xiaoguo','money':1000,'sex':'女的'} >>> a.update(b) >>> a {'name': 'xiaoguo', 'age': 18, 'job': 'student', 'money': 1000, 'sex': '女的'}

（3）字典中元素的刪除，可以使用 del()方法；或者 clear()刪除所有鍵值對；pop()刪除指定鍵值對，并返回對應的“值對象”。

>>> a = {'name':'xiaoxin','age':18,'job':'student'} >>> del(a['name']) >>> a {'age': 18, 'job': 'student'} >>> b = a.pop('age') >>> b 18

（4） popitem() ：隨機刪除和返回該鍵值對。字典是“無序可變序列”，因此沒有第一個元素、最后一個元素的概念；popitem 彈出隨機的項，若想一個接一個地移除并處理項，這個方法就非常有效（因為不用首先獲取鍵的列表）。

>>> a = {'name':'xiaoxin','age':18,'job':'student'} >>> a.popitem() ('job', 'student') >>> a {'name': 'xiaoxin', 'age': 18} >>> a.popitem() ('age', 18) >>> a {'name': 'xiaoxin'}

4、序列解包

序列解包可以用于元組、列表、字典。序列解包可以方便的對多個變量賦值。

>>> x,y,z=(20,30,10) >>> x 20>>> y 30>>> z 10>>> (a,b,c)=(9,8,10) >>> a 9>>> [a,b,c]=[10,20,30] >>> a 10>>> b 20

序列解包用于字典時，默認是對“鍵”進行操作； 如果需要對鍵值對操作，則需要使用items()；如果需要對“值”進行操作，則需要使用 values()；

>>> s = {'name':'xiaoxin','age':18,'job':'student'} >>> name,age,job=s #默認對鍵進行操作 >>> name 'name' >>> name,age,job=s.items() #對鍵值對進行操作 >>> name ('name', 'xiaoxin') >>> name,age,job=s.values() #對值進行操作 >>> name 'xiaoxin'

5、表格數據使用字典和列表存儲，并實現訪問

源代碼：

r1 = {"name":"高小一","age":18,"salary":30000,"city":"北京"} r2 = {"name":"高小二","age":19,"salary":20000,"city":"上海"} r3 = {"name":"高小五","age":20,"salary":10000,"city":"深圳"} tb = [r1,r2,r3]#獲得第二行的人的薪資 print(tb[1].get("salary")) #打印表中所有的的薪資for i in range(len(tb)): # i -->0,1,2 print(tb[i].get("salary"))#打印表的所有數據 for i in range(len(tb)): print(tb[i].get("name"),tb[i].get("age"),tb[i].get("salary"),tb[i].get("city"))

三、字典核心底層原理(重要)

字典對象的核心是散列表。

散列表是一個稀疏數組（總是有空白元素的數組），數組的每個單元叫做 bucket。每個 bucket 有兩部分：一個是鍵對象的引用，一個是值對象的引用。

由于，所有 bucket 結構和大小一致，我們可以通過偏移量來讀取指定 bucket。

1、將一個鍵值對放進字典的底層過程

>>> a = {} >>> a["name"]="xiaoxin"

假設字典 a 對象創建完后，數組長度為 8：

我們要把"name”="xiaoxin”這個鍵值對放到字典對象 a 中，首先第一步需要計算鍵”name”的散列值。Python 中可以通過 hash()來計算。

>>> bin(hash("name")) '-0b1010111101001110110101100100101'

由于數組長度為 8，我們可以拿計算出的散列值的最右邊 3 位數字作為偏移量，即“101”，十進制是數字 5。我們查看偏移量 5，對應的 bucket 是否為空。如果為空，則將鍵值對放進去。如果不為空，則依次取右邊 3 位作為偏移量，即“100”，十進制是數字4。再查看偏移量為 4 的 bucket 是否為空。直到找到為空的 bucket 將鍵值對放進去。流程圖如下：

2、擴容

python 會根據散列表的擁擠程度擴容。

“擴容”指的是:創造更大的數組，將原有內容拷貝到新數組中。

接近 2/3 時，數組就會擴容。

根據鍵查找“鍵值對”的底層過程，一個鍵值對是如何存儲到數組中的，根據鍵對象取到值對象，理解起來就簡單了。

>>> a.get("name") 'xiaoxin'

當我們調用 a.get(“name”)，就是根據鍵“name”查找到“鍵值對”，從而找到值

對象“xiaoxin”。

第一步，仍然要計算“name”對象的散列值：

>>> bin(hash("name")) '-0b1010111101001110110101100100101'

和存儲的底層流程算法一致，也是依次取散列值的不同位置的數字。 假設數組長度為8，可拿計算出的散列值的最右邊 3 位數字作為偏移量，即“101”，十進制是數字5。查看偏移量5，對應的 bucket 是否為空。如果為空，則返回 None。如果不為空，則將這個 bucket 的鍵對象計算對應散列值和之前的散列值進行比較，如果相等。則將對應“值對象”返回。如果不相等，則再依次取其他幾位數字，重新計算偏移量。依次取完后，仍沒有找到。則返回 None。流程圖如下：

3、用法總結：

（1）鍵必須可散列

(1) 數字、字符串、元組，都是可散列的。

(2) 自定義對象需要支持下面三點：

• 1 支持 hash()函數
• 2 支持通過__eq__()方法檢測相等性
• 3 若 a==b 為真，則 hash(a)==hash(b)也為真

（2）字典在內存中開銷巨大，典型的空間換時間

（3）鍵查詢速度很快

（4）往字典里面添加新建可能導致擴容，導致散列表中鍵的次序變化。因此，不要在遍歷字

典的同時進行字典的修改。

四、集合

集合是無序可變，元素不能重復。實際上，集合底層是字典實現，集合的所有元素都是字典

中的“鍵對象”，因此是不能重復的且唯一的。

1、集合創建和刪除

（1） 使用{}創建集合對象，并使用 add()方法添加元素

>>> a = {3,5,7} >>> a {3, 5, 7} >>> a.add(9) >>> a {9, 3, 5, 7}

（2） 使用 set()，將列表、元組等可迭代對象轉成集合。如果原來數據存在重復數據，則只保留一個。

>>> a = ['a','b','c','b'] >>> b = set(a) >>> b {'b', 'a', 'c'}

（3）remove()刪除指定元素；clear()清空整個集合

>>> a = {10,20,30,40,50} >>> a.remove(20) >>> a {10, 50, 30}

2、集合相關操作

像數學中概念一樣，Python 對集合也提供了并集、交集、差集等運算。

示例：

>>> a = {1,3,'xin'} >>> b = {'he','it','xin'} >>> a|b #并集 {1, 3, 'xin', 'he', 'it'} >>> a&b #交集 {'xin'} >>> a-b #差集 {1, 3} >>> a.union(b) #并集 {1, 3, 'xin', 'he', 'it'} >>> a.intersection(b) #交集 {'xin'} >>> a.difference(b) #差集 {1, 3}

總結

以上是生活随笔為你收集整理的字典删除多个键值对方法_Life is short，you need Python——Python序列（元组、字典、集合）...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。