本章內容提要：

• 列表及操作
• 元組及操作
• 字典及操作
• 集合簡介

第2章介紹了數(shù)字(整數(shù)、浮點數(shù))、邏輯值和字符串等Python內置的基本數(shù)據(jù)類型。在實際的操作中，僅僅依賴它們很難高效地完成復雜的數(shù)據(jù)處理任務。基于對基本數(shù)據(jù)類型的構建，Python拓展出列表、元組、字典與集合等更為實用的數(shù)據(jù)結構，以簡化程序的編寫與任務的實現(xiàn)。這些數(shù)據(jù)結構內置于Python，是數(shù)據(jù)分析經(jīng)常要操作的對象。

3.1　列表

列表(list)是Python中最常用的內置類型之一，是處理一組有序項目的數(shù)據(jù)結構，或者說，是一個有序對象的集合。通俗地理解，列表即序列，它是一系列數(shù)值的序列。在前文介紹的字符串中，字符串包含的值是一個個字符。而在列表中，值可以是任意類型。列表的值一般也稱為列表的元素，通過英文逗號分隔，并包含在方括號內。

3.1.1　列表的創(chuàng)建

下面創(chuàng)建一個簡單的列表，存儲英文中的5個元音字母：

In [1]: vowels = ['a', 'e', 'i', 'o', 'u']In [2]: vowelsOut[2]: ['a', 'e', 'i', 'o', 'u']

我們可以不添加任何元素來初始化一個列表：

In [3]: array_init = []In [4]: array_initOut[4]: []

如果要提取列表中的元素，使用索引是一種方法，將索引值寫在變量名后的方括號內，如提取列表vowels中的i：

In [5]: vowels[2]Out[5]: 'i'

方括號內填入的是2，而不是3。這與Python的索引機制有關—— Python的索引是從0開始的(當然也有從1開始索引的語言，比如數(shù)據(jù)分析中也非常流行的R語言)。

因此，列表vowels元素與其索引之間有以下對應關系：

a e i o u0 1 2 3 4

列表的元素可以是任意類型，因此列表可以嵌套列表。例如，用以下列表來依次表示兩個長方形的名稱、面積與相應的長和寬：

In [7]: rectangle = ['長方形1', 20, [4, 5], '長方形2', 16, [4, 4]]In [8]: rectangleOut[8]: ['長方形1', 20, [4, 5], '長方形2', 16, [4, 4]]

如果列表太長，不方便直接觀察列表的長度，那么可以利用len()函數(shù)進行計算。

In [9]: len(rectangle)Out[9]: 6

結果顯示rectangle長度為6，我們可以使用索引值0～5提取rectangle的元素。再次注意，Python索引值是從0開始的，如果使用的索引值超出界限，Python會報錯，提示我們使用的列表索引超出范圍。

In [10]: rectangle[6]---------------------------------------------------------------------------IndexError Traceback (most recent call last) in ()----> 1 rectangle[6]IndexError: list index out of range

除了從頭創(chuàng)建一個列表，也可以使用list()函數(shù)將其他數(shù)據(jù)類型轉換為列表，如下面的字符串：

In [17]: aseq = "atggctaggc"In [18]: list(aseq)Out[18]: ['a', 't', 'g', 'g', 'c', 't', 'a', 'g', 'g', 'c']

3.1.2　修改列表元素

和字符串不同，列表是可以修改的，只需對指定的列表元素重新賦值即可。

例如，用一個列表存儲10以內的奇數(shù)：

In [11]: odd_numbers = [1, 3, 5, 7, 8]

即使發(fā)現(xiàn)最后一個元素寫錯了，也不需要像下面這樣重新創(chuàng)建列表。

In [12]: odd_numbers = [1, 3, 5, 7, 9]

我們不需要重新輸入創(chuàng)建一個新的列表來糾正之前錯誤的輸入，只需要修改寫錯的元素，即利用索引對錯誤的元素重新賦值。

In [13]: odd_numbers = [1, 3, 5, 7, 8]In [14]: odd_numbers[4] = 9In [15]: odd_numbersOut[15]: [1, 3, 5, 7, 9]

除了使用自然數(shù)進行索引元素，還可以使用負整數(shù)進行反向索引，比如odd_numbers[-1]也對應著9：

In [16]: odd_numbers[-1]Out[16]: 9

我們依舊可以用之前的列表vowels來表示列表元素與反向索引之間的對應關系，如下：

