Python認知篇：常見資料類型--字元串+元組

大家好，我是辣條，最近不少人找到我問我很多跟資料類型相關的問題，于是我這裡就跟大家講幾個常見的資料類型，篇幅有點長但是耐心看完之後你會很好的掌握這些常見的資料類型的。

另外還有人在問怎麼找辣條的，今天再跟大家說一下。

→→→→點選跳轉到文末找到我, 點選跳轉到文末找到我, 點選跳轉到文末找到我←←←←

一，字元串

前言

第二次世界大戰促使了現代電子計算機的誕生，世界上的第一台通用電子計算機叫ENIAC（電子數值積分計算機），誕生于美國的賓夕法尼亞大學，占地167平米，重量27噸，每秒鐘大約能夠完成約5000次浮點運算，如下圖所示。ENIAC誕生之後被應用于飛彈彈道的計算，而數值計算也是現代電子計算機最為重要的一項功能。

随着時間的推移，雖然數值運算仍然是計算機日常工作中最為重要的組成部分，但是今天的計算機還要處理大量的以文本形式存在的資訊。如果我們希望通過Python程式來操作本這些文本資訊，就必須要先了解字元串這種資料類型以及與它相關的知識。

字元串的定義

所謂字元串，就是由零個或多個字元組成的有限序列，一般記為：

在Python程式中，如果我們把單個或多個字元用單引号或者雙引号包圍起來，就可以表示一個字元串。字元串中的字元可以是特殊符号、英文字母、中文字元、日文的平假名或片假名、希臘字母、Emoji字元等。

s1 = 'hello, world!'
s2 = "你好，世界！"
print(s1, s2)
# 以三個雙引号或單引号開頭的字元串可以折行
s3 = '''
hello, 
world!
'''
print(s3, end='')

提示： print 函數中的 end='' 表示輸出後不換行，即将預設的結束符 \n （換行符）更換為 '' （空字元）。

轉義字元和原始字元串

可以在字元串中使用

（反斜杠）來表示轉義，也就是說

後面的字元不再是它原來的意義，例如：

\n

不是代表反斜杠和字元

，而是表示換行；

\t

也不是代表反斜杠和字元

，而是表示制表符。是以如果字元串本身又包含了

、

這些特殊的字元，必須要通過

進行轉義處理。例如要輸出一個帶單引号或反斜杠的字元串，需要用如下所示的方法。

s1 = '\'hello, world!\''
print(s1)
s2 = '\\hello, world!\\'
print(s2)

Python中的字元串可以

或

開頭，這種字元串被稱為原始字元串，意思是字元串中的每個字元都是它本來的含義，沒有所謂的轉義字元。例如，在字元串

'hello\n'

中，

\n

表示換行；而在

r'hello\n'

中，

\n

不再表示換行，就是反斜杠和字元

。大家可以運作下面的代碼，看看會輸出什麼。

# 字元串s1中\t是制表符，\n是換行符
s1 = '\time up \now'
print(s1)
# 字元串s2中沒有轉義字元，每個字元都是原始含義
s2 = r'\time up \now'
print(s2)

Python中還允許在

後面還可以跟一個八進制或者十六進制數來表示字元，例如

\141

和

\x61

都代表小寫字母

，前者是八進制的表示法，後者是十六進制的表示法。另外一種表示字元的方式是在

\u

後面跟Unicode字元編碼，例如

\u9a86\u660a

代表的是中文“駱昊”。運作下面的代碼，看看輸出了什麼。

s1 = '\141\142\143\x61\x62\x63'
s2 = '\u9a86\u660a'
print(s1, s2)

字元串的運算

Python為字元串類型提供了非常豐富的運算符，我們可以使用

運算符來實作字元串的拼接，可以使用

運算符來重複一個字元串的内容，可以使用

in

和

not in

來判斷一個字元串是否包含另外一個字元串，我們也可以用

[]

和

[:]

運算符從字元串取出某個字元或某些字元。

拼接和重複

下面的例子示範了使用

和

運算符來實作字元串的拼接和重複操作。

