元组的常用操作小结

元组（Tuple）是一种不可变的容器，可以存储多个值。下面是元组的常用操作和示例：

1. 创建元组

# 创建一个简单的元组
my_tuple = ('apple', 'banana', 'cherry')print(my_tuple)  # 输出：('apple', 'banana', 'cherry')

2. 访问元组中的元素

# 使用索引访问元组中的元素
print(my_tuple[0])  # 输出：'apple'# 使用负索引访问元组的最后一个元素
print(my_tuple[-1])  # 输出：'cherry'

3. 遍历元组中的元素

for fruit in my_tuple:print(fruit)
# 输出：
# apple
# banana
# cherry

4. 元组的长度（length）

print(len(my_tuple))  # 输出：3

5. 元组的复制（copying）

new_tuple = my_tuple.copy()
print(new_tuple)  # 输出：('apple', 'banana', 'cherry')

6. 元组的连接（concatenation）

# 使用 + 运算符连接元组
new_tuple = my_tuple + ('orange',)print(new_tuple)  # 输出：('apple', 'banana', 'cherry', 'orange')# 使用 tuple() 函数连接元组
new_tuple = tuple(list(my_tuple) + ['orange'])print(new_tuple)  # 输出：('apple', 'banana', 'cherry', 'orange')

7. 元组的比较

t1 = ('apple', 'banana')
t2 = ('apple', 'banana')print(t1 == t2)  # 输出：True

8. 元组的索引

my_tuple = ('apple', 'banana', 'cherry')# 使用整数索引
print(my_tuple[0])  # 输出：'apple'
print(my_tuple[-1])  # 输出：'cherry'# 使用负整数索引
print(my_tuple[-2])  # 输出：'banana'

9. 元组的切片（slicing）

my_tuple = ('apple', 'banana', 'cherry', 'orange')# 从索引 0 到 2，获取元组中前三个元素
print(my_tuple[0:3])  # 输出：('apple', 'banana', 'cherry')# 从索引 1 到最后一个元素，获取元组中的第二个到最后一个元素
print(my_tuple[1:])  # 输出：('banana', 'cherry', 'orange')

10. 元组的 membership 测试（membership testing）

my_tuple = ('apple', 'banana', 'cherry')# 使用 in 运算符测试某个值是否在元组中
print('apple' in my_tuple)  # 输出：True
print('grape' in my_tuple)  # 输出：False

11. 元组的格式化输出（formatted output）

my_tuple = ('apple', 'banana', 'cherry')# 使用 f-string 格式化输出元组中的元素
print(f"我的favorite fruits are {my_tuple[0]}, {my_tuple[1]} and {my_tuple[-1]}")
# 输出：我的favorite fruits are apple, banana and cherry

12. 元组的转换（conversion）到列表

my_tuple = ('apple', 'banana', 'cherry')
my_list = list(my_tuple)
print(my_list)  # 输出：['apple', 'banana', 'cherry']

13. 元组的转换（conversion）到字典

my_tuple = (('apple', 1), ('banana', 2), ('cherry', 3))
my_dict = dict(my_tuple)
print(my_dict)  # 输出：{'apple': 1, 'banana': 2, 'cherry': 3}

14. 元组的转换（conversion）到集合

my_tuple = ('apple', 'banana', 'cherry')
my_set = set(my_tuple)
print(my_set)  # 输出：{'apple', 'banana', 'cherry'}

15. 元组的转换（conversion）到集合视图

my_tuple = ('apple', 'banana', 'cherry')
my_view = frozenset(my_tuple)
print(my_view)  # 输出：frozenset({'apple', 'banana', 'cherry'})

注意：在 Python 中，元组是一种不可变的数据结构，而列表、字典和集合则是可变的数据结构。如果您需要修改元素，可以考虑使用列表或字典代替元组。

16. 元组的迭代（iteration）

my_tuple  = ('apple', 'banana', 'cherry')# 使用 for 循环迭代元组中的元素
for fruit in my_tuple:print(fruit)# 使用 enumerate 函数迭代元组中的元素，并返回索引和值
for i, fruit in enumerate(my_tuple):print(f"{i}: {fruit}")

17. 元组的过滤（filtering）

my_tuple  = ('apple', 'banana', 'cherry', 'orange')# 使用 list comprehension 过滤元组中的元素
filtered_tuple  = tuple([fruit for fruit in my_tuple if fruit.startswith('a')])
print(filtered_tuple)   # 输出：('apple',)# 使用 filter 函数过滤元组中的元素
filtered_tuple  = tuple(filter(lambda x: x.startswith('a'), my_tuple))
print(filtered_tuple)   # 输出：('apple',)

