字典

是一個映射類型的數(shù)據(jù)結(jié)構(gòu)
1.每個字典中的元素都是一對鍵值對
2.字典稱為dict；鍵稱為key；值稱為value {"key":value}
3.字典不可以有相同的key但可以有相同的value

1.創(chuàng)建字典

創(chuàng)建方法為變量名={}

>>> d1 = {}    #創(chuàng)建空字典，
>>> type(d1)
<type 'dict'>
>>> d1
{}

>>> d1 = {"key":2}    #創(chuàng)建含有單個的
>>> type(d1)
<type 'dict'>
>>> d1
{'key': 2}

字典中元素是無序的
即你輸入的字典和你再次輸出的字典的順序可能是不一樣的
如：
d2 = {'shark': '鯊魚', 'qf': '千鋒'}
d2
>>>{'qf': '千鋒', 'shark': '鯊魚'}
#但是在我的實驗中輸出的和我輸入的是一樣的,不知道是不是改版的原因

2.dict（）其他的數(shù)據(jù)類型轉(zhuǎn)換成字典

>>> d_tp1 = [['a','1'],['ss','1']]    
#注意，列表是不能作為字典的值或者鍵的，但是如果在未定義字典之前不算，
#即上面的可以這樣寫的原因是因為我們需要將列表變?yōu)樽值?，這只是個轉(zhuǎn)換
>>> dict1=dict(d_tp1)   
>>> dict1
{'a': '1', 'ss': '1'}

>>> d_tp1 = [('a','1'),('ss','1')]
>>> dict1=dict(d_tp1)       
 #把這個數(shù)列轉(zhuǎn)換成字典；但必須是一對的；因為必須有鍵還有值
>>> dict1
{'a': '1', 'ss': '1'}
>>> d_tp2= ['ab','bc']     #可以看成兩個字符串
>>> dict2=dict(d_tp2)
>>> dict2
{'a': 'b', 'b': 'c'}

3.zip()并行迭代

• 會停在最短的序列

>>> who=['tom','jan','kity']
>>> age=['17','18','16','19']    #下面的19沒有繼續(xù)取出
>>> for name , old in zip(who,age):      
...     print(name, old)
... 
tom 17
jan 18
kity 16
>>> for name , age in zip(who,age):
...     print(name ,old)
... 
tom 17
jan 18
kity 16
==============================
利用 zip() 函數(shù)可以對具有相同數(shù)量的元素的序列進行配對；
返回的值不是元組，也不是列表，而是一個整合在一起的可迭代變量。
>>> who=['tom','jan','kity']
>>> age=['17','18','16','19']
>>> zip(who,age)
<zip object at 0x7fbccada04b0>
>>> type(zip(who,age))
<class 'zip'>
>>> list(zip(who,age))
[('tom', '17'), ('jan', '18'), ('kity', '16')]
>>> dict(zip(who,age))
{'tom': '17', 'jan': '18', 'kity': '16'}

4.哪些數(shù)據(jù)可以作為字典的key

key 通常是 字符串

它可以是 Python 中任意不可變類型

比如：

布爾型 True 1 False 0
整型 100 200
浮點型 1.0; 3.415
元組 （1,） （1, 2, 3）
字符串 'host_name'
關(guān)于字典的 key

哈希是指一個過程，這個過程就是把任意長度的輸入，通過哈希算法，變換成固定長度的輸出，所輸出的稱為哈希值。這種變換是一種壓縮映射，也即哈希值所占的空間一般來說遠(yuǎn)小于輸入值的空間，不同的輸入可能會哈希出相同的輸出（概率很?。?/p>

在 Python 內(nèi)部用一個哈希表來維護字典中的 key 到 value 的映射關(guān)系。
所以 key 必須是可哈希的。dong
判斷一個對象是否可哈希，可以使用 hash() 函數(shù)
返回一個整數(shù)，就是可哈希，反之會拋出 TypeError 異常

>>> hash(1)
1
>>> hash('name')      #字符串可以被哈希
-5658134882158534392
>>> hash(('1',2))       #元組也可以被哈希
8438592034789701679
>>> hash(['1',2])       #列表不能被哈希
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash({'1',2})       #集合不能被哈希
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> hash(('1',2))
8438592034789701679

5.get（）得到單個值

• 它的那個get（‘鍵’,'返回值'）非常的有用

>>> dict_obj = {'a':1,'b':2}
>>> dict_obj['a']
1
>>> dict_obj['c']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'c'
---------------------------
>>> dict_obj.get('a')       #輸入鍵名才有用
1
>>> v=dict_obj.get('a')      
>>> v
1
>>> v=dict_obj.get('c')
>>> v
>>> type(v)
<class 'NoneType'>
>>> v=dict_obj.get('c','worry')     
#當(dāng)存在c這個鍵的時候就會輸出value，如果沒有c這個鍵的時候就會輸出后面的worry字符串
>>> v
'worry'
>>> type(v)
<class 'str'>

