Python之字典

字典：無序的，可變的鍵值對集合，字典是另外一種可變容器模型，且可存儲任意類型對象
字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示：

# d = {key1 : value1, key2 : value2 }
# 鍵必須是惟一的，但值則沒必要。
# 值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。

1 info = {"name": "cq", "age": 18, "class": "first"} 2 print(info, type(info)) 3 print(info['name']) 4 print(info['age'])

輸出結果:

{'name': 'cq', 'age': 18, 'class': 'first'} <class 'dict'>
cq
18

# 方式2
# Python 字典 fromkeys() 函數用於建立一個新字典，以序列 seq 中元素作字典的鍵，value 爲字典全部鍵對應的初始值。
# fromkeys()方法語法：
# dict.fromkeys(seq[, value])

# 參數：
# seq -- 字典鍵值列表。
# value -- 可選參數, 設置鍵序列（seq）的值。

# 返回值：
# 該方法返回一個新字典
# fromkeys:是一個靜態方法，類和對象均可以調用

1 seq = ("name", "age", "class") 2 dic = dict.fromkeys(seq) 3 print("新字典爲:: ", dic) 4 
5 dic = dict.fromkeys(seq, 10) 6 print("新的字典爲:: ", dic) 7 
8 dic = dict.fromkeys([1, 2, 3], 20) 9 print("新的字典:: ", dic)

輸出結果：

新字典爲:: {'name': None, 'age': None, 'class': None}
新的字典爲:: {'name': 10, 'age': 10, 'class': 10}
新的字典:: {1: 20, 2: 20, 3: 20}

 # 字典定義的注意事項

1：key不能被重複 若是重複了，後值會把前值覆蓋掉 

1 dic = {1: "a", 2: "b", 1: "c"}
2 print(dic)

輸出結果:
{1: 'c', 2: 'b'}

  2：key必須是任意不可變類型

 

Python字典的實現原理

 

# 字典類型是Python中最經常使用的數據類型之一，它是一個鍵值對的集合，字典經過鍵來索引，關聯到相對的值
# 理論上它的複雜度是O(1)
# 那麼dict的內部實現原理是什麼呢？
# 在Python中，字典是經過哈希表實現的。
# 哈希表(hash tables)也叫散列表，根據關鍵值對(Key-value)而直接進行訪問的數據結構。它經過把key和value
# 映射到表中的一個位置來訪問記錄，這種查詢速度很是快，更新也快。而這個映射函數叫作哈希函數，存放值的數組叫作
# 哈希表，哈希函數的實現方式決定了哈希表的搜索效率，具體實現過程是：
# 1：數據添加：把key經過哈希函數轉換成一個整型數字，而後就將這個整型數字對數組長度進行取餘，取餘結果就當作數組
# 的下標，將value存儲在以該數字爲下標的數組空間裏

# 2：數據查詢：再次使用哈希函數將key轉換爲對應的數組下標，並定位到數組的位置獲取value

# 可是,對key進行hash的時候,不一樣的key可能hash出來的結果是同樣的,尤爲是數據量增多的時候這個問題叫作哈希衝突
# 若是解決這種衝突狀況呢?一般的作法有兩種,一種是連接法,另外一種是開放尋址法,Python選擇後者

# 開放尋址法中,全部的元素都存放在散列表中,當產生哈希衝忽然時,經過一個探測函數計算出下一個候選位置,若是下一個獲選
# 位置仍是有衝突,那麼不斷的經過探測函數往下找,直到找到一個空槽來存放插入元素


字典的經常使用操做

# 增長操做
# dict[key] = value
#   當key在原字典中不存在的時候，即爲新增操做

1 dic = {"name": "xq", "age": 18} 2 print(dic, id(dic)) 3 
4 dic["height"] = 180
5 print(dic, id(dic))

輸出結果：

{'name': 'xq', 'age': 18} 31652432
{'name': 'xq', 'age': 18, 'height': 180} 31652432

# 刪除操做
# del dic[key]
# key必須存在，不然就會報一個keyerror的一個錯誤

1 dic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} 2 # 刪除單個元素
3 del dic['Name'] 4 print("刪除Name關鍵字:: ", dic) 5 
6 # 刪除字典
7 del dic 8 # print(dic) 此時再打印訪問字典就會報錯，dic is not defined

輸出結果：
刪除Name關鍵字::  {'Age': 7, 'Class': 'First'}

# 字典clear()方法
# clear()是清空字典內的全部元素的，返回值爲None
# 注意：字典自己還存在，只是字典裏的內容被清空，注意和del的區別

