在Python所有的数据结构中，list具有重要地位，并且非常的方便，这篇文章主要是讲解list列表的高级应用，基础知识可以查看博客。
此文章为python英文文档的翻译版本，你也可以查看英文版：https://docs.python.org/2/tutorial/datastructures.html
use a list as a stack: #像栈一样使用列表
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
stack = [3, 4, 5] stack.append(6) stack.append(7) stack [3, 4, 5, 6, 7] stack.pop() #删除最后一个对象 7stack [3, 4, 5, 6] stack.pop() 6stack.pop() 5stack [3, 4] |
use a list as a queue: #像队列一样使用列表
|
1
2
3
4
5
6
7
8
9
10
|
> from collections import deque #这里需要使用模块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 arrivaldeque(['Michael', 'Terry', 'Graham']) |
three built-in functions： 三个重要的内建函数
filter(), map(), and reduce().
1）、filter(function, sequence):：
按照function函数的规则在列表sequence中筛选数据
|
1
2
3
4
|
> def f(x): return x % 3 == 0 or x % 5 == 0... #f函数为定义整数对象x,x性质为是3或5的倍数> filter(f, range(2, 25)) #筛选[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24] |
2）、map(function, sequence):
map函数实现按照function函数的规则对列表sequence做同样的处理，
这里sequence不局限于列表，元组同样也可。
|
1
2
3
4
|
> def cube(x): return x*x*x #这里是立方计算 还可以使用 x**3的方法...> map(cube, range(1, 11)) #对列表的每个对象进行立方计算[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000] |
注意：这里的参数列表不是固定不变的，主要看自定义函数的参数个数，map函数可以变形为：def func(x,y) map(func,sequence1，sequence2） 举例：
|
1
2
3
4
5
|
seq = range(8) #定义一个列表> def add(x, y): return x+y #自定义函数，有两个形参...> map(add, seq, seq) #使用map函数，后两个参数为函数add对应的操作数，如果列表长度不一致会出现错误[0, 2, 4, 6, 8, 10, 12, 14] |
3）、reduce(function, sequence):
reduce函数功能是将sequence中数据，按照function函数操作，如 将列表第一个数与第二个数进行function操作，得到的结果和列表中下一个数据进行function操作，一直循环下去…
举例:
|
1
2
3
4
|
def add(x,y): return x+y...reduce(add, range(1, 11))55 |
List comprehensions：
这里将介绍列表的几个应用：
squares = [x**2 for x in range(10)]
#生成一个列表，列表是由列表range(10)生成的列表经过平方计算后的结果。
[(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)] 这里是生成了一个列表，列表的每一项为元组，每个元组是由x和y组成，x是由列表[1,2,3]提供，y来源于[3,1,4]，并且满足法则x!=y。
Nested List Comprehensions：
这里比较难翻译，就举例说明一下吧：
|
1
2
3
4
5
6
7
|
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]] |
这里两层嵌套比较麻烦，简单讲解一下：对矩阵matrix，for row in matrix来取出矩阵的每一行，row[i]为取出每行列表中的第i个（下标），生成一个列表，然后i又是来源于for i in range(4) 这样就生成了一个列表的列表。
The del statement:
删除列表指定数据，举例：
|
1
2
3
4
5
6
7
8
9
10
|
> a = [-1, 1, 66.25, 333, 333, 1234.5]>del a[0] #删除下标为0的元素>a[1, 66.25, 333, 333, 1234.5]>del a[2:4] #从列表中删除下标为2，3的元素>a[1, 66.25, 1234.5]>del a[:] #全部删除 效果同 del a>a[] |
Sets: 集合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']>>> fruit = set(basket) # create a set without duplicates>>> fruitset(['orange', 'pear', 'apple', 'banana'])>>> 'orange' in fruit # fast membership testingTrue>>> 'crabgrass' in fruitFalse>>> # Demonstrate set operations on unique letters from two words...>>> a = set('abracadabra')>>> b = set('alacazam')>>> a # unique letters in aset(['a', 'r', 'b', 'c', 'd'])>>> a - b # letters in a but not in bset(['r', 'd', 'b'])>>> a | b # letters in either a or bset(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])>>> a & b # letters in both a and bset(['a', 'c'])>>> a ^ b # letters in a or b but not bothset(['r', 'd', 'b', 'm', 'z', 'l']) |
Dictionaries：字典
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
>>> 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() #取字典的所有key值['guido', 'irv', 'jack']>>> 'guido' in tel #判断元素的key是否在字典中True>>> tel.get('irv') #取数据4127 |
也可以使用规则生成字典：
|
1
2
|
>>> {x: x**2 for x in (2, 4, 6)}{2: 4, 4: 16, 6: 36} |
enumerate()：遍历元素及下标
enumerate 函数用于遍历序列中的元素以及它们的下标：
|
1
2
3
4
5
6
|
>>> for i, v in enumerate(['tic', 'tac', 'toe']):... print i, v...0 tic1 tac2 toe |
zip():
zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。
|
1
2
3
4
5
6
7
8
|
>>> 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. |
有关zip举一个简单点儿的例子：
|
1
2
3
4
5
6
7
8
9
|
>>> a = [1,2,3]>>> b = [4,5,6]>>> c = [4,5,6,7,8]>>> zipped = zip(a,b)[(1, 4), (2, 5), (3, 6)]>>> zip(a,c)[(1, 4), (2, 5), (3, 6)]>>> zip(*zipped)[(1, 2, 3), (4, 5, 6)] |
reversed():反转
|
1
2
3
|
>>> for i in reversed(xrange(1,10,2)):... print i... |
sorted(): 排序
|
1
2
3
4
5
6
7
8
|
> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']> for f in sorted(set(basket)): #这里使用了set函数... print f...applebananaorangepear |
python的set和其他语言类似, 是一个 基本功能包括关系测试和消除重复元素.
To change a sequence you are iterating over while inside the loop (for example to duplicate certain items), it is recommended that you first make a copy. Looping over a sequence does not implicitly make a copy. The slice notation makes this especially convenient:
|
1
2
3
4
5
6
7
|
>>> 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'] |
以上就是本文的全部内容，希望对大家的学习有所帮助。