s1 = 'hello' + ' ' + 'world'
print(s1)    # hello world
s2 = '!' * 3
print(s2)    # !!!
s1 += s2     # s1 = s1 + s2
print(s1)    # hello world!!!
s1 *= 2      # s1 = s1 * 2
print(s1)    # hello world!!!hello world!!!

用

實作字元串的重複是非常有意思的一個運算符，在很多程式設計語言中，要表示一個有10個

的字元串，你隻能寫成

"aaaaaaaaaa"

，但是在Python中，你可以寫成

'a' * 10

。你可能覺得

"aaaaaaaaaa"

這種寫法也沒有什麼不友善的，那麼想一想，如果字元

要重複100次或者1000次又會如何呢？

比較運算

對于兩個字元串類型的變量，可以直接使用比較運算符比較兩個字元串的相等性或大小。需要說明的是，因為字元串在計算機記憶體中也是以二進制形式存在的，那麼字元串的大小比較比的是每個字元對應的編碼的大小。例如

的編碼是

，而

的編碼是

，是以

'A' < 'a'

的結果相當于就是

65 < 97

的結果，很顯然是

True

；而

'boy' < 'bad'

，因為第一個字元都是

'b'

比不出大小，是以實際比較的是第二個字元的大小，顯然

'o' < 'a'

的結果是

False

，是以

'boy' < 'bad'

的結果也是

False

。如果不清楚兩個字元對應的編碼到底是多少，可以使用

ord

函數來獲得，例如

ord('A')

的值是

，而

ord('昊')

的值是

。下面的代碼為大家展示了字元串的比較運算。

s1 = 'a whole new world'
s2 = 'hello world'
print(s1 == s2, s1 < s2)      # False True
print(s2 == 'hello world')    # True
print(s2 == 'Hello world')    # False
print(s2 != 'Hello world')    # True
s3 = '駱昊'
print(ord('駱'), ord('昊'))               # 39558 26122
s4 = '王大錘'
print(ord('王'), ord('大'), ord('錘'))    # 29579 22823 38180
print(s3 > s4, s3 <= s4)      # True False

需要強調一下的是，字元串的比較運算比較的是字元串的内容，Python中還有一個

is

運算符（身份運算符），如果用

is

來比較兩個字元串，它比較的是兩個變量對應的字元串對象的記憶體位址（不了解先跳過），簡單的說就是兩個變量是否對應記憶體中的同一個字元串。看看下面的代碼就比較清楚

is

運算符的作用了。

s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# 比較字元串的内容
print(s1 == s2, s2 == s3)    # True True
# 比較字元串的記憶體位址
print(s1 is s2, s2 is s3)    # False True

成員運算

Python中可以用

in

和

not in

判斷一個字元串中是否存在另外一個字元或字元串，

in

和

not in

運算通常稱為成員運算，會産生布爾值

True

或

False

，代碼如下所示。

s1 = 'hello, world'
print('wo' in s1)    # True
s2 = 'goodbye'
print(s2 in s1)      # False

擷取字元串長度

擷取字元串長度沒有直接的運算符，而是使用内置函數

len

，我們在上節課的提到過這個内置函數，代碼如下所示。

s = 'hello, world'
print(len(s))                   # 12
print(len('goodbye, world'))    # 14

索引和切片

如果希望從字元串中取出某個字元，我們可以對字元串進行索引運算，運算符是

[n]

，其中

是一個整數，假設字元串的長度為

，那麼

可以是從

到

N-1

的整數，其中

是字元串中第一個字元的索引，而

N-1

是字元串中最後一個字元的索引，通常稱之為正向索引；在Python中，字元串的索引也可以是從

-1

到

-N

的整數，其中

-1

是最後一個字元的索引，而

-N

則是第一個字元的索引，通常稱之為負向索引。注意，因為字元串是不可變類型，是以不能通過索引運算修改字元串中的字元。

s = 'abc123456'
N = len(s)

# 擷取第一個字元
print(s[0], s[-N])    # a a

# 擷取最後一個字元
print(s[N-1], s[-1])  # 6 6

