[译]The Python Tutorial#5. Data Structures

xiaoxiao2021-02-28  16

[译]The Python Tutorial#Data Structures

5.1 Data Structures

本章节详细介绍之前介绍过的一些内容,并且也会介绍一些新的内容。

5.1 More on Lists

列表数据类型拥有更多方法,以下是列表对象的所有方法:

list.append(x) 在列表末尾添加新项,等同于a[len(a):] = [x]

list.extend(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的第一个项,若x不存在,方法抛出异常(ValueError异常)

list.pop([i]) 从列表中移除指定位置的项并返回。如果没有指定索引,a.pop()移除并返回列表中最后一个项。(方法签名中包裹i的方括号表示参数是可选的,而不是在这个位置写一个方括号。这种记号法在Python Library Reference中经常用到)

list.clear() 移除列表中的所有项,等同于del a[:]

list.index(x[, start[, end]]) 返回第一个值为x的项的基于0的索引,如果x不存在抛出ValueError异常。 可选参数start和end被解释为切片记号法,用来将搜索限制在列表特定的子列表内。返回的索引是相对于完整列表索引,而不是相对于start参数的。

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, reverse或者sort的这样,只改变了列表但是没有返回值打印,它们返回默认的None[1]。这是Python可变数据结构适用的设计原则。

5.1.1 Using Lists as Stacks

列表方法使得将其用作栈非常容易,栈中最后一个加入的元素第一个被释放(后进先出)。使用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 Using Lists as Queues

将列表用作队列也是可能的,队列中先添加的元素先释放(先进先出);然而,这样用列表效率非常不高。因为在列表末尾添加和取出元素很快,但是在列表开头插入或者删除元素很慢(因为不得不将其他所有元素位移一位)。

经过特殊设计的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 List Comprehensions

列表推导式为创建列表提供了简洁方式。一般的应用方式是:创建新列表,列表元素是对其他序列或者可迭代对象操作的结果;或者创建元素满足特定条件的子序列。

假如希望创建一个平方列表:

>>> 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子句的计算结果。例如,以下列表推导式组合两个列表中不相等的元素:

>>> [(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)]

注意上面两个代码段中for和if语句的顺序是相同的。

如果表达式是一个元组(如上所示的(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 Nested List Comprehensions

列表推导式开头的表达式可以是任意表达式,包括另一个列表推导式。

考虑以下示例,一个包含3个长度为4的列表的列表实现了3x4的矩阵:

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]]

前面的章节提到,嵌套的列表推导式是在其后跟随的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]]

在实践中,应该选择built-in函数来复合流程语句。在以上的用例中zip()函数更有用:

>>> list(zip(*matrix)) [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

参见 Unpacking Argument Lists了解关于上面*使用的更多详细信息。

5.2 The del statement

在提供列表索引而不是值的情况下,有一种方法可以移除列表中的元素: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会抛出异常(至少在其他值赋值给名字a之前)。接下来会有更多del的使用

5.3 Tuples and Sequences

列表和字符串有很多常用属性,比如索引和切片操作。它们是序列数据类型(参见 Sequence Types - 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])

可见,输出的元组总是放在圆括号中,以便于嵌套的元组可以被正确解析;虽然圆括号总是必须的(如果元组是其他更大表达式的一部分),但是在输入元组的时候可以选择使用圆括号。不能对元组的单个项赋值,但是可以创建包含如列表的可变对象的元组。

虽然元组和列表有些相似,但是他们通常以不同的目的,用于不同的场景。元组是不可变的,通常包含不同类型的元素,可以通过拆包操作(参见后续章节)或者索引(或者当元组是命名元组时,甚至可以通过属性来访问)来访问。列表是可变的,通常其元素也是不同类型的,可以通过对列表的迭代访问元素。

