学习python的第九天之数据类型——tuple元组

在Python中，元组（Tuple）是一个不可变的序列类型，意味着一旦元组被创建，你就不能添加、删除或更改其内的元素。元组通常用于存储不应该改变的数据集合，比如程序的配置设置或者函数返回多个值时作为返回值。

支持的数据类型：int, str, float, bool, complex, list, dictionary, tuple, set

特点：

1. 没有长度限制
2. 可以存放任意类型
3. 不允许删除、添加、修改

创建元组

使用圆括号 () 将一系列项包围起来，项之间用逗号 , 分隔。

my_tuple1 = (1, 2, 3)
print(my_tuple1)  # 输出: (1, 2, 3)

# 不使用圆括号也可以创建元组，只需简单地将项用逗号分隔。这种方法称为元组打包。
my_tuple2 = 1, 2, 3
print(type(my_tuple2), my_tuple2)  #  输出: <class 'tuple'> (1, 2, 3)

# 使用 tuple() 函数，可以将一个可迭代对象转换为元组。
my_list = [1, 2, 3]
my_tuple3 = tuple(my_list)
print(my_tuple3)  # 输出: (1, 2, 3)

# 可以包含不同类型的元素
my_tuple4 = (1, 'Hello', 3.14, True, 3+4j, [1,2], {'1':'one', '2':'two'}, (3, 4), {5, 6})
print(my_tuple4)  # 输出: (1, 'Hello', 3.14, True, 3+4j, [1,2], {'1':one, '2':two}, (3, 4), {5, 6})

# 空列表
empty_tuple1 = ()
empty_tuple2 = tuple()
print(empty_tuple1)  # 输出: ()
print(empty_tuple2)  # 输出: ()

访问元组元素

可以通过索引来访问元组中的元素，索引从0开始。

my_tuple = ('a', 'b', 'c', 'd')
print(my_tuple[0])  # 输出: 'a'
print(my_tuple[1])  # 输出: 'd'

# 使用负数索引从元组末尾开始访问
print(my_tuple[-1])  # 输出: 'd'
print(my_tuple[-2])  # 输出: 'c'

元组的切片

与列表类似，你也可以对元组进行切片操作，得到一个新的元组。使用切片时，需要指定开始索引和结束索引，格式为 tuple[start:end:step]。请注意，返回的切片会包含开始索引处的元素，但不包含结束索引处的元素。

# 创建一个元组
my_tuple = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# 获取索引2到索引5之间的元素（不包括索引5）
subtuple = my_tuple[2:5]
print(subtuple)  # 输出: (2, 3, 4)

# 获取从索引0到索引4之间的元素，每隔2个取一个
subtuple = my_tuple[0:5:2]
print(subtuple)  # 输出: (0, 2, 4)

# 获取从索引3开始到末尾的元素
subtuple = my_tuple[3:]
print(subtuple)  # 输出: (3, 4, 5, 6, 7, 8, 9)

# 获取从开始到索引7（不包括）的元素，每隔3个取一个
subtuple = my_tuple[:7:3]
print(subtuple)  # 输出: [0, 3, 6]

# 获取列表的所有元素，但是倒序（步长为-1）
reversed_tuple = my_tuple[::-1]
print(reversed_tuple)  # 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 获取列表的所有元素（相当于复制了一个列表）
copy_tuple = my_tuple[:]
print(copy_tuple)  # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

在Python中，copy_tuple = my_tuple[:] 和 copy_tuple = my_tuple 有着本质的区别。区别等同于列表。

元组的不可变性

元组的不可变性意味着一旦它被创建，你就不能修改它。

my_tuple = (1, 2, 3)
my_tuple[0] = 4  # 报错: TypeError: 'tuple' object does not support item assignment

但是，如果元组包含了可变对象（如列表），那么这些对象本身是可以被修改的。

my_tuple = (1, [2, 3])
my_tuple[1][0] = 4  # 这是允许的，因为修改的是列表，而不是元组本身
print(my_tuple)  # 输出: (1, [4, 3])

元组的常用函数

1. **len(tuple)**‌:

   • 返回元组中元素的个数。

   my_tuple = (1, 2, 3, 4, 5)
   length = len(my_tuple)
   print(length)  # 输出: 5
   

2. ‌**max(tuple)‌ 和 ‌min(tuple)**‌:

   • 返回元组中的最大值和最小值。这些函数要求元组中的元素是可比较的（例如，都是数字或都是字符串）。

   my_tuple = (3, 1, 4, 1, 5)
   max_value = max(my_tuple)
   min_value = min(my_tuple)
   print(max_value)  # 输出: 5
   print(min_value)  # 输出: 1
   

3. ‌**tuple(iterable)**‌:

   • 将一个可迭代对象（如列表、集合、字典的键或值等）转换为元组。

   my_list = [1, 2, 3, 4, 5]
   my_tuple = tuple(my_list)
   print(my_tuple)  # 输出: (1, 2, 3, 4, 5)
   

4. ‌**sum(tuple)**‌:

   • 返回元组中所有数值元素的总和。如果元组包含非数值元素，则会引发TypeError。

   my_tuple = (1, 2, 3, 4, 5)
   total = sum(my_tuple)
   print(total)  # 输出: 15
   