# 擷取索引為2或-7的字元
print(s[2], s[-7])    # c c

# 擷取索引為5和-4的字元
print(s[5], s[-4])    # 3 3

需要提醒大家注意的是，在進行索引操作時，如果索引越界（正向索引不在

到

N-1

範圍，負向索引不在

-1

到

-N

範圍），會引發

IndexError

異常，錯誤提示資訊為：

string index out of range

（字元串索引超出範圍）。

如果要從字元串中取出多個字元，我們可以對字元串進行切片，運算符是

[i:j:k]

，其中

是開始索引，索引對應的字元可以取到；

是結束索引，索引對應的字元不能取到；

是步長，預設值為

，表示從前向後擷取相鄰字元的連續切片，是以

:k

部分可以省略。假設字元串的長度為

，當

k > 0

時表示正向切片（從前向後擷取字元），如果沒有給出

和

的值，則

的預設值是

，

的預設值是

；當

k < 0

時表示負向切片（從後向前擷取字元），如果沒有給出

和

的值，則

的預設值是

-1

，j的預設值是

-N - 1

。如果不了解，直接看下面的例子，記住第一個字元的索引是

或

-N

，最後一個字元的索引是

N-1

或

-1

就行了。

s = 'abc123456'

# i=2, j=5, k=1的正向切片操作
print(s[2:5])       # c12

# i=-7, j=-4, k=1的正向切片操作
print(s[-7:-4])     # c12

# i=2, j=9, k=1的正向切片操作
print(s[2:])        # c123456

# i=-7, j=9, k=1的正向切片操作
print(s[-7:])       # c123456

# i=2, j=9, k=2的正向切片操作
print(s[2::2])      # c246

# i=-7, j=9, k=2的正向切片操作
print(s[-7::2])     # c246

# i=0, j=9, k=2的正向切片操作
print(s[::2])       # ac246

# i=1, j=-1, k=2的正向切片操作
print(s[1:-1:2])    # b135

# i=7, j=1, k=-1的負向切片操作
print(s[7:1:-1])    # 54321c

# i=-2, j=-8, k=-1的負向切片操作
print(s[-2:-8:-1])  # 54321c

# i=7, j=-10, k=-1的負向切片操作
print(s[7::-1])     # 54321cba

# i=-1, j=1, k=-1的負向切片操作
print(s[:1:-1])     # 654321c

# i=0, j=9, k=1的正向切片
print(s[:])         # abc123456

# i=0, j=9, k=2的正向切片
print(s[::2])       # ac246

# i=-1, j=-10, k=-1的負向切片
print(s[::-1])      # 654321cba

# i=-1, j=-10, k=-2的負向切片
print(s[::-2])      # 642ca

循環周遊每個字元

如果希望從字元串中取出每個字元，可以使用

for

循環對字元串進行周遊，有兩種方式。

方式一：

s1 = 'hello'
for index in range(len(s1)):
    print(s1[index])

方式二：

s1 = 'hello'
for ch in s1:
    print(ch)

字元串的方法

在Python中，我們可以通過字元串類型自帶的方法對字元串進行操作和處理，對于一個字元串類型的變量，我們可以用

變量名.方法名()

的方式來調用它的方法。所謂方法其實就是跟某個類型的變量綁定的函數，後面我們講面向對象程式設計的時候還會對這一概念詳加說明。

大小寫相關操作

下面的代碼示範了和字元串大小寫變換相關的方法。

s1 = 'hello, world!'

# 使用capitalize方法獲得字元串首字母大寫後的字元串
print(s1.capitalize())   # Hello, world!
# 使用title方法獲得字元串每個單詞首字母大寫後的字元串
print(s1.title())        # Hello, World!
# 使用upper方法獲得字元串大寫後的字元串
print(s1.upper())        # HELLO, WORLD!

s2 = 'GOODBYE'
# 使用lower方法獲得字元串小寫後的字元串
print(s2.lower())        # goodbye

查找操作

如果想在一個字元串中從前向後查找有沒有另外一個字元串，可以使用字元串的

find

或

index

方法。

