元组（定义、元素引用、切片操作、特点和应用场景、方法）

什么是元组

• 元组是一种数据类型，在 Python 中用于存储多个元素。元组可以容纳多个值，但它们有一些重要的特点。

• 元组是有序的数据结构，这意味着元组中的元素按照它们的顺序存储，并且可以通过索引进行访问和引用。

• 元组是不可变的，一旦定义后，元组中的数据不可以进行添加，修改和删除等操作。

• 元组是异构的，可以包含不同类型的元素，例如整数、浮点数、字符串等。这使得元组成为一种有效的数据结构，用于存储多种不同类型的元素。

元组的定义

元组的字面量定义

• 元组使用小括号 () 来定义，将元组中的元素括在小括号中。
• 元组中的元素通过逗号 , 进行分隔，每个元素都可以是不同的数据类型。
• 使用小括号 () 来创建一个空元组。如果没有任何元素需要添加到元组中，空元组没有任何实际意义。
• 定义元组时，逗号是必须的，即使元组只包含一个元素，也需要在元素后面加上逗号，以区分它是一个元组而不是其他数据类型。

t1 = (1, 2, "hello", True)
t2 = (1, )
t3 = ()

元组的构造方法定义

可以通过元组的构造方法定义元组。

当使用构造方法定义元组时，参数只能是可迭代的对象，构造方法会将参数中的元素构造成为元组的元素。

可以理解为将可迭代的对象强制类型转换为元组。

t1 = tuple("abc")
t2 = tuple((1,2,3))
t3 = tuple([1,2,3])

元组中元素的引用

元组同字符串一样，也可以使用下标形式引用元组中的元素。并且下标不能超过元组的元素个数减 一，否则会抛出下标越界错误。

t = (1,2,3,4,5)
print(t[0])
print(t[3])
print(t[5])

元组的切片操作

元组的切片操作同字符串一致

t = (1,2,3,4,5)
print(t[0:3])
print(t[:3])
print(t[3:])
print(t[:])
print(t[::-1])

元组的特点

• 有序性：元组中的元素按照添加顺序进行存储，并且可以通过索引来访问和引用。这意味着元组中的元素保持其原始顺序，不会发生改变。
• 不可变性：元组的元素是不可修改、删除或添加的。

t1 = (1, 2, 3)
t1[0] = 10  # 错误！元组不可修改

元组的不可变性使其在某些情况下很有用，例如在需要确保数据的完整性和不变性的场景中。它们也可以用作字典的键或作为函数的参数和返回值。

元组的应用场景

• 存储一组不可变的数据：由于元组的不可变性，它们非常适合存储一组不会发生变化的数据，如常量、配置信息等。您可以使用元组来存储相关的值，以确保数据的完整性和不变性。
• 作为字典的键值对：元组可以作为字典的键值对使用，因为元组是不可变的，可以保证字典中的键的稳定性。相比列表，元组更适合作为字典的键，因为字典的键必须是不可变的。
• 函数返回多个值：函数可以使用元组作为返回值，以便一次性返回多个相关的值。通过返回元组，函数可以将多个数据打包在一起，并且调用函数时可以方便地解包元组，获取其中的各个值。

元组的常用方法

由于元组的不可变特性，所以元组提供的操作方法非常少。

• len() 获取元组元素个数

  格式：len(t)

  t = (1,2,3,4,5)
  print(len(t))
  

• count() 统计元组中参数 value 指定值的个数。

  格式：count(value)

  t = (1,2,3,4,5,1,2,3,1,2,3,3,3,3)
  print(t.count(3))
  

• index() 在元组中查找 value 第一次出现的下标。如果指定了范围，则仅在指定范围内查找，如果查找的数据在元组中不存在，会抛出一个错误。

  格式：index(value, start,stop)

t = (1,2,3,4,5,1,2,3)
print(t.index(3))
print(t.index(3, 5,10))

# 元组操作
def tuple_info():
    # 字面量定义元组
    t1 = (1, 2, 3, 4, 5, 6, 7, 8, "Sinocare", (1, 2, 3))
    print(t1)
    print(type(t1))

    t2 = (True,)
    print(t2)
    print(type(t2))

    t3 = ()
    print(t3)
    print(type(t3))

    # 使用构造方法定义元组
    t1 = tuple("Hello")
    print(t1, type(t1))

    t2 = tuple([1, 2, 3, 4, 5])
    print(t2, type(t2))

    t3 = tuple(("a", "b", 1, 2, 3))
    print(t3, type(t3))

    # 使用下标访问元组的元素
    t1 = (1, 2, 3, "a", "b", "C", True, (11, 22, 33))
    print(t1)
    print(t1[0])
    print(t1[5])
    print(t1[7])
    # print(t1[8])
    t = t1[7]
    print(t[2])
    print(t1[7][2])  # print((11,22,33))[2]

    # 切片操作的语法是：tuple[start:end:step]
    # start：起始位置（包含）。默认为0，表示从第一个元素开始。
    # end：结束位置（不包含）。默认为元组的长度，表示到最后一个元素。
    # step：步长。默认为1，表示每次移动一个元素。
    # 元组的切片操作
    t=(0,1,2,3,4,5,6,7,8,9)
    print(t[0:5])           # (0,1,2,3,4)
    print(t[3:8:1])         # (3,4,5,6,7)
    print(t[3:8:2])         # (3,5,7)
    print(t[:5])            # (0,1,2,3,4)
    print(t[3:])            # (3,4,5,6,7,8,9)
    print(t[::-1])          # (9,8,7,6,5,4,3,2,1,0)

    # 切片操作返回的是一个新的元组，原来的元组不会被修改
    # 定义一个元组
    t = (1, 2, 3, 4, 5)

    # 提取第二个到第四个元素（不包含第四个元素）
    subtuple = t[1:4]
    print(subtuple)  # (2, 3, 4)

    # 提取从第一个元素开始的所有元素
    subtuple = t[0:]
    print(subtuple)  # (1, 2, 3, 4, 5)

    # 提取从第二个元素开始的所有元素，每次跳一个元素
    subtuple = t[1::2]
    print(subtuple)  # (2, 4)

    # 提取从第一个元素开始的所有元素，每次跳两个元素
    subtuple = t[::2]
    print(subtuple)  # (1, 3, 5)
    

# 元组的常用方法
t=(1,1,1,1,1,1,1,2,2,2,2,2,3333,22,45,67,77,22,3,4,1,7,8)
# len()获取元组元素个数
print(len(t))
# 统计方法count 元组中参数value指定值的个数
print(t.count(1))
print(t.count(222))
# 查找方法index  查找value第一次出现的下标
print(t.index(2))
print(t.index(22))



tuple_info()