2. 程式人生 > >python資料結構之字典方法

python資料結構之字典方法

阿新 • • 發佈：2018-12-21

字典是一種通過名字或者關鍵字引用的得資料結構，其鍵可以是數字、字串、元組，這種結構型別也稱之為對映。字典型別是Python中唯一內建的對映型別，基本的操作包括如下： 
(1)len()：返回字典中鍵—值對的數量； 
(2)d[k]:返回關鍵字對於的值； 
(3)d[k]=v:將值關聯到鍵值k上； 
(4)del d[k]:刪除鍵值為k的項； 
(5)key in d:鍵值key是否在d中，是返回True，否則返回False。

一、字典的建立 
1.1 直接建立字典

 

  1. d={'one':1,'two':2,'three':3}

  2. print d

  3. print d['two']

  4. print d['three']

  5. 運算結果：

  6. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  7. {'three': 3, 'two': 2, 'one': 1}

  8. 2

  9. 3

  10. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

1.2 通過dict建立字典

 

  1. # _*_ coding:utf-8 _*_

  2. items=[('one',1),('two',2),('three',3),('four',4)]

  3. print u'items中的內容:'

  4. print items

  5. print u'利用dict建立字典，輸出字典內容:'

  6. d=dict(items)

  7. print d

  8. print u'查詢字典中的內容:'

  9. print d['one']

  10. print d['three']

  11. 運算結果：

  12. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  13. items中的內容:

  14. [('one', 1), ('two', 2), ('three', 3), ('four', 4)]

  15. 利用dict建立字典，輸出字典內容:

  16. {'four': 4, 'three': 3, 'two': 2, 'one': 1}

  17. 查詢字典中的內容:

  18. 1

  19. 3

  20. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

或者通過關鍵字建立字典

 

  1. # _*_ coding:utf-8 _*_

  2. d=dict(one=1,two=2,three=3)

  3. print u'輸出字典內容:'

  4. print d

  5. print u'查詢字典中的內容:'

  6. print d['one']

  7. print d['three']

  8. 運算結果：

  9. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  10. 輸出字典內容:

  11. {'three': 3, 'two': 2, 'one': 1}

  12. 查詢字典中的內容:

  13. 1

  14. 3

  15. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

二、字典的格式化字串

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3,'four':4}

  3. print d

  4. print "three is %(three)s." %d

  5. 運算結果：

  6. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  7. {'four': 4, 'three': 3, 'two': 2, 'one': 1}

  8. three is 3.

  9. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

三、字典方法 
3.1 clear函式：清除字典中的所有項

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3,'four':4}

  3. print d

  4. d.clear()

  5. print d

  6. 運算結果：

  7. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  8. {'four': 4, 'three': 3, 'two': 2, 'one': 1}

  9. {}

  10. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

請看下面兩個例子 
3.1.1

 

  1. # _*_ coding:utf-8 _*_

  2. d={}

  3. dd=d

  4. d['one']=1

  5. d['two']=2

  6. print dd

  7. d={}

  8. print d

  9. print dd

  10. 運算結果：

  11. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  12. {'two': 2, 'one': 1}

  13. {}

  14. {'two': 2, 'one': 1}

  15. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

3.1.2

 

  1. # _*_ coding:utf-8 _*_

  2. d={}

  3. dd=d

  4. d['one']=1

  5. d['two']=2

  6. print dd

  7. d.clear()

  8. print d

  9. print dd

  10. 運算結果：

  11. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  12. {'two': 2, 'one': 1}

  13. {}

  14. {}

  15. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

