摘要：數(shù)據(jù)類型變量用來(lái)存儲(chǔ)值，值可以被改變。數(shù)據(jù)的類型是各種各樣的，在小節(jié)中我們已經(jīng)看到非常普遍的數(shù)據(jù)類型數(shù)字，布爾值，字符串。在中有個(gè)內(nèi)置函數(shù)，可以通過(guò)它來(lái)檢查一個(gè)對(duì)象的類型上面交互命令行中出現(xiàn)了四種簡(jiǎn)單的數(shù)據(jù)類型，分別是，，，。

該系列文章：

《python入門，編程基礎(chǔ)概念介紹（變量，條件，函數(shù)，循環(huán)）》

《python中的數(shù)據(jù)類型（list，tuple，dict，set，None）》

《在python中創(chuàng)建對(duì)象（object）》

python解釋器主要包含了兩大部分，一個(gè)部分相當(dāng)于編譯器，另一個(gè)部分相當(dāng)于虛擬機(jī)。python解釋器的編譯器部分首先把程序編譯成中間碼（字節(jié)碼），再由python解釋器里的虛擬機(jī)部分（Python Virtual　Machine (PVM)）運(yùn)行字節(jié)碼。

我們知道，給函數(shù)提供輸入（input），則函數(shù)會(huì)處理輸入（input），返回結(jié)果（output）或者不返回。程序就是解決問(wèn)題的一系列步驟，這被稱為面向過(guò)程（Procedure Oriented） 的編程方式。后來(lái)，編程語(yǔ)言中出現(xiàn)了一種 面向?qū)ο螅∣bject Orientend） 的思想，簡(jiǎn)單來(lái)說(shuō)，對(duì)象借鑒了現(xiàn)實(shí)世界由一個(gè)個(gè)客體組成的概念，用一個(gè)個(gè)對(duì)象間的互動(dòng)來(lái)組織起程序，跟現(xiàn)實(shí)世界的客體類似，對(duì)象有自己的特征（對(duì)象里的各種值），對(duì)象也有自己能夠做到的事（通過(guò)對(duì)象里的各種方法）。對(duì)象里的各種值被叫做對(duì)象的字段（field） ，對(duì)象里的各種方法被叫做對(duì)象的方法（method） ，對(duì)象的字段跟方法統(tǒng)稱為對(duì)象的屬性（attribute） 。

對(duì)象的字段類似于編程語(yǔ)言里的普通變量，所不同的是對(duì)象的字段是對(duì)象獨(dú)有的。如果一個(gè)對(duì)象叫a,a有個(gè)屬性是b,我們?nèi)绾卧L問(wèn)b呢？答案是通過(guò)a.b這種形式的寫法訪問(wèn)。a.b的意思就是a的屬性b。

對(duì)象的方法類似于編程語(yǔ)言中的函數(shù)，所不同的是對(duì)象的方法是對(duì)象獨(dú)有的，如果一個(gè)對(duì)象叫c，c有個(gè)方法是d，我們?nèi)绾问褂茫ㄕ{(diào)用）d呢？答案是通過(guò)c.d()這種形式的寫法來(lái)是使用，d方法可以帶參數(shù),形如這樣：c.d(a)。c.d()的意思就是使用（調(diào)用）c的方法d。

如何實(shí)現(xiàn)對(duì)象呢？有一種方法就是通過(guò)類（class）來(lái)實(shí)現(xiàn)。對(duì)象對(duì)應(yīng)于現(xiàn)實(shí)中一個(gè)個(gè)具體的客體，這些客體各不相同，但是很明顯，有一些客體是可以歸到同一個(gè)陣營(yíng)里去的，比如所有的人，所有的蘋果，所有的貓，這里的人、蘋果、貓是抽象的一般概念，程序中的類（class） 就是基于像這樣的一般概念而抽象出來(lái)的某一類客體的模板，可以是人的類，蘋果的類，貓的類。從類（模板）中可以構(gòu)造出這一類客體的對(duì)象。從類到對(duì)象，相當(dāng)于從藍(lán)圖中實(shí)現(xiàn)了一個(gè)對(duì)象，所以可以說(shuō)某對(duì)象是某個(gè)類的一個(gè)實(shí)例（實(shí)現(xiàn)了的例子）。反過(guò)來(lái)，某個(gè)類規(guī)定了將要實(shí)現(xiàn)的對(duì)象的該有的屬性跟方法，跟別的類實(shí)現(xiàn)的對(duì)象有了區(qū)別，所以對(duì)象的類型（type） 就是它所承襲的類。

內(nèi)存（memory）：是指計(jì)算中的隨機(jī)存取內(nèi)存（random access memory (RAM)）。可以認(rèn)為，內(nèi)存是一張很大的表，其中的每個(gè)表格（1個(gè)字節(jié)）有兩個(gè)屬性：地址和值。地址表示了某個(gè)表格在內(nèi)存這張大表中的位置，因此我們可以通過(guò)地址找到該表格；一旦找到該表格，就可以對(duì)該表格的值進(jìn)行擦除并重寫的操作，或者只是讀取該表格的值。具體的細(xì)節(jié)我們可以不用去考慮，我們需要更加抽象的思考地址和值，任意大小的一塊內(nèi)存都可以有一個(gè)（標(biāo)識(shí)）地址來(lái)讓我們?cè)谡麄€(gè)內(nèi)存中找到它，該內(nèi)存塊中能存儲(chǔ)復(fù)雜的值。

程序要運(yùn)行時(shí)，操作系統(tǒng)就會(huì)給它分配一塊可用的內(nèi)存，或者由某高級(jí)語(yǔ)言虛擬機(jī)提供運(yùn)行時(shí)環(huán)境。在該內(nèi)存空間（運(yùn)行時(shí)環(huán)境）里，首先會(huì)載入程序本身（機(jī)器碼或者字節(jié)碼），接下來(lái)會(huì)載入整個(gè)程序可以用的東西（全局（類）變量，模塊等），除此之外的內(nèi)存會(huì)劃分為兩種，一種是程序運(yùn)行時(shí)的調(diào)用棧（call stack），另一種則是堆（heap）。在這里，內(nèi)存并非計(jì)算機(jī)中真實(shí)的物理內(nèi)存，而是由操作系統(tǒng)通過(guò)軟硬件結(jié)合的一種技術(shù)分配的一塊虛擬內(nèi)存，該虛擬內(nèi)存中的虛擬地址跟計(jì)算機(jī)中真實(shí)的物理內(nèi)存地址之間有著映射的關(guān)系。在這樣的虛擬內(nèi)存空間里，地址是連續(xù)的，也就是說(shuō)程序運(yùn)行在某一塊特定的虛擬內(nèi)存中，可以想象成一個(gè)長(zhǎng)塊兒。