實例

>>> info_dict={"name":'yangge','age':18}
>>> na=info_dict['name']        
>>> print(na)
yangge
>>> naa =info_dict.get('age')   
>>> print(naa)
18
>>> naa = info_dict['dd']     #沒有的鍵取值會報錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'dd'
>>> age2=info_dict.get('asdf')  
>>> print(type(age2))         #沒有age2 所以也無從說類型
<class 'NoneType'>    
>>> print(type(age2),age2)     沒有age2鍵，無法取值
<class 'NoneType'> None
>>> age3 = info_dict.get('adaf', '')
>>> print(age3)
                                                        #沒有adaf這個鍵，所以輸出為空值''
>>> print(type(age3))                #空值的類型為字符
<class 'str'>
>>> print(type(age3),'')   
<class 'str'>                               輸出類型加''
>>> age4 = info_dict.get('adaf', 28)      #沒有adaf這個鍵就輸出28
>>> print(type(age4),age4)           28為整數(shù)
<class 'int'> 28

6.得到所有的鍵keys()

>>> dict_obj = {'a':1,'b':2}
>>> dict_obj.keys()         #只取得鍵
dict_keys(['a', 'b'])    
#可迭代對象，還沒展開，節(jié)省內(nèi)存；而python2展開了為['a', 'b']，如果python2 想得到可迭代對象那么就要iterkeys（）

>>> for k in dict_obj.keys():             #取得鍵的方法1
...     print(k)
... 
a
b
>>> for k in dict_obj:                       #取得鍵的方法2
...     print(k)
... 
a
b

7.獲取字典的值values（）

dict_obj.values()

info_dict = {"name":"yangge","age":18}
dict_values = info_dict.values()
print(dict_values)
   #這只能去多個的值，如果想取單個的可用get（鍵）
輸出>
dict_values(['yangge', 18])

8.同時獲取字典的鍵和值

dict_obj.items()

>>> dict_obj={'a':1,'b':2}
>>> 
>>> item=dict_obj.items()
>>> print(item)
dict_items([('a', 1), ('b', 2)])   #分別取了值不再是字典的形式了
---------------------------------------------
>>> for item in dict_obj.items():     #循環(huán)取值
...     print(item)
...    
... 
('a', 1)
('b', 2)

>>> for k,v in dict_obj.items():     
...     print(k,v)
... 
a 1
b 2    #可以自動解包了

info_dict={"name":'yangge','age':18}
for k,v in info_dict.items():
... if k == 'age':
... d6["age_o"] = v
>>> d6
{'age_o': 18}

9.使用=修改或更新字典

可以使用 等號 對字典的 key 進行直接賦值操作。

• 假如 key 不存在與字典中，這個 key 和 對應(yīng)值也會被創(chuàng)建到字典中。
• 如果存在這個key那么覆蓋這個值；多次覆蓋只顯示最后一次覆蓋之后的值

單個單個的賦值
In [50]: d5 = {}

In [51]: d5['a'] = 1

In [52]: d5['b'] = 2

In [53]: d5
Out[53]: {'a': 1, 'b': 2}

In [54]: d5['li'] = [1,3,5]

In [55]: d5
Out[55]: {'a': 1, 'b': 2, 'li': [1, 3, 5]}
-----------------------------------------
In [68]: d5 = {'a': 1, 'b': 2, 'li': [1, 3, 5]} 

In [69]: d6 = d5

In [70]: d6 is d5
Out[70]: True

In [71]: d7 = d5.copy()

In [73]: d7 is d5
Out[73]: False

In [74]: d7 == d5   # 雙等號 是用來判斷 等號兩邊的對象的值是否相等
Out[74]: True

在講is和==這兩種運算符區(qū)別之前，首先要知道Python中對象包含的三個基本要素，
分別是：id(身份標(biāo)識)、type(數(shù)據(jù)類型)和value(值)。
is和==都是對對象進行比較判斷作用的，但對對象比較判斷的內(nèi)容并不相同。下面來看看具體區(qū)別在哪。
==比較操作符和is同一性運算符區(qū)別
1.==是python標(biāo)準(zhǔn)操作符中的比較操作符，用來比較判斷兩個對象的value(值)是否相等：
2.is也被叫做同一性運算符，這個運算符比較判斷的是對象間的唯一身份標(biāo)識，也就是id是否相同。通過對下面幾個list間的比較，你就會明白is同一性運算符的工作原理：

10.更新update（）

• 注意：如果更新的key一樣就會覆蓋原來可以的值 。用來賦值也是可以的

>>> d6 = {'a': 2,'d': 2,'e': 5}
>>> d5={'a':1,'b':2}
>>> d5.update(d6)      #就是找出6中與5不同的，然后把不同的加入到d5中
>>> d5
{'a': 2, 'b': 2, 'd': 2, 'e': 5}