1 dic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} 2 returnValue = dic.clear() 3 print("returnValue:: ", returnValue)

輸出結果：

returnValue::  None

 # 字典的clear()有什麼特色呢？

1 dic = {"name": "xq", "sex": "female", "age": 18} 2 dic1 = dic 3 dic.clear() 4 print("dic:: ", dic) 5 print("dic1:: ", dic1) 6 # 能夠發現當原字典dic被引用時，想清空原字典中的元素，用clear()方法，dic1字典中的元素也同時被清除了。

輸出結果：

dic:: {}
dic1:: {}

# 字典pop()方法 dic.pop(key[, default])
# 移除字典數據pop()方法的做用是：刪除指定給定鍵所對應的值，返回這個值並從字典中把它移除。
# 注意字典pop()方法與列表pop()方法做用徹底不一樣。

1 dic = {"a": 1, "b": 2} 2 result = dic.pop("a") 3 print("result:: ", result) 4 print("dic:: ", dic) 5 # 若是給定的key不存在，則返回給定的默認值，若是沒有給定默認值，則報錯
6 dic = {"a": 1, "b": 2} 7 result = dic.pop("a1", 666) 8 print("result:: ", result) 9 # dic.pop("a1") 會報錯

輸出結果：

result:: 1
dic:: {'b': 2}
result:: 666

# 字典popitem()方法
# Python 字典 popitem() 方法隨機返回並刪除字典中的一對鍵和值(通常刪除末尾對)。
# 若是字典已經爲空，卻調用了此方法，就報出KeyError異常。

1 dic = {"name": "xq", "sex": "female", "age": 18} 2 result = dic.popitem() 3 print("result:: ", result) 4 print("dic:: ", dic)

輸出結果：

result:: ('age', 18)
dic:: {'name': 'xq', 'sex': 'female'}

# 字典修改操做
# 只能修改值，而不能修改key
# 修改單個鍵值對：
# dic[key] = value
# 直接設置，若是key不存在，則新增，若是存在，則修改

1 dic = {"name": "xq", "age": 18} 2 dic["age"] = 21
3 print("修改後的字典爲:: ", dic)

輸出結果：
修改後的字典爲::  {'name': 'xq', 'age': 21}

# 批量修改鍵值對
# oldDic.update(newDic)
# 根據新的字典，批量更新舊字典中的鍵值對
# 若是舊字典中沒有對應的key值，則新增鍵值對

1 oldDic = {"name": "xq", "age": 18} 2 newDic = {"age": 21, "address": "beijing"} 3 oldDic.update(newDic) 4 print("更新後字典爲:: ", oldDic)

輸出結果：

更新後字典爲::  {'name': 'xq', 'age': 21, 'address': 'beijing'}

# 字典的查找操做
# 1:獲取單個值的狀況
# 方式1: dic[key]
# 若是key不存在則會報錯

dic = {"name": "xq", "age": 18}
print(dic["age"])

# 方式2:
# dict.get(key, default=None)
# 參數:
# key -- 字典中要查找的鍵。
# default -- 若是指定鍵的值不存在時，返回該默認值值。

# Python 字典 get() 函數返回指定鍵的值，若是值不在字典中返回默認值

1 dic = {"name": "xq", "age": 18, "address": "beijing"} 2 v = dic.get("age") 3 print("v的返回值:: ", v) 4 result = dic.get("class", 666) 5 print(result, dic)

輸出結果：

v的返回值:: 18
666 {'name': 'xq', 'age': 18, 'address': 'beijing'}

# 方式3:
# dict.setdefault(key, default=None)
# 參數:
# key -- 查找的鍵值。
# default -- 鍵不存在時，設置的默認鍵值。

# Python 字典 setdefault() 方法和get()方法相似, 若是鍵不存在於字典中，將會添加鍵並將值設爲默認值。

1 dic = {"name": "xq", "age": 18, "address": "beijing"} 2 res = dic.setdefault("age") 3 print("res的返回值:: ", res) 4 result = dic.setdefault("class", 666) 5 print(result, dic)

輸出結果：

res的返回值:: 18
666 {'name': 'xq', 'age': 18, 'address': 'beijing', 'class': 666}

# 查詢全部的值
# 查詢全部的鍵
# 查詢全部的鍵值對

# Python 字典 values() 方法返回一個迭代器，可使用 list() 來轉換爲列表，列表爲字典中的全部值。
# 注意：Python2.x 是直接返回列表
# 語法
# dict.values()

# 返回值:
# 返回迭代器。

1 dic = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'} 2 print("字典全部值爲::", list(dic.values()))

