python高阶函数map reduce filter sorted_Python函数式编程--高阶函数(map/reduce)+filter + sorted...

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

>>> abs(-10)

10

>>> f = abs

>>> f(-10)

10

## 说明变量f现在已经指向了abs函数本身。直接调用abs()函数和调用变量f()完全相同。

传入函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

高阶函数，就是让函数的参数能够接收别的函数

f = abs

def func(a,b , f):

return f(a)+f(b) #当我们调用add(-5, 6, abs)时，参数a，b和f分别接收-5，6和abs

map/reduce

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

li = [1,2,3,4,5,6,7,8,9]

def f(x):

return x*x

if __name__ == '__main__':

l = list(map(f,li)) # map 类型转化乘 list

print(l)

#[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

li = [1,2,3,4,5,6,7,8,9]

l = []

for i in li:

l.append(i*i)

print(l)

#[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()作为高阶函数，事实上它把运算规则抽象,可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

li = [1,2,3,4,5,6,7,8,9]

l = list(map(str,li))

print(l)

#['1', '2', '3', '4', '5', '6', '7', '8', '9']

reduce

如果想进行求和 map （add，list） 肯定不行 而reduce 的作用是用于 f((x1,x2),x3),x4) 两个两个进行求和

from functools import reduce

li = [1,2,3,4,5,6,7,8,9]

def f(x,y):

return x+y

sum = reduce(f,li)

print(sum) #功能跟sum()一致

#45

#[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场

from functools import reduce

li = [1,2,3,4,5,6,7,8,9]

def f(x,y):

return x*10+y

con = reduce(f,li)

print(con)

#123456789

#字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int

#第一种

x = int(x)

y = int(y)

#第二种

from functools import reduce

li = ['0','1','2','3','4','5','6','7','8','9']

def f(x,y):

return x*10+y

def disg(x):

m = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

return m[x]

con = reduce(f,map(disg,li))

print(con)

#123456789

upper()——所有字母大写

lower()——所有字母小写

capitalize()——首字母大写，其他字母小写

title()——所有单词首字母大写，其他小写

map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：

def normalize(name):

name = name.title()

return name

'123.456'转换成浮点数123.456

可以把数字迭代乘一个整数然后除以几个小数位

from functools import reduce

def return_num(x):

lis={'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}

return lis[x]

def fn(x, y):

return x * 10 + y

def str2float(s):

n = s.index('.')

s = s.replace('.','')

float = pow(10,len(s) - n)

x =reduce(fn,map(return_num,s))

return x / float

filter

Python内建的filter()函数用于过滤序列。

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素

def is_odd(n):

return n % 2 ==1

if __name__ == '__main__':

lis = [1,2,3,4,5,6,7,8,9]

l = filter(is_odd,lis)

print(list(l))

def not_empty(s):

return s and s.strip()

print(list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])))

'''

关键知识点A：and

在布尔上下文中从左到右演算表达式的值。

0、''、[]、()、{}、None 在布尔上下文中为假，其它任何东西都为真。

关键知识点B：filter 函数

filter 函数的作用是“根据返回值是True还是False决定保留还是丢弃该元素。”（True的留下 False的去除）

因此：

如果s = None，表达式的结果是False，filter过滤该队列元素

如果s = ''，表达式的结果是False，filter过滤该队列元素

如果s = 空格，s.strip()的结果是''，表达式的结果是False，filter过滤该队列元素

如果s = 其他，表达式的结果是Ture，filer保留该队列元素（并不是s.strip后的元素）

'''

惰性计算（Lazy evaluation），是指仅仅在真正需要执行的时候才计算表达式的值。充分利用其特性可以带来很多便利。

避免不必要的计算，带来性能的提升。

对于Python中的条件表达式 if x and y,在x为false的情况下y表达式的值将不再计算。而对于if x or y，当x的值为true的时候将直接返回，不再计算y的值。因此编程中可以利用该特性，在 and逻辑中，将小概率发生的条件放在前面或者在or逻辑中，将大概率发生的时间放在前面，有助于性能的提升。

节省空间，使得无线循环的数据结构成为可能。

Python中最经典的使用延迟计算的例子就是生成式表达器了，它尽在每次需要计算的时候才通过yield产生所需要的元素。

例：斐波那契数列在Python中实现起来很容易，使用yied对于while True也不会导致其他语言中所遇到的无线循环问题。

lambda 表达式https://www.bilibili.com/video/av24639639/

def primes():

yield 2

it = odd_nums()

while(True):

n = next(it)

yield n #返回每次清洗后的序列的第一项

it = filter(not_primes(n),it) # 过滤 N 的倍数

def not_primes(n):

return lambda x: x% n>0 # 过滤背书的lambda 表达式

def odd_nums():

n = 1

while(True):

n = n +2

yield n

# 打印1000以内的素数:

for n in primes():

if n < 1000:

print(n)

else:

break

回数

def is_palindrome(n):

x = str(n)

s = 0

e = len(x)-1

while s < e :

if x[s]!= x[e]:

return False

break

s = s + 1

e = e - 1

return True

sorted

可以比较数字 也可以比较字符

a = [1 , 2, 4, -6 ,7 , 0]

a= sorted(a, key=abs)

print(a)

字符串排序 ：默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面

a = ['a', 't','b','X','M','c','r','G','d','f','Z']

a = sorted(a)

b = sorted(a , key = str.lower)

print(a)

print(b)

#a ['G', 'M', 'X', 'Z', 'a', 'b', 'c', 'd', 'f', 'r', 't']

#b ['a', 'b', 'c', 'd', 'f', 'G', 'M', 'r', 't', 'X', 'Z']

参数 reverse= true 反向排序

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

def by_name(t):

return t[0]

L2 = sorted(L, key=by_name)

print(L2)