5. ‌**any(tuple)‌ 和 ‌all(tuple)**‌:

   • any()返回True如果元组中至少有一个元素为True（或等价于True的值，如非零数字、非空字符串等）。

   • all()返回True如果元组中的所有元素都是True（或等价于True的值）。

   my_tuple = (0, 1, 2, 3, 4)
   any_result = any(my_tuple)
   all_result = all(my_tuple)
   print(any_result)  # 输出: True，因为至少有一个元素是True（非零）
   print(all_result)  # 输出: False，因为不是所有元素都是True（0是False）
   

6. ‌**enumerate(tuple)**‌:

   • 返回一个枚举对象，该对象在遍历时会产生包含元组中每个元素的索引和值的元组。

   my_tuple = ('a', 'b', 'c')
   for index, value in enumerate(my_tuple):
       print(index, value)
   # 输出:
   # 0 a
   # 1 b
   # 2 c
   

7. ‌**zip(\*tuples)**‌:

   • 将多个元组（或其他可迭代对象）的元素按照位置组合成新的元组，返回一个由这些新元组组成的迭代器。

   tuple1 = (1, 2, 3)
   tuple2 = ('a', 'b', 'c')
   zipped = zip(tuple1, tuple2)
   for item in zipped:
       print(item)
   # 输出:
   # (1, 'a')
   # (2, 'b')
   # (3, 'c')
   

8. ‌**元组解包（Unpacking）**‌:

   • 可以使用*操作符将元组解包到多个变量中，或者用于函数调用时传递参数。

   my_tuple = (1, 2, 3)
   a, b, c = my_tuple
   print(a, b, c)  # 输出: 1 2 3
   

9. ‌**元组连接（Concatenation）**‌:

   • 可以使用+操作符将多个元组连接成一个新的元组。

   tuple1 = (1, 2, 3)
   tuple2 = (4, 5, 6)
   concatenated_tuple = tuple1 + tuple2
   print(concatenated_tuple)  # 输出: (1, 2, 3, 4, 5, 6)
   

10. ‌**元组重复（Repetition）**‌:

    • 可以使用*操作符重复元组中的元素，生成一个新的元组。

    my_tuple = (1, 2, 3)
    repeated_tuple = my_tuple * 2
    print(repeated_tuple)  # 输出: (1, 2, 3, 1, 2, 3)
    

11. ‌**in和not in运算符**‌:

    • 用于检查一个值是否存在于元组中。

    my_tuple = (1, 2, 3, 4, 5)
    print(3 in my_tuple)  # 输出: True
    print(6 not in my_tuple)  # 输出: True
    

12. ‌**count(value)方法（需转换为列表后使用）**‌:

    • 虽然元组本身没有count方法，但可以将元组转换为列表后使用list.count(value)来计算某个值在元组中出现的次数。

    my_tuple = (1, 2, 3, 2, 1)
    my_list = list(my_tuple)
    count = my_list.count(2)
    print(count)  # 输出: 2
    

13. ‌**index(value)方法（需转换为列表后使用）**‌:

    • 同样，元组没有index方法，但可以转换为列表后使用list.index(value)来查找某个值在元组中的位置。

      my_tuple = (1, 2, 3, 2, 1)
      my_list = list(my_tuple)
      index = my_list.index(3)
      print(index)  # 输出: 2（注意，这里是转换后的列表的索引）
      

元组的用途

• 作为字典的键‌：因为元组是不可变的，所以它们可以被用作字典的键，而列表则不可以。
• ‌保护数据‌：当你希望保护数据不被修改时，可以使用元组。
• ‌函数返回多个值‌：函数可以直接返回一个元组，让调用者可以方便地解包得到多个返回值。

想给元组强行排序的办法

在Python中，sorted() 函数可以用于对任何可迭代对象进行排序，包括元组（tuple）列表（list）等。但需要注意的是，元组（tuple）本身是不可变的，因此当你使用 sorted() 对元组排序时，实际上是返回了一个新的列表，而不是修改原来的元组。如果你想得到一个排序后的元组，可以将排序后的列表转换为元组。

# 假设有一个元组
my_tuple = (3, 1, 4, 1, 5, 9, 2)

# 使用 sorted() 对元组排序，返回的是列表
sorted_list = sorted(my_tuple)

# 将排序后的列表转换回元组
sorted_tuple = tuple(sorted_list)

print(sorted_tuple) # 输出: (1, 1, 2, 3, 4, 5, 9)

想给元组强行添加、修改、删除的办法

核心思路就是将元组转成列表，再进行添加、修改、删除，最后再转回元组。

其实是虚假的添加、修改、删除，应为前后两个元组的地址是不一样的。

所以不建议这样操作，这样还不如直接用列表。

创建一个元素的元组（额外注意的情况）

声明一个元素的元组时，必须要在这个元素后加上逗号(,)。

# 创建一个元素的元组
my_tuple1 = (1,)
print(type(my_tuple1))  # 输出: <class 'tuple'>

my_tuple2 = (1) 
print(type(my_tuple2))  # 输出: <class 'int'>