一、建立一個資料火車——串列

1、創建串列

2、串列元素的獲取

3、串列元素的添加

4、串列元素的洗掉

5、串列元素的修改

二、串列的親兄弟——元組

1、創建元組

2、元組元素的獲取

3、元組和串列的差別

三、資料中的魔術師——字串

1、創建字串

2、字符的獲取

3、字串的處理

4、字符轉義

5、原始字串

6、多行字串

7、串列、元組、字串的通用操作

8、串列、元組、字串總結

四、索引存盤不再麻煩——字典

1、創建字典

2、字典鍵值對的添加

3、鍵值對的獲取

4、字典鍵值對的洗掉

5、字典中鍵值對修改

6、什么時候用字典

五、比較專一的大火車——集合

1、創建集合

2、集合元素的添加

3、集合元素的獲取

4、集合元素的洗掉

5、集合的運算

6、集合運算示例

7、什么時候用集合

8、獲取字典和集合中的元素數量

9、字典和集合大總結

寫在最后

前言

Hello，你好呀，我是灰小猿，一個超會寫bug的程式猿！

近期和大家分享總結了關于Python基礎進階的文章“【全網力薦】堪稱最易學的Python基礎入門教程”，然后得到了很多小伙伴的支持和肯定，但是同時很多剛開始學習的小伙伴在編程的時候還會遇見很多錯誤，所以就又為大家總結了一篇關于Python常見報錯及其解決方案的文章“全網最值得收藏的Python常見報錯及其解決方案，再也不用擔心遇到BUG了！”，來幫助大家解決在前期學習中遇到的一些bug，感興趣的小伙伴可以去閱讀一下，

之后還會繼續和大家分享更多的Python基礎及進階技術，大家可以關注我一起學習呀！

今天就繼續來和大家分享Python基礎入門之后的又一技術：串列、元組、字串處理、字典和集合型別，文章較長，建議先收藏之后慢慢學習！

可能很多小伙伴在其他的編程語言中也見過這幾個型別的使用，但是在Python對其的學習絕對會讓你不虛此讀！！！

我們之前學習了字串和串列，除此之外 Python 中還內置有元組、字典、集合等常用的資料型別，它們都被用于存放批量資料，

存放批量資料用串列不就行了嗎，為什么還要這么多資料型別？這是因為在不同的場景下，對資料的讀取和修改效率以及記憶體使用情況的要求是不一樣的，為了滿足不同的場景需求，需要以不同的組織形式來存放資料，上面所述的那些資料型別，本質上就是不同的資料組織形式，Python 直接為我們提供了它們的現成的實作，我們拿來即可使用，輕而易舉地獲取各種不同的存放、訪問和修改資料的能力，

串列、元祖、字典、集合、字串這些資料型別中所存放的一個個單獨的資料，叫作項（Item）或元素（Element），這些資料型別除了可以存放元素以外，還能通過呼叫物件方法來操作管理其中的元素，

我們來詳細學習下這五種內置資料型別，

一、建立一個資料火車——串列

串列是 Python 中非常常用的資料型別，之前的章節中我們學習過串列的一些基礎知識，這個小節將會更深入地介紹串列的各種功能，

串列是用于存放若干元素的有序序列，串列使用方括號（[]）來表示，其中的元素寫入方括號中，多個元素時用逗號分隔，如 [1, 'go', [0.1, 0.2]]，它的元素可以是任意資料型別，甚至也可以是個串列，

元素之間有順序關系，每個元素都有自己的位置，每個位置從 0 開始依次標號，這個表示位置的數字叫作索引，

串列被創建之后，我們可以對它做很多操作，包括添加元素，洗掉元素，修改元素，查找元素等，

1、創建串列

創建空的串列：
```
串列 = []
```
>>> items = []
>>> items
[]
創建包含元素的串列：
```
串列 = [元素1, 元素2, ..., 元素N]
```
>>> items = [1, 2, 3]
>>> items
[1, 2, 3]

2、串列元素的獲取

通過索引獲取元素
```
元素 = 串列[索引]
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters[2]
’c’
通過元素獲取索引

這種方式和上面相反，首先在串列中尋找元素，然后回傳元素對應的索引，
```
索引 = 串列.index(元素)
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters.index(‘c’)
2
查看元素是否存在于串列中