當(dāng)程序運(yùn)行時(shí)，主函數(shù)（main函數(shù)）或者首先被執(zhí)行的函數(shù)（方法）會(huì)被放入到調(diào)用棧中，因?yàn)檎{(diào)用棧中只有這一幀，所以它處在調(diào)用棧的頂層，一旦處在調(diào)用棧的頂層，就會(huì)被激活，被激活的幀（frame）得到程序的執(zhí)行權(quán)，該幀中的代碼被一步步執(zhí)行，我們把這一幀姑且叫第0幀吧。第0幀中調(diào)用另一個(gè)函數(shù)（方法）時(shí)，被調(diào)用函數(shù)（方法）的幀被放入到調(diào)用棧的最頂層，我們把這一幀叫第1幀，現(xiàn)在，被激活的幀就變成了第1幀，程序的執(zhí)行權(quán)轉(zhuǎn)移到第1幀中，它首先會(huì)把被調(diào)用時(shí)傳進(jìn)來(lái)的參數(shù)（如果有）存儲(chǔ)，接著就聲明和初始化局部（實(shí)例）變量，操作變量……當(dāng)第1幀調(diào)用另一個(gè)函數(shù)（方法）時(shí)，被調(diào)用函數(shù)（方法）的幀被放入到調(diào)用棧的最頂層，我們把這一幀叫第2幀，如前所述，第2幀被激活，得到程序執(zhí)行權(quán)，當(dāng)第2幀執(zhí)行結(jié)束，返回值（如果有），這時(shí)候第2幀的內(nèi)存被銷毀，包括其中的局部（實(shí)例）變量、參數(shù)等等，第2幀在調(diào)用棧中不在存在，這時(shí)候，第1幀成為調(diào)用棧的頂層，程序的執(zhí)行權(quán)又重新回到第1幀，第1幀繼續(xù)執(zhí)行剩余的代碼，當(dāng)第1幀執(zhí)行結(jié)束，返回值（如果有），第１幀被銷毀，調(diào)用棧中最頂層的幀重新變成第0幀,如果第0幀執(zhí)行結(jié)束，則調(diào)用棧空白……這其中，被調(diào)用函數(shù)（方法）放入調(diào)用棧最頂層被稱為推入（push），而在調(diào)用棧中被銷毀則被稱為彈出（pop）。

調(diào)用棧（call stack）中的函數(shù)（方法）里存儲(chǔ)著程序運(yùn)行過(guò)程中該如何做的行為（動(dòng)作、指令）和需要處理的局部（實(shí)例）變量，這些變量實(shí)際上是怎么被存儲(chǔ)的呢？不同的編程語(yǔ)言有不同的存儲(chǔ)方式，實(shí)際上有兩種最為主流的做法。

我們從上篇文章《python入門，編程基礎(chǔ)概念介紹（變量，條件，函數(shù)，循環(huán)）》已經(jīng)知道，變量的值有各種各樣的類型。像簡(jiǎn)單的數(shù)字，布爾值，字符串……，對(duì)于這些比較簡(jiǎn)單的值，一種方法就是把它們看做原始（內(nèi)置）類型，直接在調(diào)用棧內(nèi)存中分配出一塊能容納該類型值的內(nèi)存，把該值存進(jìn)去，通過(guò)變量名來(lái)使用該值。這時(shí)候變量仿佛就是這些值了。這種存儲(chǔ)類型又被稱為值類型（value type）。需要注意的是，靜態(tài)類型語(yǔ)言中的變量是有類型的，一旦聲明成某種類型的，則只能存儲(chǔ)該類型的值；動(dòng)態(tài)類型語(yǔ)言中的變量不存在類型，可以存儲(chǔ)任何類型的值。

對(duì)于簡(jiǎn)單的數(shù)字，布爾值，字符串……這些類型的值，另一種方法就是把它們都存在堆（heap）內(nèi)存空間里。在調(diào)用棧中的變量里，實(shí)際存儲(chǔ)的是堆（heap）內(nèi)存空間里的某一塊內(nèi)存的地址。當(dāng)一個(gè)變量被聲明并且被賦值的時(shí)候發(fā)生了什么呢？實(shí)際上發(fā)生的是首先在堆（heap）內(nèi)存空間中分配出一塊能容納該類型值的內(nèi)存，把該值存進(jìn)去；然后把該內(nèi)存的地址綁定到變量上。這時(shí)候我們就說(shuō)該變量引用（reference） 了該值。這種存儲(chǔ)類型被稱為引用類型（reference type）。有時(shí)候也能夠看到這種說(shuō)法：變量里存儲(chǔ)的是值的引用，可以看到，值的內(nèi)存地址跟值的引用的說(shuō)法可以互換。

前面我們簡(jiǎn)略介紹了對(duì)象，對(duì)象可以看做是種復(fù)雜類型的值，你可以想想，對(duì)象里的各種屬性和各種方法。那么當(dāng)我們有一個(gè)對(duì)象的時(shí)候，或者有某個(gè)復(fù)雜類型的值的時(shí)候，不同的編程語(yǔ)言都不約而同的選擇了堆（heap）內(nèi)存空間。這是為什么呢？因?yàn)檎{(diào)用棧中的值需要的內(nèi)存塊的大小一旦確定就不能改變，而堆則沒(méi)有這個(gè)限制，有可能一個(gè)對(duì)象占用很大的一塊內(nèi)存，并且在程序運(yùn)行過(guò)程中動(dòng)態(tài)的變大或者變小。

變量用來(lái)存儲(chǔ)值，值可以被改變。正如我們之前好幾次說(shuō)到的那樣，值的類型各種各樣，但都攜帶了某種信息，并且這種信息可以被操作（處理），我們可以認(rèn)為，它們都是數(shù)據(jù)（data）。

數(shù)據(jù)的類型（type） 是各種各樣的，在1.3小節(jié)中我們已經(jīng)看到非常普遍的數(shù)據(jù)類型：數(shù)字，布爾值，字符串。對(duì)這些簡(jiǎn)單的數(shù)據(jù)類型，我們已經(jīng)知道普遍存在的兩種存儲(chǔ)方式，那么在python中呢？在python中，一切數(shù)據(jù)類型都是對(duì)象，所以，我們存儲(chǔ)任何數(shù)據(jù)類型的方式都是通過(guò)引用（reference） 。

在python中有個(gè)內(nèi)置函數(shù)type()，可以通過(guò)它來(lái)檢查一個(gè)對(duì)象的類型：

>>> type(1)

>>> type(1.1)

>>> type("int")

>>> type(True)

>>> 

上面交互命令行中出現(xiàn)了四種簡(jiǎn)單的數(shù)據(jù)類型，分別是int，float，str，bool。如果兩個(gè)變量同時(shí)引用了相同的對(duì)象，會(huì)發(fā)生什么呢？在python中有個(gè)內(nèi)置的函數(shù)id()，這個(gè)函數(shù)返回對(duì)象的一個(gè)id，可以把該id看做該對(duì)象的引用（內(nèi)存地址）。讓我們看看兩個(gè)變量同時(shí)引用相同的對(duì)象時(shí)發(fā)生了什么：

>>> a=1
>>> b=1
>>> id(a)
255681632
>>> id(b)
255681632
>>> 

可以看到，兩個(gè)變量指向了同一個(gè)對(duì)象，那么當(dāng)我們改變了其中某個(gè)變量引用的對(duì)象，是不是另一個(gè)變量引用的對(duì)象也同時(shí)改變了呢？從理論上講會(huì)改變，對(duì)吧，因?yàn)槭峭粋€(gè)對(duì)象。我們來(lái)看看：

