列表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')