要想查看元素是否存在于串列中，需要借助 Python 的關鍵字 in，使用如下：
```
布林值 = 元素 in 串列
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> ‘a’ in letters
True
>>> ‘z’ in letters
False
統計元素在串列中的個數

統計元素在串列中的個數，或者說是元素在串列中出現的次數，
```
個數 = 串列.count(元素)
```
>>> numbers = [1, 2, 2, 3, 4, 5, 5, 7]
>>> numbers.count(5)
2

3、串列元素的添加

我們可以很靈活地向串列添加元素，如以追加的形式向串列末尾添加一個元素；以插入的形式向串列的任意位置插入元素；或者將一個串列中的所有元素批量的添加到另一個串列中，

向串列末尾追加元素
```
串列.append(元素)
```
>>> letters = [‘a’, ‘b’]
>>> letters.append(‘c’)
>>> letters
[‘a’, ‘b’, ‘c’]
向串列的任意位置插入元素
```
串列.insert(索引, 元素)
```
>>> letters = [‘a’, ‘b’]

>>> letters.insert(0, ‘c’)
>>> letters
[‘c’, ‘a’, ‘b’]

>>> letters.insert(2, ‘d’)
>>> letters
[‘c’, ‘a’, ‘d’, ‘b’]
串列末尾追加另一個串列的所有元素
```
串列.extend(另一串列)
```
>>> letters = [‘a’, ‘b’]
>>> letters.extend([‘c’, ‘d’, ‘e’])
>>> letters
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’]

4、串列元素的洗掉

洗掉元素的方式同樣很靈活，

按索引洗掉元素
```
元素 = 串列.pop(索引)
```
pop(索引) 會將索引對應的元素從串列中洗掉，同時回傳這個元素，

>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters.pop(0)
’a’
>>> letters
[‘b’, ‘c’]

也可以不傳遞索引，這樣的話默認洗掉并回傳最后一個元素，

>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters.pop()
’c’
>>> letters
[‘a’, ‘b’]
按索引洗掉元素（del 方法)

洗掉一個串列元素也可以使用 Python 中的 del 關鍵字，如下：
```
del 串列[索引]
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> del letters[0]
>>> letters
[‘b’, ‘c’]
直接洗掉元素

直接洗掉元素時，Python 會先在串列中遍歷該元素，然后將匹配到的第一個元素洗掉，
```
串列.remove(元素)
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters.remove(‘b’)
>>> letters
[‘a’, ‘c’]
清空所有元素

清空所有元素即是把串列元素全部洗掉，最后僅為串列僅為 []，
```
串列.clear()
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters.clear()
>>> letters
[]

5、串列元素的修改