輸出結果：字典全部值爲:: ['female', 7, 'Zara']

# Python3 字典 keys() 方法返回一個迭代器，可使用 list() 來轉換爲列表。
# 注意：Python2.x 是直接返回列表

# keys()方法語法：
# dict.keys()

# 返回值：
# 返回一個迭代器

1 dic = {"name": "xq", "age": 18, "address": "beijing"} 2 print("字典全部的key值:: ", list(dic.keys()))

輸出結果爲：字典全部的key值::  ['name', 'age', 'address']

# Python 字典 items() 方法以列表返回可遍歷的(鍵, 值) 元組數組。
# 注意：Python2.x 是直接返回列表
# items()方法語法：
# dict.items()

# 返回值:
# 返回可遍歷的(鍵, 值) 元組數組

1 dic = {"name": "xq", "age": 18, "address": "beijing"} 2 print("字典的全部鍵值對:: ", dic.items()) 3 
4 for i, j in dic.items(): 5     print(i, "\t:", j)

輸出結果：

字典的全部鍵值對:: dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing')])
name : xq
age : 18
address : beijing

# 另外，這幾個函數，Python2.x與Python3.x是有必定區別的，請看代碼

Python2.x版本下

 1 dic = {"name": "xq", "age": 18, "address": "beijing"}  2 
 3 # 獲取全部的值
 4 vs = dic.values()  5 
 6 # 獲取全部的key值
 7 ks = dic.keys()  8 
 9 # 獲取全部的鍵值對
10 its = dic.items() 11 
12 print(dic) 13 print(vs) 14 print(ks) 15 print(its) 16 
17 # 此時字典增長一項
18 dic["sex"] = "female"
19 
20 print(dic) 21 print(vs) 22 print(ks) 23 print(its)

輸出結果：

{'age': 18, 'name': 'xq', 'address': 'beijing'}
[18, 'xq', 'beijing']
['age', 'name', 'address']
[('age', 18), ('name', 'xq'), ('address', 'beijing')]
{'age': 18, 'sex': 'female', 'name': 'xq', 'address': 'beijing'}
[18, 'xq', 'beijing']
['age', 'name', 'address']
[('age', 18), ('name', 'xq'), ('address', 'beijing')]

 

Python3.x版本下的

 1 dic = {"name": "xq", "age": 18, "address": "beijing"}  2 
 3 # 獲取全部的值
 4 vs = dic.values()  5 
 6 # 獲取全部的key值
 7 ks = dic.keys()  8 
 9 # 獲取全部的鍵值對
10 its = dic.items() 11 
12 print(dic) 13 print(vs) 14 print(ks) 15 print(its) 16 
17 # 此時字典增長一項
18 dic["sex"] = "female"
19 
20 print(dic) 21 print(vs) 22 print(ks) 23 print(its)

輸出結果：

{'name': 'xq', 'age': 18, 'address': 'beijing'}
dict_values(['xq', 18, 'beijing'])
dict_keys(['name', 'age', 'address'])
dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing')])
{'name': 'xq', 'age': 18, 'address': 'beijing', 'sex': 'female'}
dict_values(['xq', 18, 'beijing', 'female'])
dict_keys(['name', 'age', 'address', 'sex'])
dict_items([('name', 'xq'), ('age', 18), ('address', 'beijing'), ('sex', 'female')])

看打印的結果能夠看出：Python2.x版本下，全部的鍵、值和鍵值對結果都是以列表形式呈現的，而Python3.x版本下面都是迭代器形式呈現，並且當咱們
往字典裏面增長鍵值對的時候，Python2.x版本下面並不會把新增的鍵值對放到咱們所獲取的鍵、值和鍵值對裏面，Python3.x則不是。

# 遍歷
# 1:先遍歷全部的key，而後根據key獲取對應的值
dic = {"name": "xq", "age": 18, "address": "北京"}

# 先獲取全部的keys
keys = dic.keys()

# 遍歷全部的keys
for key in keys:
    print(key, "\t:", dic[key])

# 2:直接遍歷全部的鍵值對
dic = {"name": "xq", "age": 18, "address": "北京"}

for x,y in dic.items():
    print(x, "\t:", y)

dic = {"name": "xq", "age": 18, "address": "北京"}
# 計算
# len(info)
# 計算鍵的個數
print(len(dic))


# 斷定
# x in dic
# 斷定dic中的key，是否存在x
print("name" in dic)


# x not in dic
# 斷定dic中的key,是否不存在x
print("name" not in dic)

# dic.has_key(key)
#  已通過期，建議使用in來代替，Python2.x還可使用