s = 'hello, world!'

# find方法從字元串中查找另一個字元串所在的位置
# 找到了傳回字元串中另一個字元串首字元的索引
print(s.find('or'))        # 8
# 找不到傳回-1
print(s.find('shit'))      # -1
# index方法與find方法類似
# 找到了傳回字元串中另一個字元串首字元的索引
print(s.index('or'))       # 8
# 找不到引發異常
print(s.index('shit'))     # ValueError: substring not found

在使用

find

和

index

方法時還可以通過方法的參數來指定查找的範圍，也就是查找不必從索引為

的位置開始。

find

和

index

方法還有逆向查找（從後向前查找）的版本，分别是

rfind

和

rindex

，代碼如下所示。

s = 'hello good world!'

# 從前向後查找字元o出現的位置(相當于第一次出現)
print(s.find('o'))       # 4
# 從索引為5的位置開始查找字元o出現的位置
print(s.find('o', 5))    # 7
# 從後向前查找字元o出現的位置(相當于最後一次出現)
print(s.rfind('o'))      # 12

性質判斷

可以通過字元串的

startswith

、

endswith

來判斷字元串是否以某個字元串開頭和結尾；還可以用

is

開頭的方法判斷字元串的特征，這些方法都傳回布爾值，代碼如下所示。

s1 = 'hello, world!'

# startwith方法檢查字元串是否以指定的字元串開頭傳回布爾值
print(s1.startswith('He'))    # False
print(s1.startswith('hel'))   # True
# endswith方法檢查字元串是否以指定的字元串結尾傳回布爾值
print(s1.endswith('!'))       # True

s2 = 'abc123456'

# isdigit方法檢查字元串是否由數字構成傳回布爾值
print(s2.isdigit())    # False
# isalpha方法檢查字元串是否以字母構成傳回布爾值
print(s2.isalpha())    # False
# isalnum方法檢查字元串是否以數字和字母構成傳回布爾值
print(s2.isalnum())    # True

格式化字元串

在Python中，字元串類型可以通過

center

、

ljust

、

rjust

方法做居中、左對齊和右對齊的處理。如果要在字元串的左側補零，也可以使用

zfill

方法。

s = 'hello, world'

# center方法以寬度20将字元串居中并在兩側填充*
print(s.center(20, '*'))  # ****hello, world****
# rjust方法以寬度20将字元串右對齊并在左側填充空格
print(s.rjust(20))        #         hello, world
# ljust方法以寬度20将字元串左對齊并在右側填充~
print(s.ljust(20, '~'))   # hello, world~~~~~~~~
# 在字元串的左側補零
print('33'.zfill(5))      # 00033
print('-33'.zfill(5))     # -0033

我們之前講過，在用

print

函數輸出字元串時，可以用下面的方式對字元串進行格式化。

a = 321
b = 123
print('%d * %d = %d' % (a, b, a * b))

當然，我們也可以用字元串的方法來完成字元串的格式，代碼如下所示。

a = 321
b = 123
print('{0} * {1} = {2}'.format(a, b, a * b))

從Python 3.6開始，格式化字元串還有更為簡潔的書寫方式，就是在字元串前加上

來格式化字元串，在這種以

打頭的字元串中，

{變量名}

是一個占位符，會被變量對應的值将其替換掉，代碼如下所示。

a = 321
b = 123
print(f'{a} * {b} = {a * b}')

如果需要進一步控制格式化文法中變量值的形式，可以參照下面的表格來進行字元串格式化操作。

變量值	占位符	格式化結果	說明
`3.1415926`	`{:.2f}`	`'3.14'`	保留小數點後兩位
`3.1415926`	`{:+.2f}`	`'+3.14'`	帶符号保留小數點後兩位
`-1`	`{:+.2f}`	`'-1.00'`	帶符号保留小數點後兩位
`3.1415926`	`{:.0f}`	`'3'`	不帶小數
`123`	`{:0>10d}`	`'0000000123'`	左邊補 `0` ，補夠10位
`123`	`{:x<10d}`	`'123xxxxxxx'`	右邊補 `x` ，補夠10位
`123`	`{:>10d}`	`' 123'`	左邊補空格，補夠10位
`123`	`{:<10d}`	`'123 '`	右邊補空格，補夠10位
`123456789`	`{:,}`	`'123,456,789'`	逗号分隔格式
`0.123`	`{:.2%}`	`'12.30%'`	百分比格式
`123456789`	`{:.2e}`	`'1.23e+08'`	科學計數法格式