通過賦值修改串列元素
```
串列[索引] = 新元素
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters[2] = 'd’
>>> letters
[‘a’, ‘b’, ‘d’]
反轉整個串列

反轉整個串列會將所有的元素倒序排列，
```
串列.reverse()
```
>>> letters = [‘a’, ‘b’, ‘c’]
>>> letters.reverse()
>>> letters
[‘c’, ‘b’, ‘a’]
串列元素排序
```
串列.sort()
```
>>> numbers = [2, 4, 5, 2, 1, 5, 7, 3]
>>> numbers.sort()
>>> numbers
[1, 2, 2, 3, 4, 5, 5, 7]

也可以通過指定 sort 方法的 reverse 引數來倒序排列，
```
串列.sort(reverse=True)
```
>>> numbers = [2, 4, 5, 2, 1, 5, 7, 3]
>>> numbers.sort(reverse=True)
>>> numbers
[7, 5, 5, 4, 3, 2, 2, 1]

二、串列的親兄弟——元組

元組和串列非常相似，也是用于存放元素的有序序列，它用的圓括號（()）表示，元素寫入圓括號中，多個元素時用逗號分隔，如 (1, 2, 3)，

元組同樣具有索引，索引使用方式與串列一致，其元素同樣可以是任意型別，

看起來元組就是披著圓括號外衣的串列嘛！有什么區別？

元組創建完成后，便不能向其中添加元素，也不能修改和洗掉其中的任何一個元素，所以它與串列相比，只能查找元素，也就是說只具備讀的功能，不具備寫的功能，元組的這一特性叫作不可變（性）（Immutable），而串列是可變的（Mutable），

1、創建元組

創建空的元組：
```
元組 = ()
```
>>> items = ()
>>> items
()
創建包含多個元素的元組：
```
元組 = (元素1, 元素2, ..., 元素N)
```
>>> items = (1, 2, 3)
>>> items
(1, 2, 3)
創建只包含一個元素的元組

只包含一個元素的情況需要單獨說明一下，因為它的形式與直覺不相符，

創建只包含一個元素的元組，需要在唯一的那個元素后面加上逗號，如：
```
元組 = (元素,)
```
>>> items = (1,)
>>> items
(1,)

這是因為，如果括號中只有一個元素，那么 Python 會將這個括號當作優先級符號進行處理（像數學中的那樣），而不是當作元組，可以試一下：

>>> items = (1)
>>> items
1
>>> type(items)
<class ‘int’>

2、元組元素的獲取

通過索引獲取元素
```
元素 = 元組[索引]
```
>>> letters = (‘a’, ‘b’, ‘c’)
>>> letters[2]
’c’
通過元素獲取索引
```
索引 = 元組.index(元素)
```
>>> letters = (‘a’, ‘b’, ‘c’)
>>> letters.index(‘c’)
2
查看元素是否存在于元組中
```
布林值 = 元素 in 元組
```
>>> letters = (‘a’, ‘b’, ‘c’)
>>> ‘a’ in letters
True
>>> ‘z’ in letters
False
統計元素在元組中出現的個數
```
個數 = 元組.count(元素)
```
>>> numbers = (1, 2, 2, 3, 4, 5, 5, 7)
>>> numbers.count(5)
2

3、元組和串列的差別

我們可以看到，元組所具有的操作在使用方式上與和串列非常相似，甚至在一定程度上可以將元組看作是串列的精簡版，但它們之間也有明顯的差別，

元組是不可變的（Immutable），串列是可變的（Mutable），元組在被創建之后，就不能添加、洗掉和修改元素，而串列可以
一般情況下元組的性能在略高于串列

我們在什么時候用串列，什么時候用元組？

串列還是元組，通常性能不是從它們中做選擇的主要考慮因素，因為它們之間的性能差異不是很大，我們的選擇通常圍繞著可變和不可變的特性進行，當我們需要添加元素或修改元素時，使用串列；當我們希望所有元素在創建之后便不再改變，可使用元組，

三、資料中的魔術師——字串

字串也是 Python 中非常常用的內置資料型別，我們之前學習過字串的一些內容，現在來深入的了解下，

為什么要叫它是資料中的魔術師呢？原因是因為它可以轉義成很多你想要的資料型別，接下來往下看你就知道了！

字串是 Python 中用來存放字符序列的資料型別，其中的元素只能是字符，字串使用單引號或雙引號來表示，如 'pick'，"cherry"，通常我們首先使用單引號，

字串是有序序列，可以使用索引來獲取其中某個位置的元素，它是不可變的，被創建之后其中的元素（也就是字符）不能被修改和洗掉，

1、創建字串

創建空字串（即不包含字符的字串）：
```
字串 = ''
```
>>> string = ''
>>> string
’’
創建包含元素的字串：
```
字串 = '若干字符'
```
>>> string = 'happy’
>>> string
’happy’

2、字符的獲取

通過索引獲取字符
```
字符 = 字串[索引]
```
>>> string = ‘happy’
>>> string[2]
’p’
通過子串獲取索引

所謂子串就是從字串中截取下來的一部分，可以是一個字符，一部分字符、全部字符、或空字串，如 'a'、'ppy'、'happy'、'' 都是 ‘happy’ 的子串，查找子串時，回傳的是子串的第一個字符的索引，
```
索引 = 字串.index(字符)
```
>>> string = ‘happy’
>>> string.index(‘p’)
2

>>> string = ‘happy’
>>> string.index(‘app’)
1

當字符或子串不存在時，index 方法將拋出 ValueError 錯誤，

也可采用字串的 find 方法來查找子串，使用方式與 index 一致，不同點在于 find 方法未找到子串時回傳數字 -1，而不拋例外，

>>> string = ‘happy’
>>> string.find(‘app’)
1
>>> string.find(‘z’)
-1
查看字符是否存在于字串中

查看字符是否存在于字串中，需要借助 Python 的關鍵字 in，如下：
```
布林值 = 字符 in 字串
```
>>> string = ‘happy’
>>> ‘a’ in string
True
>>> ‘z’ in string
False
統計字符在字串中的個數
```
個數 = 字串.count(字符)
```
>>> string = ‘happy’
>>> string.count(‘p’)
2

3、字串的處理

字串自帶的方法非常多，除了上面介紹的幾個之外還有四十多個，這是因為字符處理是編程時的一項高頻作業，Python 將這些字符處理相關的功能以方法的形式集成在字串里，

這里列舉幾個常見的方法：

startswith：判斷字串是否以某個子串開頭，回傳布林值

>>> string = ‘happy’
>>> string.startswith(‘ha’)
True
endswith：判斷字串是否以某個子串結尾，回傳布林值

>>> string = ‘happy’
>>> string.endswith(‘y’)
True
replace：將字串的子串用一個另一個字串替換，回傳一個新的字串

>>> string = ‘happy’
>>> string.replace(‘y’, ‘iness’)
’happiness’
strip：去除字串前后的空白符號，如空格、換行符、制表符，回傳一個新的字串

>>> string = ’ \t happy \n’
>>> string.strip()
’happy’
split：將字串用某個子串分隔開，分隔后的各個部分放入串列中，并回傳這個串列

>>> string = ‘I am happy’
>>> string.split(’ ')
[‘I’, ‘am’, ‘happy’]
join：將一個序列中的元素用某個字符（串）拼接，組成一個大的字串，并回傳這個字串

>>> words = [‘I’, ‘am’, ‘happy’]
>>> ’ '.join(words)
’I am happy’
upper：將字串轉化為大寫字母形式，回傳一個新的字串

>>> string = ‘happy’
>>> string.upper()
’HAPPY’
lower：將字串轉化為小寫字母形式，回傳一個新的字串

>>> string = ‘HAPPY’
>>> string.lower()
’happy’

注意上面的這些字符處理功能，對字串作處理后都是回傳一個新的字串，而不會直接修改原有的字串，為什么呢？字串不可變呀！

4、字符轉義

我們在創建字串時，有一些字符是沒法直接在引號中表示的，如單引號或雙引號，因為這和表示字串本身的符號沖突了，如：

>>> string = 'I’m happy’
File “”, line 1
string = ‘I’m happy’
^
SyntaxError: invalid syntax

拋出 SyntaxError 語法錯誤例外，因為 Python 將 string = 'I' 看作字串的賦值，而后面的 m happy' 就無法決議了，因為不符合任何語法，

這時就需要使用字符轉義了，我們在這類無法直接在字串中表示的字符前加上 \ 符號，形如 \'，這樣 Python 在決議時就能理解這是嵌入在字串中的單引號 '：

>>> string = 'I\'m happy’
>>> string
"I’m happy"

像 \' 這樣在前面加了反斜杠（\），為了能在字串中正常表示的字符，叫作轉義字符，而這個轉化的行為叫作字符轉義，

與單引號的用法相同，雙引號用 \" 來轉義，

字串中的 \ 用來做字符轉義了，那怎么在字串中表示斜桿 \ 這個字符呢？使用 \\，將斜桿 \ 轉義一下，除此之外，有一些空白符號也需要用轉義字符來表示，因為我們沒辦法直接在字串中表示它們，如常見的換行（\n），制表符（\t），回車（\r），

常用的轉義字符	含義
`\'`	單引號
`\"`	雙引號
`\\`	反斜杠
`\n`	換行符
`\t`	制表符（Tab）
`\r`	回車

