定義

是 Python 中內置的不可變序列。

在 Python 中使用（）定義元組，元素與元素之間使用英文的逗號分隔。

元組中只有一個元素的時候，逗號也不能省略。

元組的創建方式

（1）使用（）直接創建元組

語法

元組名=(element1,element2,......elementN)

# 使用小括號創建元組
t=('he1lo',[10,20,30],'python','world')
print(t)

（2）使用內置函數tuple()創建元組

元組名=tuple(序列)

# 使用內置函數tuple()創建元組
t=tuple('helloworld')
print(t)

元組的一些操作

引入

t=tuple([10,20,30,40])
print(t)

?這個例子說明了元組也是屬于序列的。

基本操作

t = tuple([10, 20, 30, 40])
print(t)print('10在元組中是否存在：', (10 in t))
print('10在元組不存在：', (10 not in t))
print('最大值：', max(t))
print('最小值：', min(t))
print('長度：', len(t))
print('t.index：', t.index(10))
print('t.count：', t.count(10))

??只有一個元素的情況

# 如果元組中只有一個元素
t=(10)
print(t,type(t))# 如果元組中只有一個元素，逗號不能省
y=(10,)
print(y,type(y))

?刪除元組

del 元組名

元組的切片?

語法格式

元組切片的基本語法為：tuple [ start : stop : step ] ，其中：

tuple：表示要進行切片操作的元組。

start：指定切片的起始位置（包含該位置的元素），若省略start，則從元組的開頭開始切片，默認值為 0。

stop：指定切片的結束位置（不包含該位置的元素），如果省略stop，則切片到元組的末尾

step：指定切片的步長，即每隔多少個元素取一個，step默認值為 1，表示依次取相鄰元素。

示例?

# 定義原始元組
t = (10, 20, 30, 40, 50, 60, 70, 80, 90)# 1. 獲取部分元素
print("1. 獲取部分元素:")
print("t[1:4] = " + str(t[1:4]))      # 輸出: (20, 30, 40)
print("t[:4] = " + str(t[:4]))        # 輸出: (10, 20, 30, 40)
print("t[3:] = " + str(t[3:]))        # 輸出: (40, 50, 60, 70, 80, 90)# 2. 指定步長
print("\n2. 指定步長:")
print("t[1:7:2] = " + str(t[1:7:2]))  # 輸出: (20, 40, 60)
print("t[::2] = " + str(t[::2]))      # 輸出: (10, 30, 50, 70, 90)# 3. 反向切片
print("\n3. 反向切片:")
print("t[::-1] = " + str(t[::-1]))    # 輸出: (90, 80, 70, 60, 50, 40, 30, 20, 10)
print("t[7:2:-1] = " + str(t[7:2:-1]))  # 輸出: (80, 70, 60, 50, 40)# 4. 負數索引示例
print("\n4. 負數索引示例:")
print("t[-3:] = " + str(t[-3:]))      # 輸出: (70, 80, 90)    

當然也可以同時省略起始值、終止值和步長，但需要保留冒號分隔符：

original = (1, 2, 3, 4, 5)
new_tuple = original[:]  # 省略起始值、終止值和步長print(new_tuple)        # 輸出: (1, 2, 3, 4, 5)
print(new_tuple is original)  # 輸出: False（證明是新對象）

這個用法的一些常見應用場景：

（1）創建副本

t = (1, 2, 3)
copy_t = t[:]  # 創建元組的副本

（2）?結合步長反轉元組

reversed_t = t[::-1]  # 步長為-1，從后向前遍歷，輸出: (3, 2, 1)

Python 中，元組（tuple）和列表（list）的切片操作語法完全相同

?元組生成式

使用圓括號（）包裹，并返回一個生成器對象。與列表推導式不同，元組生成式不會一次性生成所有元素，而是按需生成。

基本語法

(表達式 for 變量 in 可迭代對象 [if 條件表達式])

表達式：對每個元素進行處理的計算邏輯，生成最終的值。

for 變量 in 可迭代對象：遍歷可迭代對象（如列表、元組、字符串等）中的每個元素。

if 條件表達式（可選）：過濾元素，只對滿足條件的元素執行表達式。

用例

#生成偶數元組
even_numbers = (x for x in range(10) if x % 2 == 0)
print(tuple(even_numbers))  # 輸出: (0, 2, 4, 6, 8)#計算平方元組
squares = (x**2 for x in [1, 2, 3, 4, 5])
print(tuple(squares))  # 輸出: (1, 4, 9, 16, 25)#字符串長度元組
words = ["apple", "banana", "cherry"]
lengths = (len(word) for word in words)
print(tuple(lengths))  # 輸出: (5, 6, 6)

**注意

（1）生成器對象：元組生成式返回的是生成器對象，需要通過 tuple() 轉換為元組或迭代使用。?

（2）一次性使用：生成器對象只能遍歷一次，再次遍歷時會耗盡。

（3）內存效率：適合處理大量數據，避免一次性加載全部元素到內存。

元組與列表的區別

元組的遍歷?

1、for 循環直接遍歷元素

tup = (10, 20, "hello", 3.14)
for element in tup:print(element)

2、結合?enumerate?遍歷

語法結構

for 索引變量, 值變量 in enumerate(可迭代對象):# 循環體，使用 索引變量 和 值變量print(f"索引: {索引變量}, 值: {值變量}")

可以同時取到元素以及對應索引（位置）

tup = (10, 20, "hello", 3.14)
for index, element in enumerate(tup):print(f"索引 {index}，元素 {element}")

3、?通過索引遍歷（range + len）

range 的語法格式

#括號內只有一個值的情況
#默認輸出從 0 開始，到倒數第一個元素（意思就是不包含結束值）的整數序列。
range(stop)
#示例
for i in range(5):print(i)  # 輸出: 0, 1, 2, 3, 4#完整格式
range(start, stop, step)
#示例
# 正向，步長2
for i in range(0, 10, 2):print(i)  # 輸出: 0, 2, 4, 6, 8
# 反向，步長-1
for i in range(5, 0, -1):print(i)  # 輸出: 5, 4, 3, 2, 1

?先獲取元組的長度，再用 range 生成索引序列，再通過索引來訪問元素，適合需要精確控制索引的場景。

tup = (10, 20, "hello", 3.14)
for i in range(len(tup)):print(tup[i])

大家會發現這幾種遍歷方式都有?for...in 結構，這是因為列表、元組、字符串等都是 “可迭代對象”，它們內部實現了迭代器協議（即包含 __iter__() 方法）。for...in 循環的底層邏輯就是通過調用對象的迭代器，依次獲取元素，直到遍歷結束。

那這幾種遍歷方式可以簡記為：

1、最基本方式：for + 變量 + in + 可迭代對象；

適用場景：只需元素值，不需要索引。

2、enumerate方式：for + 索引變量，值變量 + in + 可迭代對象；

適用場景：需要同時使用索引和元素值。

3、for + 變量 + in + range（len（可迭代對象））；

適用場景：需要手動控制索引。

基于 range 方式的拓展 --?反向遍歷或跳步遍歷：

通過結合 range 的參數：

fruits = ["apple", "banana", "cherry"]# 反向遍歷（從后往前）
for i in range(len(fruits)-1, -1, -1):  # 從最后一個索引到0，步長-1print(fruits[i])  # 輸出: cherry, banana, apple# 跳步遍歷（每隔一個元素取一次）
for i in range(0, len(fruits), 2):  # 從0開始，步長2print(fruits[i])  # 輸出: apple, cherry

今天的分享就到這里啦~

謝謝大家的觀看！！