python 函数

多态

Python 不用考虑输入的数据类型，而是将其交给具体的代码去判断执行，
同样的一个函数（比如这边的相加函数 my_sum()），
可以同时应用在整型、列表、字符串等等的操作中。

函数嵌套的作用

1、保证内部函数的隐私
2、提高程序的运行效率
常用情况（检查输入是否合法）

# 数据库连接
def connect_DB():
    def get_DB_configuration():
        ...
        return host, username, password
    conn = connector.connect(get_DB_configuration())
    return conn

# 参数校验
def factorial(input):
    # validation check
    if not isinstance(input, int):
        raise Exception('input must be an integer.')
    if input < 0:
        raise Exception('input must be greater or equal to 0' )

    def inner_factorial(input):
        if input <= 1:
            return 1
        return input * inner_factorial(input-1)
    return inner_factorial(input)
print(factorial(5))

函数变量作用域

nonlocal --->修改全局变量参数
global---->声明 函数内部的变量，就是之前定义的全局变量

闭包

闭包和嵌套函数类似，
不同的是，这里外部函数返回的是一个函数，而不是一个具体的值。
返回的函数通常赋于一个变量，这个变量可以在后面被继续执行调用。
使用闭包的一个原因，是让程序变得更简洁易读

闭包常常和装饰器（decorator）一起使用。

def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是exponent_of函数

square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方 

print(square(2))  # 计算2的平方
print(cube(2)) # 计算2的立方
# 输出
4 # 2^2
8 # 2^3

匿名函数

lambda 表达式
lambda argument1, argument2,... argumentN : expression

第一，lambda 是一个表达式（expression），并不是一个语句（statement）。
第二，lambda 的主体是只有一行的简单表达式，并不能扩展成一个多行的代码块
减少代码的重复性；
模块化代码。

python 函数式编程

map()、filter() 和 reduce()通常结合匿名函数 lambda 一起使用。

map(function, iterable) 函数，对 iterable 中的每个元素，都运用 function 这个函数，最后返回一个新的可遍历的集合。

l = [1, 2, 3, 4, 5]
new_list = map(lambda x: x * 2, l) # [2， 4， 6， 8， 10]

filter(function, iterable) 函数，
它和 map 函数类似，function 同样表示一个函数对象。
filter() 函数表示对 iterable 中的每个元素，都使用 function 判断，
并返回 True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合

l = [1, 2, 3, 4, 5]
new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]

reduce(function, iterable) 函数，它通常用来对一个集合做一些累积操作。

from functools import reduce
l = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120

例题：

根据值进行由高到底的排序
d = {'mike': 10, 'lucy': 2, 'ben': 30}
anwser:
sorted(d.items(), key=lambda x: x[1], reverse=True)