5.2. The del statement

有一种通过序列元素的索引而不是元素的值来删除指定元素的方法: del. 同pop()不同之处在于,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的时候将会引发一个错误. (at least until another value is assigned to it). 我们将在后文提到更多关于del 的使用.

5.3. Tuples and Sequences 元组和数列

序列和字符串有许多相同的特效, 比如说索引和切片操作. 这里有两个关于数列数据类型的使用的栗子 (see Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple.

A tuple consists of a number of values separated by commas, for instance:

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

As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression). It is not possible to assign to the individual items of a tuple, however it is possible to create tuples which contain mutable objects, such as lists.

Though tuples may seem similar to lists, they are often used in different situations and for different purposes. Tuples are immutable, and usually contain an heterogeneous sequence of elements that are accessed via unpacking (see later in this section) or indexing (or even by attribute in the case of namedtuples). Lists are mutable, and their elements are usually homogeneous and are accessed by iterating over the list.

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective. For example:

>>> empty = ()

>>> singleton = 'hello',    # <-- note trailing comma

>>> len(empty)

0

>>> len(singleton)

1

>>> singleton

('hello',)

The statement t = 12345, 54321, 'hello!' is an example of tuple packing: the values 12345, 54321 and 'hello!' are packed together in a tuple. The reverse operation is also possible:

>>> x, y, z = t

This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires the list of variables on the left to have the same number of elements as the length of the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.

5.4. Sets

Python同样支持集合. 集合是由无序的不重复的元素构成的. Basic uses include membership testing and eliminating duplicate entries. 集合同样支持xxx,xxx,xxx的操作.

花括号或者set()可以用来创建集合. 注意: 创建一个空的集合必须使用set()而不是{} (这是一个空的字典).

一个简明的小栗子:

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> fruit = set(basket)               # create a set without duplicates

>>> fruit

set(['orange', 'pear', 'apple', 'banana'])

>>> 'orange' in fruit                 # fast membership testing

True

>>> 'crabgrass' in fruit

False

>>> # Demonstrate set operations on unique letters from two words

...

>>> a = set('abracadabra')

>>> b = set('alacazam')

>>> a                                  # unique letters in a

set(['a', 'r', 'b', 'c', 'd'])

>>> a - b                              # letters in a but not in b

set(['r', 'd', 'b'])

>>> a | b                              # letters in either a or b

set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])

>>> a & b                              # letters in both a and b

set(['a', 'c'])

>>> a ^ b                              # letters in a or b but not both

set(['r', 'd', 'b', 'm', 'z', 'l'])

同递推式构造列表一样,我们也可以这样来构造集合:

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

>>> a

set(['r', 'd'])

5.5. Dictionaries

另一个非常有用的内建Python数据类型是字典(see Mapping Types — dict). 在其他的一些程序语言中,字典可能又被称作 “associative memories” or “associative arrays”. 与由整数索引的序列不同的是,字典是通过只读(不可变)的键值(key)来索引的; 字符串和数字总是可以被充当为键值. 仅由字符串 数字或者元组构成的元组也可以充当字典的key;但是 如果元组中包含了可变的元素(不管是直接或间接的)的时候,将其充当字典的key都是不可行的. 序列不能被当作字典的key,因为它可变(我这解释,我也只能呵呵了).

字典的特性(字典中的key不可重复),使得将字典视为由key:value的组合构成的集合,想来也是极好的. 空字典的表示方式: {}.

使用del同样可以删除字典中指定的键:值组合. 为字典中已经存在的key赋新值的时候,字典中key对应的value将会被更新. 从字典中取一个不存在的key的value的时候,是会引发一个错误的.

字典的keys()返回该字典的所有的key构成的序列, in arbitrary order (if you want it sorted, just apply the sorted() function to it). in 关键字同样也可以用来判断字典中是否存在指定的key.

字典使用的一个小栗子:

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

>>> tel.keys()

['guido', 'irv', 'jack']

>>> 'guido' in tel

True

函数dict() 可以将下面这种格式的序列直接转换为字典:

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

{'sape': 4139, 'jack': 4098, 'guido': 4127}

此外,你也可以任性的构造出一个个由key:value组合而成的字典,就像下面这样:

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

{2: 4, 4: 16, 6: 36}

When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:

>>> dict(sape=4139, guido=4127, jack=4098)

{'sape': 4139, 'jack': 4098, 'guido': 4127}

5.6. Looping Techniques

通过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(xrange(1,10,2)):

...     print i

...

9

7

5

3

1

sorted() 会根据指定的条件直接将原始的序列排序(前面已经指出过,返回None).

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for f in sorted(set(basket)):

...     print f

...

apple

banana

orange

pear

使用iteritems()方法可以在遍历字典的时候同时取到字典中的key和对应的value:

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}

>>> for k, v in knights.iteritems():

...     print k, v

...

gallahad the pure

robin the brave

想要在遍历一个序列的同时改变该序列, 一个很好的方法是首先遍历该序列的一个拷贝.切片是个不错的获取序列的拷贝的方法:

>>> words = ['cat', 'window', 'defenestrate']

>>> for w in words[:]:  # Loop over a slice copy of the entire list.

...     if len(w) > 6:

...         words.insert(0, w)

...

>>> words

['defenestrate', 'cat', 'window', 'defenestrate']

5.7. More on Conditions

The conditions used in while and if statements can contain any operators, not just comparisons.

The comparison operators in and not in check whether a value occurs (does not occur) in a sequence. The operators is and is not compare whether two objects are really the same object; this only matters for mutable objects like lists. All comparison operators have the same priority, which is lower than that of all numerical operators.

Comparisons can be chained. For example, a < b == c tests whether a is less than b and moreover b equals c.

Comparisons may be combined using the Boolean operators and and or, and the outcome of a comparison (or of any other Boolean expression) may be negated with not. These have lower priorities than comparison operators; between them, not has the highest priority and or the lowest, so that A and not B or C is equivalent to (A and (not B)) or C. As always, parentheses can be used to express the desired composition.

The Boolean operators and and or are so-called short-circuit operators: their arguments are evaluated from left to right, and evaluation stops as soon as the outcome is determined. For example, if A and C are true but B is false, A and B and C does not evaluate the expression C. When used as a general value and not as a Boolean, the return value of a short-circuit operator is the last evaluated argument.

It is possible to assign the result of a comparison or other Boolean expression to a variable. For example,

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'

>>> non_null = string1 or string2 or string3

>>> non_null

'Trondheim'

Note that in Python, unlike C, assignment cannot occur inside expressions. C programmers may grumble about this, but it avoids a common class of problems encountered in C programs: typing = in an expression when == was intended.

5.8. Comparing Sequences and Other Types

Sequence objects may be compared to other objects with the same sequence type. The comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one. Lexicographical ordering for strings uses the ASCII ordering for individual characters. Some examples of comparisons between sequences of the same type:

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

Note that comparing objects of different types is legal. The outcome is deterministic but arbitrary: the types are ordered by their name. Thus, a list is always smaller than a string, a string is always smaller than a tuple, etc. [1] Mixed numeric types are compared according to their numeric value, so 0 equals 0.0, etc.

Footnotes