>>> info_dict
{'age': 18, 'name': 'yangge'}
>>> d7 = {'a':1}
>>> info_dict.update(d7)
>>> info_dict
{'age': 18, 'name': 'yangge', 'a': 1}

11.判斷成員 in

判斷key的時候可以不寫key（）
但是判斷value的是時候要加value（）

>>> d5
{'a': 2, 'b': 2, 'd': 2, 'e': 5}
>>> 'a' in d5         #可以不寫key因為默認(rèn)用key匹配
True
>>> 'a' in d5.keys()
True
>>> '2' in d5.values()     #‘2’是字符串
False
>>> 2 in d5.values()
True

12.清空和刪除字典

1)del刪除特定的的鍵值對或者全刪

刪除單個
>>> d5
{'a': 2, 'b': 2, 'd': 2, 'e': 5}
>>> del d5.key('a')
>>> del d5['a']     #注意這個寫法。和取值是一樣的
>>> d5
{'b': 2, 'd': 2, 'e': 5}
刪除字典
>>> d5
{'b': 2, 'd': 2, 'e': 5}
>>> del d5
>>> d5            # 刪除字典本身，字典自身就不存在于內(nèi)存中了
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd5' is not defined

del適用于python的所有對象；不會返回值

2）清空clear()
dict_obj.clear() # 字典本身還在內(nèi)存中，只是內(nèi)容沒了

3)刪除特定的鍵值對pop（）
從字典中刪除指定 key 的鍵值對，并返回這個 key 對應(yīng)的值 ;括號內(nèi)不能不輸入
返回的的

>>> d6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}
>>> 
>>> li = d6.pop('li')
>>> print(li)
[1, 3, 5]
>>> d6
{'b': 2, 'c': '3', 'd': 'new key'}

popitem()
刪除字典中的鍵值對，并返回這個鍵和值 ；默認(rèn)刪除最后一個

>>> d6 = {'b': 2, 'c': '3', 'd': 'new key', 'li': [1, 3, 5]}
>>> item = d6.popitem()     
>>> print(item)
('li', [1, 3, 5])
>>> print(d6)
{'b': 2, 'c': '3', 'd': 'new key'}

練習(xí)
d6={'b': 2, 'c': '3', 'd': 'new key'，'li', [1, 3, 5]}
item = d6.popitem()

print(item)
print(d6)

"""答案
('li', [1, 3, 5])
{'b': 2, 'c': '3', 'd': 'new key'}
"""

擴展知識： setdefault 處理缺失的鍵

1. key 不存在，添加 key: value 到字典中,并且返回字典中的 value 對象，也就是說返回的 value 和剛添加到字典中的 value 是同一個對象 ；
2. key 存在, 返回對應(yīng)的 value，原字典不變

>>> obj.setdefault('ala',[])       #沒有ala所以會添加到字典中
[]
>>> obj.setdefault('ala',[]).append('s')      #這是一個延伸的
>>> obj
{'ala': ['s']}
>>> obj.setdefault('ala',[]).append('by')   #這樣就可以加入多個數(shù)列 的值
>>> obj
{'ala': ['s', 'by']}

擴展知識

f={True: 'yes', 1: 'no', 1.0: 'maybe'}    #True的值=1=1.0 ，所以會覆蓋賦予key“True” 的值
date=['no', 'yes'][True]       #這個True是索引號1的意思
print(f)
print(date)

{True: 'maybe'}
yes

集合

1 集合特性介紹

集合本身也不能被哈希
集合不能包含有相同的元素

在 python 中集合看起來像是只有 key 的字典

{'disk','cpu','memory','motherboard'}

在 python 解釋器中表現(xiàn)為 set()

集合內(nèi)的元素不允許重復(fù)

2.把其他的類型轉(zhuǎn)換成集合set（）

創(chuàng)建一個空的集合
d=set()       #用這個而不是{}，{}是創(chuàng)建空字典的

 >>>set('disk')
 {'d', 'i', 'k', 's'}

 >>>set(['disk','cpu','memory'])
 {'cpu', 'disk', 'memory'}

 >>>set(('disk','cpu','memory'))
 {'cpu', 'disk', 'memory'}

 >>>set({'disk': '560G','cpu': '4'})
 {'cpu', 'disk'}

3.添加一個元素add()

>>>s2 = {12,3,4,5,6,}

>>>s2.add('n')

>>>s2
{12, 3, 4, 5, 6, 'n'}

4.刪除一個元素remove()

>>>s2.remove('n')

>>> s2
 {4, 5, 6, 12}

5.隨機干掉一個元素pop()

s2 = {12,3,4,5,6,}
print(s2.pop())

輸出>3

6.集合的運算
a.交集$ :獲取 兩個集合都含有的
b.并集| :獲取兩個集合加起來的
c.差集-:獲取第一個集合中獨有的
d.異或運算^:獲取兩個集合中分別獨有的元素，組合成一個新的集合