3.1.2與3.1.1唯一不同的是在對字典d的清空處理上，3.1.1將d關聯到一個新的空字典上，這種方式對字典dd是沒有影響的，所以在字典d被置空後，字典dd裡面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內容，clear是一個原地操作的方法，使得d中的內容全部被置空，這樣dd所指向的空間也被置空。 
3.2 copy函式：返回一個具有相同鍵值的新字典

 

  1. # _*_ coding:utf-8 _*_

  2. x={'one':1,'two':2,'three':3,'test':['a','b','c']}

  3. print u'初始X字典：'

  4. print x

  5. print u'X複製到Y：'

  6. y=x.copy()

  7. print u'Y字典：'

  8. print y

  9. y['three']=33

  10. print u'修改Y中的值，觀察輸出：'

  11. print y

  12. print x

  13. print u'刪除Y中的值，觀察輸出'

  14. y['test'].remove('c')

  15. print y

  16. print x

  17. 運算結果：

  18. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  19. 初始X字典：

  20. {'test': ['a', 'b', 'c'], 'three': 3, 'two': 2, 'one': 1}

  21. X複製到Y：

  22. Y字典：

  23. {'test': ['a', 'b', 'c'], 'one': 1, 'three': 3, 'two': 2}

  24. 修改Y中的值，觀察輸出：

  25. {'test': ['a', 'b', 'c'], 'one': 1, 'three': 33, 'two': 2}

  26. {'test': ['a', 'b', 'c'], 'three': 3, 'two': 2, 'one': 1}

  27. 刪除Y中的值，觀察輸出

  28. {'test': ['a', 'b'], 'one': 1, 'three': 33, 'two': 2}

  29. {'test': ['a', 'b'], 'three': 3, 'two': 2, 'one': 1}

  30. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

注：在複製的副本中對值進行替換後，對原來的字典不產生影響，但是如果修改了副本，原始的字典也會被修改。deepcopy函式使用深複製，複製其包含所有的值，這個方法可以解決由於副本修改而使原始字典也變化的問題。

 

  1. # _*_ coding:utf-8 _*_

  2. from copy import deepcopy

  3. x={}

  4. x['test']=['a','b','c','d']

  5. y=x.copy()

  6. z=deepcopy(x)

  7. print u'輸出：'

  8. print y

  9. print z

  10. print u'修改後輸出：'

  11. x['test'].append('e')

  12. print y

  13. print z

  14. 運算輸出：

  15. 輸出：

  16. {'test': ['a', 'b', 'c', 'd']}

  17. {'test': ['a', 'b', 'c', 'd']}

  18. 修改後輸出：

  19. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  20. {'test': ['a', 'b', 'c', 'd', 'e']}

  21. {'test': ['a', 'b', 'c', 'd']}

  22. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

3.3 fromkeys函式：使用給定的鍵建立新的字典，鍵預設對應的值為None

 

  1. # _*_ coding:utf-8 _*_

  2. d=dict.fromkeys(['one','two','three'])

  3. print d

  4. 運算輸出：

  5. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  6. {'three': None, 'two': None, 'one': None}

  7. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

或者指定預設的對應值

 

  1. # _*_ coding:utf-8 _*_

  2. d=dict.fromkeys(['one','two','three'],'unknow')

  3. print d

  4. 運算結果：

  5. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  6. {'three': 'unknow', 'two': 'unknow', 'one': 'unknow'}

  7. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

3.4 get函式：訪問字典成員

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. print d.get('one')

  5. print d.get('four')

  6. 運算結果：

  7. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  8. {'three': 3, 'two': 2, 'one': 1}

  9. 1

  10. None

  11. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

注：get函式可以訪問字典中不存在的鍵，當該鍵不存在是返回None 
3.5 has_key函式：檢查字典中是否含有給出的鍵

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. print d.has_key('one')

  5. print d.has_key('four')

  6. 運算結果：

  7. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  8. {'three': 3, 'two': 2, 'one': 1}

  9. True

  10. False

  11. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

3.6 items和iteritems函式:items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器物件而不是列表

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. list=d.items()

  5. for key,value in list:

  6. print key,':',value

  7. 運算結果：

  8. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  9. {'three': 3, 'two': 2, 'one': 1}

  10. three : 3

  11. two : 2

  12. one : 1

  13. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. it=d.iteritems()

  5. for k,v in it:

  6. print "d[%s]="%k,v

  7. 運算結果：

  8. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  9. {'three': 3, 'two': 2, 'one': 1}

  10. d[three]= 3

  11. d[two]= 2

  12. d[one]= 1

  13. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

3.7 keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. print u'keys方法：'

  5. list=d.keys()

  6. print list

  7. print u'\niterkeys方法：'

  8. it=d.iterkeys()

  9. for x in it:

  10. print x

  11. 運算結果：

  12. {'three': 3, 'two': 2, 'one': 1}

  13. keys方法：

  14. ['three', 'two', 'one']

  15.  

  16. iterkeys方法：

  17. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  18. three

  19. two

  20. one

  21. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