>>> a=1
>>> b=1
>>> id(a)
255681632
>>> id(b)
255681632
>>> b=2 #改變b的值
>>> a
1
>>>

事實(shí)并不像我們認(rèn)為的那樣，另一個(gè)變量的對(duì)象并沒(méi)有改變。這是因?yàn)椋趐ython中，上面出現(xiàn)的這四種簡(jiǎn)單的數(shù)據(jù)類型都是不可變（immutable） 對(duì)象。舉個(gè)數(shù)字的例子來(lái)理解這種不可變性：數(shù)字1是個(gè)對(duì)象，是個(gè)獨(dú)立的客體，看起來(lái)這個(gè)對(duì)象簡(jiǎn)單到不能再簡(jiǎn)單，我們無(wú)法改變它，如果將變量的引用從數(shù)字1改變成數(shù)字2，那么，已經(jīng)是另一個(gè)對(duì)象了，相當(dāng)于是更新了變量的引用。

直到現(xiàn)在，我們處理過(guò)的數(shù)據(jù)類型都很簡(jiǎn)單，但是當(dāng)我們想要存儲(chǔ)更為復(fù)雜多變的數(shù)據(jù)，用我們目前知道的數(shù)據(jù)類型來(lái)存儲(chǔ)就會(huì)越來(lái)越繁瑣，容易出錯(cuò)了。比如我們想要在程序里一次性處理包含6個(gè)數(shù)字的內(nèi)容（7，9，11，36，74，12），難道我們要給每個(gè)數(shù)字都提供一個(gè)變量名，并一一存儲(chǔ)嗎？我們還有更多選擇，在python中，它提供了一種叫列表（list） 的數(shù)據(jù)類型，這種數(shù)據(jù)類型像個(gè)容器，可以裝進(jìn)去其他各種數(shù)據(jù)類型，甚至也可以將其他列表（list）嵌套進(jìn)去。我們要把7，9，11，36，74，12放進(jìn)一個(gè)列表（list）中，可以這么做：

#把這幾個(gè)數(shù)字放進(jìn)列表，并賦值給變量x
x=[7,9,11,36,74,12]  
#可以定義一個(gè)空列表
y=[]
#使用內(nèi)置函數(shù)list()創(chuàng)建列表
a=list("abc")
b=list()

現(xiàn)在把數(shù)字放進(jìn)一個(gè)列表了，那么我們?cè)趺茨贸瞿硞€(gè)數(shù)字呢？跟字符串類似，列表中的元素組成了一串，每個(gè)元素在列表中都是有順序的。每個(gè)元素都被分配了一個(gè)位置索引（index）。我們可以通過(guò)特定的索引來(lái)訪問(wèn)對(duì)應(yīng)的元素，根據(jù)慣例，索引總是從0開(kāi)始。

x=[7,9,11,36,74,12]
z=len(x)
#從列表x中循環(huán)取出數(shù)字，并打印到命令行
for index in range(z):
    print(str(x[index]))

列表中的元素的值能不能改變呢？能不能增加或者減少元素？答案是可以的。我們說(shuō)python中一切數(shù)據(jù)類型都是對(duì)象，列表也是對(duì)象，所有它有自己的專屬方法。可以通過(guò)列表的append()方法來(lái)增加元素，增加的元素被追加到列表結(jié)尾。刪除一個(gè)元素呢，可以通過(guò)del語(yǔ)句來(lái)刪除，也可以通過(guò)列表的remove()方法或者pop()方法來(lái)刪除。這里要注意，remove方法通過(guò)值來(lái)刪除，pop方法通過(guò)索引來(lái)刪除，并且remove方法沒(méi)有返回值，而pop方法則返回要?jiǎng)h除的值。如果我們不只想刪除某一個(gè)元素，而是想清空整個(gè)列表，則可以使用列表的clear()方法。看下面：

a=["change me",["first",1,2],2019,True]
#以下注釋都根據(jù)慣例，從0開(kāi)始計(jì)數(shù)
#改變第0個(gè)元素的值
a[0]="changed"
print("列表a: {}".format(a))
#改變第1個(gè)元素（list）中的第0個(gè)元素
a[1][0]=0
print("列表a: {}".format(a))
#增加一個(gè)元素
a.append(2019)
print("列表a: {}".format(a))
#刪除一個(gè)元素,通過(guò)del語(yǔ)句
del a[0]
print("列表a: {}".format(a))
#刪除一個(gè)元素，通過(guò)remove方法
a.remove(True)
print("列表a: {}".format(a))
#刪除一個(gè)元素，通過(guò)pop方法,并將返回值賦給變量b
b=a.pop(2)
print("被刪除的元素是{}".format(b))
print("列表a: {}".format(a))
#清空列表
a.clear()
print("列表a: {}".format(a))

