Python中怎么定義和使用元組

本篇內容介紹了“Python中怎么定義和使用元組”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

定義和使用元組

在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)

現在我們可以反過來思考一下函數的可變參數，可變參數其實就是將多個參數打包成了一個元組，可以通過下面的代碼來證明這一點。

def add(*args):
    print(type(args), args)
    total = 
0
    for val in args:
        total += 
val
    return total
add(1, 
10, 
20)        # <class 'tuple'> (1, 
10, 
20)
add(1, 
2, 
3, 
4, 
5)    # <class 'tuple'> (1, 
2, 
3, 
4, 
5)

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

交換兩個變量的值是編程語言中的一個經典案例，在很多編程語言中，交換兩個變量的值都需要借助一個中間變量才能做到，如果不用中間變量就需要使用比較晦澀的位運算來實現。在Python中，交換兩個變量a和b的值只需要使用如下所示的代碼。

a, b = b, a

同理，如果要將三個變量a、b、c的值互換，即b賦給a，c賦給b，a賦給c，也可以如法炮制。

a, b, c = b, c, a

需要說明的是，上面并沒有用到打包和解包語法，Python的字節碼指令中有ROT_TWO和ROT_THREE這樣的指令可以實現這個操作，效率是非常高的。但是如果有多于三個變量的值要依次互換，這個時候沒有直接可用的字節碼指令，執行的原理就是我們上面講解的打包和解包操作。

例子3：讓函數返回多個值。

有的時候一個函數執行完成后可能需要返回多個值，這個時候元組類型應該是比較方便的選擇。例如，編寫一個找出列表中最大值和最小的函數。

def find_max_and_min(items):
    """找出列表中最大和最小的元素
    :param items: 列表
    :return: 最大和最小元素構成的二元組
    """
    max_one, min_one = items[0], items[0]
    for item 
in items:
        if item > max_one:
            max_one = item
        elif item < min_one:
            min_one = item
    return max_one, min_one

上面函數的return語句中有兩個值，這兩個值會組裝成一個二元組然后返回。所以調用find_max_and_min函數會得到這個二元組，如果愿意也可以通過解包語法將二元組中的兩個值分別賦給兩個變量。

元組和列表的比較

這里還有一個非常值得探討的問題，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中怎么定義和使用元組”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！