3.8 pop函式：刪除字典中對應的鍵

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. d.pop('one')

  5. print d

  6. 運算結果：

  7. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  8. {'three': 3, 'two': 2, 'one': 1}

  9. {'three': 3, 'two': 2}

  10. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

3.9 popitem函式：移出字典中的項

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. d.popitem()

  5. print d

  6. 運算結果：

  7. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  8. {'three': 3, 'two': 2, 'one': 1}

  9. {'two': 2, 'one': 1}

  10. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

3.10 setdefault函式：類似於get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值

 

  1. # _*_ coding:utf-8 _*_

  2. d={'one':1,'two':2,'three':3}

  3. print d

  4. print d.setdefault('one',1)

  5. print d.setdefault('four',4)

  6. print d

  7. 運算結果：

  8. {'three': 3, 'two': 2, 'one': 1}

  9. 1

  10. 4

  11. {'four': 4, 'three': 3, 'two': 2, 'one': 1}

  12. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

3.11 update函式：用一個字典更新另外一個字典

 

  1. # _*_ coding:utf-8 _*_

  2. d={

  3. 'one':123,

  4. 'two':2,

  5. 'three':3

  6. }

  7. print d

  8. x={'one':1}

  9. d.update(x)

  10. print d

  11. 運算結果：

  12. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  13. {'three': 3, 'two': 2, 'one': 123}

  14. {'three': 3, 'two': 2, 'one': 1}

  15. >>>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

3.12 values和itervalues函式：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由於在字典中值不是唯一的，所以列表中可以包含重複的元素

 

  1. # _*_ coding:utf-8 _*_

  2. d={

  3. 'one':123,

  4. 'two':2,

  5. 'three':3,

  6. 'test':2

  7. }

  8. print d.values()

  9. 運算結果：

  10. =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

  11. [2, 3, 2, 123]

  12. >>>

相關推薦

python資料結構之字典方法

字典是一種通過名字或者關鍵字引用的得資料結構，其鍵可以是數字、字串、元組，這種結構型別也稱之為對映。字典型別是Python中唯一內建的對映型別，基本的操作包括如下：  (1)len()：返回字典中鍵—值對的數量；  (2)d[k]:返回關鍵字對於的值；  (3)d[k]

python資料結構之字串方法

1.capitalize():將字串中首字母轉換成大寫，其餘字元轉換成小寫 Str="this is string example from runoob ...wow!!!" print("Str.capitalize():",Str.capitalize())#該方法返回一個首字母大寫的字串

python資料型別之字典(dict)和其常用方法

字典的特徵： key-value結構key必須可hash,且必須為不可變資料型別、必須唯一。 # hash值都是數字，可以用類似於2分法(但比2分法厲害的多的方法）找。可存放任意多個值、可修改、可以不唯一無序查詢速度快常用方法： info = {'stu01': 'alex', 'stu02':

python資料結構之列表、字典、元組、集合

列表 列表在python裡是有序集合物件型別。列表裡的物件可以是任何物件：數字，字串，列表或者字典，元組。與字串不同，列表是可變物件，支援原處修改的操作python的列表是： 任意物件的有序集合 通過偏移讀取 可變長度、異構以及任意巢狀 屬於可變序列的分組 物件引用陣列 列表的

Python資料結構之二叉樹（涵蓋了構建、刪除、查詢、字典轉換、非遞迴與遞迴遍歷等）

MyTree.py #coding=utf-8 import math class BinTree: def __init__(self): self.root=None def is_empty(self):

redis 系列6 資料結構之字典(下)

一.概述 　　接著上篇繼續，這篇把資料結構之字典學習完， 這篇知識點包括：雜湊演算法，解決鍵衝突， rehash , 漸進式rehash,字典API。 　　1.1 雜湊演算法 　　　　當一個新的鍵值對 需要新增到字典裡面時，程式需要先根據“鍵值對”的鍵計算出雜湊值和索引值，再根據索引值，將包含新“鍵值對

Python資料結構之: 棧與佇列