以上代碼中，用到了str的format()方法，這種方法通過(guò)在字符串保留一對(duì){}，來(lái)讓format方法中的參數(shù)填充其中，參數(shù)可以是任意多個(gè)（需要與前面{}的數(shù)量一致），可以是各種數(shù)據(jù)類型。這個(gè)方法大大簡(jiǎn)化了我們想把其他數(shù)據(jù)類型加入到字符串的過(guò)程。運(yùn)行結(jié)果如下：

列表a: ["changed", ["first", 1, 2], 2019, True]
列表a: ["changed", [0, 1, 2], 2019, True]
列表a: ["changed", [0, 1, 2], 2019, True, 2019]
列表a: [[0, 1, 2], 2019, True, 2019]
列表a: [[0, 1, 2], 2019, 2019]
被刪除的元素是2019
列表a: [[0, 1, 2], 2019]
列表a: []

既然python中的數(shù)據(jù)類型都是對(duì)象，那么我們?nèi)绾闻袛鄡蓚€(gè)對(duì)象是否是同一個(gè)呢。答案用is操作符。比如我們想要判斷a對(duì)象與b對(duì)象是否同一，則可以通過(guò)a is b來(lái)判斷，其結(jié)果是布爾值。

我們看到，列表里的元素可以比一個(gè)多，字符串里的字符也可以比一個(gè)多，所以我們給這種其中的元素或者屬性可以比一個(gè)多的對(duì)象運(yùn)用in操作符（查看某元素是否屬于該對(duì)象,這被稱為成員檢測(cè)），來(lái)提供給for循環(huán)語(yǔ)句或者別的語(yǔ)句，讓這些語(yǔ)句逐個(gè)訪問(wèn)其中的元素或者屬性，這個(gè)行為可以稱為迭代。前面說(shuō)到的內(nèi)置函數(shù)list()可接受的參數(shù)就是可以被迭代的對(duì)象。上篇文章中講到的for...in循環(huán)就是迭代的一個(gè)例子。

#in操作符的例子
>>> x="hello"
>>> "h" in x
True
>>>

在講列表（list）之前，我們說(shuō)到了不可變對(duì)象。那么列表的情況又是如何呢？我們把那個(gè)例子中的數(shù)據(jù)類型換成列表來(lái)看看：

a=["change me",["first",1,2],2019,True]
#把同樣的引用賦值給變量b
b=a
#看看引用是否相同，是否對(duì)象是同一個(gè)
print(a is b)
#通過(guò)變量b改變列表
b[0]="changed"
#現(xiàn)在打印出變量a，看是否有變化
print(a)

以上代碼運(yùn)行結(jié)果如下：

True
["changed", ["first", 1, 2], 2019, True]

從運(yùn)行結(jié)果來(lái)看，列表是可以改變的，所以是可變（mutable）對(duì)象。現(xiàn)在我們已經(jīng)把可變對(duì)象和不可變對(duì)象的行為差不多摸清楚了。講不可變對(duì)象的時(shí)候我們講解了一個(gè)數(shù)字對(duì)象的例子來(lái)幫助理解不可變對(duì)象，現(xiàn)在我們來(lái)通過(guò)字符串的例子來(lái)進(jìn)一步說(shuō)明，假如我們把一個(gè)字符串“string”的引用賦值給變量a，那么我們是不能對(duì)其中的字符來(lái)進(jìn)行修改的，如下圖：

>>> a="string"
>>> a[0]="a"
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "str" object does not support item assignment

但是對(duì)于變量a來(lái)說(shuō)，它是完全可以更新的，可以把另一個(gè)對(duì)象的引用重新賦值給它：

>>> a="string"
>>> a[0]="a"
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "str" object does not support item assignment
>>> a="hello"
>>> a
"hello"
>>>

事實(shí)上不可變對(duì)象無(wú)論是看著無(wú)法改變的，還是直覺(jué)上感覺(jué)可以改變的（比如字符串），都是python中規(guī)定好了的。所以不必糾結(jié)于直覺(jué)，我們要做的是記住哪些數(shù)據(jù)類型是可變的，而哪些數(shù)據(jù)類型又是不可變的。下面將介紹一種新的數(shù)據(jù)類型，它跟列表類似，最大的不同是，它是不可變的。它叫元組（tuple）。

元組（tuple） 中可以裝進(jìn)去其他各種數(shù)據(jù)類型，甚至也可以將其他元組（tuple）嵌套進(jìn)去。元組（tuple）的元素有索引（index），可以通過(guò)索引訪問(wèn)到。

#空元組
tuple1=()
#一個(gè)元素的tuple,寫法特殊一點(diǎn)。如果在元素后面不加逗號(hào)
#則python解釋器會(huì)當(dāng)成元素的數(shù)據(jù)類型，而不認(rèn)為是個(gè)元組
tuple2=(2,)
#另一個(gè)元組，它里面有個(gè)列表作為元素
tuple3=(2,"lalala",True,45,[4,5])
#使用內(nèi)置函數(shù)tuple()創(chuàng)建元組，該函參數(shù)接受可迭代的對(duì)象
a=tuple()
b=tuple([1,2,3])

因?yàn)樵M是不可變對(duì)象，所以它其中的元素是不能修改的。元素也不能增刪。但整個(gè)元組是可以通過(guò)del語(yǔ)句刪除的。但是當(dāng)元組中的元素是可變對(duì)象時(shí)，比如元組中的某個(gè)元素是列表，那該列表能不能修改？因?yàn)樵摿斜硎强勺儗?duì)象，所以該列表中的元素是可以自然增刪修改的，但該列表因?yàn)槭遣豢勺儗?duì)象中的元素，所以無(wú)法刪除，如下：

>>> d=(2, "lalala", True, 45, [5, 5])
>>> d[4][0]=88
>>> print(d)
(2, "lalala", True, 45, [88, 5])
>>> del d[4]
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "tuple" object doesn"t support item deletion
>>> del d[4][0]
>>> print(d)
(2, "lalala", True, 45, [5])
>>>