构建包含零个或者1个项的元组比较特殊:一种额外的奇怪语法可以适用于这种情况。空元组由一对空的圆括号创建;一个元素的元组由一个跟着逗号的值创建(在圆括号中放入单个值是不够的。译注:这种情况:(1)表示整数而不是元组,使用(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

非常恰当地称之为序列解包,适用于任何在等号右边的序列(译注:等号右操作数)。序列解包要求等号左边待赋值的变量数量与序列包含元素数目相同。注意多重赋值只是封装元组和序列解包的结合(译注:多重赋值:i, j = 1, 2)

5.4 Set

Python也包含实现了集合的数据类型。集合是无序不重复的元素集。基本功能包括成员关系测试和重复实体消除。集合对象也支持并集,交集,差集以及对称差集等数学操作。

可以使用花括号和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'}

与列表推导式相同,Python也支持集合推导式:

>>> a = {x for x in 'abracadabra' if x not in 'abc'} >>> a {'r', 'd'}

5.5 Dictionaries

另一个内嵌入Python中的数据结构是字典(参见 Mapping Types - dict)。字典在其他一些语言中被称为“联合存储”或者“联合数组”。与序列不同,序列以一系列数字作索引,字典以键作索引,键可以是任何不可变类型;通常使用字符串和数字作为键。只包含字符串,数字或者其他元组的元组也可以作为键;直接或者间接包含可变对象的元组不能作为键。因为列表可以使用索引赋值,切片赋值或者append()以及extend()等方法改变自身,所以列表不能作为键。

最好的理解字典的方式是将其认为是键值对的无序集合,同一集合中键唯一。一对花括号创建空字典:{}。在花括号中放置由逗号分隔键值对列表可以为字典添加初始键值对;这也是字典输出的格式。

字典提供的主要操作是:使用键存储值以及取值。可以使用del删除一个键值对。如果使用已经存在的键来存储值,那么与键关联的旧值会被重写。使用不存在的键来取值会抛出异常。

在字典上执行list(d.keys())返回字典所有键的无序列表(使用sorted(d.keys())使其有序)[2]。使用关键字in检查键在字典中是否存在。

以下是使用字典的示例:

>>> tel = {'jack': 4098, 'sape': 4139} >>> tel['guido'] = 4127 >>> tel {'sape': 4139, 'guido': 4127, 'jack': 4098} >>> tel['jack'] 4098 >>> del tel['sape'] >>> tel['irv'] = 4127 >>> tel {'guido': 4127, 'irv': 4127, 'jack': 4098} >>> list(tel.keys()) ['irv', 'guido', 'jack'] >>> sorted(tel.keys()) ['guido', 'irv', 'jack'] >>> 'guido' in tel True >>> 'jack' not in tel False

dict()构造器直接使用键值对序列构造字典:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'jack': 4098, 'guido': 4127}

此外,字典推导式可以从任意键值表达式中创建字典:

>>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36}

当键是简单的字符串时,可以使用关键字参数来指定键值对:

>>> dict(sape=4139, guido=4127, jack=4098) {'sape': 4139, 'jack': 4098, 'guido': 4127}

5.6 Looping Techniques

遍历字典时,使用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 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 More on Conditions

while和if语句中使用的条件可以包含任意操作符,不仅仅是比较运算符。

比较运算符in和not in检查指定值在序列中是否存在(不存在)。操作符is和is not比较两个对象是否真正相同(内存地址比较);这两个操作符只对像列表那样的可变对象重要。所有的比较运算符拥有相同的优先级,并且都低于数字运算符。

比较运算符可以链接起来。例如a < b == c测试b是否大于a同时b等于c(译注:同其他高级语言的:a < b and b == c)

比较运算符可以结合布尔运算符and和or使用,比较的结果(或者其他任何布尔表达式)可以使用not来作否定。and,or和not优先级比比较运算符低;其中not的优先级最高而or优先级最低,因此A and not B or C等同于(A and (not B)) or C。一如既往,可以使用圆括号表述想要的优先级顺序。

布尔运算符and和or号称短路运算符:它们的参数从左向右求值,一旦结果确定,求值过程就会停止。例如,如果A和C是真,B是假,A and B and C不会对表达式C求值(译注:A and 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语言一样在表达式内发生。C程序员也许会抱怨,但是这避免了C程序中遇到的一个普遍问题:当想要表示==时候可能误用了=。

5.8 Comparing Sequences and Other Types

相同序列类型之间的序列对象可以相互比较。比较使用字典序:首先比较两个序列的第一项,如果它们不同,比较运算的结果就可确定了;如果它们不同,比较两个序列中的下一个项,以此类推,直到其中一个序列耗尽。如果被比较的两个项是同一类型的,那么使用字典序递归比较。如果两个序列的所有项都是相等的,那么他们相等。如果其中一个序列是另一个序列的子序列,那么短的一个序列较小。字符串的字典序使用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。否则,解释器会抛出TypeException异常,而不是随意提供结果

Footnotes

[1] 其他语言可能返回改变后的对象,从而允许方法链接,如:d->insert("a")>remove("b")->sort(); [2] 调用d.keys()返回一个dictionary view对象。从而支持如成员关系测试和迭代之类的操作,但是其内容并不是独立于原始字典的,只是一个视图

转载请注明原文地址: https://www.6miu.com/read-1099990.html

最新回复(0)