舉個例子，如果在字串使用了 \n，那么在用 print() 輸出字串的時候，這個字串會被換行輸出，如：

>>> print(‘第一行\n第二行’)
第一行
第二行

使用 \n 換行符使得我們能夠在一行的字串來表示多行的內容，

說明：轉義字符雖然在書寫時使用了兩個字符，但是在程式中它只是一個字符，可以自己來試驗下：
>>> len(’\n’)
1
>>> len(’\’’)
1

如果我們就想在字串中表示 \n 這兩個字符，而不是讓它表示換行，該怎么辦？有兩種方式：

使用 \\n，將 \n 前面的反斜杠轉義

>>> print(‘第一行\\n第二行’)
第一行\n第二行
使用原始字串

5、原始字串

原始字串就是在字串的起始引號前加上一個 r 或 R 字母，這樣字串中的內容將不會被轉義，將按照原樣輸出，使用方法：

r'字串內容'

>> print(r’第一行\n第二行’)
第一行\n第二行

6、多行字串

我們之前所使用的字串都被書寫成一行，要想讓字串可以跨行書寫，寫成多行的形式，有兩種方法：

字串的每行末尾使用 \ 續行

以多行的形式書寫字串，每行的末尾使用 \ 續行，需要注意輸出內容為一行，
```
string = '第一行\
第二行\
第三行'
```
>>> string = '第一行\
… 第二行\
… 第三行’
>>> print(string)
‘第一行第二行第三行’

可以看到這種方式可以讓字串以多行的方式來書寫，但是輸出內容還是被當作一行，如果想要輸出內容為多行，需要在字串中顯式地使用 \n 進行換行，

>>> string = '第一行\n\
… 第二行\n\
… 第三行’
>>> print(string)
第一行
第二行
第三行
使用三個單引號或三個雙引號來表示字串

在 Python 中字串也可以使用三個單引號或三個雙引號來表示字串，這樣字串中的內容就可以多行書寫，并且被多行輸出，
```
string = '''第一行
第二行
第三行'''
```
>>> string = ‘’‘第一行
… 第二行
… 第三行’’'
>>> print(string)
第一行
第二行
第三行

使用三引號的方式，字串可被多行書寫，且被多行輸出，其中不需要顯式地指明 \n 換行，

7、串列、元組、字串的通用操作

我們把串列、元組、字串統稱為序列，

使用 len() 函式獲取序列長度

>>> letters = (‘a’, ‘b’)
>>> len(letters)
2

>>> letters = ‘abcd’
>>> len(letters)
4
獲取序列中的一個子序列

獲取序列中的子序列可以使用切片，以 [起始索引:結束索引] 表示，切片其實代表一個索引區間，這個區間是一個左閉右開區間，該區間內的所有元素作為子序列被回傳，如：

>>> numbers = (1, 2, 3, 4, 5)
>>> numbers[0:2]
(1, 2)

>>> numbers[2:4]
(3, 4)

>>> letters = ‘abcd’
>>> letters[1:5]
’bcd’
使用 + 符號來拼接兩個序列