a e i o u-5 -4 -3 -2 -1

3.1.3　遍歷列表

想象一下，如果列表元素非常多，而我們想要對列表中的每一個元素進行操作或變換，難道要一個一個利用索引取出，然后修改嗎？逐一訪問列表的元素稱為遍歷列表。這里需要初步借助第4章介紹的循環(huán)來解決類似的問題。

循環(huán)的作用在于將單一枯燥的重復性工作交給機器去實現(xiàn)，而用戶只需要關注去掉循環(huán)的操作本身。

最常用的循環(huán)結構是for循環(huán)。如果需要逐一打印10以內的奇數(shù)，我們不需要逐步使用print()函數(shù)打印列表的每一個元素。

print(odd_numbers[0])print(odd_numbers[1])print(odd_numbers[2])print(odd_numbers[3])print(odd_numbers[4])

只需要兩行代碼就可以實現(xiàn)列表的遍歷，如下所示：

In [24]: for i in odd_numbers: print(i)13579

這里列表odd_numbers中元素的值會逐個傳給i，然后通過print()函數(shù)將i的值輸出打印。使用循環(huán)除了使代碼更清晰簡潔外，另一個好處是用戶不需要知道列表有多長！既然for循環(huán)可以遍歷列表中所有的元素，那么如果元素是一個列表，它會對這個列表接著遍歷嗎？

假設創(chuàng)建一個列表存儲小明、小紅、小藍3個人跳遠的成績記錄，如下：

In [26]: nested_list = ['記錄', 3, ['小明', '小紅', '小藍'], [2.30, 2.41, 2.33]]

使用for循環(huán)是將該列表中的所有元素一個一個輸出，還是會輸出其他的結果呢？

In [27]: for i in nested_list: ...: print(i) ...:記錄3['小明', '小紅', '小藍'][2.3, 2.41, 2.33]

結果顯示，for循環(huán)并沒有將列表的所有元素單個傳入變量i，而是將列表最外面一層的元素傳入了變量i。打個比方，簡單的列表像一層洋蔥，而嵌套了列表的列表相當于多層洋蔥，for循環(huán)只負責剝開一層。

因此，如果想剝開例子中的“兩層洋蔥”—— nested_list，我們需要使用兩次for循環(huán)。for循環(huán)的操作和使用在第4章會詳細介紹。

3.1.4　列表操作符

列表操作符用于便利地操作列表，使用它們如同使用數(shù)值的加、減、乘、除一樣簡單。

1．加號

加號 + 不僅能用于數(shù)字相加、字符連接，還能用于列表的拼接。

In [28]: a = [1, 2, 3]In [29]: b = [4, 5, 6]In [30]: a + bOut[30]: [1, 2, 3, 4, 5, 6]

a + b的結果是將列表b中的元素拼接到列表a的后面，生成了一個新的列表。

如果兩個列表是不同的數(shù)據(jù)類型，還能拼接嗎？

In [31]: b = [4, 5, '6']In [32]: a + bOut[32]: [1, 2, 3, 4, 5, '6']

代碼運行結果說明是可以的，列表包容萬物，而含不同數(shù)據(jù)類型的列表拼接只是將它們放到了一起，并沒有其他特殊的操作。

2．星號

星號 * 操作符可以將列表重復指定的次數(shù)，如下所示：

