Python基础必备技巧之列表List和元组Tuple

列表List 和 元组Tuple 可以说是 Python 中最通用、最有用的数据类型。

列表 List

列表是任意对象的集合，有点类似于许多其他编程语言中的数组，但更灵活。列表在 Python 中通过将逗号分隔的对象序列括在方括号 ( [] ) 中。

>>> a = ['foo', 'bar', 'baz', 'qux']

>>> print(a)
['foo', 'bar', 'baz', 'qux']
>>> a
['foo', 'bar', 'baz', 'qux']

列表的主要特征：有序、可以包含任意对象、元素可以通过索引访问、可以嵌套到任意深度、可变、动态的。

列表是有序的

列表是对象的有序集合。定义列表时指定元素的顺序是该列表的固有特征，并在该列表的生命周期内保持不变。

# 具有不同顺序的相同元素的列表是不相同的。
>>> a = ['foo', 'bar', 'baz', 'qux']
>>> b = ['baz', 'qux', 'bar', 'foo']
>>> a == b
False
>>> a is b
False

>>> [1, 2, 3, 4] == [4, 1, 3, 2]
False

列表可以包含任意对象

列表可以包含任何种类的对象，允许存储的最大时根据计算机性能而定。

列表的元素都可以是同一类型。

>>> a = [2, 4, 6, 8]
>>> a
[2, 4, 6, 8]
 

元素可以是不同的类型。

>>> a = [21.42, 'foobar', 3, 4, 'bark', False, 3.14159]
>>> a
[21.42, 'foobar', 3, 4, 'bark', False, 3.14159]

列表甚至可以包含复杂的对象，例如函数、类和模块。

>>> int
<class 'int'>
>>> len
<built-in function len>
>>> def foo():
...     pass
...
>>> foo
<function foo at 0x035B9030>
>>> import math
>>> math
<module 'math' (built-in)>

>>> a = [int, len, foo, math]
>>> a
[<class 'int'>, <built-in function len>, <function foo at 0x02CA2618>,
<module 'math' (built-in)>]

列表对象不必是唯一的。给定对象可以多次出现在列表中。

>>> a = ['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']
>>> a
['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']

可以通过索引访问列表元素

可以使用方括号中的索引访问列表中的各个元素。像字符串一样列表索引是从 0 开始。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[0]
'foo'
>>> a[2]
'baz'
>>> a[5]
'corge'
>>> a[-1]
'corge'
>>> a[-2]
'quux'
>>> a[-5]
'bar'

有关于字符串索引的东西都适用于列表，例如负列表索引从列表末尾开始计数。

切片表达式 [m:n] 返回索引 m 到 n 包括索引 n 的元素。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2:5]
['baz', 'qux', 'quux']

字符串切片的其他特性也适用于列表切片。

指定正索引和负索引。

>>> a[-5:-2]
['bar', 'baz', 'qux']
>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[-5:-2] == a[1:4]
True

省略第一个索引从列表的开头开始切片，省略第二个索引将切片扩展到列表的末尾。

>>> print(a[:4], a[0:4])
['foo', 'bar', 'baz', 'qux'] ['foo', 'bar', 'baz', 'qux']
>>> print(a[2:], a[2:len(a)])
['baz', 'qux', 'quux', 'corge'] ['baz', 'qux', 'quux', 'corge']

>>> a[:4] + a[4:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:4] + a[4:] == a
True

指定一个步幅——正的或负的。

>>> a[0:6:2]
['foo', 'baz', 'quux']
>>> a[1:6:2]
['bar', 'qux', 'corge']
>>> a[6:0:-2]
['corge', 'qux', 'bar']

反转列表的语法与字符串相同。

>>> a[::-1]
['corge', 'quux', 'qux', 'baz', 'bar', 'foo']

字符串、列表[:]返回对同一对象的引用。

>>> s = 'foobar'
>>> s[:]
'foobar'
>>> s[:] is s
True

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:]
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[:] is a
False

运算符和内置函数处理列表。

运算符 in 和 not in。

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> 'qux' in a
True
>>> 'thud' not in a
True

连接( + )和复制( * )运算符。

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a + ['grault', 'garply']
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']
>>> a * 2
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'foo', 'bar', 'baz',
'qux', 'quux', 'corge']

函数len()、min()、max()。

>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> len(a)
6
>>> min(a)
'bar'
>>> max(a)
'qux'

列表可以嵌套

列表中的元素可以是任何类型的对象，一个列表可以包含子列表，而子列表又可以包含子列表本身，依此类推。

常规嵌套列表操作。

>>> x = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']