修剪操作

字元串的

strip

方法可以幫我們獲得将原字元串修剪掉左右兩端空格之後的字元串。這個方法非常有實用價值，通常用來将使用者輸入中因為不小心鍵入的頭尾空格去掉，

strip

方法還有

lstrip

和

rstrip

兩個版本，相信從名字大家已經猜出來這兩個方法是做什麼用的。

s = '   [email protected]  \t\r\n'
# strip方法獲得字元串修剪左右兩側空格之後的字元串
print(s.strip())    # [email protected]

替換操作

如果希望用新的内容替換字元串中指定的内容，可以使用

replace

方法，代碼如下所示。

replace

方法的第一個參數是被替換的内容，第二個參數是替換後的内容，還可以通過第三個參數指定替換的次數。

s = 'hello, world'
print(s.replace('o', '@'))     # hell@, w@rld
print(s.replace('o', '@', 1))  # hell@, world

拆分/合并操作

可以使用字元串的

split

方法将一個字元串拆分為多個字元串（放在一個清單中），也可以使用字元串的

join

方法将清單中的多個字元串連接配接成一個字元串，代碼如下所示。

s = 'I love you'
words = s.split()
print(words)            # ['I', 'love', 'you']
print('#'.join(words))  # I#love#you

需要說明的是，

split

方法預設使用空格進行拆分，我們也可以指定其他的字元來拆分字元串，而且還可以指定最大拆分次數來控制拆分的效果，代碼如下所示。

s = 'I#love#you#so#much'
words = s.split('#')
print(words)  # ['I', 'love', 'you', 'so', 'much']
words = s.split('#', 3)
print(words)  # ['I', 'love', 'you', 'so#much']

編碼/解碼操作

Python中除了字元串

str

類型外，還有一種表示二進制資料的位元組串類型（

bytes

）。所謂位元組串，就是由零個或多個位元組組成的有限序列。通過字元串的

encode

方法，我們可以按照某種編碼方式将字元串編碼為位元組串，我們也可以使用位元組串的

decode

方法，将位元組串解碼為字元串，代碼如下所示。

a = '駱昊'
b = a.encode('utf-8')
c = a.encode('gbk')
print(b, c)  # b'\xe9\xaa\x86\xe6\x98\x8a' b'\xc2\xe6\xea\xbb'
print(b.decode('utf-8'))
print(c.decode('gbk'))

注意，如果編碼和解碼的方式不一緻，會導緻亂碼問題（無法再現原始的内容）或引發

UnicodeDecodeError

錯誤導緻程式崩潰。

其他方法

對于字元串類型來說，還有一個常用的操作是對字元串進行比對檢查，即檢查字元串是否滿足某種特定的模式。例如，一個網站對使用者注冊資訊中使用者名和郵箱的檢查，就屬于模式比對檢查。實作模式比對檢查的工具叫做正規表達式，Python語言通過标準庫中的

re

子產品提供了對正規表達式的支援，我們會在後續的課程中為大家講解這個知識點。

簡單的總結

知道如何表示和操作字元串對程式員來說是非常重要的，因為我們需要處理文本資訊，Python中操作字元串可以用拼接、切片等運算符，也可以使用字元串類型的方法。

二，元組

常用資料結構之元組

Python中容器型的資料類型肯定不止清單一種，接下來我們為大家講解另一種重要的容器型資料類型，它的名字叫元組（tuple）。

定義和使用元組

在Python中，元組也是多個元素按照一定的順序構成的序列。元組和清單的不同之處在于，元組是不可變類型，這就意味着元組類型的變量一旦定義，其中的元素不能再添加或删除，而且元素的值也不能進行修改。定義元組通常使用