>>> letters_1 = (‘a’, ‘b’)
>>> letters_2 = (‘c’, ‘d’, ‘e’)
>>> letters_1 + letters_2
(‘a’, ‘b’, ‘c’, ‘d’, ‘e’)

>>> letters_1 = ‘ab’
>>> letters_2 = ‘cde’
>>> letters_1 + letters_2
’abcde’
使用 * 符號來重復序列中的元素

>>> letters = (‘a’, ‘b’)
>>> letters * 3
(‘a’, ‘b’, ‘a’, ‘b’, ‘a’, ‘b’)

>>> letters = ‘abcd’
>>> letters * 2
’abcdabcd’

注意上面的操作結果都是回傳一個新的序列，不會對修改序列的內部元素，

8、串列、元組、字串總結

串列、元組、字串都是有序序列，都可以使用索引，

串列和元組中可以存放任意資料型別的元素，而字串中只能存放字符，

串列是可變的，而元組和字串是不可變的，

四、索引存盤不再麻煩——字典

字典是一種用來存放若干鍵值對的資料型別，

什么是鍵值對呢？鍵值對就是兩個物件，其中一個是用來做定位的資料，叫做鍵（Key），另一個是要存放的資料，叫做值（Value），在字典中，鍵值對作為一個整體被存放，我們可以通過鍵來快速獲取到對應的值，

在 Python 中字典用花括號（{}）來表示，鍵值對以 鍵:值 的方式寫入花括號中，有多個鍵值對時用逗號分隔，

如 {'010': 'beijing', '021': 'shanghai'} 便是一個字典，其中包含兩個鍵值對

'010': 'beijing'
'021': 'shanghai'

使用時，我們可以通過 '010' 快速查詢到其對應的值是 'beijing'，這就好比現實中的一本字典一樣，通過拼音或偏旁來映射一個具體的字詞，以此來實作字詞的快速查找，而這個拼音或偏旁就相當于 Python 字典的鍵，而字詞就相當于 Python 字典的值，它們在字典中是映射關系，

Python 字典中的鍵是有要求的，需要是不可變的型別，如元組、字串、數字，而字典中的值可以是任意型別，字典本身是可變的，我們可以向其中添加、洗掉、修改鍵值對，

因為字典不是序列，更不是有序的，所有它沒有串列那樣的索引，也不能保證每個鍵值對的存放次序，

1、創建字典

創建空的字典
```
字典 = {}
```
>>> empty_dict = {}
>>> empty_dict
{}
創建包含鍵值對的字典
```
字典 = {鍵1:值1, 鍵2:值2, ..., 鍵N:值N}
```
如城市和其對應的電話區號：

>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes
{‘beijing’: ‘010’, ‘shanghai’: ‘021’}

2、字典鍵值對的添加

向字典中增加鍵值對
```
字典[鍵] = 值
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes[‘tianjin’] = '022’
>>> codes
{‘beijing’: ‘010’, ‘shanghai’: ‘021’, ‘tianjin’: ‘022’}

使用這種方式時，若字典中沒有這個鍵，則會創建這個鍵值對；若字典中原本已有這個鍵，則是修改鍵所對應的值，

3、鍵值對的獲取

通過鍵獲取值
```
值 = 字典[鍵]
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes[‘beijing’]
‘010’

注意若鍵不存在則將拋出 KeyError 例外：

>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes[‘a’]
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘a’
通過鍵獲取值（ get 方法）

如果通過鍵獲取值時不希望 KeyError 例外拋出，可以使用 get 方法，若鍵不存在，則直接回傳 None，
```
值 = 字典.get(鍵)
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.get(‘a’)
>>>

回傳的 None 代表什么都沒有，所以沒有任何值顯示，

也可以給 get 方法傳遞第二個引數作為默認值，使得鍵不存在時直接回傳默認值，
```
值 = 字典.get(鍵, 默認值)
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.get(‘a’, ‘000’)
>>> ‘000’
判斷字典中是否包含某個鍵
```
布林值 = 鍵 in 字典
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> ‘beijing’ in codes
True
>>> ‘guangzhou’ in codes
False
獲取所有鍵
```
鍵的串列 = 字典.keys()
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.keys()
dict_keys([‘beijing’, ‘shanghai’])

獲取到的所有鍵是以迭代器的形式存在，至于什么是迭代器我們將在之后的章節中介紹，在這里我們可以用 list() 函式將迭代器轉換為串列，如下：

>>> list(codes.keys())
[‘beijing’, ‘shanghai’]
獲取所有值
```
值的串列 = 字典.values()
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.values()
dict_values([‘010’, ‘021’])

獲取到的所有值是以迭代器的形式存在，我們用 list() 函式將迭代器轉換為串列，如下：

>>> list(codes.values())
[‘010’, ‘021’]
獲取所有鍵值對的串列
```
值的串列 = 字典.items()
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.items()
dict_items([(‘beijing’, ‘010’), (‘shanghai’, ‘021’)])

