一个表达式，函数体相对简单
• 不是一个代码块，仅仅是一个表达式
• 可以有参数，逗号隔开

# lambda表达式的用法
#以lambda开头
#紧跟一定的参数
#参数后用冒号和表达式主题隔开
#没有return
stm = lambda x:100*x
print(stm(89))

>>>
8900

----
stmt = lambda x,y,z:x+y*12+z*90
print(stmt(100,34,5))

>>>
958

高阶函数

• 把函数作为参数来使用的函数

def funA():
print("In funA")
funB = funA
funB()

>>>
In funA

• 函数名称时变量
• funA和funB是指名称不一样
• 既然时变量就可以当参数传入

# funA是一个普通函数，
def funA(n):
return n * 100
def funC(n, f):
return f(n)*3
print(funC(9, funA))

>>>
2700

map

• 愿意就是映射，即把集合或者列表的元素，每一个人元素都按照一定规则进行操作，生成一个新的列表或者集合
• map函数时系统提供的具有映射功能的函数，返回值是一个迭代对象

l1 = [i for i in range(10)]
def mulTen(n):
return n*10
l2 = map(mulTen, l1) # l2的类型是可迭代的，直接用for、循环遍历
for i in l2:
print(i)

reduce

• 愿意时归并，缩减
• 把一个课迭代的内容最后归并为一个结果
• 对于作为参数的函数要求，必须有两个参数，必须有两个返回结果
• reduce([1,2,3,4,5]) == f(f(f(f(1,2),3),4),5)
• 需要导入functools包

from functools import reduce
def myAdd(x,y):
return x+y
# 先把前两个参数计算，返回值再与第三个数计算，返回值再与第四个数计算......
rst = reduce(myAdd, [1,2,3,4,5,6])
print(rst)

>>>
21

filter 函数

• 过滤函数，对一组数据进行过滤，符合条件的数据会生成一个新的列表返回
• 跟map相比较 相同：都对列表的每一个元素进行操作
• 不同： map生成一个跟原来数据相对应的新列表
• filter不一定，只要符合条件的才会进入新的数据集合

利用给定函数进行判断
• 返回值一定时布尔值
• 调用格式：filter(f,data),f时过滤函数，data数据

# 对于一个列表，对其进行过滤，偶数组成一个新列表
def isEven(a):
return a%2 == 0
l = [3,4,45,23,345,56,57,56,8,86,9,45,24,2]
rst = filter(isEven, l)
print([i for i in rst])

>>>
[4, 56, 56, 8, 86, 24, 2]

排序

• 把一个序列按照给定算法进行排序
• key：在排序前对每一个元素进行key函数运算

a = [23,43,5,65,77,68,99,732,4]
al = sorted(a, reverse = True) # reverse倒序
print(al)

>>>
[732, 99, 77, 68, 65, 43, 23, 5, 4]

-----
a = [-23, 34,54,675,78,-54,-76,3]
# 按照绝对值排序
al = sorted(a, key=abs, reverse = True)
print(al)

>>>
[675, 78, -76, 54, -54, 34, -23, 3]

-----
astr = ['dana', 'Danna','nihao','Taobao']
str = sorted(astr)
print(str)

>>>
['Danna', 'Taobao', 'dana', 'nihao']

返回函数

• 函数可以返回具体的值
• 也可以返回一个函数作为结果

# 函数作为返回值返回，被返回的函数在函数体内定义
def myF2():
def myF3():
print("In myF3")
return 3
return myF3
f3 = myF2()
print(type(f3))
print(f3)
print(f3())

>>>
<class 'function'>
<function myF2.<locals>.myF3 at 0x000001525EA8BC80>
In myF3
3

def myF4(*args):
def myF5():
rst = 0
for n in args:
rst += n
return rst
return myF5
f5 = myF4(1,2,3,4,5,6,7,8,9,0)
print(f5())

>>>
45

闭包closure

• 当一个函数在内部定义函数，并且内部的函数应用外部函数的参数或者局部变量，当内部函数被当作返回值的时候，相关参数和变量保存在返回的函数中，这种结果叫做闭包

# 闭包常见的坑
def count():
fs = []
for i in range(1,4):
def f():
return i*i
fs.append(f)
return fs
f1,f2,f3=count()
print(f1())
print(f2())
print(f3())
# 本来期望的是1，4，9

>>>
9
9
9

• 造成上述状况的是，返回函数引用了变量i，i并非立即执行，而是等到三个函数都返回的时候才同意使用，此时i已经变成3，最终调用的都是3*3
• 返回闭包是，返回函数不能引用任何循环变量
• 解决方案：在创建一个函数，用该函数的参数绑定循环变量的当前值，无论循环变量以后如何改变，已经绑定的函数参数值不再改变

def count2():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1,4):
fs.append(f(i))
return fs
f1,f2,f3 = count2()
print(f1())
print(f2())
print(f3())

>>>
1
4
9

装饰器decrator

• 在不改动函数代码的基础上无限制扩展函数功能的一种机制，本质上讲，装饰器是一个返回函数的高阶函数
• 装饰器的使用，使用@语法，即每次要扩展到函数定义前使用@+函数名

import time
def printTime(f):
def wrapper(*args, **kwargs):
print("Time:", time.ctime())
return f(*args, **kwargs)
return wrapper
# 在执行hello之前，先打印时间
@printTime # 借助于@语法糖
def hello():
print("hello world")
hello()

>>>
Time: Tue Jul 23 12:26:53 2019
hello world

----
# 手动执行装饰器
hello3 = printTime(hello)
hello3()

>>>
Time: Tue Jul 23 12:34:14 2019
Time: Tue Jul 23 12:34:14 2019
hello world

偏函数

# 新建一个函数，此函数是默认输入的字符串是16进制数字
# 把此字符串返回十进制的数字
def int16(x, base=16):
return int(x, base)
int16("12345")

>>>
74565

• 偏函数
• 参数固定的函数，相当于一个由特定参数的函数体
• functools.partial的作用是，把一个把函数某些函数固定，返回一个新函数

import functools
int16 = functools.partial(int, base=16)
print(int16("12345"))

>>>
74565