本章內容提要：

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

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

3.1　列表

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

3.1.1　列表的創建

下面創建一個簡單的列表，存儲英文中的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開始索引的語言，比如數據分析中也非常流行的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()函數進行計算。

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

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

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

3.1.2　修改列表元素

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

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

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

即使發現最后一個元素寫錯了，也不需要像下面這樣重新創建列表。

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

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

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

除了使用自然數進行索引元素，還可以使用負整數進行反向索引，比如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章介紹的循環來解決類似的問題。

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

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

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

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

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

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

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

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

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

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

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

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

3.1.4　列表操作符

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

1．加號

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

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的后面，生成了一個新的列表。

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

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

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

2．星號

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

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

3.1.5　列表切片

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

例如，如果存在包含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']

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

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

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']

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

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　列表方法、函數與操作

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

注意，當下文提及方法時，一般指在變量名后加點號然后加函數。例如，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)：使用另一個列表作參數，然后把所有的元素添加到一個列表上。

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的元素并返回它的值，如果沒有參數，則默認刪除和返回最后一個。

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

(2)remove(element)：移除參數中指定的元素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．列表排序

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

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()函數，并把結果賦值給新的變量。

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．簡單統計

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

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

如果要對出現相同元素計數，可以使用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()函數可以對數值列表求和。

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()函數用于邏輯值列表，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．最常見操作方法匯總

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

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

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

表示

描述

l.append(x)

添加元素x到列表

l.count(x)

計算列表中x出現的次數

l.index(x)

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

l.remove(x)

從列表中移除x

l.reverse()

翻轉列表

l.sort()

列表排序

3.1.7　列表與字符串

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

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

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()函數將一個字符串分開成一個個字符(字母)。如果要把字符串切分成一個個單詞，可以使用split()方法，如下所示：

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

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

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

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

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

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

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

3.1.8　列表對象與值

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

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

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

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

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

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

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

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實際上是先創建了一個字符串對象，內容是orange，然后給這個對象打上標簽a。

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

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不是重新創建，而是將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最核心的概念和數據結構，也是理解其他基礎數據結構的橋梁。掌握好了列表，讀者對本章接下來介紹的數據結構都可以觸類旁通，其使用和操作方法大同小異。重要的差異會給出提示和強調，讀者需要留心注意。

3.2　元組

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

3.2.1　元組的創建

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

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

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

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

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

請看下面的代碼：

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

前兩個命令創建的都是數字1，后兩個命令創建的才是元組，包含元素數字1。

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

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是已經創建的變量，t是一個臨時變量t = aa = bb = t

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

a, b = b, a

3.2.3　元組與列表的區別

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

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

3.3　字典

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

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

3.3.1　字典的創建與使用

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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　字典操作

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

例如，提取字典長度。

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()方法可以無意外地獲取字典值，它需要提供兩個參數，除了鍵，還需要指定如果查找不到應當返回的信息。

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

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

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　集合

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

3.4.1　集合的創建

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

在下面代碼中，當集合出現不唯一的字符時，創建的集合中只會保存一個。

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屬性，說明花括號僅能初始化字典。

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

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　冰凍集

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

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

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個重要基本數據結構，分別是列表、元組、字典和集合。

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

本文摘自《交互的Python：數據分析入門》

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

總結

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

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