那么情況反過(guò)來(lái)呢？當(dāng)可變對(duì)象中的元素是不可變對(duì)象時(shí)，比如當(dāng)列表中的某元素是個(gè)元組，該元組是否能夠被修改？因?yàn)樵撛M是不可變對(duì)象，所以該元組中的元素不能被修改，但是該元組本身是可變對(duì)象的元素，所以可以被刪除，如下：

>>> e=["he!",0,(4,5,"last")]
>>> e[2][0]=5
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "tuple" object does not support item assignment
>>> del e[2][0]
Traceback (most recent call last):
  File "", line 1, in 
TypeError: "tuple" object doesn"t support item deletion
>>> del e[2]
>>> print(e)
["he!", 0]
>>>

一個(gè)數(shù)據(jù)集合里面的元素根據(jù)放入的先后順序排成一串，這種形式的數(shù)據(jù)可以被稱為序列。字符串，列表，元組都有著類似序列的結(jié)構(gòu)，所以也就有類似的行為，它們都可以被索引，都可以被迭代，都能夠通過(guò)索引訪問(wèn)到其中的元素；不僅僅是能夠訪問(wèn)到其中的某一個(gè)元素，還能訪問(wèn)到其中的某幾個(gè)元素，這種同時(shí)訪問(wèn)到好幾個(gè)元素的行為，稱為切片（也可以把被訪問(wèn)的這些元素稱為數(shù)據(jù)的切片），因?yàn)檫@樣做相當(dāng)于從整個(gè)數(shù)據(jù)序列中切下來(lái)一部分，如下：

x="string"
y=[1,2,3,4,5,6]
z=(7,8,9,10,11,12)
#以下注釋都根據(jù)慣例，從0開(kāi)始計(jì)數(shù)
#打印出字符串的第3個(gè)字符
print(x[3])
#打印出字符串的倒數(shù)第2個(gè)字符
print(x[-2])
#打印出字符串的一部分，從第1個(gè)開(kāi)始，到第3個(gè)字符，不包括第4個(gè)字符
print(x[1:4])
#打印出列表的倒數(shù)第3個(gè)元素
print(str(y[-3]))
#打印出列表的一部分，從第1個(gè)元素開(kāi)始，到第4個(gè)元素，不包括第5個(gè)元素
print(str(y[1:5]))
#打印出列表的一部分，從第1個(gè)元素開(kāi)始，直到結(jié)束
print(str(y[1:]))
#打印出元組的倒數(shù)第4個(gè)元素
print(str(z[-4]))
#打印出元組的一部分，從第1個(gè)元素開(kāi)始，到第4個(gè)元素，不包括第5個(gè)元素
print(str(z[1:5]))
#打印出列表的一部分，從第1個(gè)元素開(kāi)始，直到結(jié)束
print(str(z[1:]))

運(yùn)行如下：

i
n
tri
4
[2, 3, 4, 5]
[2, 3, 4, 5, 6]
9
(8, 9, 10, 11)
(8, 9, 10, 11, 12)

切片中可以設(shè)置步長(zhǎng)，就是說(shuō)可以設(shè)置隔著幾個(gè)元素的方式訪問(wèn)數(shù)據(jù)的一部分，默認(rèn)步長(zhǎng)為1，如下：

>>> a=(1,2,3,4,5,6,7,8,9,10)
>>> a[::1]
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
>>> a[::2]
(1, 3, 5, 7, 9)
>>>

當(dāng)我們把數(shù)據(jù)的切片賦值給變量時(shí)會(huì)發(fā)生什么？一般來(lái)說(shuō)，數(shù)據(jù)被切片部分會(huì)被復(fù)制一份副本，然后把副本的引用賦值給變量。但是，有個(gè)特殊情況，就是當(dāng)數(shù)據(jù)的被切片部分是全部數(shù)據(jù)本身時(shí)，那該數(shù)據(jù)要看是可變對(duì)象還是不可變對(duì)象了。列表（可變對(duì)象）則會(huì)復(fù)制一份副本，然后把副本的引用賦值給變量，而字符串、元組（不可變對(duì)象）則會(huì)直接將該數(shù)據(jù)本身的引用直接賦值給變量，如下：

>>> a=[1,2,3,4]
>>> b=a[:]  #省略掉開(kāi)頭跟結(jié)尾index則切片結(jié)果是數(shù)據(jù)本身
>>> id(a)
140046385947272
>>> id(b)
140046386409992
>>> c=(1,2,[2,3])
>>> d=c[:]
>>> id(c)
140046385743768
>>> id(d)
140046385743768
>>> 

前面我們介紹了序列，我們知道序列的索引隱含在數(shù)據(jù)類型里，不需要我們明確去定義，因?yàn)槎际?，1，2，3，4……有順序的排列下去，當(dāng)可變對(duì)象里的元素被刪除，保留下來(lái)的元素的索引會(huì)改變，因?yàn)樾蛄欣锏乃饕肋h(yuǎn)都是順序排列的數(shù)字，這些數(shù)字沒(méi)有跟元素綁定，而只是允許我們通過(guò)索引的數(shù)字來(lái)訪問(wèn)該位置的元素。那如果我們想要自定義索引，用字符串，數(shù)字等來(lái)做索引，并希望這些索引能夠跟特定的元素綁定在一起，我們?cè)撛趺崔k？更簡(jiǎn)單的說(shuō)，就是我們希望索引是獨(dú)特并且容易記住，有語(yǔ)義，我們?cè)撛趺崔k？python給我們提供了一種數(shù)據(jù)類型字典（dict），可以勝任這樣的要求。我們把這樣的索引可以看作是鍵 （keys）,它與要存儲(chǔ)的值綁定在一起，叫做鍵值對(duì)。

字典里存儲(chǔ)鍵值對(duì)兒，索引獨(dú)特，所以是沒(méi)有順序的。順序已經(jīng)無(wú)關(guān)緊要，我們只需要記住獨(dú)特的鍵就行了。如何創(chuàng)建字典，如何存儲(chǔ)鍵值對(duì)，看下面的例子：

>>> a={}    #創(chuàng)建一個(gè)空字典
>>> type(a)

