Cookbook—函数

1. 编写可接受任意数量参数的函数

　　1.1 接受任意数量的位置参数，使用以 * 开头的参数，例如：

def avg(first, *args):
    print(args)
    return (first + sum(args)) / (1 + len(args))
                    
print(avg(1, 2))     1.5
print(avg(1, 2, 3, 4, 5))    3.0

　　args是一个元组，包含所有传过来的位置参数，代码在之后的计算中会将其视为一个元组序列来处理。

　　1.2 接收任意数量的关键字参数，使用以 ** 开头的参数，例如：

def func(name, **kwargs):
    print(kwargs)
    age = kwargs.get("age") or 18
    return f"name: {name}, age: {age}"


print(func("ming", gender="female"))            # name: ming, age: 18
print(func("ming", gender="female", age=22))    # name: ming, age: 22

　　kwargs是一个字典，包含所有传过来的关键字参数，代码中要是用到相关参数，可通过字典的方式取值。

　　一个函数想要同时接收任意数量的位置参数和关键字参数，只要联合使用 *  和 ** 即可，所有的位置参数都会放置在元组args中，所有的关键字参数都会放置在字典kwargs中。

　　1.3 在定义函数时，以 * 打头的参数后仍然可以跟其他参数，这种参数只能作为关键字参数使用，称为keyword-only参数。

def func2(*args, name):
    pass

func2("a", "b", "c", "d")   # TypeError: func2() missing 1 required keyword-only argument: 'name'
func2("a", "b", "c", name="d")

2. 将元数据信息附加到函数参数上

　　我们在编写好一个函数后，希望为参数附加上一些额外的信息（即函数的参数注解），这样其他人可以对函数的使用方法有更多的了解。

　　函数注解只会保存在函数的__annotations__属性中。

def func3(x: int, y: int=20) -> int:
    return x + y

print(func3(60))                # 80
print(func3("a", "b"))          # ab
print(func3.__annotations__)    # {'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}

　　上述函数注解即：x，y为int类型参数，y的默认值为20，输出的结果类型为int类型。

　　python 解释器应不会附加任何语法意义到这些参数注解上，他们既不是类型检查也不会改变Python的行为，所以即使声明形参x，y为int类型，但是调用函数的时候实参为字符串，函数也能正常执行。

　　尽管可以将任何类型的对象作为函数注解附加到函数定义上（比如数字，字符串，实例等），但是通常只有类和字符串才显得最有意义。

3. 定义带有默认值参数的函数

　　3.1 如何定义？只需要在定义函数参数时为参数赋值，并确保默认值参数出现在形参最后即可。

def func4(a, b=50):
    return a + b

print(func4(10))
print(func4(10, 100))

　　给默认参数赋值时的值一定是不可变对象，比如 None，True，False，数字或者字符串或者元组。否则默认值在函数体之外被修改了，那么这种修改会对参数的默认值产生持续影响。

def func5(a, score_list=[]):
    return score_list

result1 = func5(25)
print(result1)      # []
result1.append(50)
result1.append(100)

result2 = func5(25)
print(result2)      # [50, 100]  因为result1和score_list的内存地址一样，result1添加值导致score_list也被修改了，所以result2再次调用函数时，对应的score_list已经是修改过的了，已经不再是空[]了

　　3.2 如果默认值是可变容器（list，set，dict）时，此时应该把None作为默认值，在函数体里面再对默认参数处理。

　　在函数体对默认参数处理时一定是使用 is 操作符，如果使用 if not score_list: pass，那么输入值为空list，空dict，空字符串也会被判定为False。

def func6(score_list=None):
    if score_list is None:
        score_list = []
        return score_list

　　这样 result1=func6()，实际上result1的内存地址对应的是函数体里面重新赋值的空 [] 的内存地址，不会对参数的默认值产生影响。

　　3.3 如果不打算提供默认值，只是想检测可选参数是否被赋予了某个特定的值，可以用object()创建一个私有实例。