()

字面量文法，也建議大家使用這種方式來建立元組。元組類型支援的運算符跟清單是一樣。下面的代碼示範了元組的定義和運算。

# 定義一個三元組
t1 = (30, 10, 55)
# 定義一個四元組
t2 = ('駱昊', 40, True, '四川成都')

# 檢視變量的類型
print(type(t1), type(t2))    # <class 'tuple'> <class 'tuple'>
# 檢視元組中元素的數量
print(len(t1), len(t2))      # 3 4

# 通過索引運算擷取元組中的元素
print(t1[0], t1[-3])         # 30 30
print(t2[3], t2[-1])         # 四川成都 四川成都

# 循環周遊元組中的元素
for member in t2:
    print(member)

# 成員運算
print(100 in t1)    # False
print(40 in t2)     # True

# 拼接
t3 = t1 + t2
print(t3)           # (30, 10, 55, '駱昊', 40, True, '四川成都')

# 切片
print(t3[::3])      # (30, '駱昊', '四川成都')

# 比較運算
print(t1 == t3)    # False
print(t1 >= t3)    # False
print(t1 < (30, 11, 55))    # True

一個元組中如果有兩個元素，我們就稱之為二進制組；一個元組中如果五個元素，我們就稱之為五元組。需要提醒大家注意的是，

()

表示空元組，但是如果元組中隻有一個元素，需要加上一個逗号，否則

()

就不是代表元組的字面量文法，而是改變運算優先級的圓括号，是以

('hello', )

和

(100, )

才是一進制組，而

('hello')

和

(100)

隻是字元串和整數。我們可以通過下面的代碼來加以驗證。

# 空元組
a = ()
print(type(a))    # <class 'tuple'>
# 不是元組
b = ('hello')
print(type(b))    # <class 'str'>
c = (100)
print(type(c))    # <class 'int'>
# 一進制組
d = ('hello', )
print(type(d))    # <class 'tuple'>
e = (100, )
print(type(e))    # <class 'tuple'>

元組的應用場景

講到這裡，相信大家一定迫切的想知道元組有哪些應用場景，我們給大家舉幾個例子。

例子1：打包和解包操作。

當我們把多個用逗号分隔的值賦給一個變量時，多個值會打包成一個元組類型；當我們把一個元組指派給多個變量時，元組會解包成多個值然後分别賦給對應的變量，如下面的代碼所示。

# 打包
a = 1, 10, 100
print(type(a), a)    # <class 'tuple'> (1, 10, 100)
# 解包
i, j, k = a
print(i, j, k)       # 1 10 100

在解包時，如果解包出來的元素個數和變量個數不對應，會引發

ValueError

異常，錯誤資訊為：

too many values to unpack

（解包的值太多）或

not enough values to unpack

（解包的值不足）。

a = 1, 10, 100, 1000
# i, j, k = a             # ValueError: too many values to unpack (expected 3)
# i, j, k, l, m, n = a    # ValueError: not enough values to unpack (expected 6, got 4)

有一種解決變量個數少于元素的個數方法，就是使用星号表達式，我們之前講函數的可變參數時使用過星号表達式。有了星号表達式，我們就可以讓一個變量接收多個值，代碼如下所示。需要注意的是，用星号表達式修飾的變量會變成一個清單，清單中有0個或多個元素。還有在解包文法中，星号表達式隻能出現一次。

a = 1, 10, 100, 1000
i, j, *k = a
print(i, j, k)          # 1 10 [100, 1000]
i, *j, k = a
print(i, j, k)          # 1 [10, 100] 1000
*i, j, k = a
print(i, j, k)          # [1, 10] 100 1000
*i, j = a
print(i, j)             # [1, 10, 100] 1000
i, *j = a
print(i, j)             # 1 [10, 100, 1000]
i, j, k, *l = a
print(i, j, k, l)       # 1 10 100 [1000]
i, j, k, l, *m = a
print(i, j, k, l, m)    # 1 10 100 1000 []