In [33]: a * 5Out[33]: [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

3.1.5　列表切片

除了上一節(jié)提到的 + 操作符與 * 操作符，冒號 : 操作符可以對列表執(zhí)行切片操作。切片操作是利用冒號操作符進行取子集的過程。因為該操作符經(jīng)常使用，所以單列一節(jié)進行介紹。

例如，如果存在包含7個字母的列表如下：

In [34]: letters7 = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

如果只想要a、b、c、d這4個字母，那么切片操作如下：

In [37]: you_want = letters7[0:4]In [38]: you_wantOut[38]: ['a', 'b', 'c', 'd']

列表索引規(guī)則是start:stop:step，其中，stop值不被包含在內(即區(qū)間前閉后開)。上面代碼中，start對應0(再次提醒Python索引從0開始)，stop對應4，而step默認為1，可以省略。

理解了切片的規(guī)則，我們就可以知道下面的操作會得到一樣的結果。

In [39]: letters7[0:4:1]Out[39]: ['a', 'b', 'c', 'd']

索引的起始位置也可以省略，默認從0開始。

In [40]: letters7[:4]Out[40]: ['a', 'b', 'c', 'd']

索引的終止位置也可以省略，默認為列表長度，也就是到最后一個元素。

In [41]: letters7[:7]Out[41]: ['a', 'b', 'c', 'd', 'e', 'f', 'g']In [42]: letters7[4:]Out[42]: ['e', 'f', 'g']

注意，加 : 操作符與不加是不同的。加 : 操作符，結果返回的是一個列表，而不加返回的是元素本身。

In [43]: letters7[-1]Out[43]: 'g'In [44]: letters7[-1:]Out[44]: ['g']

在理解了上面操作的基礎上，理解下面的操作結果也順理成章。

In [45]: letters7[::1]Out[45]: ['a', 'b', 'c', 'd', 'e', 'f', 'g']In [46]: letters7[::2]Out[46]: ['a', 'c', 'e', 'g']

步長還可以取負整數(shù)，代表逆序切片。

In [47]: letters7[::-1]Out[47]: ['g', 'f', 'e', 'd', 'c', 'b', 'a']In [48]: letters7[::-2]Out[48]: ['g', 'e', 'c', 'a']

另外，切片運算符放到賦值語句等號左邊時可以對多個元素進行更新。

In [49]: letters7[0:2] = ['h', 'i']In [50]: letters7Out[50]: ['h', 'i', 'c', 'd', 'e', 'f', 'g']

注意，左右兩邊可以不等長。

In [51]: letters7[0:2] = ['a']In [52]: letters7Out[52]: ['a', 'c', 'd', 'e', 'f', 'g']In [53]: letters7[0:1] = ['a', 'b']In [54]: letters7Out[54]: ['a', 'b', 'c', 'd', 'e', 'f', 'g']

如果是單個元素，等號右側也可以不加方括號。

In [55]: letters7[0:2] = 'h'In [56]: letters7Out[56]: ['h', 'c', 'd', 'e', 'f', 'g']

3.1.6　列表方法、函數(shù)與操作

Python為列表提供了很多方法，用來簡化列表的各項常用操作。常用操作包括添加元素、刪除元素、插入元素等。

注意，當下文提及方法時，一般指在變量名后加點號然后加函數(shù)。例如，list.append()指對列表list使用append()方法。

1．添加元素

Python中有3種方法可以為列表添加元素，分別是append()、insert()和extend()。

(1)append(element)：將元素element添加到列表的末尾。

In [59]: example_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]In [60]: example_list.append(11)In [61]: example_listOut[61]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

(2)insert(position, element)：將元素element插入列表指定position位置。

In [62]: example_list.insert(2, 12)In [63]: example_listOut[63]: [1, 2, 12, 3, 4, 5, 6, 7, 8, 9, 10, 11]

(3)extend(list)：使用另一個列表作參數(shù)，然后把所有的元素添加到一個列表上。

In [64]: example_list.extend([13,14])In [65]: example_listOut[65]: [1, 2, 12, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14]

2．刪除元素

同樣地，Python也有3種方法刪除列表中的元素。

(1)pop([index])：移除索引位置index的元素并返回它的值，如果沒有參數(shù)，則默認刪除和返回最后一個。

In [67]: example_list.pop()Out[67]: 14In [68]: example_list.pop(2)Out[68]: 12

(2)remove(element)：移除參數(shù)中指定的元素element，如果存在多個同樣的值，則移除最左邊的。不同于pop()，這個方法不返回任何值。

In [69]: example_list.remove(13)In [70]: example_listOut[70]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

(3)另一種方式是使用del命令，del list[0]類似于list.pop(0)，但前者不會返回被刪除的元素。

In [71]: del example_list[10]In [72]: example_listOut[72]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

除了上面提到的3種方法，另有clear()方法可以清洗列表，它會清空列表中的所有元素。

In [73]: example_list.clear()In [74]: example_listOut[74]: []

3．列表排序

當把數(shù)值數(shù)據(jù)存儲在列表后，一個常見的需求是對列表中的值進行排序，利用sort()方法可以實現(xiàn)。

In [78]: a = [3, 1, 2, 5, 4, 6]In [79]: a.sort()In [80]: aOut[80]: [1, 2, 3, 4, 5, 6]

可以看到，使用sort()方法后，列表本身被改變了。如果不想改變原始列表，可以使用sorted()函數(shù)，并把結果賦值給新的變量。

