python基础——数据类型(五)元组

¶（一）概述：

tuple元组是由一系列按特定顺序排序的元素组成的不可变的序列结构。

元组各种性质和列表是类似的（无限元素，任意类型，一个元组内可保存不同类型数据），但是元组保存的数据无法被修改（注意，如果保存了列表，那么不能修改指向的列表，但是可以修改指向列表的内容），也就没有了着增删改查等等操作。

通常而言，元组被用于需要同构数据的不可变序列的情况，或者存储异构数据的多项集。

a=1,2,3,[1,2,3]
a[3][1]=4   #元组内列表可修改
print(a)
# 输出结果：
# (1, 2, 3, [1, 4, 3])

¶(二)创建形式：

python用()表示列表，用逗号分隔元素。

用()包括所有元素不是必须的，如果将一串元素用逗号隔开不加括号，python编译器也会认为其为元组——决定该类型是否为元组的符号是逗号，而不是圆括号。

形式为：元组名=(元素1 , 元素2 , ...... , 元素n) / 元组名=() / 元组名=元素1, ...

注意：如果仅有一个元素又想要生成元组，只需要在这个元素后面加一个逗号，python编译器就会将其解释为元组类型。（不加括号的情况下）

但是唯一元素时加小括号是不足够的，必须在该元素后面加一个逗号才能表示其为元组。（元组的判断关键在于逗号，而不是小括号）

a=(1,2,3,4.22,"555",[123,321])
b=1,2,3,4.22,"555",[123,321]    #可以不带括号
c=()  #空元组
d=1,  #唯一元素的元组
e=("a")  #此为字符串
f="a",   #此为元组，关键在于后面的逗号
print("a:",a,"  type:",type(a))
print("b:",b,"  type:",type(b))
print("c:",c,"  type:",type(c))
print("d:",d,"  type:",type(d))
print("e:",e,"  type:",type(e))
print("f:",f,"  type:",type(f))
# 输出结果：
# a: (1, 2, 3, 4.22, '555', [123, 321])   type: <class 'tuple'>
# b: (1, 2, 3, 4.22, '555', [123, 321])   type: <class 'tuple'>
# c: ()   type: <class 'tuple'>
# d: (1,)   type: <class 'tuple'>
# e: a   type: <class 'str'>
# f: ('a',)   type: <class 'tuple'>

¶（三）元组的特性：

¶1. 访问：

和列表的操作完全相同，不再赘述，详情请见：python基础——数据类型(四)列表

¶2. 删除：

python自带垃圾回收机制，已创建的元组如不再使用，将会被编译器自动回收，不会产生内存垃圾。

如果需要可以手动删除，使用del 关键字手动删除，详细方法同见上方。

¶3. 多维元组：

元组同样可以嵌套，和列表的性质相同。

注意：多维元组中除了含有列表时可修改列表内内容以外，任意元素不得修改。

¶4. 元组的主要操作：

无增删，只有改查。

• 修改元组（不是修改元组元素！）：

  如有列表元素，修改列表请见上文中的列表链接。

  除此以外不可修改元素，只能进行替换和拼接。

  • 替换：

    即重新赋值。

    a=(1,2,3)
    a=(4,5,6)
    print(a)
    # 输出结果：
    # (4, 5, 6)

  • 拼接：

    实质上也是重新赋值。但是可以在某个/某些元组的基础上完成重新赋值。

    "+"组合多个元组：

    格式：tuplename = tuplename1+tuplename2+...+tuplenamen

    生成新的元组，元素顺序即按照所加顺序逐个元素填入新元组。

    "*"重复n遍元组：

    格式：tuplename= tuplename1 ***** n

    生成新元组，将原元组元素重复n遍。

    a=(1,2,3,4,5)
    b=(6,7,8,9,10)
    a = a+b+a
    b = b*4
    print(a)
    print(b)
    # 输出结果：
    # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5)
    # (6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10, 6, 7, 8, 9, 10)

• 查询元素：

  方法和列表相同，不再赘述。

¶5. 元组的其他操作：

• 获得最大，最小值以及长度：

  分别为max()，min()和len()方法。

  具体代码省略（有兴趣的自行尝试）。

• sorted方法排序：

  格式：sorted(iterable, ***** ,key=None, reverse=False)

  元组没有内置的排序方法，只能使用python提供的sorted方法排序，sorted方法从一个可迭代对象根据iterable的项返回一个新的排序列表（注意不是元组）。

  key：指定带有一个参数的函数，用于从每个序列元素中提取比较键。对应于传入序列中的每一项的键会被计算一次，然后在整个排序过程中使用，默认值None代表直接对序列项排序，不计算单独的键值。

  reverse：为一个布尔值，默认False，表示升序排序，如果指定了True，则表示降序排序

  a=(1,2,3,4,5)
  b=sorted(a,reverse=True)
  print(b,"   ",type(b))
  # 输出结果：
  # [5, 4, 3, 2, 1]     <class 'list'>

• 复制：

  • 直接赋值：

    = 直接赋值是非拷贝方法。

    两个元组是等价的，修改其中任何一个元组都会影响另一个元组。

    注意和重新赋值区别（重新赋值不会影响另一个元组）。

  • 使用切片（浅拷贝）：

    格式：tuplenewname = tuplename[:]

    python中浅拷贝是指tuple保存的地址同样被复制过去，而不是创建新的地址复制值过去。

    对嵌套的tuple只能对第一层实现深拷贝，而其内嵌套的tuple仍是浅拷贝。

    a = [1,2,3,[1,2,3]]
    b =a[:]
    a[3][0]=3
    print(a)
    print(b)
    # 输出结果：
    # [1, 2, 3, [3, 2, 3]]
    # [1, 2, 3, [3, 2, 3]]

  • for循环（浅拷贝）：

    此略（较简单）

  • 元组生成式：

    格式：tuplenewname = (i for i in tuplename )

    从形式上看，元组生成式和列表生成式类似，只是元组生成器推导式使用小括号，列表推导式直接生成列表对象，元组生成器推导式生成的不是列表又不是元组，而是一个生成器对象。

    a = (1,2,3,[1,2,3])
    b = (i for i in a)
    a[3][0]=3
    print(a)
    print(b)
    print(tuple(b))
    # 输出结果：
    # (1, 2, 3, [3, 2, 3])
    # <generator object <genexpr> at 0x000001C8DFD89150> 这是生成器
    # (1, 2, 3, [3, 2, 3])

  • deepcopy方法（深拷贝）：

    格式：tuplenewname= copy.deepcopy(tuplename)

    是深拷贝，原来的列表和新列表完全无关。

    需要import copy库

    import copy
    a = (1,2,3,[1,2,3])
    b = copy.deepcopy(a)
    a[3][0]=3
    print(a)
    print(b)
    # 输出结果：
    # (1, 2, 3, [3, 2, 3])
    # (1, 2, 3, [1, 2, 3])