python中list列表高级函数

use a list as a stack: #像栈一样使用列表

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]

use a list as a queue: #像队列一样使用列表

> 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
&＃39;Eric&＃39;
> queue.popleft()         # The second to arrive now leaves
&＃39;John&＃39;
> queue              # Remaining queue in order of arrival
deque([&＃39;Michael&＃39;, &＃39;Terry&＃39;, &＃39;Graham&＃39;])

three built-in functions： 三个重要的内建函数

filter(), map(), and reduce().
1）、filter(function, sequence):：
按照function函数的规则在列表sequence中筛选数据

> 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不局限于列表，元组同样也可。

> 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） 举例：

 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操作，一直循环下去…
举例:

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：
这里比较难翻译，就举例说明一下吧：

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:
删除列表指定数据，举例：

> 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: 集合

> basket = [&＃39;apple&＃39;, &＃39;orange&＃39;, &＃39;apple&＃39;, &＃39;pear&＃39;, &＃39;orange&＃39;, &＃39;banana&＃39;]
>>> fruit = set(basket)        # create a set without duplicates
>>> fruit
set([&＃39;orange&＃39;, &＃39;pear&＃39;, &＃39;apple&＃39;, &＃39;banana&＃39;])
>>> &＃39;orange&＃39; in fruit         # fast membership testing
True
>>> &＃39;crabgrass&＃39; in fruit
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set(&＃39;abracadabra&＃39;)
>>> b = set(&＃39;alacazam&＃39;)
>>> a                 # unique letters in a
set([&＃39;a&＃39;, &＃39;r&＃39;, &＃39;b&＃39;, &＃39;c&＃39;, &＃39;d&＃39;])
>>> a - b               # letters in a but not in b
set([&＃39;r&＃39;, &＃39;d&＃39;, &＃39;b&＃39;])
>>> a | b               # letters in either a or b
set([&＃39;a&＃39;, &＃39;c&＃39;, &＃39;r&＃39;, &＃39;d&＃39;, &＃39;b&＃39;, &＃39;m&＃39;, &＃39;z&＃39;, &＃39;l&＃39;])
>>> a & b               # letters in both a and b
set([&＃39;a&＃39;, &＃39;c&＃39;])
>>> a ^ b               # letters in a or b but not both
set([&＃39;r&＃39;, &＃39;d&＃39;, &＃39;b&＃39;, &＃39;m&＃39;, &＃39;z&＃39;, &＃39;l&＃39;])

Dictionaries：字典

>>> tel = {&＃39;jack&＃39;: 4098, &＃39;sape&＃39;: 4139}
>>> tel[&＃39;guido&＃39;] = 4127 #相当于向字典中添加数据
>>> tel
{&＃39;sape&＃39;: 4139, &＃39;guido&＃39;: 4127, &＃39;jack&＃39;: 4098}
>>> tel[&＃39;jack&＃39;] #取数据
4098
>>> del tel[&＃39;sape&＃39;] #删除数据
>>> tel[&＃39;irv&＃39;] = 4127   #修改数据
>>> tel
{&＃39;guido&＃39;: 4127, &＃39;irv&＃39;: 4127, &＃39;jack&＃39;: 4098}
>>> tel.keys()    #取字典的所有key值
[&＃39;guido&＃39;, &＃39;irv&＃39;, &＃39;jack&＃39;]
>>> &＃39;guido&＃39; in tel #判断元素的key是否在字典中
True
>>> tel.get(&＃39;irv&＃39;) #取数据
4127

也可以使用规则生成字典：

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

enumerate()：遍历元素及下标
enumerate 函数用于遍历序列中的元素以及它们的下标：

>>> for i, v in enumerate([&＃39;tic&＃39;, &＃39;tac&＃39;, &＃39;toe&＃39;]):
...   print i, v
...
0 tic
1 tac
2 toe

zip():
zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。

>>> questiOns= [&＃39;name&＃39;, &＃39;quest&＃39;, &＃39;favorite color&＃39;]
>>> answers = [&＃39;lancelot&＃39;, &＃39;the holy grail&＃39;, &＃39;blue&＃39;]
>>> for q, a in zip(questions, answers):
...   print &＃39;What is your {0}? It is {1}.&＃39;.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举一个简单点儿的例子：

>>> 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():反转

>>> for i in reversed(xrange(1,10,2)):
...   print i
...

sorted(): 排序

> basket = [&＃39;apple&＃39;, &＃39;orange&＃39;, &＃39;apple&＃39;, &＃39;pear&＃39;, &＃39;orange&＃39;, &＃39;banana&＃39;]
> for f in sorted(set(basket)):       #这里使用了set函数
...   print f
...
apple
banana
orange
pear

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:

>>> words = [&＃39;cat&＃39;, &＃39;window&＃39;, &＃39;defenestrate&＃39;]
>>> for w in words[:]: # Loop over a slice copy of the entire list.
...   if len(w) > 6:
...     words.insert(0, w)
...
>>> words
[&＃39;defenestrate&＃39;, &＃39;cat&＃39;, &＃39;window&＃39;, &＃39;defenestrate&＃39;]

以上就是本文的全部内容，希望对大家的学习有所帮助。

更多python中list列表高级函数相关文章请关注PHP中文网！