In [81]: nums = [-1, 34, 0.2, -4, 309]In [82]: nums_desc = sorted(nums, reverse=True)In [83]: numsOut[83]: [-1, 34, 0.2, -4, 309]In [84]: nums_descOut[84]: [309, 34, 0.2, -1, -4]

reverse()方法可以將列表按位置翻轉。

In [90]: numsOut[90]: [1, 2, 2, 2, 3, 3, 4, 5]In [91]: nums.reverse()In [92]: numsOut[92]: [5, 4, 3, 3, 2, 2, 2, 1]

4．簡單統(tǒng)計

min()與max()函數(shù)可以計算列表最小值與最大值。

In [85]: min(nums)Out[85]: -4In [86]: max(nums)Out[86]: 309

如果要對出現(xiàn)相同元素計數(shù)，可以使用count()方法。

In [87]: nums = [1, 2, 2, 2, 3, 3, 4, 5]In [88]: nums.count(2)Out[88]: 3In [89]: nums.count(3)Out[89]: 2

sum()函數(shù)可以對數(shù)值列表求和。

In [93]: sum(nums)Out[93]: 22

5．邏輯判斷

如果需要查看列表中是否存在某個元素，可以使用關鍵字in，結果返回的是邏輯值。

In [76]: 4 in example_listOut[76]: FalseIn [77]: 3 in example_listOut[77]: True

all()與any()函數(shù)用于邏輯值列表，all()判別列表所有值是否都為真，全真時返回True，否則返回False；any()用于判別只要任一元素為真，則返回True，否則返回False。

In [94]: conditions = [True, False, True]In [95]: all(conditions)Out[95]: FalseIn [96]: any(conditions)Out[96]: True

如果要比較兩個列表是否一致，則可以直接使用兩個等號進行邏輯判斷。

In [97]: a = [1, 2, 3, 4]In [98]: a == [1, 2, 3, 5]Out[98]: FalseIn [99]: a == [1, 3, 2, 4]Out[99]: FalseIn [100]: a == [1, 2, 3, 4]Out[100]: True

6．最常見操作方法匯總

上面介紹了大量的列表操作、函數(shù)與方法，但實際上可用的遠不止這些。對Python有深入了解后，我們可以自己創(chuàng)建操作列表的方法和函數(shù)。

表3-1中列出了常見的操作方法。

表3-1　常見的列表操作方法匯總

表示

描述

l.append(x)

添加元素x到列表

l.count(x)

計算列表中x出現(xiàn)的次數(shù)

l.index(x)

返回元素x的位置(索引)

l.remove(x)

從列表中移除x

l.reverse()

翻轉列表

l.sort()

列表排序

3.1.7　列表與字符串

字符串是一系列字符的序列，而列表是一系列值的序列，但一個由字符組成的列表是不同于字符串的。要把一個字符串轉換成字符列表，可以用list()函數(shù)。

下例是將字符串轉換為字符列表：

In [101]: s = 'interactive Python'In [102]: t = list(s)In [103]: tOut[103]:['i', 'n', 't', 'e', 'r', 'a', 'c', 't', 'i', 'v', 'e', ' ', 'P', 'y', 't', 'h', 'o', 'n']

在上面的代碼中，list()函數(shù)將一個字符串分開成一個個字符(字母)。如果要把字符串切分成一個個單詞，可以使用split()方法，如下所示：

In [104]: s.split()Out[104]: ['interactive', 'Python']

注意，方法中有一個可選的參數(shù)是定界符，用于確定單詞邊界。

下例用短橫線作為定界符來拆分兩個單詞：

In [105]: s = 'interactive-Python'In [107]: s.split('-')Out[107]: ['interactive', 'Python']

另一個方法join()的功能與split()方法的功能相反，它接收一個字符串列表，然后把所有元素拼接到一起作為字符串。join()是一個字符串方法，所以必須把join()放到定界符后面來調用，并且傳遞一個列表作為參數(shù)。

In [108]: t = ['我','是', '誰', '？']In [109]: ''.join(t)Out[109]: '我是誰？'

注意，上面代碼中的定界符是一個空格字符。

3.1.8　列表對象與值

請思考：下面對象a與b是同一個對象嗎？

In [4]: a = 'banana'In [5]: b = 'banana'

