參考資料：
創(chuàng)新互聯(lián)建站專注為客戶提供全方位的互聯(lián)網(wǎng)綜合服務(wù)，包含不限于成都做網(wǎng)站、網(wǎng)站建設(shè)、外貿(mào)營(yíng)銷網(wǎng)站建設(shè)、紅古網(wǎng)絡(luò)推廣、微信小程序開(kāi)發(fā)、紅古網(wǎng)絡(luò)營(yíng)銷、紅古企業(yè)策劃、紅古品牌公關(guān)、搜索引擎seo、人物專訪、企業(yè)宣傳片、企業(yè)代運(yùn)營(yíng)等，從售前售中售后，我們都將竭誠(chéng)為您服務(wù)，您的肯定，是我們最大的嘉獎(jiǎng)；創(chuàng)新互聯(lián)建站為所有大學(xué)生創(chuàng)業(yè)者提供紅古建站搭建服務(wù)，24小時(shí)服務(wù)熱線：18980820575，官方網(wǎng)址：www.cdcxhl.com
Python中常見(jiàn)的數(shù)據(jù)結(jié)構(gòu)可以統(tǒng)稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
一、序列（列表、元組和字符串）
序列中的每個(gè)元素都有自己的編號(hào)。Python中有6種內(nèi)建的序列。其中列表和元組是最常見(jiàn)的類型。其他包括字符串、Unicode字符串、buffer對(duì)象和xrange對(duì)象。下面重點(diǎn)介紹下列表、元組和字符串。
1、列表
列表是可變的，這是它區(qū)別于字符串和元組的最重要的特點(diǎn)，一句話概括即：列表可以修改，而字符串和元組不能。
（1）、創(chuàng)建
通過(guò)下面的方式即可創(chuàng)建一個(gè)列表：
輸出：
['hello', 'world']
[1, 2, 3]
可以看到，這中創(chuàng)建方式非常類似于javascript中的數(shù)組。
（2）、list函數(shù)
通過(guò)list函數(shù)（其實(shí)list是一種類型而不是函數(shù)）對(duì)字符串創(chuàng)建列表非常有效：
輸出：
['h', 'e', 'l', 'l', 'o']
2、元組
元組與列表一樣，也是一種序列，唯一不同的是元組不能被修改（字符串其實(shí)也有這種特點(diǎn)）。
（1） 、創(chuàng)建
輸出：
(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)
從上面我們可以分析得出：
a、逗號(hào)分隔一些值，元組自動(dòng)創(chuàng)建完成；
b、元組大部分時(shí)候是通過(guò)圓括號(hào)括起來(lái)的；
c、空元組可以用沒(méi)有包含內(nèi)容的圓括號(hào)來(lái)表示；
d、只含一個(gè)值的元組，必須加個(gè)逗號(hào)（,）；
（2）、tuple函數(shù)
tuple函數(shù)和序列的list函數(shù)幾乎一樣：以一個(gè)序列（注意是序列）作為參數(shù)并把它轉(zhuǎn)換為元組。如果參數(shù)就算元組，那么該參數(shù)就會(huì)原樣返回：
輸出：
(1, 2, 3)
('j', 'e', 'f', 'f')
(1, 2, 3)
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
t4=tuple(123)
TypeError: 'int' object is not iterable
3、字符串
（1）創(chuàng)建
輸出：
Hello world
H
H
e
l
l
o
w
o
r
l
d
（2）、格式化
format（）：
print(‘{0} was {1} years old when he wrote this book’. format(name,age) )
print(‘{} was {} years old when he wrote this book’. format(name,age) )
print(‘{name} was {age} years old when he wrote this book’. format(name=’Lily’,age=’22’) )
#對(duì)于浮點(diǎn)數(shù)“0.333”保留小數(shù)點(diǎn)后三位
print(‘{0 : .3f}’.format(1.0/3) )
結(jié)果：0.333
#使用下劃線填充文本，并保持文字處于中間位置
#使用^定義‘_____hello_____’字符串長(zhǎng)度為11
print(‘{0 : ^_11}’.format(‘hello’) )
結(jié)果：_____hello_____
% :
格式化操作符的右操作數(shù)可以是任何東西，如果是元組或者映射類型（如字典），那么字符串格式化將會(huì)有所不同。
輸出：
Hello,world
Hello,World
注意：如果需要轉(zhuǎn)換的元組作為轉(zhuǎn)換表達(dá)式的一部分存在，那么必須將它用圓括號(hào)括起來(lái)：
輸出：
Traceback (most recent call last):
File "F:\Python\test.py", line 2, in
str1='%s,%s' % 'Hello','world'
TypeError: not enough arguments for format string
如果需要輸出%這個(gè)特殊字符，毫無(wú)疑問(wèn)，我們會(huì)想到轉(zhuǎn)義，但是Python中正確的處理方式如下：
輸出：100%
對(duì)數(shù)字進(jìn)行格式化處理，通常需要控制輸出的寬度和精度：
輸出：
3.14
3.141593
3.14
字符串格式化還包含很多其他豐富的轉(zhuǎn)換類型，可參考官方文檔。
4、通用序列操作（方法）
從列表、元組以及字符串可以“抽象”出序列的一些公共通用方法（不是你想像中的CRUD），這些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及檢查某個(gè)元素是否屬于序列的成員。除此之外，還有計(jì)算序列長(zhǎng)度、最大最小元素等內(nèi)置函數(shù)。
（1）索引
輸出
H
2
345
索引從0（從左向右）開(kāi)始，所有序列可通過(guò)這種方式進(jìn)行索引。神奇的是，索引可以從最后一個(gè)位置（從右向左）開(kāi)始，編號(hào)是-1：
輸出：
o
3
123
（2）分片
分片操作用來(lái)訪問(wèn)一定范圍內(nèi)的元素。分片通過(guò)冒號(hào)相隔的兩個(gè)索引來(lái)實(shí)現(xiàn)：
輸出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4]
[6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[7, 8]
[7, 8, 9]
不同的步長(zhǎng)，有不同的輸出：
輸出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[0, 3, 6, 9]
[]
（3）序列相加
輸出：
Hello world
[1, 2, 3, 2, 3, 4]
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
print str1+num1
TypeError: cannot concatenate 'str' and 'list' objects
（4）乘法
輸出：
[None, None, None, None, None, None, None, None, None, None]
HelloHello
[1, 2, 1, 2]
Traceback (most recent call last):
File "F:\Python\test.py", line 5, in
print str1*num1
TypeError: can't multiply sequence by non-int of type 'list'
（5）成員資格
in運(yùn)算符會(huì)用來(lái)檢查一個(gè)對(duì)象是否為某個(gè)序列（或者其他類型）的成員（即元素）：
輸出：
False
True
True
（6）長(zhǎng)度、最大最小值
通過(guò)內(nèi)建函數(shù)len、max和min可以返回序列中所包含元素的數(shù)量、最大和最小元素。
輸出：
5
o
H
5
123
1
二、映射（字典）
映射中的每個(gè)元素都有一個(gè)名字，如你所知，這個(gè)名字專業(yè)的名稱叫鍵。字典（也叫散列表）是Python中唯一內(nèi)建的映射類型。
1、鍵類型
字典的鍵可以是數(shù)字、字符串或者是元組，鍵必須唯一。在Python中，數(shù)字、字符串和元組都被設(shè)計(jì)成不可變類型，而常見(jiàn)的列表以及集合（set）都是可變的，所以列表和集合不能作為字典的鍵。鍵可以為任何不可變類型，這正是Python中的字典最強(qiáng)大的地方。
輸出：
{1: 1}
Traceback (most recent call last):
File "F:\Python\test.py", line 6, in
d[list1]="Hello world."
TypeError: unhashable type: 'list'
2、自動(dòng)添加
即使鍵在字典中并不存在，也可以為它分配一個(gè)值，這樣字典就會(huì)建立新的項(xiàng)。
3、成員資格
表達(dá)式item in d（d為字典）查找的是鍵（containskey），而不是值（containsvalue）。
三、集合
集合（Set）在Python 2.3引入，通常使用較新版Python可直接創(chuàng)建，如下所示：
strs=set(['jeff','wong','cnblogs'])
nums=set(range(10))
看上去，集合就是由序列（或者其他可迭代的對(duì)象）構(gòu)建的。集合的幾個(gè)重要特點(diǎn)和方法如下：
1、副本是被忽略的
集合主要用于檢查成員資格，因此副本是被忽略的，如下示例所示,輸出的集合內(nèi)容是一樣的。
輸出如下：
set([0, 1, 2, 3, 4, 5])
set([0, 1, 2, 3, 4, 5])
2、集合元素的順序是隨意的
這一點(diǎn)和字典非常像，可以簡(jiǎn)單理解集合為沒(méi)有value的字典。
輸出如下：
set(['wong', 'cnblogs', 'jeff'])
3、集合常用方法
a、并集union
輸出：
set([1, 2, 3])
set([2, 3, 4])
set([1, 2, 3, 4])
union操作返回兩個(gè)集合的并集，不改變?cè)屑?。使用按位與（OR）運(yùn)算符“|”可以得到一樣的結(jié)果：
輸出和上面union操作一模一樣的結(jié)果。
其他常見(jiàn)操作包括（交集）,=,=,-,copy()等等，這里不再列舉。
輸出如下：
set([1, 2, 3])
set([2, 3, 4])
set([2, 3])
True
set([1, 2, 3])
False
b、add和remove
和序列添加和移除的方法非常類似，可參考官方文檔：
輸出：
set([1])
set([1, 2])
set([1])
set([1])
False
Traceback (most recent call last):
File "F:\Python\test.py", line 9, in
set1.remove(29) #移除不存在的項(xiàng)
KeyError: 29
4、frozenset
集合是可變的，所以不能用做字典的鍵。集合本身只能包含不可變值，所以也就不能包含其他集合：
輸出如下：
Traceback (most recent call last):
File "F:\Python\test.py", line 3, in
set1.add(set2)
TypeError: unhashable type: 'set'
可以使用frozenset類型用于代表不可變（可散列）的集合：
輸出：
set([1, frozenset([2])])
Python內(nèi)置函數(shù)有很多，為大家推薦5個(gè)神仙級(jí)的內(nèi)置函數(shù)：
(1)Lambda函數(shù)
用于創(chuàng)建匿名函數(shù)，即沒(méi)有名稱的函數(shù)。它只是一個(gè)表達(dá)式，函數(shù)體比def簡(jiǎn)單很多。當(dāng)我們需要?jiǎng)?chuàng)建一個(gè)函數(shù)來(lái)執(zhí)行單個(gè)操作并且可以在一行中編寫(xiě)時(shí)，就可以用到匿名函數(shù)了。
Lamdba的主體是一個(gè)表達(dá)式，而不是一個(gè)代碼塊。僅僅能在lambda表達(dá)式中封裝有限的邏輯進(jìn)去。
利用Lamdba函數(shù)，往往可以將代碼簡(jiǎn)化許多。
(2)Map函數(shù)
會(huì)將一個(gè)函數(shù)映射到一個(gè)輸入列表的所有元素上，比如我們先創(chuàng)建了一個(gè)函數(shù)來(lái)返回一個(gè)大寫(xiě)的輸入單詞，然后將此函數(shù)應(yīng)有到列表colors中的所有元素。
我們還可以使用匿名函數(shù)lamdba來(lái)配合map函數(shù)，這樣可以更加精簡(jiǎn)。
(3)Reduce函數(shù)
當(dāng)需要對(duì)一個(gè)列表進(jìn)行一些計(jì)算并返回結(jié)果時(shí)，reduce()是個(gè)非常有用的函數(shù)。舉個(gè)例子，當(dāng)需要計(jì)算一個(gè)整數(shù)列表所有元素的乘積時(shí)，即可使用reduce函數(shù)實(shí)現(xiàn)。
它與函數(shù)的最大的區(qū)別就是，reduce()里的映射函數(shù)(function)接收兩個(gè)參數(shù)，而map接收一個(gè)參數(shù)。
(4)enumerate函數(shù)
用于將一個(gè)可遍歷的數(shù)據(jù)對(duì)象(如列表、元組或字符串)組合為一個(gè)索引序列，同時(shí)列出數(shù)據(jù)和數(shù)據(jù)下標(biāo)，一般用在for循環(huán)當(dāng)中。
它的兩個(gè)參數(shù)，一個(gè)是序列、迭代器或其他支持迭代對(duì)象;另一個(gè)是下標(biāo)起始位置，默認(rèn)情況從0開(kāi)始，也可以自定義計(jì)數(shù)器的起始編號(hào)。
(5)Zip函數(shù)
用于將可迭代的對(duì)象作為參數(shù)，將對(duì)象中對(duì)應(yīng)的元素打包成一個(gè)個(gè)元組，然后返回由這些元組組成的列表
當(dāng)我們使用zip()函數(shù)時(shí)，如果各個(gè)迭代器的元素個(gè)數(shù)不一致，則返回列表長(zhǎng)度與最短的對(duì)象相同。
python join函數(shù)用法如下：
join函數(shù)python就是把一個(gè)list中所有的串按照你定義的分隔符連接起來(lái)。join是string類型的一個(gè)函數(shù)，用調(diào)用他的字符串去連接參數(shù)里的列表，python里面萬(wàn)物皆對(duì)象，調(diào)用join函數(shù)，將后面的列表里的值用逗號(hào)連接成新的字符串。str（i）foriinlist這是一個(gè)映射，就是把list中每個(gè)值都轉(zhuǎn)換成字符串。
函數(shù)含義
python中得thread的一些機(jī)制和C/C++不同：在C/C++中，主線程結(jié)束后，其子線程會(huì)默認(rèn)被主線程kill掉。而在python中，主線程結(jié)束后，會(huì)默認(rèn)等待子線程結(jié)束后，主線程才退出。
python對(duì)于thread的管理中有兩個(gè)函數(shù)：join和setDaemon。
join：如在一個(gè)線程B中調(diào)用threada。join（），則threada結(jié)束后，線程B才會(huì)接著threada。join（）往后運(yùn)行。
setDaemon：主線程A啟動(dòng)了子線程B，調(diào)用b。setDaemaon（True），則主線程結(jié)束時(shí)，會(huì)把子線程B也殺死，與C/C++中得默認(rèn)效果是一樣的。
字典是一種通過(guò)名字或者關(guān)鍵字引用的得數(shù)據(jù)結(jié)構(gòu)，其鍵可以是數(shù)字、字符串、元組，這種結(jié)構(gòu)類型也稱之為映射。字典類型是Python中唯一內(nèi)建的映射類型，基本的操作包括如下：
(1)len()：返回字典中鍵—值對(duì)的數(shù)量；
(2)d[k]:返回關(guān)鍵字對(duì)于的值；
(3)d[k]=v:將值關(guān)聯(lián)到鍵值k上；
(4)del d[k]:刪除鍵值為k的項(xiàng)；
(5)key in d:鍵值key是否在d中，是返回True，否則返回False。
(6)clear函數(shù)：清除字典中的所有項(xiàng)
(7)copy函數(shù)：返回一個(gè)具有相同鍵值的新字典；deepcopy()函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個(gè)方法可以解決由于副本修改而使原始字典也變化的問(wèn)題
(8)fromkeys函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對(duì)應(yīng)的值為None
(9)get函數(shù)：訪問(wèn)字典成員
(10)has_key函數(shù)：檢查字典中是否含有給出的鍵
(11)items和iteritems函數(shù):items將所有的字典項(xiàng)以列表方式返回，列表中項(xiàng)來(lái)自（鍵，值），iteritems與items作用相似，但是返回的是一個(gè)迭代器對(duì)象而不是列表
(12)keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器
(13)pop函數(shù)：刪除字典中對(duì)應(yīng)的鍵
(14)popitem函數(shù)：移出字典中的項(xiàng)
(15)setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值
(16)update函數(shù)：用一個(gè)字典更新另外一個(gè)字典
(17)?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素
一、字典的創(chuàng)建
1.1 直接創(chuàng)建字典
d={'one':1,'two':2,'three':3}
printd
printd['two']
printd['three']
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1.2 通過(guò)dict創(chuàng)建字典
# _*_ coding:utf-8 _*_
items=[('one',1),('two',2),('three',3),('four',4)]
printu'items中的內(nèi)容:'
printitems
printu'利用dict創(chuàng)建字典，輸出字典內(nèi)容:'
d=dict(items)
printd
printu'查詢字典中的內(nèi)容:'
printd['one']
printd['three']
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
items中的內(nèi)容:
[('one',1), ('two',2), ('three',3), ('four',4)]
利用dict創(chuàng)建字典，輸出字典內(nèi)容:
{'four':4,'three':3,'two':2,'one':1}
查詢字典中的內(nèi)容:
或者通過(guò)關(guān)鍵字創(chuàng)建字典
# _*_ coding:utf-8 _*_
d=dict(one=1,two=2,three=3)
printu'輸出字典內(nèi)容:'
printd
printu'查詢字典中的內(nèi)容:'
printd['one']
printd['three']
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
輸出字典內(nèi)容:
{'three':3,'two':2,'one':1}
查詢字典中的內(nèi)容:
二、字典的格式化字符串
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
print"three is %(three)s."%d
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
threeis3.
三、字典方法
3.1?clear函數(shù)：清除字典中的所有項(xiàng)
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
d.clear()
printd
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
{}
請(qǐng)看下面兩個(gè)例子
3.1.1
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d={}
printd
printdd
運(yùn)算結(jié)果：
=======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
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{}
3.1.2與3.1.1唯一不同的是在對(duì)字典d的清空處理上，3.1.1將d關(guān)聯(lián)到一個(gè)新的空字典上，這種方式對(duì)字典dd是沒(méi)有影響的，所以在字典d被置空后，字典dd里面的值仍舊沒(méi)有變化。但是在3.1.2中clear方法清空字典d中的內(nèi)容，clear是一個(gè)原地操作的方法，使得d中的內(nèi)容全部被置空，這樣dd所指向的空間也被置空。
3.2?copy函數(shù)：返回一個(gè)具有相同鍵值的新字典
# _*_ coding:utf-8 _*_
x={'one':1,'two':2,'three':3,'test':['a','b','c']}
printu'初始X字典：'
printx
printu'X復(fù)制到Y(jié)：'
y=x.copy()
printu'Y字典：'
printy
y['three']=33
printu'修改Y中的值，觀察輸出：'
printy
printx
printu'刪除Y中的值，觀察輸出'
y['test'].remove('c')
printy
printx
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
初始X字典：
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
X復(fù)制到Y(jié)：
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}
注：在復(fù)制的副本中對(duì)值進(jìn)行替換后，對(duì)原來(lái)的字典不產(chǎn)生影響，但是如果修改了副本，原始的字典也會(huì)被修改。deepcopy函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個(gè)方法可以解決由于副本修改而使原始字典也變化的問(wèn)題。
# _*_ coding:utf-8 _*_
fromcopyimportdeepcopy
x={}
x['test']=['a','b','c','d']
y=x.copy()
z=deepcopy(x)
printu'輸出：'
printy
printz
printu'修改后輸出：'
x['test'].append('e')
printy
printz
運(yùn)算輸出：
=======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函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對(duì)應(yīng)的值為None
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'])
printd
運(yùn)算輸出：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':None,'two':None,'one':None}
或者指定默認(rèn)的對(duì)應(yīng)值
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'],'unknow')
printd
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':'unknow','two':'unknow','one':'unknow'}
3.4?get函數(shù)：訪問(wèn)字典成員
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.get('one')
printd.get('four')
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1
None
注：get函數(shù)可以訪問(wèn)字典中不存在的鍵，當(dāng)該鍵不存在是返回None
3.5?has_key函數(shù)：檢查字典中是否含有給出的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.has_key('one')
printd.has_key('four')
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
True
False
3.6?items和iteritems函數(shù):items將所有的字典項(xiàng)以列表方式返回，列表中項(xiàng)來(lái)自（鍵，值），iteritems與items作用相似，但是返回的是一個(gè)迭代器對(duì)象而不是列表
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
list=d.items()
forkey,valueinlist:
printkey,':',value
運(yùn)算結(jié)果：
=======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
運(yùn)算結(jié)果：
=======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
運(yùn)算結(jié)果：
=======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函數(shù)：刪除字典中對(duì)應(yīng)的鍵
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.pop('one')
printd
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'three':3,'two':2}
3.9?popitem函數(shù)：移出字典中的項(xiàng)
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.popitem()
printd
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'two':2,'one':1}
3.10?setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.setdefault('one',1)
printd.setdefault('four',4)
printd
運(yùn)算結(jié)果：
{'three':3,'two':2,'one':1}
{'four':4,'three':3,'two':2,'one':1}
3.11?update函數(shù)：用一個(gè)字典更新另外一個(gè)字典
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3
}
printd
x={'one':1}
d.update(x)
printd
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':123}
{'three':3,'two':2,'one':1}
3.12?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3,
'test':2
}
printd.values()
運(yùn)算結(jié)果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
[2,3,2,123]
內(nèi)置函數(shù)就是Python給你提供的，拿來(lái)直接用的函數(shù)，比如print.，input等。
截止到python版本3.6.2 ，python一共提供了68個(gè)內(nèi)置函數(shù)，具體如下
本文將這68個(gè)內(nèi)置函數(shù)綜合整理為12大類，正在學(xué)習(xí)Python基礎(chǔ)的讀者一定不要錯(cuò)過(guò)，建議收藏學(xué)習(xí)！
（1）列表和元組
（2）相關(guān)內(nèi)置函數(shù)
（3）字符串
frozenset 創(chuàng)建一個(gè)凍結(jié)的集合，凍結(jié)的集合不能進(jìn)行添加和刪除操作。
語(yǔ)法：sorted(Iterable, key=函數(shù)(排序規(guī)則), reverse=False)
語(yǔ)法：fiter(function. Iterable)
function: 用來(lái)篩選的函數(shù). 在?lter中會(huì)自動(dòng)的把iterable中的元素傳遞給function. 然后根據(jù)function返回的True或者False來(lái)判斷是否保留留此項(xiàng)數(shù)據(jù) , Iterable: 可迭代對(duì)象
搜索公眾號(hào)頂級(jí)架構(gòu)師后臺(tái)回復(fù)“面試”，送你一份驚喜禮包。
語(yǔ)法 : map(function, iterable)
可以對(duì)可迭代對(duì)象中的每一個(gè)元素進(jìn)行映射. 分別去執(zhí)行 function
hash : 獲取到對(duì)象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空間換的時(shí)間 比較耗費(fèi)內(nèi)存
重慶分公司
重慶分公司
