5. 数据结构¶
本章将更详细地介绍您已经了解的一些内容,并添加一些新内容。
5.1. 更多关于列表¶
列表数据类型还有一些方法。以下是列出对象的所有方法:
- list.append(x)
将项目添加到列表末尾。相当于
a[len(a):] = [x]
.
- list.extend(iterable)
通过附加ITerable中的所有项来扩展列表。相当于
a[len(a):] = iterable
.
- list.insert(i, x)
在给定位置插入项目。第一个参数是要插入的元素的索引,所以
a.insert(0, x)
在列表前面插入,以及a.insert(len(a), x)
等于a.append(x)
.
- list.remove(x)
从值等于的列表中删除第一个项 x . 它提出了一个
ValueError
如果没有这样的项目。
- list.pop([i])
删除列表中给定位置的项,然后将其返回。如果没有指定索引,
a.pop()
删除并返回列表中的最后一项。(方括号围绕 i 在方法签名中,表示参数是可选的,而不是在该位置键入方括号。您将在python库参考中经常看到这个符号。)
- list.clear()
从列表中删除所有项目。相当于
del a[:]
.
- list.index(x[, start[, end]])
返回值等于的第一个项的列表中基于零的索引 x . 提出一个
ValueError
如果没有这样的项目。可选参数 开始 和 end 在切片符号中解释为,用于将搜索限制到列表的特定子序列。返回的索引是相对于完整序列的开始而不是 开始 参数。
- list.count(x)
返回次数 x 出现在列表中。
- list.sort(*, key=None, reverse=False)
对列表中的项进行就地排序(参数可用于排序自定义,请参见
sorted()
为了他们的解释)。
- list.reverse()
在适当的位置反转列表元素。
- list.copy()
返回列表的浅显副本。相当于
a[:]
.
使用大多数列表方法的示例:
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4) # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'
你可能已经注意到 insert
, remove
或 sort
只修改列表而不打印返回值——它们返回默认值 None
. 1 这是Python中所有可变数据结构的设计原则。
您可能注意到的另一件事是,并非所有数据都可以排序或比较。例如, [None, 'hello', 10]
不排序,因为整数不能与字符串和 None 无法与其他类型进行比较。还有一些类型没有定义的排序关系。例如, 3+4j < 5+7j
不是有效的比较。
5.1.1. 将列表用作堆栈¶
列表方法使得将列表用作堆栈非常容易,其中添加的最后一个元素是检索到的第一个元素(“后进先出”)。要将项添加到堆栈顶部,请使用 append()
. 要从堆栈顶部检索项,请使用 pop()
没有显式索引。例如::
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]
5.1.2. 将列表用作队列¶
也可以将列表用作队列,其中添加的第一个元素是检索到的第一个元素(“先进先出”);但是,为此目的,列表并不高效。虽然列表末尾的appends和pop很快,但是从列表开头执行insert或pop却很慢(因为所有其他元素都必须移动一个元素)。
要实现队列,请使用 collections.deque
它的设计目的是有快速的附加物和从两端弹出。例如::
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
5.1.3. 列表推导¶
列表理解提供了一种创建列表的简洁方法。常见的应用程序是创建新的列表,其中每个元素都是应用于另一个序列或ITerable的每个成员的某些操作的结果,或者创建满足特定条件的这些元素的子序列。
例如,假设我们要创建一个正方形列表,例如:
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
注意,这会创建(或覆盖)一个名为 x
循环完成后仍然存在。我们可以使用以下公式计算没有任何副作用的方块列表:
squares = list(map(lambda x: x**2, range(10)))
或者,等价地:
squares = [x**2 for x in range(10)]
更简洁易读。
列表理解由括号组成,括号中包含一个表达式,后跟一个 for
从句,然后是零或更多 for
或 if
条款。结果将是在 for
和 if
后面的条款。例如,如果两个列表中的元素不相等,则此listcomp将它们组合在一起:
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
它相当于:
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
如果表达式是一个元组(例如 (x, y)
在前面的示例中),它必须用括号括起来。地址:
>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1, in <module>
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> # flatten a list using a listcomp with two 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
列表理解可以包含复杂表达式和嵌套函数::
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
5.1.4. 嵌套列表理解¶
列表理解中的初始表达式可以是任意表达式,包括另一个列表理解。
考虑以下3x4矩阵的示例,该矩阵实现为3个长度为4的列表:
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
下面的列表理解将换行和换列:
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
正如我们在上一节中看到的,嵌套的listcomp是在 for
因此,这个例子等价于:
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
反过来,这与:
>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
在现实世界中,您应该更类似于内置函数而不是复杂的流语句。这个 zip()
对于这个用例,函数可以做得很好:
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
见 解包参数列表 有关此行星号的详细信息。
5.2. 这个 del
陈述¶
有一种方法可以从给定其索引而不是其值的列表中移除项: del
语句。这与 pop()
返回值的方法。这个 del
语句还可以用于从列表中删除切片或清除整个列表(前面我们通过将空列表分配给切片来完成)。例如::
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
del
也可用于删除整个变量:
>>> del a
引用名称 a
此后是一个错误(至少在为其分配另一个值之前)。我们会找到其他的用途 del
后来。
5.3. 元组和序列¶
我们看到列表和字符串有许多共同的属性,例如索引和切片操作。它们是 序列 数据类型(参见 序列类型--- list , tuple , range )由于Python是一种不断发展的语言,因此可以添加其他序列数据类型。还有另一种标准序列数据类型: 元组 .
元组由逗号分隔的值组成,例如:
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
如您所见,在输出时,元组总是用括号括起来,这样嵌套的元组就可以被正确地解释;它们可以是带或不带括号的输入,尽管通常括号是必需的(如果元组是更大表达式的一部分)。无法为元组的各个项赋值,但是可以创建包含可变对象(如列表)的元组。
尽管元组看起来像列表,但它们通常用于不同的情况和不同的目的。元组是 immutable ,并且通常包含通过解包(参见本节后面的内容)或索引(甚至在以下情况下通过属性)访问的异类元素序列: namedtuples
)列表是 mutable 它们的元素通常是同构的,可以通过遍历列表来访问。
一个特殊的问题是包含0或1项的元组的构造:语法有一些额外的怪癖来适应这些。空元组是由一对空括号构成的;只有一个项的元组是由一个带逗号的值构成的(不足以将单个值括在括号中)。丑陋,但有效。例如::
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)
声明 t = 12345, 54321, 'hello!'
是一个例子 元组 价值观 12345
, 54321
和 'hello!'
被打包成一个元组。也可以进行反向操作:
>>> x, y, z = t
这就是所谓的,恰当地说, 顺序拆包 并且适用于右侧的任何序列。序列解包要求等号左侧的变量与序列中的元素一样多。注意,多重分配实际上只是元组打包和序列解包的组合。
5.4. 集合¶
python还包括 sets . 集合是一个无序集合,没有重复的元素。基本用途包括成员资格测试和消除重复条目。集合对象还支持数学运算,如并集、交集、差分和对称差分。
花括号还是 set()
函数可用于创建集合。注意:要创建空集,必须使用 set()
不是 {{}}
;后者创建一个空字典,这是我们在下一节中讨论的数据结构。
下面是一个简短的演示:
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}
类似于 list comprehensions ,也支持集合理解::
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
5.5. 辞典¶
另一种内置在python中的有用数据类型是 词典 (见 映射类型--- dict )字典有时在其他语言中被发现为“关联存储器”或“关联数组”。不同于由一系列数字索引的序列,字典的索引是 keys ,可以是任何不可变类型;字符串和数字始终可以是键。如果元组仅包含字符串、数字或元组,则可以将其用作键;如果元组直接或间接包含任何可变对象,则不能将其用作键。不能将列表用作键,因为可以使用索引分配、切片分配或类似方法就地修改列表 append()
和 extend()
.
最好把字典看作是一套 关键:价值 配对,要求键是唯一的(在一个字典中)。一对大括号创建一个空字典: {{}}
. 在大括号内放置一个逗号分隔的key:value对列表,将初始key:value对添加到字典中;这也是在输出中编写字典的方式。
字典的主要操作是用某个键存储一个值,并提取给定键的值。也可以删除键:值对 del
. 如果使用已在使用的密钥存储,则与该密钥关联的旧值将被忽略。使用不存在的键提取值是一个错误。
表演 list(d)
在字典上,按插入顺序返回字典中使用的所有键的列表(如果要对其排序,只需使用 sorted(d)
取而代之的是)要检查字典中是否有单个键,请使用 in
关键字。
下面是一个使用字典的小例子:
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
这个 dict()
构造函数直接从键值对序列生成字典::
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
此外,dict理解可用于从任意键和值表达式创建字典:
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
当键是简单字符串时,有时使用关键字参数指定对更容易:
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}
5.6. 循环技术¶
当遍历字典时,可以同时使用 items()
方法。::
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
通过序列循环时,可以同时使用 enumerate()
功能。::
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
要同时循环两个或多个序列,可以将条目与 zip()
功能。::
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
若要反向循环序列,请先指定正向序列,然后调用 reversed()
功能。::
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
要按排序顺序循环序列,请使用 sorted()
函数,在保持源不变的情况下返回新的排序列表。::
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for i in sorted(basket):
... print(i)
...
apple
apple
banana
orange
orange
pear
使用 set()
在序列上消除重复元素。使用 sorted()
与 set()
覆盖序列是按排序顺序循环覆盖序列中唯一元素的惯用方法。:
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
当您循环遍历一个列表时,有时很容易改变它;但是,创建一个新的列表通常更简单、更安全。::
>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
... if not math.isnan(value):
... filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]
5.7. 附加条件¶
使用的条件 while
和 if
语句可以包含任何运算符,而不仅仅是比较。
比较运算符 in
和 not in
检查值是否按顺序出现(不出现)。运营商 is
和 is not
比较两个对象是否真的是同一个对象;这只对列表之类的可变对象很重要。所有比较运算符的优先级都相同,低于所有数值运算符的优先级。
可以链接比较。例如, a < b == c
测试是否 a
小于 b
而且 b
等于 c
.
可以使用布尔运算符组合比较 and
和 or
,并且比较(或任何其他布尔表达式)的结果可以用 not
. 它们的优先级比比较运算符低;在它们之间, not
具有最高优先级和 or
最低的,所以 A and not B or C
等于 (A and (not B)) or C
. 和往常一样,括号可以用来表示所需的合成。
布尔运算符 and
和 or
所谓 short-circuit 运算符:从左到右对其参数进行评估,一旦确定结果,评估就会停止。例如,如果 A
和 C
是真的 B
A and B and C
不计算表达式的值 C
. 当用作一般值而不是布尔值时,短路运算符的返回值是最后计算的参数。
可以将比较或其他布尔表达式的结果赋给变量。例如:
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
注意,在Python中,与C不同,表达式内部的赋值必须显式地使用 walrus operator :=
. 这避免了在C程序中遇到的一类常见问题:键入 =
在表达式中,当 ==
是故意的。
5.8. 比较序列和其他类型¶
序列对象通常可以与具有相同序列类型的其他对象进行比较。比较使用 词典编纂的 排序:首先比较前两个项目,如果它们不同,则确定比较的结果;如果它们相等,则比较后两个项目,依此类推,直到两个序列都用尽。如果要比较的两个项目本身是同一类型的序列,则递归执行词典编纂比较。如果两个序列的所有项比较相等,则认为序列相等。如果一个序列是另一个序列的初始子序列,则较短的序列是较小(较小)的序列。字符串的词典编排顺序使用Unicode代码点编号对单个字符进行排序。相同类型序列之间的比较示例:
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
请注意,将不同类型的对象与 <
或 >
如果对象具有适当的比较方法,则是合法的。例如,混合数字类型根据其数值进行比较,因此0等于0.0等。否则,解释器将引发 TypeError
例外。
脚注
- 1
其他语言可能返回突变的对象,这允许方法链接,例如
d->insert("a")->remove("b")->sort();
.