如果把對象看作籃子，內容banana看作籃子里的雞蛋。現(xiàn)在需要判斷的是，變量名a和b是同一個籃子的兩個便簽(雞蛋只有一個)，還是兩個不同籃子(每一個籃子都有一個雞蛋)的便簽？

使用is操作符，可以得到答案。

In [6]: a is bOut[6]: True

從上面的代碼運行結果來看，答案是第一種情況：Python只創(chuàng)建了一個字符串對象，內容為banana，a和b都是這個對象的便簽。

另外，可以使用id()函數(shù)提取對象的唯一標識符。這就像居民身份證一樣，雖然同一個人可能會有不同的稱呼，但身份證號碼只有一個。

In [10]: id(a)Out[10]: 1691582590008In [11]: id(b)Out[11]: 1691582590008

從結果中可見，a和b確實是完全相同的。那么，如果改變a，那么b也會隨之改變嗎？

In [12]: a = "orange"In [13]: bOut[13]: 'banana'

結果是不會。實際上，Python對象是它指向的內容，變量名a和b本身只是一個方便使用的標簽，所以當我們將另一個字符串賦值給變量a時，Python實際上是先創(chuàng)建了一個字符串對象，內容是orange，然后給這個對象打上標簽a。

如果創(chuàng)建兩個列表，盡管它們的內容相同，但它們也是不同的對象，下面的代碼運行結果可以驗證這一點。

In [14]: a = [1, 2, 3]In [15]: b = [1, 2, 3]In [16]: a is bOut[16]: FalseIn [17]: id(a)Out[17]: 1691581888264In [18]: id(b)Out[18]: 1691582794120

在這個情況下，可以說兩個列表是相等的，因為它們有相同的元素，但不是同一個列表，因為它們并不是同一個對象。如果兩個對象是同一個對象，那么它們必然是相等的；但如果它們相等，卻未必是同一個對象。

注意，如果這里的b不是重新創(chuàng)建，而是將a賦值給b，那么a和b就是完全相同的，因為它們指向同一個列表對象。

In [19]: b = aIn [20]: a is bOut[20]: TrueIn [21]: id(b)Out[21]: 1691581888264

因此，我們盡量不要對Python的列表進行e=f=e=c=a這樣的賦值操作，一旦修改了某一個元素，其他變量全部會跟著改變！

In [22]: e = aIn [23]: eOut[23]: [1, 2, 3]In [24]: aOut[24]: [1, 2, 3]In [25]: a[1] = 4In [26]: eOut[26]: [1, 4, 3]

到這里，本章一一介紹了Python列表的基礎知識和相應操作。本章的大部分內容是在講解列表，列表不僅是Python最核心的概念和數(shù)據(jù)結構，也是理解其他基礎數(shù)據(jù)結構的橋梁。掌握好了列表，讀者對本章接下來介紹的數(shù)據(jù)結構都可以觸類旁通，其使用和操作方法大同小異。重要的差異會給出提示和強調，讀者需要留心注意。

3.2　元組

元組(tuple)就是不可更改的列表，一旦創(chuàng)建，便不可更改。除了表示的方式有點不一樣、元組的元素不可更改，元組的其他特性與列表基本一致。

3.2.1　元組的創(chuàng)建

In [1]: a_tuple = (1, 2, 3)In [2]: a_list = [1, 2, 3]

上面代碼分別創(chuàng)建了一個元組和列表，可以清晰地看到它們定義的差別所在。其實元組的語法是一系列用逗號分隔的值，也就是說括號是可以省略的。

In [6]: another_tuple = 1,2,3In [7]: type(another_tuple)Out[7]: tuple

作為初學者，創(chuàng)建元組時盡量使用括號，這樣在書寫和查看代碼時可以非常清楚地區(qū)分什么是列表、什么是元組。Python中常見的數(shù)據(jù)類型在表示上都有著非常鮮明的特點，這可以幫助讀者構建優(yōu)良的代碼。

當創(chuàng)建的元組只有一個元素時，需要特別注意：元組中的元素后需要一個逗號。

請看下面的代碼：

In [8]: 1Out[8]: 1In [9]: (1)Out[9]: 1In [10]: 1,Out[10]: (1,)In [11]: (1,)Out[11]: (1,)

前兩個命令創(chuàng)建的都是數(shù)字1，后兩個命令創(chuàng)建的才是元組，包含元素數(shù)字1。