>>> b={"id":4667,"name":"john"}  #創(chuàng)建一個(gè)有兩對(duì)鍵值對(duì)的字典
>>> b["id"]  #通過(guò)鍵"id"來(lái)獲得對(duì)應(yīng)的值
4667
>>> c=dict(id=4555,name="li")  #通過(guò)內(nèi)置的dict函數(shù)創(chuàng)建字典
>>> print(c)
{"id": 4555, "name": "li"}
>>> 

字典是可變對(duì)象。為了通過(guò)鍵來(lái)查找值，就需要字典鍵（keys）保持唯一性，如果鍵用了可變對(duì)象來(lái)存儲(chǔ)，會(huì)出現(xiàn)不可控因素，舉個(gè)例子，假如兩個(gè)鍵都是由列表來(lái)存儲(chǔ)，則一旦把這兩個(gè)列表修改相同，那么查找這兩個(gè)鍵所對(duì)應(yīng)的值時(shí)就會(huì)出現(xiàn)矛盾，所以鍵一定要用不可變對(duì)象來(lái)存儲(chǔ)，包括數(shù)字，布爾值，字符串，元組（需要元組中的元素不包含可變對(duì)象）。又因?yàn)樽值涫强勺儗?duì)象，所以字典中鍵值對(duì)里的值是可以改變的。如下：

>>> c={("id",):46678,"name":"john_ss"}
>>> c[("id",)]
46678
>>> d=8
>>> e={d:8,"d":"8"}
>>> e[d]
8
>>> e["d"]
"8"
>>> e[d]=123
>>> print(e)
{8: 123, "d": "8"}
>>> 

在字典中，也可以用字典的get()方法通過(guò)鍵獲取值。如果要給字典里增加鍵值對(duì)，可以直接用方括號(hào)（下標(biāo)）的方式增加，例如dict["key_word"]="some values"。可以用字典的pop()方法來(lái)刪除鍵值對(duì)，要注意的是，pop()方法在刪除鍵值對(duì)的同時(shí)會(huì)返回要移除的鍵值對(duì)，把返回值賦給變量，變量就會(huì)得到被移除的鍵值對(duì)：pair=dict.pop("id")。如果我們不只想刪除某一個(gè)鍵值對(duì)，而是想清空整個(gè)字典，則可以使用字典的clear()方法。如果看下面的例子：

>>> a={1:1,2:2,3:3}
>>> a.get(1)
1
>>> a["appended"]="ok,then!"
>>> print(a)
{1: 1, 2: 2, 3: 3, "appended": "ok,then!"}
>>> a.pop(2)
2
>>> print(a)
{1: 1, 3: 3, "appended": "ok,then!"}
>>> a.clear()
>>> print(a)
{}
>>> 

當(dāng)我們嘗試像迭代序列那樣直接迭代字典時(shí)，交互命令行顯示結(jié)果如下，明顯只迭代了鍵值對(duì)中的鍵（key）：

>>> a={1: 1, 2: 2, 3: 3, "appended": "ok,then!"}
>>> for item in a:
...     print(item)
... 
1
2
3
appended
>>> 

這時(shí)候字典中有兩個(gè)內(nèi)置方法可以協(xié)助來(lái)完成迭代，分別是items()跟keys()。items()返回字典中無(wú)序的鍵值對(duì)，keys()返回字典中無(wú)序的鍵（keys）。如下：

>>> a={1: 1, 2: 2, 3: 3, "appended": "ok,then!"}
>>> for item in a.items():
...     print(item)
... 
(1, 1)   #可以看到把鍵值對(duì)裝進(jìn)了元組
(2, 2)
(3, 3)
("appended", "ok,then!")
>>> for key in a.keys():
...     print(key)
... 
1
2
3
appended
>>> 

前面我們介紹了字典，跟字典類似，在python里還有一種無(wú)序的數(shù)據(jù)類型：集合（set）。基本上，這兒的集合跟數(shù)學(xué)上的集合的概念是一樣的。其中的元素是無(wú)序的，并且每個(gè)元素都是唯一不可重復(fù)的。創(chuàng)建集合跟創(chuàng)建字典的符號(hào)一樣，都是花括號(hào)“{}”，所以當(dāng)創(chuàng)建空集合時(shí)，會(huì)跟創(chuàng)建空字典的符號(hào)有沖突，所以python里“{}”表示創(chuàng)建空字典，而創(chuàng)建空集合只能用內(nèi)置函數(shù)set()來(lái)創(chuàng)建，如下：

>>> a={1,4,7,"string",("lalala",2,3,4)}  #創(chuàng)建集合
>>> print(a)
{1, 4, 7, "string", ("lalala", 2, 3, 4)}
>>> b={}   #空字典
>>> type(b)

>>> c=set()  #空集合
>>> type(c)

>>> 

集合是可變對(duì)象，但是它的元素則要求一定是不可變對(duì)象，根據(jù)集合的定義，每個(gè)元素都是唯一不可重復(fù)，那么一旦元素是可變對(duì)象，則有了可重復(fù)的可能，比如元素中有兩個(gè)列表的話，通過(guò)一些操作有可能會(huì)讓這兩個(gè)列表成為一樣的。如下：

>>> d={1,2,[1,2]}
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unhashable type: "list"
>>> 

既然集合是可變對(duì)象，我們就可以通過(guò)add()方法增加元素，通過(guò)remove()、discard()方法、pop()方法刪除元素，前提是所有元素都要是不同的，通過(guò)pop()方法刪除元素時(shí)，不帶參數(shù)，并且集合無(wú)序，所以無(wú)法預(yù)知哪個(gè)元素被丟掉，但pop()方法會(huì)返回被丟的元素：

>>> a={1,4,7,("string",55),"hello"}
>>> a.add("hello,world!") #add方法新增元素
>>> print(a)
{1, 4, 7, "hello,world!", ("string", 55), "hello"}
>>> a.remove(7) #remove方法刪除元素
>>> print(a)
{1, 4, "hello,world!", ("string", 55), "hello"}
>>> a.discard(1) #discard方法刪除元素
>>> print(a)
{4, "hello,world!", ("string", 55), "hello"}
>>> a.pop()   #通過(guò)pop方法刪除隨機(jī)某個(gè)元素并返回被刪除的元素，可以使用變量來(lái)存儲(chǔ)
4
>>> print(a)
{"hello,world!", ("string", 55), "hello"}

