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），是指仅仅在真正需要执行的时候才计算表达式的值。充分利用其特性可以带来很多便利。

1. 避免不必要的计算，带来性能的提升。
   对于Python中的条件表达式 if x and y,在x为false的情况下y表达式的值将不再计算。而对于if x or y，当x的值为true的时候将直接返回，不再计算y的值。因此编程中可以利用该特性，在 and逻辑中，将小概率发生的条件放在前面或者在or逻辑中，将大概率发生的时间放在前面，有助于性能的提升。
2. 节省空间，使得无线循环的数据结构成为可能。
   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)