除了使用逗號分隔創(chuàng)建元組，創(chuàng)建元組的另一種方式是使用tuple()函數(shù)。如果參數(shù)為一個序列(比如字符串、列表或者元組)，結果就會得到一個以該序列元素組成的元組。

In [14]: tuple("Python")Out[14]: ('P', 'y', 't', 'h', 'o', 'n')In [15]: tuple(["I", "am", ["learning", "Python"]])Out[15]: ('I', 'am', ['learning', 'Python'])

3.2.2　元組操作

適用于列表的操作符和方法基本也適用于元組。

1．操作符

代碼如下：

In [16]: ('a',) + ('b',)Out[16]: ('a', 'b')In [17]: ('a',) * 3Out[17]: ('a', 'a', 'a')

2．切片

代碼如下：

In [18]: pythonName = tuple("Python")In [19]: pythonNameOut[19]: ('P', 'y', 't', 'h', 'o', 'n')In [20]: pythonName[0]Out[20]: 'P'In [21]: pythonName[0:3]Out[21]: ('P', 'y', 't')In [22]: pythonName[3:]Out[22]: ('h', 'o', 'n')

3．修改

元組是不可修改的，所以不能使用append()和pop()等方法對元素進行添加、刪除、修改等操作。

In [23]: pythonName[0] = 'p'---------------------------------------------------------------------------TypeError Traceback (most recent call last) in ()----> 1 pythonName[0] = 'p'TypeError: 'tuple' object does not support item assignment

但可以用另一個元組來替換已有的元組。

In [24]: newName = ('p',) + pythonName[1:]In [25]: newNameOut[25]: ('p', 'y', 't', 'h', 'o', 'n')

4．變量值交換

利用中間變量對變量的值進行交換是一個常見的操作。

例如，要交換變量a和b的值，我們一般會采用如下策略：

# a和b是已經(jīng)創(chuàng)建的變量，t是一個臨時變量t = aa = bb = t

有了元組，我們就可以使用下面一行代碼簡化這一過程。

a, b = b, a

3.2.3　元組與列表的區(qū)別

看到這里，讀者可能會產生疑問：元組能做的事情列表好像都能做，列表還沒有元組這么多的約束，那么只用列表不是更好嗎？

元組相比于列表的優(yōu)點之一是可以使代碼更安全，特別是與數(shù)據(jù)有關的，元組不能修改的屬性看起來是一層靈活性限制，其實也是一層安全性的保障，而且這個屬性讓元組像一個坐標系統(tǒng)(中學數(shù)學也用括號來填入坐標，并用逗號分隔)，比如3個元素c(x,y,z)，所以它廣泛用于參數(shù)的傳遞。關于參數(shù)傳遞，本書在第5章會詳述。另外，元組的一個隱形的優(yōu)點是它比列表占用的內存更少，這在大數(shù)據(jù)計算時需要考量。

3.3　字典

字典的含義和表示都與其語義相似，就像我們小時候查找漢字，可以通過拼音字母(或筆畫)進行檢索。我們可以自己定義Python中的字典名字，然后通過這個名字查找到對應的數(shù)值。其中的名字叫作“鍵”，對應的數(shù)值簡稱“值”，所以字典也稱“鍵值對”。需要注意的是，字典沒有順序一說，所有的值僅能用鍵獲取。

簡而言之，字典被看作無序的鍵值對或有名字的元素列表。

3.3.1　字典的創(chuàng)建與使用

下面代碼使用字典存儲了3個人的體重數(shù)據(jù)。

In [5]: weight = {'小紅':65, '小明':45, '我':75}

字典的內容放在花括號內，鍵值對以英文冒號連接，不同的鍵值對以英文逗號隔開。

下面代碼用于查看對字典的打印輸出：

In [6]: weightOut[6]: {'小明': 45, '小紅': 65, '我': 75}

從結果中可以看到，輸出的順序與鍵入的順序是有差別的(也有可能相同)。

有了字典，我們可以用比列表更簡單和直觀地提取對應內容的數(shù)據(jù)。例如，可以使用下面的代碼獲取小明的體重。

In [7]: weight['小明']Out[7]: 45

既然字典有鍵與值的區(qū)分，那么該如何獲取鍵與值的內容呢？為此Python提供了兩個方法，分別是keys()和values()。

In [8]: weight.keys()Out[8]: dict_keys(['小紅', '小明', '我'])In [9]: weight.values()Out[9]: dict_values([65, 45, 75])