# x[0], x[2], 和x[4]是字符串
>>> print(x[0], x[2], x[4])
a g j


# x[1]和x[3]是子列表
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[3]
['hh', 'ii']


# 访问子列表中的元素需附加索引
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[1][0]
'bb'
>>> x[1][1]
['ccc', 'ddd']
>>> x[1][2]
'ee'
>>> x[1][3]
'ff'
>>> x[3]
['hh', 'ii']
>>> print(x[3][0], x[3][1])
hh ii


# x[1][1]是另一个子列表，访问需要添加索引
>>> x[1][1]
['ccc', 'ddd']
>>> print(x[1][1][0], x[1][1][1])
ccc ddd


# 索引和切片的常用语法也适用于子列表。
>>> x[1][1][-1]
'ddd'
>>> x[1][1:3]
[['ccc', 'ddd'], 'ee']
>>> x[3][::-1]
['ii', 'hh']


# 运算符和函数仅适用于指定操作级别的列表。
>>> x
['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j']
>>> len(x)
5

>>> x[0]
'a'
>>> x[1]
['bb', ['ccc', 'ddd'], 'ee', 'ff']
>>> x[2]
'g'
>>> x[3]
['hh', 'ii']
>>> x[4]
'j'


# in 操作符使用。
>>> 'ddd' in x
False
>>> 'ddd' in x[1]
False
>>> 'ddd' in x[1][1]
True

列表是可变的

创建列表后，可以随意添加、删除、移动和移动元素。

修改单个列表值。

列表中的单个值可以通过索引和简单赋值来替换，不可直接替换

>>> s = 'foobarbaz'
>>> s[2] = 'x'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

使用del命令删除列表项。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> del a[3]
>>> a
['foo', 'bar', 'baz', 'quux', 'corge']

修改多个列表值。

通过切片实现 a[m:n] = <iterable>。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[1:4]
['bar', 'baz', 'qux']
>>> a[1:4] = [1.1, 2.2, 3.3, 4.4, 5.5]
>>> a
['foo', 1.1, 2.2, 3.3, 4.4, 5.5, 'quux', 'corge']
>>> a[1:6]
[1.1, 2.2, 3.3, 4.4, 5.5]
>>> a[1:6] = ['Bark!']
>>> a
['foo', 'Bark!', 'quux', 'corge']

插入多个元素来代替单个元素，需使用仅表示一个元素的切片。

>>> a = [1, 2, 3]
>>> a[1:2] = [2.1, 2.2, 2.3]
>>> a
[1, 2.1, 2.2, 2.3, 3]

>>> a = [1, 2, 3]
>>> a[1] = [2.1, 2.2, 2.3]
>>> a
[1, [2.1, 2.2, 2.3], 3]

[n:n]在所需索引处指定一个形式的切片（零长度切片）。

>>> a = [1, 2, 7, 8]
>>> a[2:2] = [3, 4, 5, 6]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]

切片分配给空列表来删除列表中间的多个元素。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[1:5] = []
>>> a
['foo', 'corge']

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> del a[1:5]
>>> a
['foo', 'corge']

将项目附加或附加到列表。
+可以使用连接运算符或+=扩展赋值运算符将其他项目添加到列表的开头或结尾。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a += ['grault', 'garply']
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 'grault', 'garply']

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']

>>> a = [10, 20] + a
>>> a
[10, 20, 'foo', 'bar', 'baz', 'qux', 'quux', 'corge']

列表与列表连接，如果只想添加一个元素，则需要将其指定为单例列表。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a += 20
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    a += 20
TypeError: 'int' object is not iterable

>>> a += [20]
>>> a
['foo', 'bar', 'baz', 'qux', 'quux', 'corge', 20]

用于修改列表的内置方法。list.append(<obj>) 将对象附加到列表中

将对象<obj>追加到列表末尾。

>>> a = ['a', 'b']
>>> a.append(123)
>>> a
['a', 'b', 123]

结果是直接修改列表二不返回新列表。

>>> a = ['a', 'b']
>>> x = a.append(123)
>>> print(x)
None
>>> a
['a', 'b', 123]

+运算符用于连接列表时，如果目标操作数是可迭代的，则其元素将被分解并单独附加到列表中。

>>> a = ['a', 'b']
>>> a + [1, 2, 3]
['a', 'b', 1, 2, 3]

.append() 方式结果不同，直接作为元素实体添加。

>>> a = ['a', 'b']
>>> a.append([1, 2, 3])
>>> a
['a', 'b', [1, 2, 3]]
>>> a = ['a', 'b']
>>> a.append('foo')
>>> a
['a', 'b', 'foo']

list.extend(<iterable>)