可以使用update方法來(lái)增加多個(gè)元素，使用clear()方法來(lái)清空整個(gè)集合，接上面的例子：

>>> a.update([1,2,3,4])  #用列表來(lái)更新集合
>>> a.update((5,6,7))    #用元組來(lái)更新集合
>>> print(a)
{1, 2, 3, 4, 5, 6, 7, "hello,world!", ("string", 55), "hello"}
>>> a.clear()
>>> print(a)
set()   #代表空集合

集合可以實(shí)現(xiàn)數(shù)學(xué)上的并集，交集，差集，對(duì)稱差，有兩種方式：操作符跟方法。并集是兩個(gè)集合中所有的元素組成的新集合，交集是兩個(gè)集合中都存在的元素組成的新集合。差集是兩個(gè)集合中在某個(gè)集合中存在，并且在另一個(gè)集合中不存在的元素組成的新集合。對(duì)稱差集是兩個(gè)集合中所有元素，除去在交集中的元素，由這樣的元素組成的新集合。下面這個(gè)表顯示python的操作方法：

通過(guò)例子來(lái)看看：

>>> A={1,2,4,6,7}
>>> B={1,3,4,5,8}
>>> print(A | B)
{1, 2, 3, 4, 5, 6, 7, 8}
>>> print(A.union(B))
{1, 2, 3, 4, 5, 6, 7, 8}
>>> print(A & B)
{1, 4}
>>> print(A.intersection(B))
{1, 4}
>>> print(A - B)
{2, 6, 7}
>>> print(A.difference(B))
{2, 6, 7}
>>> print(B - A)
{8, 3, 5}
>>> print(B.difference(A))
{8, 3, 5}
>>> print(A ^ B)
{2, 3, 5, 6, 7, 8}
>>> print(A.symmetric_difference(B))
{2, 3, 5, 6, 7, 8}
>>> 

從上面的例子可以看出來(lái)，兩個(gè)集合的并集，交集，對(duì)稱差集都是可以互換的，而差集不是，差集需要區(qū)分A-B跟B-A。

在python中，還可以創(chuàng)建類似于tuple這樣的不可變對(duì)象的set，那就是frozenset，frozen在英文中是凍結(jié)了的意思，顧名思義，frozenset就是凍結(jié)的集合。frozenset不能增加或者更新元素，刪除或者清除元素，類似于只讀文件。并集，交集，差集，對(duì)稱差的操作對(duì)于frozenset同樣適用。如下：

>>> a=frozenset([1,2,3])   #創(chuàng)建一個(gè)frozenset
>>> print(a)
frozenset({1, 2, 3})
>>> a.add(4)
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: "frozenset" object has no attribute "add"
>>> a.clear()
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: "frozenset" object has no attribute "clear"
>>> b=frozenset((4,5,3))
>>> a.union(b)
frozenset({1, 2, 3, 4, 5})
>>> 

在python中，有個(gè)help()內(nèi)置函數(shù)可以獲取關(guān)于對(duì)象的說(shuō)明文檔。但說(shuō)明文檔中有關(guān)于該對(duì)象實(shí)現(xiàn)的細(xì)節(jié)，當(dāng)我們只是想知道各數(shù)據(jù)類型的常用內(nèi)置方法及其使用時(shí)，就會(huì)變得很不方便。我寫了一個(gè)很短的程序，運(yùn)行該程序可以將help函數(shù)的輸出簡(jiǎn)化（刪去實(shí)現(xiàn)對(duì)象的相關(guān)細(xì)節(jié)）并存入當(dāng)前目錄新建的一個(gè)文本文件中，并且該程序還有將方法的解釋翻譯成中文的可選功能。下面是該程序內(nèi)容：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys
import re
#如果想將解釋翻譯成中文，把下面一行的注釋取消
#from translate import Translator

def command_line_arguments(usge,len_of_arguments):
    if len(sys.argv)!=len_of_arguments+1:
        print(usge)
    return sys.argv

def stdout_to_file(dir,func,func_arguments):
    #把函數(shù)的標(biāo)準(zhǔn)輸出存入文件中
    default_stdout = sys.stdout
    with open(dir,"w") as w:
        sys.stdout=w
        func(func_arguments)
    sys.stdout=default_stdout
    
def simpler_help(object):
    
    stdout_to_file("simpler_help_{}.txt".format(object),help,object)
    
    #把文件中的內(nèi)容分行存入內(nèi)存
    with open("simpler_help_{}.txt".format(object),"r") as r:
        lines=r.readlines()
    
    #將內(nèi)存中的內(nèi)容修改后寫入同名文件，覆蓋原有文件
    #mark1，為了將帶有“__”的特殊函數(shù)不要寫入，并將其下面的解釋一并略過(guò)
    mark1=False
    #mark2，為了將“---”下面的內(nèi)容略過(guò)
    mark2=False
    with open("simpler_help_{}.txt".format(object),"w") as w:
        for line in lines:
            
            #將帶有“__”的特殊方法不要寫入，并將其下面的解釋一并略過(guò)
            if "__" in line:
                mark1=True
                continue  
            elif mark1==True:
                result=re.search("[A-Za-z]+",line)
                if result==None:
                    mark1=False
                    continue
                

            #將“---”下面的內(nèi)容略過(guò)
            elif "---" in line:
                mark2=True
                continue
            elif mark2==True:
                pass
            
            #將行中的self跟“/”替換成空
            else:
                if ("self," in line) or ("/" in line):
                    if ("self," in line) and ("/" in line):
                        w.write(line.replace("self,","").replace("/","").replace(", )"," )").replace(" , "," "))
                    elif ("self," in line) and ("/" not in line):
                        w.write(line.replace("self,",""))
                    elif ("self," not in line) and ("/" in line):
                        w.write(line.replace("/","").replace(", )"," )").replace(" , "," "))          
                else:
                    w.write(line)

