Python函数 map() reduce() filter() zip() sort() sorted()

map() 函数

将函数作用到序列的每个元素上，可以用列表生成式来实现同样的效果，map()是对列表的每一个元素做相同的操作

a=map(lambda x:x+100, [1,2,3,4,5])
list(a)
[101, 102, 103, 104, 105]


# 用列表生成式实现
a=[x+100 for x in [1,2,3,4,5]]
[101, 102, 103, 104, 105]

reduce() 函数

把一个函数作用在一个序列[x1, x2, x3, x4]上， 这个函数必须接收两个参数，reduce() 把结果继续和序列的下一个元素做累积计算， Python3 中，reduce()函数已经被从全局函数中移除了,被放置在fucntools模块里

# Python3 引入模块 functools
from functools import reduce


# 对序列做累加运算
reduce(lambda x,y:x+y, [1,2,3,4])
10


# 可以给定一个初始值 10
reduce(lambda x,y:x+y, [1,2,3,4], 10)
20

filter() 函数

对可迭代对象进行过滤，可以给定过滤的元素字段。filter() 的第一个参数是一个函数，该函数接收一个列表、元组、集合的每一个元素， 满足函数则保留下来，否则被过滤掉。看下面例子

a=[{'id': 2}, {'id': 6}, {'id': 8}]


# 保留 id 值为2或者6的元素
filter(lambda x:x["id"] in (2,6), a)


# 保留 id 值为6的元素
filter(lambda x:x["id"]==6, a)


# 保留不在 1,2,3 中任意一个的元素
a = set((1,2,3,4,5,6))
b = filter(lambda x:x not in (1,2,3), a)

zip() 函数

可以接受任意多个序列，它按照顺序取出每一个序列的值，组成一个一一对应的元组，然后将生成的多个元组在组成一个大的列表，看例子就明白了。

# 一一对应组成新的元组列表
zip([1, 2], ['a', 'b'])
[(1, 'a'), (2, 'b')]


# 一一对应组成新的元组列表， 新的元组大小根据最小的列表的大小确定
zip([1, 2, 3], ('a', 'b'))
[(1, 'a'), (2, 'b')]


# 一一对应组成新的元组列表， 最小的为空，所以结果也为空
zip([1, 2], ['a', 'b', 'c'], [])
[]

sort() 函数

sort()是 list 内置的方法，用于对list排序，所以sort() 只能是针对 list。

# 默认会对 list 使用升序排， 如果列表中包含有字符，则会用 ord() 函数将其转换成ASCII对应的值再比较。
a = [7, 6, 5, 4, 3]
a.sort()


# 对列表升序排序
a = [7, 6, 5, 4, 3]
a.sort(reverse=True)

• sort() 有三个默认参数 sort(cmp=None, key=None, reverse=False)
  1、cmp: 是一个全局的比较函数默认调用该函数来比较值的大小。将 list 的所有数两两比较，如果返回为正，则交换a,b的位置，即b在前，a在后；否则a在前，b在后（只适用于Python2.7）。
  2、key: 是一个函数，每一个列表的 元素 即将被比较的字符串都会被传递给该函数，由该函数进行对该元素处理（比如转换为小写等），然后返回进行比较（即根据key指定的字段值进行排序）。
  3、reverse : 是否倒叙

# 自己定义 cmp 然后传递给 sort 根据比较的值进行倒叙排序，不使用reverser参数。（只适用于Python2.7）
tmpcmp = lambda x,y : y-x
a = [1, 2, 3, 4, 5, 6]
a.sort(tmpcmp)


# 列表 a 中的每个元素是一个字典
a=[{'id': 2, "age":90}, {'id': 16}, {'id': 8}]
a.sort(key=lambda x:x['id'], reverse=True)
[{'id': 16}, {'id': 8}, {'age': 90, 'id': 2}]

sorted() 函数

python 内置的全局方法，用来对可迭代的序列排序生成新的序列。

从 sorted() 的定义 sorted(iterable, key=None, reverse=False)中，可以看出传递给它的是可迭代对象，key是指定排序元素，reverse是指定是否倒叙。

# sorted()简单排序（元组本身、列表本身）
a=[1,2,3,4]
sorted(a,reverse=True)


# sorted()元组、字典作为可迭代的元素
a = [('ycs', 23), ('yxx', 33), ('gxs', 10)]
sorted(a, key=lambda x:x[1])
[('gxs', 10), ('ycs', 23), ('yxx', 33)]


# 对列表元素为字典的排序
a=[{"age":23, "name":"yxx"}, {"age":23, "name":"gxs"}, {"age":10, "name":"ycs"}]
sorted(a, key=lambda x:x["age"])
[{'age': 10, 'name': 'ycs'},
 {'age': 23, 'name': 'yxx'},
 {'age': 23, 'name': 'gxs'}]
 
 
# student 列表的元素是一个用户对象， 用 key 关键字指定排序的字段，表示根据学生的年龄倒叙排序。
student = [user1, user2, user3]
sorted(student, key=lambda x:x.age, reverse=True)