使用来自可迭代对象的对象扩展列表。

>>> a = ['a', 'b']
>>> a.extend([1, 2, 3])
>>> a
['a', 'b', 1, 2, 3]

list.insert(<index>, <obj>)

将对象插入列表。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.insert(3, 3.14159)
>>> a[3]
3.14159
>>> a
['foo', 'bar', 'baz', 3.14159, 'qux', 'quux', 'corge']

list.remove(<obj>)

从列表中移除一个对象。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.remove('baz')
>>> a
['foo', 'bar', 'qux', 'quux', 'corge']

如果不在中列表，则会引发异常。

>>> a.remove('Bark!')
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    a.remove('Bark!')
ValueError: list.remove(x): x not in list

list.pop(index=-1)

从列表中删除一个元素，需要指定索引并返回被移除的项目的值。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.pop()
'corge'
>>> a
['foo', 'bar', 'baz', 'qux', 'quux']
>>> a.pop()
'quux'
>>> a
['foo', 'bar', 'baz', 'qux']

指定了index时候，pop(-1) 等价于 pop() 。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a.pop(1)
'bar'
>>> a
['foo', 'baz', 'qux', 'quux', 'corge']
>>> a.pop(-3)
'qux'
>>> a
['foo', 'baz', 'quux', 'corge']

列表是动态的，随着项目数据的变化而变化。

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
# 数据增加
>>> a[2:2] = [1, 2, 3]
>>> a += [3.14159]
>>> a
['foo', 'bar', 1, 2, 3, 'baz', 'qux', 'quux', 'corge', 3.14159]
# 数据删除
>>> a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']
>>> a[2:3] = []
>>> del a[0]
>>> a
['bar', 'qux', 'quux', 'corge']

元组 Tuple

对象的有序集合，称为元组。与列表的区别在于元组是通过括号 ( () ) 而不是方括号 ( [] ) 中来定义的，以及元素不可变。

定义和使用元组

>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t
('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t[0]
'foo'
>>> t[-1]
'corge'
>>> t[1::2]
('bar', 'qux', 'corge')


# 可以进行倒序排列
>>> t[::-1]
('corge', 'quux', 'qux', 'baz', 'bar', 'foo')


# 元组不可修改
>>> t = ('foo', 'bar', 'baz', 'qux', 'quux', 'corge')
>>> t[2] = 'Bark!'
Traceback (most recent call last):
  File "<pyshell#65>", line 1, in <module>
    t[2] = 'Bark!'
TypeError: 'tuple' object does not support item assignment

元素对比列表的优点

• 处理速度更快。
• 防止被意外修改。
• 字典需要不可变更类型的值作为组件。

# 元素用,分割
>>> a = 'foo'
>>> b = 42
>>> a, 3.14159, b
('foo', 3.14159, 42)


# 定义一个空的元组
>>> t = ()
>>> type(t)
<class 'tuple'>


# 定义项目的元组
>>> t = (2,)
>>> type(t)
<class 'tuple'>
>>> t[0]
2
>>> t[-1]
2

# 元组单一元素会包含符号
>>> print(t)
(2,)

元组分配、打包和解包

可以将包含多个项目的文字元组分配给单个对象。

>>> t
('foo', 'bar', 'baz', 'qux')
>>> t[0]
'foo'
>>> t[-1]
'qux'

被打包的对象直接被分配新的元组中，并解释到各个元组对象。

>>> (s1, s2, s3, s4) = t
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'

解包时，左边的变量个数必须与元组中的值个数相匹配。

>>> (s1, s2, s3) = t
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    (s1, s2, s3) = t
ValueError: too many values to unpack (expected 3)

>>> (s1, s2, s3, s4, s5) = t
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    (s1, s2, s3, s4, s5) = t
ValueError: not enough values to unpack (expected 5, got 4)


# 直接一步操作
>>> (s1, s2, s3, s4) = ('foo', 'bar', 'baz', 'qux')
>>> s1
'foo'
>>> s2
'bar'
>>> s3
'baz'
>>> s4
'qux'

可以省略通常用于表示元组的括号。

>>> t = 1, 2, 3
>>> t
(1, 2, 3)

>>> x1, x2, x3 = t
>>> x1, x2, x3
(1, 2, 3)

>>> x1, x2, x3 = 4, 5, 6
>>> x1, x2, x3
(4, 5, 6)

>>> t = 2,
>>> t
(2,)

可以通过元组互换进行互换赋值。

>>> a = 'foo'
>>> b = 'bar'
>>> a, b
('foo', 'bar')
>>> a, b = b, a
>>> a, b
('bar', 'foo')