#如果想將解釋翻譯成中文，可以把下面的函數(shù)注釋取消                
"""
def translation_of_help(object):
    translator= Translator(to_lang="zh")
    with open("simpler_help_{}_zh.txt".format(object),"r") as r:
        lines=r.readlines()
    with open("simpler_help_{}_zh.txt".format(object),"w") as w:
        line_process=""
        count_line=0
        for line in lines:
            if ("(" in line) and (")"in line) and ("." not in line):
                w.write(line)
            else:
                if count_line<=1:
                    w.write(translator.translate(line)+"
")
                else:
                    line_process=line.replace("|","")
                    w.write(" |        "+translator.translate(line_process)+"
")
            count_line=count_line+1
"""

len_of_arguments=1
arguments=command_line_arguments("""You need provide a name of object,for example:
python3 simpler_help.py list""",len_of_arguments)
if len(arguments)==len_of_arguments+1:
    simpler_help(arguments[1])
    #如果想將解釋翻譯成中文，可以把下面一行的注釋取消
    #translation_of_help("list")      
    

將上面內(nèi)容復(fù)制粘貼，并命名為simpler_help.py。舉個(gè)例子，如果想知道列表中的內(nèi)置方法，則在命令行中通過(guò)類似這樣的python3 simpler_help.py list命令來(lái)運(yùn)行，特別注意需要在文件名空一格后寫上需要查詢的數(shù)據(jù)類型名稱。下面是程序創(chuàng)建的簡(jiǎn)化版的列表的help函數(shù)輸出，保存在當(dāng)前目錄的simpler_help_list.txt中:

Help on class list in module builtins:

class list(object)
 |  list(iterable=() )
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 |  Methods defined here:
 |  
 |  append( object )
 |      Append object to the end of the list.
 |  
 |  clear( )
 |      Remove all items from list.
 |  
 |  copy( )
 |      Return a shallow copy of the list.
 |  
 |  count( value )
 |      Return number of occurrences of value.
 |  
 |  extend( iterable )
 |      Extend list by appending elements from the iterable.
 |  
 |  index( value, start=0, stop=9223372036854775807 )
 |      Return first index of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  insert( index, object )
 |      Insert object before index.
 |  
 |  pop( index=-1 )
 |      Remove and return item at index (default last).
 |      
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove( value )
 |      Remove first occurrence of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  reverse( )
 |      Reverse *IN PLACE*.
 |  
 |  sort( *, key=None, reverse=False)
 |      Stable sort *IN PLACE*.
 | 
 

通過(guò)程序創(chuàng)建的文件，可以大概了解各數(shù)據(jù)類型都有哪些內(nèi)置方法，之后可以從網(wǎng)上通過(guò)關(guān)鍵詞搜索出更為詳細(xì)的介紹跟用例。另外，如果想將方法的解釋翻譯成中文，把simpler_help.py中相關(guān)內(nèi)容的注釋取消，并且首先需要在命令行中執(zhí)行pip install translate。

>>> type(None)

>>>

None屬于NoneType這個(gè)數(shù)據(jù)類型（對(duì)象），是它唯一的值。并且，NoneType對(duì)象并不像別的數(shù)據(jù)類型一樣，可以有很多實(shí)例，而是從始至終都只能有一個(gè)實(shí)例。

>>> None==False
False
>>> None==1
False
>>> None==""
False
>>> None==0
False
>>> None=={}
False
>>> None==None
True
>>>

從上面的例子（做邏輯判斷）可以看出來(lái)，None不等于其他任何值，None只等于None。None一般用來(lái)代表數(shù)據(jù)的缺失,看下面的例子：

def addTwo(a,b):
    if (type(a)==int or type(a)==float) and ((type(b)==int or type(b)==float)):
        return a+b
    else:
        return None

b=addTwo("ss",4)
print(b)

#OUTPUT應(yīng)該為None,None代表函數(shù)沒(méi)法合理的處理參數(shù)，只能返回None。

當(dāng)我們拿到某個(gè)數(shù)據(jù)，我們想要判斷它不是None的時(shí)候該如何做呢，這時(shí)候應(yīng)該用is，因?yàn)镹one是數(shù)據(jù)類型，也是對(duì)象，所以我們一般會(huì)想要這樣做：if an_object is not None:。此處not的位置跟成員檢測(cè)if an_object not in an_object:的位置不同，需要特別注意。如下：

a=1

if a is not None:
    print("a is not None")
else:
    print("a is None")

#OUTPUT應(yīng)該為"a is not None"。

有些時(shí)候我們會(huì)在別人的代碼中看到if an_object:這樣的寫法,這種寫法跟上面的判斷某數(shù)據(jù)（對(duì)象）是不是None的寫法沒(méi)有什么聯(lián)系，這種代碼暗示了數(shù)據(jù)（對(duì)象）本身在做邏輯判斷時(shí)會(huì)另外呈現(xiàn)出或真或假的布爾值，事實(shí)上也的確如此，在各種數(shù)據(jù)類型中，會(huì)有某些特殊的值在邏輯判斷的時(shí)候布爾值表現(xiàn)為False，其余值表現(xiàn)為True。在python中，規(guī)定了一套規(guī)則，當(dāng)我們拿某個(gè)數(shù)據(jù)本身來(lái)做邏輯判斷的時(shí)候，解釋器如何解確定其布爾值：

布爾型，F(xiàn)alse表示False，其他為True

整數(shù)和浮點(diǎn)數(shù)，0表示False，其他為True

字符串和類字符串類型（包括bytes和unicode），空字符串表示False，其他為True

序列類型（包括tuple，list，dict，set等），空表示False，非空表示True

None永遠(yuǎn)表示False

舉個(gè)例子，當(dāng)我們?cè)诶碚撋蟻?lái)說(shuō)從某函數(shù)（方法）返回了一個(gè)列表list1,我們用if list1:來(lái)判斷的時(shí)候，則會(huì)出現(xiàn)三種情況：list1是None，list1是空列表，list1是非空列表，這時(shí)候list1在第一和第二種情況下表現(xiàn)出的布爾值為False,在第三種情況下表現(xiàn)出的布爾值為True。如下：

list1=[]

while True:
    if list1:
        print("true")
    else:
        if list1 != None:
            print("false,empty list")
            list1=None
        else:
            print("false,None")
            list1=[]

#OUTPUT應(yīng)該永遠(yuǎn)在None跟空列表之間徘徊。交替打印“false,empty list”和“false,None”。

[歡迎瀏覽我的個(gè)人博客，https://diwugebingren.github.io
](https://diwugebingren.github....