18. 元组的映射（mapping）

my_tuple  = ('apple', 'banana', 'cherry')# 使用 map 函数将元组中的元素转换为大写
mapped_tuple  = tuple(map(lambda x: x.upper(), my_tuple))
print(mapped_tuple)   # 输出：('APPLE', 'BANANA', 'CHERRY')

19. 元组的排序（sorting）

my_tuple  = ('banana', 'apple', 'cherry')# 使用 sorted 函数对元组中的元素进行排序
sorted_tuple  = tuple(sorted(my_tuple))
print(sorted_tuple)   # 输出：('apple', 'banana', 'cherry')

20. 元组的搜索（searching）

my_tuple  = ('apple', 'banana', 'cherry')# 使用 in 运算符搜索元组中的元素
if 'banana' in my_tuple:print("Found 'banana'!")
else:print("Not found!")# 使用 index 函数搜索元组中的元素
index  = my_tuple.index('banana')
print(f"Index of 'banana': {index}")

21. 元组的合并（concatenation）

my_ tuple1 = ('apple', 'banana')
my_ tuple2 = ('cherry', 'orange')# 使用 + �算符将两个元组合并
combined_tuple = my_ tuple1 + my_ tuple2
print(combined_tuple)  # 输出：('apple', 'banana', 'cherry', 'orange')

22. 元组的重复（repeating）

my_ tuple = ('apple',)# 使用 * 运算符将元组中的元素重复
repeated_tuple = my_ tuple * 3
print(repeated_tuple)  # 输出：('apple', 'apple', 'apple')

23. 元组的交集（intersection）和并集（union）

my_ tuple1 = ('apple', 'banana', 'cherry')
my_ tuple2 = ('banana', 'orange', 'grape')# 使用 set.intersection 函数获取交集
intersection_tuple = set(my_ tuple1).intersection(set(my_ tuple2))
print(intersection_tuple)  # 输出：{'banana'}# 使用 set.union 函数获取并集
union_tuple = set(my_ tuple1).union(set(my_ tuple2))
print(union_tuple)  # 输出：{'apple', 'banana', 'cherry', 'orange', 'grape'}

24. 元组的差集（difference）

my_ tuple1 = ('apple', 'banana', 'cherry')
my_ tuple2 = ('banana', 'orange', 'grape')# 使用 set.difference 函数获取差集
difference_tuple = set(my_ tuple1).difference(set(my_ tuple2))
print(difference_tuple)  # 输出：{'apple', 'cherry'}

25. 元组的成员测试（membership testing）

my_ tuple = ('apple', 'banana', 'cherry')# 使用 in 运算符测试元组中的元素是否存在
if 'banana' in my_ tuple:print("Found  'banana'!")
else:print("Not found!")# 使用 not in 运算符测试元组中的元素是否不存在
if 'grape' not in my_ tuple:print("Grape is not found!")
else:print("Grape is found!")

26. 元组的转换（conversion）到字典视图

my_ tuple = [('apple', 1), ('banana', 2), ('cherry', 3)]# 使用 dict 函数将元组转换为字典视图
dict_view = dict(my_ tuple)
print(dict_view)   # 输出：{'apple': 1, 'banana': 2, 'cherry': 3}

27. 元组的转换（conversion）到集合视图

my_ tuple = ('apple', 'banana', 'cherry')# 使用 set 函数将元组转换为集合视图
set_view = set(my_ tuple)
print(set_view)   # 输出：{'apple', 'banana', 'cherry'}

28. 元组的转换（conversion）到列表视图

my_ tuple = ('apple', 'banana', 'cherry')# 使用 list 函数将元组转换为列表视图
list_view = list(my_ tuple)
print(list_view)   # 输出：['apple', 'banana', 'cherry']

29. 元组的排序（sorting）

my_ tuple = ('apple', 'banana', 'cherry')# 使用 sorted 函数对元组进行排序
sorted_tuple = sorted(my_ tuple)
print(sorted_tuple)   # 输出：['apple', 'banana', 'cherry']

30. 元组的反转（reversal）

my_ tuple = ('apple', 'banana', 'cherry')# 使用 reversed 函数对元组进行反转
reversed_tuple = reversed(my_ tuple)
print(list(reversed_tuple))   # 输出：['cherry', 'banana', 'apple']