想要熟练掌握Python元组?你需要了解这10件应知事项

开发 后端
在今天的文章里,小芯将带领大家回顾正确使用Python元组的最常用方法。

本文转载自公众号“读芯术”(ID:AI_Discovery)

人生苦短,Python是岸。

作为一种通用编程语言,Python已成为各学术和工业领域中最流行的语言之一。

此前,IEEESpectrum 发布的第五届年度编程语言交互排行榜中,Python 不但雄踞第一,在综合指数、用户增速、就业优势和开源语言单项中,全部霸占榜首。

[[322228]]

Python拥有强大的数据结构集合,例如int、 string、 list、 dict和 tuple——一个大小固定且不可变数据序列。

在今天的文章里,小芯将带领大家回顾正确使用Python元组的最常用方法。

1. 使用索引访问元组中的单个元素

创建元组后,有时需要访问它的一些值。一种方法是使用基于0的索引对其进行访问。参见下方示例。值得注意的是,在Python中,使用负数以相反的顺序索引序列。例如,-1是序列中最后一个元素的索引。当然,如试图使用范围之外的索引访问元素,将看到IndexError(索引错误)。

  1. >>> tuple_index = (100,'text', False, {1: 'five', 2: True})>>> tuple_index[0] 
  2. 100>>> tuple_index[-1] 
  3. {1: 'five', 2: True}>>> tuple_index[2] 
  4. False>>> tuple_index[6] 
  5. Traceback (most recent call last): 
  6.   File "<stdin>", line 1,in <module> 
  7. IndexError: tuple index out of range 

2. 可变元素

虽然一个元组不能作为一个对象整体改变,但如果单个元素本身是可变的,就可以对其进行更改。参见下方示例。具体来说,修改了tuple(元组)中的 list 和 dict.

  1. >>> mutable_elements =(1, [1, 2], {0: 'zero', 1: 'one'})>>> mutable_elements[1].append(3) 
  2. >>> mutable_elements 
  3. (1, [1, 2, 3], {0: 'zero', 1: 'one'})>>> mutable_elements[2][2] ='two' 
  4. >>> mutable_elements 
  5. (1, [1, 2, 3], {0: 'zero', 1: 'one', 2: 'two'}) 

3. 高级元组拆包

有时拆包一个元组,并不需要访问所有的单个元素。对于那些不重要的元素,可以用下划线(_)表示。另一种高级的tuple (元组)拆包技术是,使用星号(*)表示tuple (元组)中的元素序列。_和*用法也可以组合使用。

  1. >>> advanced_unpacking0= (1, 2, 3) 
  2. >>> a, _, c = advanced_unpacking0 
  3. >>> a 
  4. >>> c 
  5. 3>>> advanced_unpacking1 = (1, 2, 3, 4, 5, 11, 12, 13, 14, 15) 
  6. >>> a, *middle, c = advanced_unpacking1 
  7. >>> middle 
  8. [2, 3, 4, 5, 11, 12, 13, 14] 
  9. >>> _, *tail = advanced_unpacking1 
  10. >>> tail 
  11. [2, 3, 4, 5, 11, 12, 13, 14, 15] 
  12. >>> head, *_ = advanced_unpacking1 
  13. >>> head 

4. 使用值序列创建元组

创建元组时,需使用逗号分隔值序列。括号是可选的,尤其在声明表达式不直接的情况下,使用括号可以提高可读性。

  1. >>> tuple0 = 1, 4, 5 
  2. >>> print(tuple0) 
  3. (1, 4, 5)>>> tuple1 = (1, 2, 'three') 
  4. >>> print(tuple1) 
  5. (1, 2, 'three')>>> tuple2 = (4, 7, ('a', 'b'), lambda x: x+1) 
  6. >>> print(tuple2) 
  7. (4, 7, ('a', 'b'), <function <lambda> at 0x106e98830>)>>>tuple3 = () 
  8. >>> print(tuple3) 
  9. ()>>> tuple4 = 'one'
  10. >>> print(tuple4) 
  11. ('one',) 

特殊的情况是:使用一对括号创建一个空tuple(元组);在唯一值后使用逗号创建单值tuple(元组)。

5. 计算元组中元素的数量

由于tuple(元组)是一个序列,所以可使用len()函数计算所有元素总数。另一个函数 count()也很方便,可用做计算调用时指定的某个值的个数。参见下方示例。

  1. >>> tuple_len = (1, 3,'one', 'three', 'five') 
  2. >>> len(tuple_len) 
  3. 5>>> tuple_count = (1, 1, 2, 2, 2, 2, 3, 3, 3) 
  4. >>> tuple_count.count(2) 
  5. >>> tuple_count.count(3) 

