【Python Cookbook学习笔记】第七章函数

刺骨的言语ヽ痛彻心扉 2022-05-15 01:23 192阅读 0赞

# 7.1 可接受任意数量参数的函数
    # 注意，*参数后面仍然可以定义其他参数
    def b(x, *args, y, **kwargs):
        pass
    
    # 7.2 只接受关键字参数的函数(命名关键字参数，强制关键字参数)
    # 希望函数的某些参数强制使用关键字参数传递，将该参数放到某个*参数或者单个*后面就可以
    def recv(maxsize, *, block):
        print('receives a message')
    
    # recv(1024,True)  # TypeError: recv() takes 1 positional argument but 2 were given，说明只接收一个位置参数
    recv(1024,block=True)
    
    help(recv)
    
    # 7.3 给函数参数增加元信息
    def recv(maxsize:int, *, block:bool) -> int:
        print('receives a message')
    help(recv)
    recv(1024,block=True)
    
    # 7.4 函数返回多个值，直接用元组，return时不需要加()
    def func():
        return 1,2,3
    for j in func():
        print(j)
    
    # 7.5 定义有默认参数的函数
    x = 42
    def spam(a, b=x):
        print(a, b)
    spam(1)
    x = 23
    spam(1)  # 输出还是42，默认参数的值仅仅在函数定义的时候赋值一次
    # 默认参数的值应该是不可变的对象，不能是[]等可变的对象
    def spam(a, b=[]):
        print(b)
        return b
    x = spam(1)
    print(x)
    x.append(99)
    spam(1)
    # 判断一个参数是否是None的时候要用 is None，不能not b，否则空字符串、列表、元组、字典not的值都是True
    # 微妙的问题：判断某个可选参数是否被用户传递进来
    _no_vlue = object()
    def spam(a, b=_no_vlue):
        if b is _no_vlue:
            print('No b value supplied')
    spam(1)
    
    # 7.6定义匿名或内联函数
    # lambda只能定义单个表达式
    names = ['David Beazley', 'Brian Jones','Raymond Aettinger', 'Ned Batchelder']
    print(sorted(names,key=lambda name: name.split()[-1].lower()))
    
    # 7.7 匿名函数捕获变量值
    x = 10
    a = lambda y: x+y  # x在运行时才绑定值,而不是定义时绑定
    x = 20
    b = lambda y: x+y
    print(a(10),b(10))
    
    # 如果想lambda函数参数在定义时就捕获到值，将参数定义成默认参数
    x = 10
    a = lambda y,x=x: x+y  # x在运行时才绑定值,而不是定义时绑定
    x = 20
    b = lambda y,x=x: x+y
    print(a(10),b(10))
    
    x = 10
    def c(y):
        return x+y  # 结果一样，x在运行时才绑定值,而不是定义时绑定
    x = 20
    def d(y):
        return x+y
    print(c(10),d(10))
    
    # 7.8减少可调用对象的参数个数
    # functool.partial()
    from functools import partial
    def spam(a, b, c, d):
        print(a, b, c, d)
    s1 = partial(spam, 1)
    s1(2, 3, 4)
    s2 = partial(spam,d=10)
    s2(1,2,3)
    
    # 7.9 将单方法的类转化为函数:使用闭包
    from urllib.request import urlopen
    class UrlTemplate:
        def __init__(self, template):
            self.template = template
    
        def open(self, **kwargs):
            return urlopen(self.template)
    baidu = UrlTemplate('https://www.baidu.com')
    for line in baidu.open(name='IBM,APPL,FB',fields='sl1c1v'):
        # print(line.decode('utf-8'))
        pass
    
    # 7.10 带额外状态信息的回调函数
    def apply_async(func, args, *, callback):
        result = func(*args)
        callback(result)
    
    def print_result(result):
        print('Got',result)
    
    def add(x, y):
        return x+y
    
    apply_async(add,(2,3),callback=print_result)
    
    # 让回调函数访问外部信息
    # 方法1：使用一个绑定方法来代替一个简单函数
    class ResultHandler:
        def __init__(self):
            self.sequence = 0
    
        def handler(self,result):
            self.sequence += 1
            print('[{}] Got:{}'.format(self.sequence, result))
    
    r = ResultHandler()
    apply_async(add,(2,3),callback=r.handler)
    
    # 方法2：作为类的替代，使用一个闭包捕获状态值
    def make_handler():
        sequence = 0
        def handler(result):
            nonlocal sequence
            sequence += 1
            print('[{}] Got:{}'.format(sequence, result))
        return handler
    
    handler = make_handler()
    apply_async(add,(2,3),callback=handler)
    
    # 方法3：使用协程达到同样的效果
    def make_handler2():
        sequence = 0
        while True:
            result = yield
            sequence += 1
            print('[{}] Got:{}'.format(sequence, result))
    
    handler2 = make_handler2()
    next(handler2)  # 启动协程
    apply_async(add,(2,3),callback=handler2.send)
    
    # 7.11内敛回调函数 TODO 看不懂！
    # 使用生成器和协程可以使得回调函数内联在某个函数中
    # def apply_async(func, args, *, callback):
    #     result = func(*args)
    #     callback(result)
    #
    # from queue import Queue
    # from functools import wraps
    #
    # class Async:
    #     def __init__(self, func, args):
    #         self.func = func
    #         self.args = args
    #
    # def inlined_async(func):
    #     @wraps(func)
    #     def wrapper(*args):
    #         f = func(*args)
    #         result_queue = Queue()
    #         result_queue.put(None)
    #         while True:
    #             result = result_queue.get()
    #             try:
    #                 a = f.send(result)
    #                 apply_async(a.func, a.args, callback=result_queue.put)
    #             except StopIteration:
    #                 break
    #         return wrapper
    
    
    # 7.12 访问闭包中定义的变量
    def sample():
        n = 0
        def func():
            print('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()
    f.set_n(10)
    f()
    print(f.get_n())
    
    def f1():
        n = 3
        print('in f1')
        def f2():
            print(n)
            print('in f2')
            return 3
        return f2
    print(f1()())