_no_value_var = object()
def func7(score_list=_no_value_var):
    if score_list is _no_value_var:
        print("there is no varies!")

func7()

　　在函数中检测是否对可选参数提供了某个特定值，我们不能用None，0，False等作为默认值来检测用户是否提供了参数，因为这些值都是完全合法的参数，用户极有可能把它们当做入参使用。这时我们可以用object()创造一个独特的私有变量，因为对用户来说把这个实例变量作为入参是几乎不可能的，所以它就成为了一个恶意用来安全比较的值。

4. 匿名函数中绑定变量的值

　　4.1 定义匿名函数时，给定默认值：就行普通函数的默认值参数一样。

f = lambda x, y=10: x + y
print(f(10))        # 20
print(f(10, 40))    # 50

　　4.2 我们在定义匿名函数时，希望对某个变量进行绑定。

func_list = [lambda x: x+n for n in range(5)]
for f in func_list:
    print(f(0))

　　仔细思考一下，输出的结果是什么？为什么是5个4呢？这是因为lambda表达式中用到的n是一个自由变量，n只有在执行时才进行绑定而不是定义的时候绑定，所以上面的func_list的5个元素都是x+n，在for循环遍历func_list时，n已经等于4了，所以每一次for循环都是return 0+4！如果我们在定义匿名函数时进行变量绑定，将某个值作为默认参数和变量进行绑定，这样匿名函数在定义时就能捕获到n的值了，如下：

func_list2 = [lambda x, n=n: x+n for n in range(5)]
for f in func_list2:
    print(f(0))

　　在每次遍历 range(5) 时，都把变量n的值作为默认参数赋值给匿名函数，匿名函数中的变量n的内存地址指向该次遍历值得内存空间，所以得到的结果就为0，1，2，3，4

5. 让带有N个参数的可调用对象能够以较少的参数个数调用

　　对下面一组数据进行排序（如果值小于20就加100）。

info = {'lilee': 25, 'age': 24, 'phone': 12}

def add_val(x):
    return x[1] + 100 if x[1] < 20 else x[1]

print(sorted(info.items(), key=add_val))        # [('age', 24), ('lilee', 25), ('phone', 12)]

　　上面的100是我们规定好了的，如果让用户自己输入值呢？那就在add_val函数中再增加一个参数，但是在sorted函数中就会报错，因为sorted()方法可接受一个key参数用来做自定义的排序处理，但是这个key只能和接受单个参数的函数一个工作，因此不能在add_val中添加第二个参数！

　　如果需要减少交互函数的入参个数，应该使用 functools.partial()，函数partial()允许我们给一个或多个参数指定固定的值，以此减少需要提供给交互函数的参数数量。上面的排序就可以重新实现：

def add_val_2(x, y, z):
    return x[1] + y + z if x[1] < 20 else x[1]

info = {'lilee': 25, 'age': 24, 'phone': 12}

from functools import partial
print(sorted(info.items(), key=partial(add_val_2, y=50, z=100)))

　　例1：以多进程异步方式计算某个结果，并将这个结果传递个给一个回调函数，还毁掉函数可接受这个结果以及一个可选的日志参数：

import logging
from multiprocessing import Pool
from functools import partial

logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger("test")

def add(x, y):
    return x + y

def output_result(result, log=None):
    if log is not None:
        log.debug(f"Get result: {result}")
    else:
        print(f"Get result: {result}")

if __name__ == '__main__':
    p = Pool()
    # p.apply_async(add, args=(3, 4), callback=output_result)
    p.apply_async(add, args=(3, 4), callback=partial(output_result, log=log))
    p.close()
    p.join()

　　用 partial() 就可以继续给回调函数传多个参数（log对象或其他参数），非常实用！

　　注意：有时候使用lambda表达式也可以来代替 partial()，所以上面的表达式也可以这么写：

sorted(info.items(), key=lambda x: add_val_2(x, y=0, z=100))
p.apply_async(add, args=(3, 4), callback=lambda x: output_result(x, log=log))