棧(stacks) 是一種只能通過訪問其一端來實現資料儲存與檢索的線性資料結構，具有後進先出(last in first out，LIFO)的特徵 stack = [] stack.append("A") #A入棧 stack.append("B") #B入棧 st

python資料結構之KMP演算法的實現

我相信網上已經有很多關於KMP演算法的講解，大致都是關於部分匹配表的實現思路和作用，還有就是目標串的下標不變，僅改變模式串的下標來進行匹配，確實用KMP演算法，當目標串很大模式串很小時，其效率很高的，但都是相對而言。至於對於部分匹配表的作用以及實現思路，建議看一下這篇文章寫的是比較易懂的

redis 系列5 資料結構之字典(上)

原文: redis 系列5 資料結構之字典(上) 一. 概述 　　字典又稱符號表(symbol table),關聯陣列(associative array), 對映(map)，是一種用於儲存鍵值對(key-value pair)的抽象資料結構。在字典中，一個key和一個value進行關聯稱為鍵值對。在字典

python資料結構之二叉樹

這裡用python 實現了二叉樹 # Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left =

資料結構之字典

JavaScript實現字典 字典資料結構 建立字典 1. 連結串列資料結構 在電腦科學中，關聯陣列（英語：Associative Array），又稱對映（Map）、字典（Dictionary）是

python資料結構之串——概述和基本演算法

概述： 字串（string）簡稱串，也是一種線性結構。在python中和array差不多，因為py的陣列也可以包括各種字元（在C/Java一類的語法中，陣列必須是同一種資料型別的元素）。線性結構，有限序列，是主要特點。串其中可以包含各種元素，也是計算機主要處理的一類物件。因

Cris 複習Python日記（四）：Python 資料結構之序列和列表

1. 簡單認識序列和列表 # 序列 # 序列是Python 中最基本的資料結構，用於儲存一組有序的資料，所有資料都在序列中擁有一個唯一索引，並且按照元素新增的順序來指定序列 # 序列的分類 # 1.

python資料結構之棧和佇列

1.功能實現 之前文章有，可以點開看看 棧 佇列 2.應用(1)括號匹配及字尾表示式 class Solution(object): def isValid(self, s): """ :type s: str :rtype

python資料結構之連結串列

1.功能實現 連結串列（Linked list）是一種常見的基礎資料結構，是一種線性表，但是並不會按線性的順序儲存資料，而是在每一個節點裡存到下一個節點的指標(Pointer)。由於不必須按順序儲存，連結串列在插入的時候可以達到O(1)的複雜度，比另一種線性表順序錶快得多，但是查詢一個節點或者訪

python 資料結構之列表操作

lt = [1, 2, 3, 4, 5] #列表取值與切片 #切片規則與字串相同 print(lt[0])#1 print(lt[-1])#5 print(lt[1:3])#[2, 3] print(len(lt))#列表長度5 # 修改元素 lt[0] = 100 print(lt)#[100,

python資料結構之字串格式化

字串格式化： 1.簡單運用 字串型別格式化採用format()方法，基本使用格式是：      <模板字串>.format(<逗號分隔的引數>) 呼叫format()方法後會返回一個新的字串，引數從0 開始編號

python資料結構之列表、元組

（與字串和元組的區別）列表是可變的----------可以改變列表的內容，並且列表中含有很多有用的專門的方法。 list函式： 可以將字串建立成列表 程式碼： a=list('Hello') print(a) 輸出： ['H', 'e', 'l', 'l', 'o'] 基本的

python資料結構之序列及其操作

序列       在Python中最基本的資料結構是序列（sequence）。序列中的每個元素被分配一個序號----即元素的位置，也稱索引。索引從0開始，0,1,2,3，...。也可以從最後一個數開始，標記為-1，依次為-1，-2，-3.... 列表與元組的區別

python資料結構之深淺拷貝

Python中深淺拷貝詳解 變數-引用-物件（可變物件，不可變物件）-切片-拷貝（淺拷貝，深拷貝） 變數：在Python中一切都是物件，比如：3,3.14，“Hello world”，【1,2,3,4】，{‘a’:1}…. 輸出： 甚至連Type其本身也是物件，type物