因為字典需要唯一的鍵去提取正確的內容(值)，所以并不是所有的對象都可以用作鍵。只有不能改變的元組、數(shù)字、字符串等能作為鍵。

如果要初始化字典，類似于列表使用符號[]、元組使用符號()、字典使用符號{}。

In [10]: int_dict = {}In [11]: int_dictOut[11]: {}

除了重新創(chuàng)建字典，還可以把從其他數(shù)據(jù)類型轉換為字典。例如，下面有一個存儲了RGB16進制的列表，我們使用dict()函數(shù)將其轉換為字典。

In [13]: rgb = [('red', 'ff0000'), ('green', '00ff00'), ('blue', '0000ff')]In [14]: dict(rgb)Out[14]: {'blue': '0000ff', 'green': '00ff00', 'red': 'ff0000'}

此外，還可以以傳遞參數(shù)給dict()函數(shù)的方式創(chuàng)建字典。下面代碼創(chuàng)建的字典與上面代碼創(chuàng)建的字典完全相同。

In [15]: dict(red='ff0000',green='00ff00', blue='0000ff')Out[15]: {'blue': '0000ff', 'green': '00ff00', 'red': 'ff0000'}

如果需要不斷地往字典中添加鍵值，那么要先初始化字典，然后使用賦值的方式添加鍵值對。

In [16]: rgb = {}In [17]: rgb['red'] = 'ff0000'In [18]: rgb['green'] = '00ff00'In [19]: rgb['blue'] = '0000ff'In [20]: rgbOut[20]: {'blue': '0000ff', 'green': '00ff00', 'red': 'ff0000'}

3.3.2　字典操作

一些常見的函數(shù)和方法都可以用在字典上。

例如，提取字典長度。

In [21]: len(rgb)Out[21]: 3

使用pop()方法可以從字典中刪除某個值，并返回該值。注意，需要指明鍵。

In [22]: rgb.pop()---------------------------------------------------------------------------TypeError Traceback (most recent call last) in ()----> 1 rgb.pop()TypeError: pop expected at least 1 arguments, got 0In [23]: rgb.pop('blue')Out[23]: '0000ff'In [24]: rgbOut[24]: {'green': '00ff00', 'red': 'ff0000'}

使用del關鍵字可以刪除字典。

In [25]: del rgbIn [26]: rgb---------------------------------------------------------------------------NameError Traceback (most recent call last) in ()----> 1 rgbNameError: name 'rgb' is not defined

使用get()方法可以無意外地獲取字典值，它需要提供兩個參數(shù)，除了鍵，還需要指定如果查找不到應當返回的信息。

In [28]: rgb.get('red', '鍵不存在')Out[28]: 'ff0000'In [29]: rgb.get('yellow', '鍵不存在')Out[29]: '鍵不存在'

如果不改變字典的順序，可以使用collections模塊的OrderedDict()函數(shù)。下面的代碼將之前創(chuàng)建的字典rgb轉換為了有序字典，還給出了一個新的創(chuàng)建示例，可以發(fā)現(xiàn)列表輸出的順序確實沒有改變。

In [32]: from collections import OrderedDictIn [33]: OrderedDict(rgb)Out[33]: OrderedDict([('red', 'ff0000'), ('green', '00ff00'), ('blue', '0000ff')])In [35]: order_dict = OrderedDict()In [36]: order_dict['a'] = 1In [37]: order_dict['b'] = 2In [38]: order_dict['c'] = 3In [39]: order_dictOut[39]: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

3.4　集合

集合是無序的對象集，它和字典一樣使用花括號，但沒有鍵值對的概念。集合屬于可變的數(shù)據(jù)類型，一般用于保持序列的唯一性—— 也就是同樣的元素僅出現(xiàn)一次。

3.4.1　集合的創(chuàng)建

在使用集合時一定要注意集合的“無序”和“唯一”兩個特點，避免出錯。

在下面代碼中，當集合出現(xiàn)不唯一的字符時，創(chuàng)建的集合中只會保存一個。

In [40]: a_set = {1, 2, 3, 4, 5, 5, 4}In [41]: a_setOut[41]: {1, 2, 3, 4, 5}

既然集合與字典都使用花括號，那么如果要初始化一個空集合，該怎么辦？還能用花括號嗎？

