dict字典學習記錄

時間 2019-11-09

標籤 dict 字典學習記錄简体版

原文原文鏈接

---恢復內容開始---html

dict字典是python內置的一種映射（mapping），key：value的格式，key只能用不能改變的序列（元組tuple，string）或者數字表示。key：value 被稱爲字典的一項itempython

一、初始化字典shell

>>> a = dict()
>>> a
{}express

也能夠寫成a = {} 直接初始化一個空的字符串app

二、空的字典是能夠插入鍵值對的，可是list不能夠，函數

>>> a = dict()
>>> a
{}
>>> a['name']='Beth'
>>> a
{'name': 'Beth'}ui

>>> a=dict([("name","Beth"),("age",43)])##dict 能夠接受一個可迭代的參數，如list，tuple
>>> a
{'name': 'Beth', 'age': 43}this

也能夠直接賦值spa

a = {'name': 'Beth', 'age': 43}htm

>>> b = [] ###空的list裏是沒有元素的，插入元素會提示下標index超出範圍；對於有值的list，若是插入的下標index超出範圍，也會提示這個錯誤
>>> b[0]=1
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
b[0]=1
IndexError: list assignment index out of range

三、len()方法，返回字典item的數量

>>> a
{'name': 'Beth', 'age': 43}
>>> len(a)
2

四、dict[key],返回k對應的值

>>> a = {'name': 'Beth', 'age': 43}

>>> a['name']
'Beth'

五、key in dict ，in成員檢查方法，返回值是布爾值，是返回true，不是返回false；字典的成員檢測只能用key值，不能用value值；n in list,n不是list的下標而是元素；

>>> a = {'name': 'Beth', 'age': 43}

>>> 'name' in a
True
>>> 'addr' in a
False

>>> 'Beth' in a ###字典的成員檢測只能用key值，不能用value值
False

####在字典中判斷key的成員資格，比在list中判斷元素成員資格要高效，數據越大，越明顯

六、dict[k]=v,若是字典dict中沒有k值，則字典增長k：v項，若是字典中有k，則將k原對應的值，修改爲k

>>> a = {'name': 'Beth', 'age': 43}

>>> a['addr'] = '北京' ###增長項
>>> a
{'name': 'Beth', 'age': 43, 'addr': '北京'}
>>> a['age']=44 ###修改key對應的值
>>> a
{'name': 'Beth', 'age': 44, 'addr': '北京'}

七、字典的格式化字符串%s--->%(key)s,寬度精度，符號也是適用的放在%(key)符號寬度.精度s，

>>> "this is %(mode)s time"%{'mode':'beautiful'}
'this is beautiful time'

>>> "this is %(mode)10.3s time"%{'mode':'beautiful'}
'this is bea time'
>>> "this is %(mode)-10.3s time"%{'mode':'beautiful'}
'this is bea time'

實例：

template = '''
<html>
    <head><title>%(title)s</title></head>
    <body>
        <h1>%(title)s</h1>
        <p>%(text)s</p>
    </body>
</html>

'''

data = {'title':'My Home Page','text':'Welcome to my home page!'}

print(template % data)

八、clear（），清除dict裏的全部項，改變原字典，沒有返回值

>>> a
{'name': 'Beth', 'age': 44, 'addr': '北京'}
>>> a.clear()
>>> a
{}

##############

>>> a = {'name': 'Beth', 'age': 44, 'addr': '北京'}

>>> b=a

>>> b
{'name': 'Beth', 'age': 44, 'addr': '北京'}

並非b複製了字典a,獲得一個字典a的副本，而是a和b都指向了內容{'name': 'Beth', 'age': 44, 'addr': '北京'}，a和b任意一個修改字典，另外一個也會改變

>>> b['addr']="上海"
>>> b
{'name': 'Beth', 'age': 44, 'addr': '上海'}
>>> a
{'name': 'Beth', 'age': 44, 'addr': '上海'}

>>> del a['name'] ###del 刪除字典的某一項
>>> a
{'age': 44, 'addr': '上海'}
>>> b
{'age': 44, 'addr': '上海'}

九、copy方法，能夠複製一個字典的副本出來，可是這個函數屬於‘淺複製’，副本刪除或者增長項或者替換key對應的value值都不會影響原字典；可是若是值爲list或者tuple，修改他們，原字典也會跟着改變；

