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

本文最后更新于:1 年前

(一)概述:

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

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

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

1
2
3
4
5
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编译器就会将其解释为元组类型。(不加括号的情况下)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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. 元组的主要操作:

无增删,只有改查。

  • 修改元组(不是修改元组元素!):

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

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

    • 替换:

      即重新赋值。

      1
      2
      3
      4
      5
      a=(1,2,3)
      a=(4,5,6)
      print(a)
      # 输出结果:
      # (4, 5, 6)
    • 拼接:

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

      "+"组合多个元组:

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

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

      "*"重复n遍元组:

      格式:tuplename= tuplename1 ***** n

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

      1
      2
      3
      4
      5
      6
      7
      8
      9
      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,则表示降序排序

    1
    2
    3
    4
    5
    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仍是浅拷贝。

      1
      2
      3
      4
      5
      6
      7
      8
      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 )

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

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      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库

      1
      2
      3
      4
      5
      6
      7
      8
      9
      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])

python基础——数据类型(五)元组
https://github.com/xiaohei07/xiaohei07.github.io/2023/03/22/python基础——数据类型(五)元组/
作者
07xiaohei
发布于
2023年3月22日
许可协议