　　这些代码也可以正常运行，但是却显得非常啰嗦，让人读起来特别地费解。使用partial()会使你的意图更加明确，partial()即为某些函数的参数提供默认值。

6. 用函数替代只有单个方法的类

class PerInfo:
    
    def __init__(self, name):
        self.name = name

    def get_name(self):
        return self.name

p = PerInfo("ming")
name = p.get_name()

　　我们使用单个方法（不包括__init__()方法）的类的唯一原因就是保存额外的状态给类的方法使用。但是一个类里只有一个方法是不是有点大题小做了？使用嵌套函数或者说闭包常常会显得更加优雅。

def person_info(name, baseage=15):
    def get_age():
        return f"{name} age is {baseage}"
    return get_age()

age = person_info("gang")
print(age)

　　闭包就是一个函数，但是它还保存着额外的变量环境，是的这些个变量可以在函数中使用。闭包的核心特性就是他可以记住定义闭包时的环境。所以在编写代码中遇到需要附加额外的状态给函数时，我们可以考虑使用闭包。

7. 访问定义在闭包内的变量

　　7.1 为函数添加属性

　　函数定义好之后，我们能否继续为这个函数添加一些属性？

def func():
    return "123"

func.name = "get_123"
print(func())    # 123
print(func.name)        # get_123

　　显然是可以的，这是因为我们在定义函数时，关键字def 有两个功能：它可以创建一个函数对象；然后把这个函数对象赋值给一个变量（即我们的函数名）。函数的属性以字典的形式存储，key为属性名，value为属性值，可以在定义函数的同时定义属性，也可以在定义函数完成之后再定义函数属性（函数属性可以用过__dict__()查看所有属性）

def func():
    return "123"
print(func.__dict__)    # {}
func.name = "get_123"
print(func.__dict__)    # {'name': 'get_123'}

　　7.2 访问并修改闭包内的变量

　　在闭包内层定义的变量对于外界来说是完全隔离的，但是可以通过编写存取函数（如下示例的 get_n，set_n）并将它们作为函数属性附加到闭包上来提供对内存变量的访问支持，如下：

def sample():
    n = 0
    def func():
        print(f"n={n}")

    def get_n():
        return n

    def set_n(value):
        nonlocal n
        n = value
    func.get_n = get_n
    func.set_n = set_n
    return func

f = sample()
f()
print(f.get_n())    # 0
f.set_n(100)
print(f.get_n())    # 100

　　这里主要用到了两个特性：nonlocal声明使得编写函数来修改内层变量成为可能；将存取函数以属性的方式附加到闭包函数上，使闭包函数可以直接调用。

 8. 在回调函数中携带额外的状态参数

　　我们在编写使用回调函数的代码时，希望回调函数可以携带额外的状态参数以便在回调函数内部使用。

def apply_async(func, args, callback=None):
    result = func(*args)
    callback(result)

def add(x, y):
    return x + y

def print_result(result):
    print(f"the final result is {result}")

apply_async(add, args=(2, 5), callback=print_result)

　　上述的回调函数的入参只能是add()的返回结果，无法携带第二个或多个参数，有多种方式可以解决这个问题。

　　1. 使用partial() 或 lambda匿名函数来为回调函数提供多个参数，详细内容可参考上述第5条；

　　2. 在回调函数时使用绑定类实例方法：

def apply_async(func, args, callback=None):
    result = func(*args)
    callback(result)

def add(x, y):
    return x + y

class ResultHandler:
    def __init__(self, n):
        self.multi_value = n

    def handler(self, result):
        final_result = result * self.multi_value
        print(f"the final result is {final_result}")

n = int(input("input multi_value: "))
hd = ResultHandler(n)
apply_async(add, args=(2, 5), callback=hd.handler)

　　3.作为类的替代方案，也可以使用闭包来捕获状态：

def apply_async(func, args, callback=None):
    result = func(*args)
    callback(result)

