当前位置:Gxlcms > Python > [译]ThePythonTutorial#DataStructures

[译]ThePythonTutorial#DataStructures

时间:2021-07-01 10:21:17 帮助过:24人阅读

[译]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异常。
    可选参数startend被解释为切片记号法,用来将搜索限制在列表特定的子列表内。返回的索引是相对于完整列表索引,而不是相对于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子句的表达式再加上中括号,构成了列表推导式。其返回结果是一个新的列表,列表的元素是表达式中forif子句的计算结果。例如,以下列表推导式组合两个列表中不相等的元素:

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

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

如果表达式是一个元组(如上所示的(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, 54321hello!被封装到了一个元组中。逆向操作也是可行的:

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

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

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

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

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

布尔运算符andor号称短路运算符:它们的参数从左向右求值,一旦结果确定,求值过程就会停止。例如,如果AC是真,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对象。从而支持如成员关系测试和迭代之类的操作,但是其内容并不是独立于原始字典的,只是一个视图

以上就是[译]The Python Tutorial#Data Structures的详细内容,更多请关注Gxl网其它相关文章!

人气教程排行