函数的使用方式

  • 将函数视为“一等公民”

    • 函数可以赋值给变量
    • 函数可以作为函数的参数
    • 函数可以作为函数的返回值

  • 高阶函数的用法（filter、map以及它们的替代品）

    1. items1 = list(map(lambda x: x ** 2, filter(lambda x: x % 2, range(1, 10))))
    2. items2 = [x ** 2 for x in range(1, 10) if x % 2]

  • 位置参数、可变参数、关键字参数、命名关键字参数

  • 参数的元信息（代码可读性问题）

  • 匿名函数和内联函数的用法（lambda函数）

  • 闭包和作用域问题

    • Python搜索变量的LEGB顺序（Local >>> Embedded >>> Global >>> Built-in）

    • global和nonlocal关键字的作用

      global：声明或定义全局变量（要么直接使用现有的全局作用域的变量，要么定义一个变量放到全局作用域）。

      nonlocal：声明使用嵌套作用域的变量（嵌套作用域必须存在该变量，否则报错）。

  • 装饰器函数（使用装饰器和取消装饰器）

    例子：输出函数执行时间的装饰器。

    1. def record_time(func):
    2.     """自定义装饰函数的装饰器"""
    4.     @wraps(func)
    5.     def wrapper(*args, **kwargs):
    6.         start = time()
    7.         result = func(*args, **kwargs)
    8.         print(f'{func.__name__}: {time() - start}秒')
    9.         return result
    11.     return wrapper

    如果装饰器不希望跟print函数耦合，可以编写可以参数化的装饰器。

    ```Python from functools import wraps from time import time

def record(output): “””可以参数化的装饰器”””

  1.   def decorate(func):
  3.       @wraps(func)
  4.       def wrapper(*args, **kwargs):
  5.           start = time()
  6.           result = func(*args, **kwargs)
  7.           output(func.__name__, time() - start)
  8.           return result
  10.       return wrapper
  12.   return decorate
  2.   ```Python
  3.   from functools import wraps
  4.   from time import time
  7.   class Record():
  8.       """通过定义类的方式定义装饰器"""
  10.       def __init__(self, output):
  11.           self.output = output
  13.       def __call__(self, func):
  15.           @wraps(func)
  16.           def wrapper(*args, **kwargs):
  17.               start = time()
  18.               result = func(*args, **kwargs)
  19.               self.output(func.__name__, time() - start)
  20.               return result
  22.           return wrapper

说明：由于对带装饰功能的函数添加了@wraps装饰器，可以通过func.__wrapped__方式获得被装饰之前的函数或类来取消装饰器的作用。

例子：用装饰器来实现单例模式。

  1.   from functools import wraps
  4.   def singleton(cls):
  5.       """装饰类的装饰器"""
  6.       instances = {}
  8.       @wraps(cls)
  9.       def wrapper(*args, **kwargs):
  10.           if cls not in instances:
  11.               instances[cls] = cls(*args, **kwargs)
  12.           return instances[cls]
  14.       return wrapper
  17.   @singleton
  18.   class President:
  19.       """总统(单例类)"""
  20.       pass

提示：上面的代码中用到了闭包（closure），不知道你是否已经意识到了。还没有一个小问题就是，上面的代码并没有实现线程安全的单例，如果要实现线程安全的单例应该怎么做呢？

线程安全的单例装饰器。

  1.   from functools import wraps
  2.   from threading import RLock
  5.   def singleton(cls):
  6.       """线程安全的单例装饰器"""
  7.       instances = {}
  8.       locker = RLock()
  10.       @wraps(cls)
  11.       def wrapper(*args, **kwargs):
  12.           if cls not in instances:
  13.               with locker:
  14.                   if cls not in instances:
  15.                       instances[cls] = cls(*args, **kwargs)
  16.           return instances[cls]
  18.       return wrapper

提示：上面的代码用到了with上下文语法来进行锁操作，因为锁对象本身就是上下文管理器对象（支持__enter__和__exit__魔术方法）。在wrapper函数中，我们先做了一次不带锁的检查，然后再做带锁的检查，这样做比直接加锁检查性能要更好，如果对象已经创建就没有必须再去加锁而是直接返回该对象就可以了。