>>> x = {'username':'admin','machines':['foo','bar','baz']}
>>> y = x.copy()
>>> y
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

>>> y['username']='user' ###替換username對應的值，原字典未變
>>> y
{'username': 'user', 'machines': ['foo', 'bar', 'baz']}
>>> x
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

>>> y['machines']=['A','B'] ####替換machines對應的list的值，原字典不改變
>>> y
{'username': 'admin', 'machines': ['A', 'B']}
>>> x
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

>>> x ={'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> y = x.copy()
>>> y
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> y['machines'][1]='sun' ####修改machines對應list的某個元素，原字典也跟着改變
>>> y
{'username': 'admin', 'machines': ['foo', 'sun', 'baz']}
>>> x
{'username': 'admin', 'machines': ['foo', 'sun', 'baz']}

>>> y['machines'].append('test') ####machines對應的lis增長元素，原字典也跟着改變
>>> y
{'username': 'admin', 'machines': ['foo', 'sun', 'baz', 'test']}
>>> x
{'username': 'admin', 'machines': ['foo', 'sun', 'baz', 'test']}

>>> y['machines'].remove('foo') ####刪除machines對應的list的某個元素，原字典也跟着改變
>>> y
{'username': 'admin', 'machines': ['sun', 'baz', 'test']}
>>> x
{'username': 'admin', 'machines': ['sun', 'baz', 'test']}

十、deepcopy 深複製，修改值對應的list，原字典也不會改變

from copy import deepcopy

>>> a = {'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> b = deepcopy(a)
>>> b
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}
>>> b['machines'].remove('foo')
>>> b
{'username': 'admin', 'machines': ['bar', 'baz']}

>>> a
{'username': 'admin', 'machines': ['foo', 'bar', 'baz']}

十一、fromkeys（iterable，value=None）用iterable建立key，若是未指定默認值，則默認值爲None

>>> {}.fromkeys(('name','age'))
{'name': None, 'age': None}
>>> {}.fromkeys(('name','age'),'N/A')
{'name': 'N/A', 'age': 'N/A'}
>>> dict.fromkeys(['name','age',(1,)])
{'name': None, 'age': None, (1,): None}

十二、get（key，defalut=None），有點相似dict[key],有一點不一樣若是訪問的key值不存在dict中，dict[key]就會報錯，而dict.get(key)則不報錯返回None，也能夠指定返回的內容

>>> b={'username': 'admin', 'machines': ['bar', 'baz']}
>>> b['username']
'admin'
>>> b.get('username')
'admin'
>>> b.get('age','not available') ####指定訪問的key不存在時，返回‘not available’
'not available'

實例：

# 根據客戶輸入的名字和命令，輸出客戶的電話或者地址
# 創建people庫
people = {
    'alice':{
        'phone':'2341',
        'addr':'Foo driver 23'
    },
    'Beth':{
        'phone':'9120',
        'addr':'Bar street 42'
    },
    'cecil':{
        'phone':'3158',
        'addr':'Baz avenue 90'
    }
}

# 方便獲取客戶命令
lable = {'p':'phone','d':'addr'}
# 獲取客戶輸入的名字
name = input('Name:')
# 選擇要獲取的信息
key = input('Phone number(p) or address(a)?')

###若是name在people中，根據客戶命令輸出 
if name in people:
    print("%s's %s is:%s "%(name,lable[key],people[name][lable[key]]))
else:
    print("%s is not here"%name)

##若是name存在people中可是客戶輸入的命令不是咱們提供的p和a，系統就會報錯，程序的容錯性很差，只考慮了name不存在的狀況

####用get（）方法改寫上面的程序

person = people.get(name,{})##name存在則正常返回值，不存在則返回{}
request=lable.get(key,key)##考慮到客戶輸入的命令對錯都要輸出因此，key存在則正常返回命令，錯誤返回客戶輸入的命令
result = person.get(request,'not available')###客戶輸入的key對應的request存在，則返回對應的值，不在則提示not available
print("%s's %s is %s"%(name,request,result))

1三、keys(),返回一個dict_keys對象，是一種like_set對象，能夠遍歷取值；python2是直接返回keys組成的列表

>>> d={'phone': 'phone number', 'addr': 'address'}
>>> d.keys()
dict_keys(['phone', 'addr']) ####這是一個對象

>>> for key in d.keys(): ###遍歷dict_keys對象
　　　　print(key)

phone
addr
>>> b = [key for key in d.keys()] ##使用列表推導式，將遍歷獲得的key值，存放到一個新的列表中
>>> b
['phone', 'addr']

1四、items（）、values（）方法和keys（）方法一致，items（）方法返回dict_items對象，values（）返回dict_values對象

>>> I = [item for item in d.items()]
>>> I
[('phone', 'phone number'), ('addr', 'address')]
>>> V = [value for value in d.values()]
>>> V
['phone number', 'address']

1五、pop（k[,d]）方法刪除指定k，並返回k對應的value值；若是刪除的k不存在，怎返回d（若是給了參數d），若是沒有給參數d，k也不存在則拋出KeyError

>>> d = {'phone': 'phone number', 'addr': 'address'}
>>> d.pop('age','age is not available') ###刪除的key值不存在，d='age is not available'
'age is not available'
>>> d.pop('addr','addr not available') ###刪除的key值存在，則返回k對應的v
'address'
>>> d
{'phone': 'phone number'}
>>> d.pop('age') ####刪除的k值不存在，d未給定，raise KeyError；
Traceback (most recent call last):
File "<pyshell#48>", line 1, in <module>
d.pop('age')
KeyError: 'age'

1六、popitem(),沒有參數值，刪除dict中的某個item，並返回該item（k，v），可是這個刪除是隨機的，由於字典是無序的。

>>> d = {'phone': 'phone number', 'addr': 'address'}
>>> d.popitem()
('addr', 'address')

1七、setdefault(self, key, default=None, /) 若是字典中沒有這個key值，這個函數就插入key值和它對應的default的值，修改字典；若是這個key已經存在則返回key對應的value值，不修改字典；setdefault（）是不接受關鍵字參數的，用關鍵字參數會報錯

>>> d
{'phone': 'phone number'}
>>> d.setdefault('addr',None) ####無關鍵字參數，第二個參數能夠本身指定
>>> d
{'phone': 'phone number', 'addr': None}

>>> d.setdefault('age',default=None) ###關鍵字參數
Traceback (most recent call last):
File "<pyshell#54>", line 1, in <module>
d.setdefault('age',default=None)
TypeError: setdefault() takes no keyword arguments

>>> d.setdefault('phone','telephone') ###key值已存在字典中，返回字典中key對應的value，不改變字典
'phone number'
>>> d
{'phone': 'phone number', 'addr': None}

1七、 D.update([E, ]**F) -> None. Update D from dict/iterable E 或 F.；這個函數只接受一個參數E或F

　　##用字典F更新字典D，若是key值重複，則覆蓋D字典的值；key值不重複，則添加到字典D中

　　　　>>> d = {'phone':'phone number','addr':'address'}
　　　　>>> f = {'phone':'telephone','Home':'Beijng'}
　　　　>>> d.update(f)
　　　　>>> d
　　　　　　{'phone': 'telephone', 'addr': 'address', 'Home': 'Beijng'}　　

　　###用可迭代的鍵/值對來更新字典，不能直接使用元素會報錯

　　　　>>> d = {'phone':'phone number','addr':'address'}

　　　　>>> e = [('age',18),('home','Beijing')] ####list中存放元組
　　　　>>> d.update(e)
　　　　>>> d
　　　　　　{'phone': 'phone number', 'addr': 'address', 'age': 18, 'home': 'Beijing'}

　　　　>>> d = {'phone':'phone number','addr':'address'}
　　　　>>> e = ('gentle','男') ###update函數是取元素裏的鍵值對，直接用元組會把第一個元素當成要執行的鍵值對來對待，放到list就能夠了
　　　　>>> d.update(e)
　　　　Traceback (most recent call last):
　　　　File "<pyshell#98>", line 1, in <module>
　　　　d.update(e)
　　　　ValueError: dictionary update sequence element #0 has length 6; 2 is required

　　　　關鍵字參數替換　　　　

　　　　>>> d = {'phone':'phone number','addr':'address'}
　　　　>>> d.update(age=18) ###不能寫成‘age’=18 這個是表達式，不是關鍵字參數
　　　　>>> d
　　　　　　{'phone': 'phone number', 'addr': 'address', 'age': 18}

　　　　>>> d.update('home'='beijing')
　　　　SyntaxError: keyword can't be an expression

---恢復內容結束---