需要說明一點，解包文法對所有的序列都成立，這就意味着對清單以及我們之前講到的

range

函數傳回的範圍序列都可以使用解包文法。大家可以嘗試運作下面的代碼，看看會出現怎樣的結果。

a, b, *c = range(1, 10)
print(a, b, c)
a, b, c = [1, 10, 100]
print(a, b, c)
a, *b, c = 'hello'
print(a, b, c)

例子2：交換兩個變量的值。

交換兩個變量的值是程式設計語言中的一個經典案例，在很多程式設計語言中，交換兩個變量的值都需要借助一個中間變量才能做到，如果不用中間變量就需要使用比較晦澀的位運算來實作。在Python中，交換兩個變量

和

的值隻需要使用如下所示的代碼。

a, b = b, a

同理，如果要将三個變量

、

的值互換，即

賦給

，

賦給

，

賦給

，也可以如法炮制。

a, b, c = b, c, a

需要說明的是，上面并沒有用到打包和解包文法，Python的位元組碼指令中有

ROT_TWO

和

ROT_THREE

這樣的指令可以實作這個操作，效率是非常高的。但是如果有多于三個變量的值要依次互換，這個時候沒有直接可用的位元組碼指令，執行的原理就是我們上面講解的打包和解包操作。

元組和清單的比較

這裡還有一個非常值得探讨的問題，Python中已經有了清單類型，為什麼還需要元組這樣的類型呢？這個問題對于初學者來說似乎有點困難，不過沒有關系，我們先抛出觀點，大家可以一邊學習一邊慢慢體會。

元組是不可變類型，不可變類型更适合多線程環境，因為它降低了并發通路變量的同步化開銷。關于這一點，我們會在後面講解多線程的時候為大家詳細論述。
元組是不可變類型，通常不可變類型在建立時間和占用空間上面都優于對應的可變類型。我們可以使用 sys 子產品的 getsizeof 函數來檢查儲存相同元素的元組和清單各自占用了多少記憶體空間。我們也可以使用 timeit 子產品的 timeit 函數來看看建立儲存相同元素的元組和清單各自花費的時間，代碼如下所示。

import sys
import timeit

a = list(range(100000))
b = tuple(range(100000))
print(sys.getsizeof(a), sys.getsizeof(b))    # 900120 800056

print(timeit.timeit('[1, 2, 3, 4, 5, 6, 7, 8, 9]'))
print(timeit.timeit('(1, 2, 3, 4, 5, 6, 7, 8, 9)'))

Python中的元組和清單是可以互相轉換的，我們可以通過下面的代碼來做到。

# 将元組轉換成清單
info = ('駱昊', 175, True, '四川成都')
print(list(info))       # ['駱昊', 175, True, '四川成都']
# 将清單轉換成元組
fruits = ['apple', 'banana', 'orange']
print(tuple(fruits))    # ('apple', 'banana', 'orange')

簡單的總結

清單和元組都是容器型的資料類型，即一個變量可以儲存多個資料。清單是可變資料類型，元組是不可變資料類型，是以清單添加元素、删除元素、清空、排序等方法對于元組來說是不成立的。但是清單和元組都可以進行拼接、成員運算、索引和切片這些操作，後面我們要講到的字元串類型也是這樣，因為字元串就是字元按一定順序構成的序列，在這一點上三者并沒有什麼差別。我們推薦大家使用清單的生成式文法來建立清單，它很好用，也是Python中非常有特色的文法。

Python認知篇：常見資料類型--字元串+元組

目錄

一，字元串

前言

字元串的定義

轉義字元和原始字元串

字元串的運算

拼接和重複

比較運算

成員運算

擷取字元串長度

索引和切片

循環周遊每個字元

字元串的方法

大小寫相關操作

查找操作

性質判斷

格式化字元串

修剪操作

替換操作

拆分/合并操作

編碼/解碼操作

其他方法

簡單的總結

二，元組

常用資料結構之元組

定義和使用元組

元組的應用場景

例子1：打包和解包操作。

例子2：交換兩個變量的值。

元組和清單的比較

簡單的總結

繼續閱讀