6. 使用tuple()函数创建元组

可使用内置 tuple()方法创建元组,该方法将 iterable (迭代)作为唯一参数。生成的tuple (元组)将是 iterable 的迭代项序列。如下示例中,元组分别从str、dict和 list生成。

  1. >>> tupletuple5 =tuple(['a', 'b']) 
  2. >>> print(tuple5) 
  3. ('a', 'b')>>> tupletuple6 = tuple('tuple') 
  4. >>> print(tuple6) 
  5. ('t', 'u', 'p', 'l', 'e')>>> tupletuple7 = tuple({'a': 1, True: 4}) 
  6. >>> print(tuple7) 
  7. ('a', True)>>> tupletuple8 = tuple((1, 'two', [1, 2])) 
  8. >>> print(tuple8) 
  9. (1, 'two', [1, 2]) 

7. 使用拆包方法访问元组的单个元素

使用元组可能经常听到的另一个概念是tuple(元组)拆包,它允许访问单个元素。参见下方示例。

  1. >>> tuple_unpacking =(1, 'two', [3, 3, 3], {'four': 4}) 
  2. >>> a, b, c, d = tuple_unpacking>>> a 
  3. >>> b 
  4. 'two' 
  5. >>> c 
  6. [3, 3, 3] 
  7. >>> d 
  8. {'four': 4} 

8. for循环中的元组

时常需要在for循环中使用元组。由于元组是可迭代的,所以可直接在for循环中使用,该循环将迭代元组的单个元素。或者,如果想应用计数器,可使用元组内置的 enumerate() 方法。参见下方示例。

  1. >>> tuple_for_loop =('one', 'two', 'three') 
  2. >>> for i in tuple_for_loop: 
  3. ... print(i) 
  4. ... 
  5. one 
  6. two 
  7. three>>> for (i, item) in enumerate(tuple_for_loop, start=1): 
  8. ... print(str(i) + ': is ' + item) 
  9. ... 
  10. 1: is one 
  11. 2: is two 
  12. 3: is three 

9. 元组的不可变性

正如本文开头提到的,元组是一个不可变值序列。因此,不能改变单个元素的值。

  1. >>> immut_tuple = (3,5, 7) 
  2. >>> immut_tuple[0] = 1 
  3. Traceback (most recent call last): 
  4. File "<stdin>", line 1,in <module> 
  5. TypeError: 'tuple' object does not support item assignment 

10. 元组连接

可使用加号(+)运算符连接多个元组,来创建一个新元组。或者,如果想通过多次连接同一元组来创建一个新的元组,可使用乘法(*)运算符。

  1. >>> concat_tuple0 = (1,2) + ('three', 4) + ('five', 6) 
  2. >>> concat_tuple0 
  3. (1, 2, 'three', 4, 'five', 6)>>> concat_tuple1 = ('odd', 'event') * 4 
  4. >>> concat_tuple1 
  5. ('odd', 'event', 'odd', 'event', 'odd', 'event', 'odd', 'event') 

元组是笔者在Python编程中最喜欢使用的数据结构之一,因其便于构造和访问单个元素。当然,请记住元组是不可变的,并且没有过多的方法,这可能限制其更广泛的使用,这种情况下,可以考虑使用list 或dict。

 

责任编辑:赵宁宁 来源: 读芯术
相关推荐

2019-07-11 10:45:34

MQ中间件 API

2021-01-16 11:44:46

编程语言开发

2009-10-29 15:50:49

VB.NET Exce

2020-01-09 08:26:16

代码JS开发

2009-12-04 08:53:49

TechNet杂志

2009-12-16 17:31:30

Ruby on Rai

2013-07-31 11:05:05

硬件处理ITM硬件

2017-05-08 11:39:33

Web WorkersWeb

2012-06-26 10:13:55

2011-04-01 11:16:06

hessian

2015-07-15 13:34:37

JS开发习惯

2012-06-27 09:11:47

2012-07-16 11:48:51

2019-09-03 15:33:35

网络安全保险网络安全网络攻击

2013-10-11 15:26:32

linux网络监控

2016-11-01 16:41:08

直通网线连接端口传输数据

2020-11-16 10:45:21

物联网

2020-11-17 09:49:40

物联网

2020-07-15 07:45:51

Python开发工具

2022-01-04 19:28:05

VMware云端虚拟化
点赞
收藏

51CTO技术栈公众号