5.4 KiB
5.4 KiB
| title | localeTitle |
|---|---|
| The Tuples | 元组 |
元组
元组是一系列Python对象。元组是不可变的，这意味着它们在创建后不能被修改，这与列表不同。
创建：
使用一对圆括号()创建一个空tuple ：
>>> empty_tuple = ()
>>> print(empty_tuple)
()
>>> type(empty_tuple)
<class 'tuple'>
>>> len(empty_tuple)
0
通过用逗号分隔元素来创建带元素的tuple （围绕圆括号， () ，可选，但有例外）：
>>> tuple_1 = 1, 2, 3 # Create tuple without round brackets.
>>> print(tuple_1)
(1, 2, 3)
>>> type(tuple_1)
<class 'tuple'>
>>> len(tuple_1)
3
>>> tuple_2 = (1, 2, 3) # Create tuple with round brackets.
>>> print(tuple_2)
(1, 2, 3)
>>> tuple_3 = 1, 2, 3, # Trailing comma is optional.
>>> print(tuple_3)
(1, 2, 3)
>>> tuple_4 = (1, 2, 3,) # Trailing comma in round brackets is also optional.
>>> print(tuple_4)
(1, 2, 3)
具有单个元素的tuple必须具有尾随逗号（带或不带圆括号）：
>>> not_tuple = (2) # No trailing comma makes this not a tuple.
>>> print(not_tuple)
2
>>> type(not_tuple)
<class 'int'>
>>> a_tuple = (2,) # Single element tuple. Requires trailing comma.
>>> print(a_tuple)
(2,)
>>> type(a_tuple)
<class 'tuple'>
>>> len(a_tuple)
1
>>> also_tuple = 2, # Round brackets omitted. Requires trailing comma.
>>> print(also_tuple)
(2,)
>>> type(also_tuple)
<class 'tuple'>
在歧义的情况下需要圆括号（如果元组是更大表达式的一部分）：
请注意，它实际上是一个逗号，它产生一个元组，而不是括号。括号是可选的，除了空元组情况，或者需要它们以避免语法歧义。例如，
f(a, b, c)是具有三个参数的函数调用，而f((a, b, c))是以3元组作为唯一参数的函数调用。
>>> print(1,2,3,4,) # Calls print with 4 arguments: 1, 2, 3, and 4
1 2 3 4
>>> print((1,2,3,4,)) # Calls print with 1 argument: (1, 2, 3, 4,)
(1, 2, 3, 4)
>>> 1, 2, 3 == (1, 2, 3) # Equivalent to 1, 2, (3 == (1, 2, 3))
(1, 2, False)
>>> (1, 2, 3) == (1, 2, 3) # Use surrounding round brackets when ambiguous.
True
一个tuple也可以与创建的tuple的构造函数：
>>> empty_tuple = tuple()
>>> print(empty_tuple)
()
>>> tuple_from_list = tuple([1,2,3,4])
>>> print(tuple_from_list)
(1, 2, 3, 4)
>>> tuple_from_string = tuple("Hello campers!")
>>> print(tuple_from_string)
('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!')
>>> a_tuple = 1, 2, 3
>>> b_tuple = tuple(a_tuple) # If the constructor is called with a tuple for
the iterable,
>>> a_tuple is b_tuple # the tuple argument is returned.
True
访问tuple元素：
访问tuples元素并以与lists相同的方式编制索引。
>>> my_tuple = 1, 2, 9, 16, 25
>>> print(my_tuple)
(1, 2, 9, 16, 25)
零索引
>>> my_tuple[0]
1
>>> my_tuple[1]
2
>>> my_tuple[2]
9
包裹索引
>>> my_tuple[-1]
25
>>> my_tuple[-2]
16
包装和拆包：
声明t = 12345, 54321, 'hello!'是元组封装的一个例子：值12345 ， 54321和'hello!'在元组中包装在一起。反向操作也是可能的：
>>> x, y, z = t
这足够恰当地称为序列解包，适用于右侧的任何序列。序列解包需要在等号左侧有尽可能多的变量，因为序列中有元素。请注意，多重赋值实际上只是元组打包和序列解包的组合。
>>> t = 1, 2, 3 # Tuple packing.
>>> print(t)
(1, 2, 3)
>>> a, b, c = t # Sequence unpacking.
>>> print(a)
1
>>> print(b)
2
>>> print(c)
3
>>> d, e, f = 4, 5, 6 # Multiple assignment combines packing and unpacking.
>>> print(d)
4
>>> print(e)
5
>>> print(f)
6
>>> a, b = 1, 2, 3 # Multiple assignment requires each variable (right)
have a matching element (left).
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
一成不变的：
tuples是不可变的容器，保证其对象它们含有不会改变。它并不能保证它们包含的对象不会改变：
>>> a_list = []
>>> a_tuple = (a_list,) # A tuple (immutable) with a list (mutable) element.
>>> print(a_tuple)
([],)
>>> a_list.append("Hello campers!")
>>> print(a_tuple) # Element of the immutable is mutated.
(['Hello campers!'],)
用途：
函数只能返回单个值，但是，异构tuple可用于从函数返回多个值。一个例子是内置的enumerate函数，它返回一个可迭代的异构tuples ：
>>> greeting = ["Hello", "campers!"]
>>> enumerator = enumerate(greeting)
>>> enumerator.next()
>>> enumerator.__next__()
(0, 'Hello')
>>> enumerator.__next__()
(1, 'campers!')