In [42]: a_set = {}In [43]: a_set.add(1)---------------------------------------------------------------------------AttributeError Traceback (most recent call last) in ()----> 1 a_set.add(1)AttributeError: 'dict' object has no attribute 'add'

結果顯示報錯，信息顯示字典沒有add屬性，說明花括號僅能初始化字典。

集合對應的函數(shù)是set()，因而我們必須使用它初始化或將其他數(shù)據(jù)類型轉換為字典。

In [44]: a_set = set()In [45]: a_set.add(1)In [46]: a_setOut[46]: {1}

3.4.2　集合操作

集合的常見用處是進行集合操作，這涉及3個基本方面：合集(并集)、交集和差集。

1．合集

合集使用union()方法如下。

In [47]: a_set = set([1, 2, 3, 4, 5])In [48]: b_set = set([4, 5, 6, 7, 8])In [49]: a_setOut[49]: {1, 2, 3, 4, 5}In [50]: b_setOut[50]: {4, 5, 6, 7, 8}In [51]: a_set.union(b_set)Out[51]: {1, 2, 3, 4, 5, 6, 7, 8}

2．交集

交集使用intersection()方法如下。

In [52]: a_set.intersection(b_set)Out[52]: {4, 5}

3．差集

差集使用difference()方法如下。

In [53]: a_set.difference(b_set)Out[53]: {1, 2, 3}

3.4.3　冰凍集

上一節(jié)提到，集合是可變的數(shù)據(jù)類型。在實際的數(shù)據(jù)分析中，有時希望集合存儲的數(shù)據(jù)不能改變，以防信息被惡意篡改或者出現(xiàn)其他數(shù)據(jù)失真的情況。

冰凍集(frozenset)提供了集合的不可變版本，它的內容不能改變，因此不存在add()與remove()方法。frozenset()函數(shù)可以將輸入的迭代對象轉換為冰凍集。

In [1]: fs = frozenset(['a', 'b'])In [2]: fsOut[2]: frozenset({'a', 'b'})In [3]: fs.remove('a')---------------------------------------------------------------------------AttributeError Traceback (most recent call last) in ()----> 1 fs.remove('a')AttributeError: 'frozenset' object has no attribute 'remove'In [4]: fs.add('c')---------------------------------------------------------------------------AttributeError Traceback (most recent call last) in ()----> 1 fs.add('c')AttributeError: 'frozenset' object has no attribute 'add'

冰凍集由于是不可變對象，所以可以用作字典的鍵。

3.5　章末小結

本章詳細介紹了Python內置的4個重要基本數(shù)據(jù)結構，分別是列表、元組、字典和集合。

其中，列表是日常工作分析主要接觸和使用的數(shù)據(jù)結構。元組與列表極為相似，但它們存在一個重要的區(qū)別—— 元組不可修改！字典實現(xiàn)了鍵與值的配對，可以快速實現(xiàn)內容的索引。集合相對少用些，它是存儲數(shù)據(jù)唯一值的一個集合。四者使用的初始化符號或函數(shù)都是不同的，讀者需要能夠區(qū)分并熟練掌握。本章的核心在列表部分，列表的重要性不言而喻，理解列表也可以幫助讀者快速理解其他幾個數(shù)據(jù)結構的意義與操作方法。在接下來的章節(jié)中，本書也將更深入地介紹和運用它們。

本文摘自《交互的Python：數(shù)據(jù)分析入門》

Python具有強大的應用能力，以及便捷高效的數(shù)據(jù)分析和可視化擴展包系統(tǒng)。本書重點講解Python數(shù)據(jù)分析的基礎知識，使讀者通過Python理解數(shù)據(jù)分析的邏輯，并掌握基本的Python編程知識和分析實現(xiàn)方法。本書系統(tǒng)全面、循序漸進地介紹了Python編程基礎、數(shù)據(jù)導入、數(shù)據(jù)分析和可視化內容，包括條件判斷與循環(huán)控制、從Excel中導入數(shù)據(jù)、使用Pandas庫進行數(shù)據(jù)的轉換和計算，以及使用Plotnine庫繪制ggplot風格的圖形等。此外，本書還涉及Markdown、基本的統(tǒng)計理論和IPython魔術命令等內容。

總結

以上是生活随笔為你收集整理的eclipse索引4超出范围_Python内置的4个重要基本数据结构：列表、元组、字典和集合的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內容還不錯，歡迎將生活随笔推薦給好友。