獲取到的所有鍵值對是以迭代器的形式存在，我們用 list() 函式將迭代器轉換為串列，如下：

>>> list(codes.items())
[(‘beijing’, ‘010’), (‘shanghai’, ‘021’)]

串列中的每一個元素是都是二元組（即包含兩個元素的元組），每個二元組的第一個元素是鍵，第二個元素是值，

4、字典鍵值對的洗掉

通過鍵洗掉鍵值對

可以使用 pop 方法洗掉一個鍵值對，并將值回傳，
```
值 = 字典.pop(鍵)
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.pop(‘beijing’)
’010’
>>> codes
{‘shanghai’: ‘021’}

如果 pop 一個不存在的鍵，則會拋出 KeyError 例外：

>>> codes.pop(‘a’)
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘a’

如果你不希望例外拋出，可以傳遞 pop 方法的第二個引數作為默認值，默認值僅在鍵不存在時生效，此時方法將直接回傳這個默認值，且跳過洗掉操作：
```
值 = 字典.pop(鍵, 默認值)
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.pop(‘guangzhou’, ‘000’)
’000’
通過鍵洗掉鍵值對（del 方法）

也可以通過關鍵字 del 來洗掉鍵值對，
```
del 字典[鍵]
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> del codes[‘beijing’]
>>> codes
{‘shanghai’: ‘021’}
隨機洗掉一個鍵值對

使用 popitem 隨機洗掉一個鍵值對，并回傳這個鍵值對的二元組，二元組的第一個元素是鍵，第二個元素是值，
```
鍵值二元組 = 字典.popitem()
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.popitem()
(‘shanghai’, ‘021’)
>>> codes
{‘beijing’: ‘010’}
清空所有鍵值對
```
鍵值二元組 = 字典.clear()
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.clear()
>>> codes
{}

5、字典中鍵值對修改

修改鍵對應的值
```
字典[鍵] = 值
```
>>> codes = {‘beijing’: ‘010’}
>>> codes[‘beijing’] = '021’
>>> codes
{‘beijing’: ‘021’}

如果鍵不存在，則創建鍵值對，
用字典批量更新鍵值對
```
字典.update(另一字典)
```
>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> codes.update({‘guangzhou’: ‘020’, ‘shanghai’: ‘000’})
>>> codes
{‘beijing’: ‘010’, ‘shanghai’: ‘000’, ‘guangzhou’: ‘020’}

可以看到字典中新增了 'guangzhou': '020' 這個鍵值對，同時將 'shanghai': '021' 修改為 'shanghai': '000'，

6、什么時候用字典

字典的顯著優勢是可以通過鍵快速地查詢資料，字典中的元素以鍵值對的形式存在，使用時通過鍵來獲取和修改值，由于字典內部的特殊實作，字典通過鍵獲取值的效率非常高，

如果我們希望將批量的資料存放起來，并且在需要時能以很高的執行效率來獲取其中某個指定的資料，這時就可以使用字典，除此之外，如果我們想在程式中暫時維護一個映射關系，也可以使用字典，因為字典本質上就是一個映射關系，

如，我們可以將城市名和對應的區號保存在字典中，這樣就可以通過城市名快速地查詢到其區號，而不需要進行遍歷，

area_codes = {
    '北京': '010',
    '上海': '021',
    '天津': '022',
    '重慶': '023',
    '沈陽': '024',
    '南京': '025',
    '武漢': '027',
    '成都': '028',
}

>>> area_codes[‘成都’]
‘028’
>>> area_codes[‘南京’]
‘025’

五、比較專一的大火車——集合

集合是一個用于存放批量元素的資料型別，它不是有序的，其中的元素沒有順序關系，集合中的元素沒有重復，重復的元素將被自動剔除最終只留下一個，

集合也是用花括號（{}）來表示，不同于字典的是，花括號中放的是一個個資料，而不是鍵值對，

集合是可變的，我們可以向其中添加、洗掉、修改元素，

1、創建集合

創建包含元素的集合
```
集合 = {元素1, 元素2, 元素N}
```
>>> numbers = {1, 2, 3}
>>> numbers
{1, 2, 3}
創建空集合
```
集合 = set()
```
注意創建空集合不能直接使用 {}，那樣是表示空字典，而是使用 set()，這才表示空集合，

>>> empty_set = set()
>>> empty_set
set()

2、集合元素的添加

向集合中添加一個元素
```
集合.add(元素)
```
>>> numbers = {1, 2}
>>> numbers.add(3)
>>> numbers
{1, 2, 3}

向集合中添加重復元素時，會被去重處理，

>>> numbers = {1, 2}
>>> numbers.add(2)
>>> numbers
{1, 2}
從另一集合中批量添加元素
```
集合.update(另一集合)
```
>>> numbers_1 = {1, 2}
>>> numbers_2 = {2, 3, 4}
>>> numbers_1.update(numbers_2)
>>> numbers_1
{1, 2, 3, 4}

可以看到，集合numbers_2 中的所有元素被添加到了集合 numbers_1 中，并且其中重復的元素被剔除僅保留一份，

3、集合元素的獲取

集合不能像串列那樣通過索引來獲取元素，也不能像字典那樣通過鍵來獲取值，集合沒法直接獲取到某個指定的元素，想要獲取元素，只能通過遍歷的方式，

雖然集合不能直接獲取到元素，但是我們依然可以用 in 關鍵字來判斷元素是否存在于集合中，

查看元素是否存在于集合中
```
布林值 = 元素 in 集合
```
>>> letters = {‘a’, ‘b’, ‘c’}
>>> ‘a’ in letters
True
>>> ‘z’ in letters
False

4、集合元素的洗掉

隨機洗掉一個元素，并回傳這個元素
```
元素 = 集合.pop()
```
使用 pop 方法隨機洗掉一個元素的時候，這個元素會被回傳，

>>> numbers = {1, 2, 3}
>>> numbers.pop()
1
>>> numbers.pop()
2
>>> numbers
{3}
洗掉一個指定的元素
```
集合.remove(元素)
```
>>> numbers = {1, 2, 3}
>>> numbers.remove(1)
>>> numbers
{2, 3}

如果要洗掉的元素不存在，則拋出 KeyError 例外：

>>> numbers = {1, 2, 3}
>>> numbers.remove(4)
Traceback (most recent call last):
File “”, line 1, in
KeyError: 4
洗掉一個指定的元素，且不拋出 KeyError 例外

使用 remove 方法洗掉一個不存在的元素時，會拋出 KeyError 例外，如果我們不想讓例外拋出，可以使用 discard 方法，
```
集合.discard(元素)
```
>>> numbers = {1, 2, 3}
>>> numbers.discard(4)
>>> numbers
{1, 2, 3}
清空所有元素
```
集合.clear()
```
與串列和字典一樣，想要清空所有元素，可以使用 clear 方法，

>>> numbers = {1, 2, 3}
>>> numbers.clear()
>>> numbers
set()

順便考大家一個問題，為什么元組沒有這個方法？因為元組是不可變的！我們不能洗掉元組的元素，也不能添加和修改元素，

5、集合的運算

看到這里你可能會想，集合不就是閹割版的串列嘛？不是的，集合的功能不止于此，

Python 中的集合和數學中的集合頗為相似，首先集合的所有元素都是唯一的，不存在重復；此外集合有子集、超集的概念，也可以進行交集、并集、差集的運算，

求交集

可以通過 intersection 方法求多個集合的交集，
```
交集 = 集合1.intersection(集合2, 集合3, 集合N)
```
>>> numbers_1 = {1, 2, 3}
>>> numbers_2 = {2, 3, 4}
>>> numbers_3 = {3, 4, 5}
>>> numbers_1.intersection(numbers_2, numbers_3)
{3}

也可以直接使用與運算子 & 來代替，完全等效：
```
交集 = 集合1 & 集合2 & 集合N
```
>>> numbers_1 & numbers_2 & numbers_3
{3}
求并集
```
并集 = 集合1.union(集合2, 集合3, 集合N)
```
>>> numbers_1 = {1, 2, 3}
>>> numbers_2 = {2, 3, 4}
>>> numbers_3 = {3, 4, 5}
>>> numbers_1.union(numbers_2, numbers_3)
{1, 2, 3, 4, 5}

也可以直接使用或運算子 | 來代替，完全等效：
```
并集 = 集合1 | 集合2 | 集合N
```
>>> numbers_1 | numbers_2 | numbers_3
{1, 2, 3, 4, 5}
求差集
```
差集 = 集合1.difference(集合2, 集合3, 集合N)
```
>>> numbers_1 = {1, 2, 3}
>>> numbers_2 = {2, 3, 4}
>>> numbers_3 = {3, 4, 5}
>>> numbers_1.difference(numbers_2, numbers_3)
{1}

也可以直接使用運算子 - 來代替，完全等效：
```
差集 = 集合1 - 集合2 - 集合N
```
>>> numbers_1 - numbers_2 - numbers_3
{1}
判斷是否為子集
```
布林值 = 集合1.issubset(集合2)
```
判斷 集合1 是否為 集合2 的子集，

>>> numbers_1 = {2, 3}
>>> numbers_2 = {1, 2, 3}
>>> numbers_1.issubset(numbers_2)
True
>>> numbers_3 = {3, 4}
>>> numbers_1.issubset(numbers_3)
False
判斷是否為超集
```
布林值 = 集合1.issuperset(集合2)
```
判斷 集合1 是否為 集合2 的子集，

>>> numbers_1 = {1, 2, 3}
>>> numbers_2 = {2, 3}
>>> numbers_1.issuperset(numbers_2)
True
>>> numbers_3 = {3, 4}
>>> numbers_1.issuperset(numbers_3)
False

6、集合運算示例

集合運算在編程時有什么用呢？以差集為例舉個例子，

假如大學里有一個班，班里同學的花名冊是「趙大，錢二，孫三，李四，周五，吳六，鄭七，王八」，有一天上課，老師要求同學們在一張白紙上簽到，大家陸續寫上了自己的名字，上面有「周五，李四，王八，趙大，錢二，馮九，陳十」，哪些人缺席了呢？

要判斷哪些人缺席了，通常的做法時，逐一從簽到表上取出名字，然后去花名冊上尋找并做標記，最侄訓名冊上沒被標記的名字便是缺席的，有些麻煩，這可苦了助教了，

我們可以用 Python 集合來快速解決這個問題，將花名冊上的名字保存在集合中，將簽到表上的名字保存在另一個集合中，然后求一下差集，如下：

>>> 花名冊 = {‘趙大’, ‘錢二’, ‘孫三’, ‘李四’, ‘周五’, ‘吳六’, ‘鄭七’, ‘王八’}
>>> 簽到表 = {‘周五’, ‘李四’, ‘王八’, ‘趙大’, ‘錢二’, ‘馮九’, ‘陳十’}
>>> 花名冊 - 簽到表
{‘吳六’, ‘孫三’, ‘鄭七’}

吳六，孫三，鄭七沒來！

我們用反過來用 簽到表 - 花名冊 看看：

>>> 簽到表 - 花名冊
{‘陳十’, ‘馮九’}

還有兩個旁聽生！

7、什么時候用集合

集合非常重要的一個特性是元素無重復，每個元素都是唯一的，重復的元素將被自動剔除（去重），

所以如果我們需要存放一系列的資料，并且不希望其中出現重復，那么就可以使用集合，

另外如果想計算兩個資料集的交集、并集、差集，使用集合來承載資料再合適不過了，集合自帶的集合運算能輕松解決這些問題，

8、獲取字典和集合中的元素數量

我們可以通過 len() 函式來獲取字典中的鍵值對數量和集合中的元素數量，

>>> codes = {‘beijing’: ‘010’, ‘shanghai’: ‘021’}
>>> len(codes)
2

>>> numbers = {1, 2, 3, 4}
>>> len(numbers)
4

9、字典和集合大總結

字典是一種用來存放若干鍵值對的資料型別，可通過鍵來快速查找值，

字典的鍵需要是不可變的型別，如數字，字串和元組，字典的值可以是任意型別，字典本身是可變的，所以可向其中添加、修改、洗掉鍵值對，

集合是一個用于存放批量元素的序列，它不是有序的，且元素不會有重復，集合也是可變的，我們可以向其中添加、洗掉、修改元素，

寫在最后

關于Python中常用資料型別的總結就先和大家總結分享到這里，其中有不足或不懂的地方歡迎大家在評論區留言指出，

之后還會繼續和大家分享有關Python函式、迭代、運算式等進階內容，

歡迎小伙伴們點贊關注博主！

持續為大家帶來更多優質干貨和技術分享哦！

灰小猿陪您一起進步呀！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/278090.html

標籤：python

上一篇：Python128道面試題及答案詳解，爆肝熬夜整理，助你吊打面試官上岸成功

下一篇：別催啦別催啦，Python Socket編程

萬字長文爆肝Python基礎入門【第二彈、超詳細資料型別總結】

前言

之后還會繼續和大家分享更多的Python基礎及進階技術，大家可以關注我一起學習呀！

一、建立一個資料火車——串列

1、創建串列

2、串列元素的獲取

3、串列元素的添加

4、串列元素的洗掉

5、串列元素的修改

二、串列的親兄弟——元組

1、創建元組

2、元組元素的獲取

3、元組和串列的差別

三、資料中的魔術師——字串

1、創建字串

2、字符的獲取

3、字串的處理

4、字符轉義

5、原始字串

6、多行字串

7、串列、元組、字串的通用操作

8、串列、元組、字串總結

四、索引存盤不再麻煩——字典

1、創建字典

2、字典鍵值對的添加

3、鍵值對的獲取

4、字典鍵值對的洗掉

5、字典中鍵值對修改

6、什么時候用字典

五、比較專一的大火車——集合

1、創建集合

2、集合元素的添加

3、集合元素的獲取

4、集合元素的洗掉

5、集合的運算

6、集合運算示例

7、什么時候用集合

8、獲取字典和集合中的元素數量

9、字典和集合大總結

寫在最后

關于Python中常用資料型別的總結就先和大家總結分享到這里，其中有不足或不懂的地方歡迎大家在評論區留言指出，

之后還會繼續和大家分享有關Python函式、迭代、運算式等進階內容，

歡迎小伙伴們點贊關注博主！

持續為大家帶來更多優質干貨和技術分享哦！

灰小猿陪您一起進步呀！