python--map、reduce、filter、sorted

• map
• reduce
• filter
• sorted

map

map()函数是 Python 内置的高阶函数，它接收一个函数 f 和一个list(或多个 list,但list个数与f函数的参数个数必须相等)，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
简而言之，map（）函数可以把一个list，转换为另一个新的list，它并不改变原来的list。

1.简单使用

# 1.map(function, iterable, ...)
# 根据提供的函数对指定序列做映射
# function需要几个参数，后面就需要跟几个可迭代变量iterable
# 返回值是一个迭代器
map(lambda x: x ** 2, [1, 2, 3, 4, 5])

# 多参数时，以短的为准
list(map(lambda x, y: x + y, ['a', 'b'], ['c', 'd', 'e'])) =》['ac', 'be']

2.特殊用法：做类型转换

l = map(int,'1234')
for i in l:
    print(type(i))
    print(i)
a=(1,2,3,4,5)
b=[1,2,3,4,5]
c="zhangkang"

la=map(str,a)
lb=map(str,b)
lc=map(str,c)

reduce

格式：reduce( func, seq[, init] )=>list
注意：
（1）python3需要这样导入：from functools import reduce
（2）对比与map返回迭代器，这里由于结果是一个值，所以返回的不是迭代器，是基本数据类型

reduce函数即为化简，它是这样一个过程：每次迭代，将上一次的迭代结果（第一次时为init的元素，如没有init则为seq的第一个元素）与下一个元素一同执行一个二元的func函数。在reduce函数中，init是可选的，如果使用，则作为第一次迭代的第一个元素使用。

简单来说，可以用这样一个形象化的式子来说明
reduce( func, [1, 2,3,4] ) = func(func( func(1, 2), 3),4)

举个例子来说，阶乘是一个常见的数学方法，Python中并没有给出一个阶乘的内建函数，我们可以使用reduce实现一个阶乘的代码。

# reduce实现累加--无初始值init
>>> from functools import reduce
>>> reduce(lambda x,y:x+y, range(0,101))
5050
# reduce实现累加--有初始值init
>>> reduce(lambda x,y:x+y, range(0,101), 100)
5150

# reduce实现阶乘
>>> reduce(lambda x,y:x*y, range(1,5))
24

filter

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

格式：filter(function, iterable)

把iterable中的每个值传入function函数，保留return值为True的值放入结果列表中，是一个迭代器

#过滤出列表中的所有奇数：
def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist) ==》[1, 3, 5, 7, 9]

# 过滤掉后缀为sb的人名--去掉sb
name = ['alex', 'nihao_sb', 'haha', 'haha_sb']
list(filter(lambda x:not x.endswith('sb'), name))
# 过滤出后缀为sb的人名--保留sb
name = ['alex', 'nihao_sb', 'haha', 'haha_sb']
list(filter(lambda x: x.endswith('sb'), name))

# 过滤出age大于1001的
name = [
    {"name": 'alex', 'age': 1000},
    {"name": 'wupeiqi', 'age': 10000},
    {"name": 'yaunhao', 'age': 9000},
    {"name": 'linhaifeng', 'age': 18}
]
print(list(filter(lambda x: x['age'] >= 1001, name)))
# 或者也可以用列表解析式
l = [i for i in name if i.get('age') >= 1001]

sorted

sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

格式：sorted(iterable, key=None, reverse=False)

iterable – 可迭代对象。
key --主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
res=>返回重新排序的列表(一个新列表，不会影响原列表)。

示例：

>>>sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]  

你也可以使用 list 的 list.sort() 方法。这个方法会修改原始的
list（返回值为None）。通常这个方法不如sorted()方便-如果你不需要原始的
list，list.sort()方法效率会稍微高一些；另一个区别在于list.sort() 方法只为 list 定义。而 sorted()
函数可以接收任何的 iterable。

>>>a=[5,2,3,1,4]
>>> a.sort()
>>> a
[1,2,3,4,5]

sort和sorted的区别
虽然python3中sort()和sorted()都可以用来排序，但二者有以下两个最主要的区别：
sort只能应用在列表list上，而sorted可以对所有可迭代的对象进行排序的操作
sort方法会在原list上直接进行排序，不会创建新的list。而sorted方法不会对原来的数据做任何改动，排序后的结果是新生成的。如果我们不需要原来的数据而且数据是list类型，可以用sort方法，能够节省空间。否则要用sorted方法。

sort 在python2中，sort方法可以有3个参数：key、cmp和reverse。但在python3中取消了cmp这个参数，只有key和reverse两个可选参数。参数reverse指定排序是正序还是倒序，默认是正序FALSE，不在多说。参数key指定了只含一个参数的方法，这个方法用来从列表的每个元素中提取比较键。可以看看下面几个例子：

1.通过元素长度排序
> strlist = ["bbb","ccc","bac","ab","ba"]
strlist.sort(key=len)
print(strlist)==》['ab', 'ba', 'bbb', 'ccc', 'bac']

2.通过元素的字符顺序
strlist = ["bbb","BBB","bAc","ab","bac"]
strlist.sort()
print(strlist)==》['BBB', 'ab', 'bAc', 'bac', 'bbb']
strlist.sort(key=str.lower)
print(strlist)==》['ab', 'bAc', 'bac', 'BBB', 'bbb']

3.list里的元素是一个字典，通过字典的某个属性值排序。下面是通过学生的年龄排序
student = [{"name": "a", "age": 12, "score": 90},
           {"name": "b", "age": 13, "score": 84},
           {"name": "c", "age": 14, "score": 85},
           {"name": "d", "age": 15, "score": 89},
           {"name": "e", "age": 15, "score": 92},
           {"name": "f", "age": 16, "score": 89},
           {"name": "g", "age": 16, "score":70},
           {"name": "h", "age": 16, "score":90},
           {"name": "i", "age": 12, "score": 88}]
student.sort(key=lambda a: a["age"])
4.存在二级排序:
(1)先按照age、再按照score
student.sort(key=lambda a: (a["age"],a["score"]))
(2)先按照score、再按照age
student.sort(key=lambda a: (a["score"],a["age"]))

sorted
所有可以迭代的对象都可以用sorted来进行排序，排序不会改变原来的对象。sorted接收3个参数：
sorted(iterable, *, key=None, reverse=False)
其中key，reverse和sort函数相同

student_tuples = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)]
new_tuples = sorted(student_tuples, key=lambda student: student[2])
print(student_tuples)==>[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(new_tuples)==>[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

由于这种含有key参数的方法很普遍，所以python中提供了一些方法使得访问器函数更加方便。比如operator模块中的itemgetter(), attrgetter()方法。

from operator import itemgetter
data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
# 对第2个元素排序
print(sorted(data, key=itemgetter(0))) ==>[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]
# 对第1个元素排序
print(sorted(data, key=itemgetter(1))) ==>[('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
# 先对元组的第2个元素进行排序，然后对第一个元素进行排序，形成多级排序
print(sorted(data, key=itemgetter(1, 0))) ==>[('blue', 1), ('red', 1), ('blue', 2), ('red', 2)]

student = [{"name": "a", "age": 12, "score": 90},
           {"name": "b", "age": 13, "score": 84},
           {"name": "c", "age": 14, "score": 85},
           {"name": "d", "age": 15, "score": 89},
           {"name": "e", "age": 15, "score": 92},
           {"name": "f", "age": 16, "score": 89},
           {"name": "g", "age": 16, "score":70},
           {"name": "h", "age": 16, "score":90},
           {"name": "i", "age": 12, "score": 88}]
sorted(student, key=itemgetter('score', 'age')))