8.Python（高阶函数，内置函数）

一、高阶函数

A.函数式编程

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

B.高阶函数

把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

C.匿名函数

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

f = lambda x: x * x
print(f)
print(f(5))

D.map()函数

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

def f(x):
   return x * x

r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))

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

map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x*x，还可以计算任意复杂的函数。

num = [1, 2, 3, 4]
res = map(lambda x: x+1, num)
print(list(res))

E.reduce()

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算.

from functools import reduce
num_l = [1, 2, 3, 100]
print(reduce(lambda x, y: x+y, num_l, 5)) #5是初始值
print(reduce(lambda x, y: x+y, num_l))

F.filter()

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

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

删掉偶数，保留奇数

def is_odd(n):
    return n % 2 == 1

print(list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])))

movie_people = ['alex_sb', 'wupeiqi_sb', 'linhaifeng', 'yuanhao_sb']
print(list(filter(lambda n: not n.endswith('sb'), movie_people)))

 G.匿名函数（这段完全抄的廖雪峰老师的）

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。

1.计算一个列表中每个元素的平方

print(list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])))

可以看出 lambda x:x*x 可以等效为

def f(x):
    return x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

2、用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

f = lambda x: x * x
print(f)
print(f(5))

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y

二、内置函数

https://www.runoob.com/python/python-built-in-functions.html

补充几个上面没有的

1.https://www.runoob.com/python3/python3-func-bytes.html

name='你好'
print(bytes(name,encoding='utf-8'))
print(bytes(name,encoding='utf-8').decode('utf-8'))

print(bytes(name,encoding='gbk'))
print(bytes(name,encoding='gbk').decode('gbk'))

2.

print(bin(10))#10进制->2进制
print(hex(12))#10进制->16进制
print(oct(12))#10进制->8进制

3.zip()函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

print(list(zip(('a','n','c'),(1,2,3))))
print(list(zip(('a','n','c'),(1,2,3,4))))
print(list(zip(('a','n','c','d'),(1,2,3))))

4.max（），min（）

（1） 类型为字符串，返回最大值

a='1,2,3,4'
print(max(a))

类型为列表（里面组成元素相同）同理

不同类型不能比较，比如一个字符和一个整形是无法比较的

（2）与zip（）结合使用

age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}
print(list(max(zip(age_dic.values(),age_dic.keys()))))

默认比较的是字典的key
 print(max(age_dic))

max（[(1,2),(2,3),(3,4)]）

按照元素里面元组的第一个元素的排列顺序，输出最大值（如果第一个元素相同，则比较第二个元素，输出最大值）据推理是按ascii码进行排序的

（3）max（）函数当传入一个可迭代对象，比如列表，则函数内部可自己进行循环，取出列表中的元素，然后进行比较大小。

people = [
    {'name': 'alex', 'age': 1000},
    {'name': 'wupei', 'age': 10000},
    {'name': 'yuanhao', 'age': 9000},
    {'name': 'linhaifeng', 'age': 18},
]

print(max(people, key=lambda dic: dic['age']))

#这个程序相当的绕，不要脸，不好看，而且我也不知道我理解的对不对
#首先max（）函数将people这个列表内部循环变成了 people[0],people[1],people[2],people[3]
#然后 把这些东西扔到后面的匿名函数，顺利取出age这个key下的value，
#最后，就开始进行比较，看到10000最大，打印出他所在的这个字典，也就是people列表中的一个元素
######最重要的是，我不知道为什么会这样，可能是固定用法，先死记住吧