def add(x, y):
    return x + y

def result_handler(n):
    multi_value = n
    def result_multi(result):
        nonlocal multi_value
        multi_value += 1
        final_result = result * multi_value
        print(f"the final result is {final_result}")
    return result_multi

n = int(input("input multi_value: "))               # 10
handler = result_handler(n)
apply_async(add, args=(2, 5), callback=handler)     # 77
apply_async(add, args=(2, 5), callback=handler)     # 84
apply_async(add, args=(2, 5), callback=handler)     # 91

　　4. 利用生成器的方式实现（yield关键字用法参考 https://www.cnblogs.com/wushuaishuai/p/9212812.html）：

def apply_async(func, args, callback=None):
    result = func(*args)
    callback(result)

def add(x, y):
    return x + y

def func_count():
    sequence = 0
    while 1:
        result = yield
        sequence += 1
        print(f"times:{sequence}, result value is {result}")

handler = func_count()
next(handler)
apply_async(add, args=(2, 5), callback=handler.send)    # times:1, result value is 7
apply_async(add, args=(2, 5), callback=handler.send)    # times:2, result value is 7

　　首先实现一个生成器，然后调用next()方法，使程序执行到 result=yield这句，因为是一个yield语句，所以整个执行过程被挂起，next()的返回值为yield后面的内容，即None；然后在执行send()方法时，将表达式yield的返回值定义为send()方法的参数值（即经过add()计算后的result值），即程序中的result=add()返回值，然后程序继续执行后面的语句，+=1...print...

　　注意：在使用生成器的send()方法时，一定要先对其调用一次next()，使程序运行到yield处然后挂起。

 9. 内联回调函数

　　我们在编写使用回调函数代码时，总是担心小型函数在代码中大肆泛滥，程序的控制流就会因此而失控，比如下面的这几段代码。

# 回调函数功能：将计算出的结果打印出来
def apply_sync(func, args, callback):
    result = func(*args)
    callback(result)

def add(a, b):
    return a + b

def printout(result):
    print(result)

apply_sync(add, args=(2, 3), callback=printout)

　　我们希望能够有某种方法使代码看起来更像一般的过程式步骤，如何实现？我们可以通过生成器和协程将回调函数内联到一个函数中：

from functools import wraps
from queue import Queue

class Async:
    def __init__(self, func, args):
        self.func = func
        self.args = args

def apply_sync(func, args, callback):
    result = func(*args)
    callback(result)

def add(a, b):
    return a + b

def inline_async(func):
    @wraps(func)
    def wrapper(*args):
        result = func(*args)
        result_queue = Queue()
        result_queue.put(None)
        while True:
            result_from_queue = result_queue.get()
            try:
                a = result.send(result_from_queue)
                apply_sync(a.func, a.args, callback=result_queue.put)
            except StopIteration:
                break
    return wrapper

@inline_async
def test():
    r1 = yield Async(add, (2, 3))
    print(r1)
    r2 = yield Async(add, ("hello", "world"))
    print(r2)

test()

　　除了上面特殊的装饰器和对yield的使用外，我们发现代码中根本没有出现回调函数（它们事不过隐藏在装饰器里而已）。

　　程序的核心点在inline_async()装饰器函数中：对于生成器函数的所有yield语句，装饰器都会逐条进行跟踪，一次一个。我们创建了一个队列来保存结果，初始值我们用None来填充，当执行到send(None)时， 生成器函数开始执行并在yield处挂起，然后用变量a来接收yield后面的值（即Async的实例），紧接着执行spply_sync()，并将结果put入队列里，之后通过循环将结果从队列中取出，然后send()发送给生成器，生成器紧接着执行yield表达式并将yield表达式的返回值定义为取出来的结果，用变量接收，然后打印出来，实现回调函数的功能；如果从队列中什么都没有get()到，操作就会阻塞，等待之后某个时刻会有结果到来。至于结果如何产生就取决于apply_async()主体函数的实现了。