㈠ python字典操作函數
字典是一種通過名字或者關鍵字引用的得數據結構,其鍵可以是數字、字元串、元組,這種結構類型也稱之為映射。字典類型是Python中唯一內建的映射類型,基本的操作包括如下:
(1)len():返回字典中鍵—值對的數量;
(2)d[k]:返回關鍵字對於的值;
(3)d[k]=v:將值關聯到鍵值k上;
(4)del d[k]:刪除鍵值為k的項;
(5)key in d:鍵值key是否在d中,是返回True,否則返回False。
(6)clear函數:清除字典中的所有項
(7)函數:返回一個具有相同鍵值的新字典;deep()函數使用深復制,復制其包含所有的值,這個方法可以解決由於副本修改而使原始字典也變化的問題
(8)fromkeys函數:使用給定的鍵建立新的字典,鍵默認對應的值為None
(9)get函數:訪問字典成員
(10)has_key函數:檢查字典中是否含有給出的鍵
(11)items和iteritems函數:items將所有的字典項以列表方式返回,列表中項來自(鍵,值),iteritems與items作用相似,但是返回的是一個迭代器對象而不是列表
(12)keys和iterkeys:keys將字典中的鍵以列表形式返回,iterkeys返回鍵的迭代器
(13)pop函數:刪除字典中對應的鍵
(14)popitem函數:移出字典中的項
(15)setdefault函數:類似於get方法,獲取與給定鍵相關聯的值,也可以在字典中不包含給定鍵的情況下設定相應的鍵值
(16)update函數:用一個字典更新另外一個字典
(17) values和itervalues函數:values以列表的形式返回字典中的值,itervalues返回值得迭代器,由於在字典中值不是唯一的,所以列表中可以包含重復的元素
一、字典的創建
1.1 直接創建字典
d={'one':1,'two':2,'three':3}
printd
printd['two']
printd['three']
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
>>>
1.2 通過dict創建字典
# _*_ coding:utf-8 _*_
items=[('one',1),('two',2),('three',3),('four',4)]
printu'items中的內容:'
printitems
printu'利用dict創建字典,輸出字典內容:'
d=dict(items)
printd
printu'查詢字典中的內容:'
printd['one']
printd['three']
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
items中的內容:
[('one',1), ('two',2), ('three',3), ('four',4)]
利用dict創建字典,輸出字典內容:
{'four':4,'three':3,'two':2,'one':1}
查詢字典中的內容:
>>>
或者通過關鍵字創建字典
# _*_ coding:utf-8 _*_
d=dict(one=1,two=2,three=3)
printu'輸出字典內容:'
printd
printu'查詢字典中的內容:'
printd['one']
printd['three']
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
輸出字典內容:
{'three':3,'two':2,'one':1}
查詢字典中的內容:
>>>
二、字典的格式化字元串
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
print"three is %(three)s."%d
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
threeis3.
>>>
三、字典方法
3.1 clear函數:清除字典中的所有項
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
d.clear()
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
{}
>>>
請看下面兩個例子
3.1.1
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d={}
printd
printdd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{'two':2,'one':1}
>>>
3.1.2
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d.clear()
printd
printdd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{}
>>>
3.1.2與3.1.1唯一不同的是在對字典d的清空處理上,3.1.1將d關聯到一個新的空字典上,這種方式對字典dd是沒有影響的,所以在字典d被置空後,字典dd裡面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內容,clear是一個原地操作的方法,使得d中的內容全部被置空,這樣dd所指向的空間也被置空。
3.2 函數:返回一個具有相同鍵值的新字典
# _*_ coding:utf-8 _*_
x={'one':1,'two':2,'three':3,'test':['a','b','c']}
printu'初始X字典:'
printx
printu'X復制到Y:'
y=x.()
printu'Y字典:'
printy
y['three']=33
printu'修改Y中的值,觀察輸出:'
printy
printx
printu'刪除Y中的值,觀察輸出'
y['test'].remove('c')
printy
printx
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
初始X字典:
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
X復制到Y:
Y字典:
{'test': ['a','b','c'],'one':1,'three':3,'two':2}
修改Y中的值,觀察輸出:
{'test': ['a','b','c'],'one':1,'three':33,'two':2}
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
刪除Y中的值,觀察輸出
{'test': ['a','b'],'one':1,'three':33,'two':2}
{'test': ['a','b'],'three':3,'two':2,'one':1}
>>>
註:在復制的副本中對值進行替換後,對原來的字典不產生影響,但是如果修改了副本,原始的字典也會被修改。deep函數使用深復制,復制其包含所有的值,這個方法可以解決由於副本修改而使原始字典也變化的問題。
# _*_ coding:utf-8 _*_
fromimportdeep
x={}
x['test']=['a','b','c','d']
y=x.()
z=deep(x)
printu'輸出:'
printy
printz
printu'修改後輸出:'
x['test'].append('e')
printy
printz
運算輸出:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
輸出:
{'test': ['a','b','c','d']}
{'test': ['a','b','c','d']}
修改後輸出:
{'test': ['a','b','c','d','e']}
{'test': ['a','b','c','d']}
>>>
3.3 fromkeys函數:使用給定的鍵建立新的字典,鍵默認對應的值為None
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'])
printd
運算輸出:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':None,'two':None,'one':None}
>>>
或者指定默認的對應值
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'],'unknow')
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':'unknow','two':'unknow','one':'unknow'}
>>>
3.4 get函數:訪問字典成員
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.get('one')
printd.get('four')
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1
None
>>>
註:get函數可以訪問字典中不存在的鍵,當該鍵不存在是返回None
3.5 has_key函數:檢查字典中是否含有給出的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.has_key('one')
printd.has_key('four')
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
True
False
>>>
3.6 items和iteritems函數:items將所有的字典項以列表方式返回,列表中項來自(鍵,值),iteritems與items作用相似,但是返回的是一個迭代器對象而不是列表
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
list=d.items()
forkey,valueinlist:
printkey,':',value
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
three :3
two :2
one :1
>>>
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
it=d.iteritems()
fork,vinit:
print"d[%s]="%k,v
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
d[three]=3
d[two]=2
d[one]=1
>>>
3.7 keys和iterkeys:keys將字典中的鍵以列表形式返回,iterkeys返回鍵的迭代器
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printu'keys方法:'
list=d.keys()
printlist
printu'\niterkeys方法:'
it=d.iterkeys()
forxinit:
printx
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
keys方法:
['three','two','one']
iterkeys方法:
three
two
one
>>>
3.8 pop函數:刪除字典中對應的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.pop('one')
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'three':3,'two':2}
>>>
3.9 popitem函數:移出字典中的項
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.popitem()
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'two':2,'one':1}
>>>
3.10 setdefault函數:類似於get方法,獲取與給定鍵相關聯的值,也可以在字典中不包含給定鍵的情況下設定相應的鍵值
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.setdefault('one',1)
printd.setdefault('four',4)
printd
運算結果:
{'three':3,'two':2,'one':1}
{'four':4,'three':3,'two':2,'one':1}
>>>
3.11 update函數:用一個字典更新另外一個字典
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3
}
printd
x={'one':1}
d.update(x)
printd
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':123}
{'three':3,'two':2,'one':1}
>>>
3.12 values和itervalues函數:values以列表的形式返回字典中的值,itervalues返回值得迭代器,由於在字典中值不是唯一的,所以列表中可以包含重復的元素
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3,
'test':2
}
printd.values()
運算結果:
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
[2,3,2,123]
>>>
㈡ Python中的字典是什麼
字典(Dictionary)
字典也是Python語言中經常使用的一種數據類型。跟列表類似,字典是另外一種可存儲任意類型的數據,並且字典儲存的數據也是可以修改的。
不同於列表的是,字典每個基本元素都包括兩個部分:鍵(key) 和 鍵對應的值(value)。
鍵和值之間用冒號(:)分割,每對元素之間用逗號(,)分割,整個字典的數據在大括弧{}中,格式如下所示:
在字典中,鍵的內容是不可重復的。鍵為不可變數據類型,值可以是任何數據類型。在這里,鍵只支持字元串類型。
字典最大的優勢就是能在海量數據下利用「鍵」快速查找出想要的值,當有很多數據需要存儲的時候,我們給每個值都打個標簽,也就是「鍵」;想要調用這個值時,字典能夠利用這個標簽快速幫我們找到它。但是如果標簽重復了,字典不知道哪個值才是對的,就會報錯哦~
列表是根據排序來記錄每項的值,但是字典是沒有順序的,所以同一字典,每次列印出的排序可能是不同的。「鍵」才是調用字典的關鍵元素。
字典是基礎的數據類型,所以變數也可以被賦值為字典。
㈢ python-字典
1、字典:
兩大特點:無序,鍵唯一
無序存儲,鍵值對的形式存儲數據
鍵是唯一不可修改的,不能用列表做鍵
2、python中不可變類型:整形,字元串,元組
可變類型:字典,列表
3、字典中方法:
增加:
dic1 = {'name':'alex'}
dic1 = ['age'] =18
*dic1 = {'age':18,'name':'alex'}
dic1.setdefault() 鍵存在,不改動,返回字典相應鍵對應的值,鍵不存在,在字典中增加新的鍵值對,並返回相應的值
查找:
通過鍵查找
dic1.keys()列印字典中所有鍵
#dict1.keys['name','age'] --轉換成列表:list(dic1.keys())
dic1.values()列印字典中所有值
dic1.items()列印所有鍵值對
修改:
直接賦值
dic3= {'name':'alex','age':18}
dic4 = {'sex':'male','age':36}
dic3.update(dic4) #有相同的key,值會修改
刪除:
dic.clear() #清空字典
del dic['name'] #刪除字典中指定鍵值對
dic.pop('age')#刪除字典中指定鍵值對,並返回該鍵值對的值
dic.popitem() #隨機刪除鍵值對,並以元組方式返回
其他操作涉及的方法:
dic1 =dict.formkeys(['host1','host2'],'test')#{'host1':'test','host2':'test'}
dic1 =dict.formkeys(['host1','host2','host3'],['test1','test2'])#{'host1':['test1','test2'],'host2':['test1','test2'],'host3':['test1','test2']}
dic1['host2'][1] = 'test3' #{'host3':['test1''test3'],'host2':['test1''test3'],'host1':['test1''test3']}
字典的嵌套:
字典的排序:
字典的遍歷:
字元串的操作
a = '123'
b= 'abc'
c = a+b #123abc
c='****'.join([a,b])#123****abc
st = 'hello kitty{name} is {age}'
st.count('l') #2 統計元素個數
st.captialize() #Hello kitty 首字母大寫
st.center(50,'-')#--------hello kitty --------居中
st.endswith('tty3')#判斷是否以某個內容結尾
st.startswith('he')#判斷是否以某個內容開頭
st.find('t') #8 查找第一個元素,並返回索引,不存在是返回-1
st.format(name = 'alex',age= 37)#hello kitty alex is 37
st.format_map({'name' :'alex','age':27})#hello kitty alex is 27
st.index('t') #8 返回索引,找不到報錯
『ab'.isalnum()
'123'.isdigit()