元编程

在函数上添加包装器

问题：

　　你想在函数上添加一个包装器，增加额外的操作处理(比如日志、计时等)

解决方案：

　　如果你想使用额外的代码包装一个函数，可以定义一个装饰器函数，例如：

import  time
from functools import wraps


def timethis(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        start = time.time()
        result = func(*args,**kwargs)
        end = time.time()
        print(func.__name__,end-start)
        return result
    return wrapper

@timethis           #等同于timethis(countdown)
def countdown(n):
    while n > 0:
        n -= 1

countdown(100000)
countdown(1000000)

以上代码的执行结果为:

countdown 0.008307218551635742
countdown 0.10066509246826172

创建装饰器时保留函数元信息

问题：

　　你写了一个装饰器作用在某个函数上，但是这个函数的重要的元信息比如名字、文档字符串、注解和参数签名都丢失了

解决方案：

　　任何时候你定义装饰器的时候，都应该使用functools 库中的@wraps 装饰器来注解底层包装函数。例如：

import time
from functools import wraps

def timethis(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(func.__name__, end-start)
        return result
    return wrapper

@timethis
def countdown(n:int):
    """
    装饰器内部调用的函数
    :param n:
    :return:
    """
    while n>0:
        n -= 1

    return 'countdown'

countdown(100000)
print('name:', countdown.__name__)
print('doc:', countdown.__doc__)
print('annotations:', countdown.__annotations__)

'''
@wraps 有一个重要特征是它能让你通过属性wrapped 直接访问被包装函数。例如:
'''
print('wrapped:', countdown.__wrapped__(100000))

'''
wrapped 属性还能让被装饰函数正确暴露底层的参数签名信息。例如：
'''
from inspect import signature
print('signatrue:', signature(countdown))

以上代码的执行结果为:

countdown 0.008561134338378906
name: countdown
doc: 
    装饰器内部调用的函数
    :param n:
    :return:
    
annotations: {'n': <class 'int'>}
wrapped: countdown
signatrue: (n:int)

解除一个装饰器

问题：

　　一个装饰器已经作用在一个函数上，你想撤销它，直接访问原始的未包装的那个函数

解决方案：

　　假设装饰器是通过@wraps来实现的，那么你可以通过访问__wrapped__ 属性来访问原始函数：

from functools import wraps


def decorator(func):
    @wraps(func)
    def wrapper(x, y):
        result = func(x, y)
        return result
    return wrapper

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

orig_add = add.__wrapped__
print('orig_add:', orig_add(3, 5))

以上代码的执行结果为:

orig_add: 8

定义一个带参数的装饰器

问题：

　　你想定义一个可以接受参数的装饰器

解决方案：

　　我们用一个例子详细阐述下接受参数的处理过程。假设你想写一个装饰器，给函数添加日志功能，当时允许用户指定日志的级别和其他的选项。下面是这个装饰器的定义和使用示例：

from functools import wraps
import logging

def logged(level, name=None, message=None):
    """
    Add logging to a function. level is the logging
    level, name is the logger name, and message is the
    log message. If name and message aren't specified,
    they default to the function's module and name.
    """
    def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args, **kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)
        return wrapper
    return decorate

@logging(logging.DEBUG)         #等同于logging(loggin.DEBUG)(add)(x,y)
def add(x, y):
    return x +y


@logged(logging.CRITICAL, 'example')
def spam():
    print('Spam!')

可自定义属性的装饰器

问题：

　　你想写一个装饰器来包装一个函数，并且允许用户提供参数在运行时控制装饰器行为

解决方案：

　　引入一个访问函数，使用nolocal 来修改内部变量。然后这个访问函数被作为一个属性赋值给包装函数

def logged(level, name=None, message=None):
    '''
    Add logging to a function. level is the logging
    level, name is the logger name, and message is the
    log message. If name and message aren't specified,
    they default
    '''
    def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args, **kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)

        @attch_wrapper(wrapper)
        def set_level(newlevel):
            nonlocal level
            level = newlevel

        @attch_wrapper(wrapper)
        def set_message(newmsg):
            nonlocal logmsg
            logmsg = newmsg

        return wrapper

    return decorate

@logged(logging.DEBUG)
def add(x, y):
    return x + y

@logged(logging.CRITICAL, 'example')
def spam():
    print('Spam!')

import logging
logging.basicConfig(level=logging.DEBUG)
print(add(10, 11))

以上代码的执行结果为:

21
DEBUG:__main__:add

带可选参数的装饰器

 问题：

　　你想写一个装饰器，既可以不传参数给它，比如@decorator ，也可以传递可选参数给它，比如@decorator(x,y,z) 

解决方案：

　　下面是日志装饰器的一个修改版本：

from functools import wraps, partial
import logging


def logged(func=None, *, level=logging.DEBUG, name=None, message=None):
    if func is None:
        return partial(logged, level=level, name=name, message=message)

    logname = name if name else func.__module__
    log = logging.getLogger(logname)
    logmsg = message if message else func.__name__

    @wraps(func)
    def wrapper(*args, **kwargs):
        log.log(level, logmsg)
        return func(*args, **kwargs)

    return wrapper

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

@logged(level=logging.CRITICAL, name='example')
def spam():
    print('Spam!')

print(add(10, 20))
print('*'*40)
spam()

以上代码的执行结果为:

30
spam
****************************************
Spam!

总结：

　　这里提到的这个问题就是通常所说的编程一致性问题。当我们使用装饰器的时候，大部分程序员习惯了要么不给它们传递任何参数，要么给它们传递确切参数。其实从技术上来讲，我们可以定义一个所有参数都是可选的装饰器，就像下面这样： 

@logged
def add(x, y):
    """
    等同于 add = logged(add)
    这时候，被装饰函数会被当做第一个参数直接传递给logged 装饰器。因此，logged() 中的第一个参数就是被包装函数本身。所有其他参数都必须有默认值
    """
    return x + y

@logged(level=logging.CRITICAL, name='example')
def spam():
    """
    等同于 spam = logged(level=logging.CRITICAL, name='example')(spam)
    
    初始调用logged() 函数时，被包装函数并没有传递进来。因此在装饰器内，它必
    须是可选的。这个反过来会迫使其他参数必须使用关键字来指定。并且，但这些参数
    被传递进来后，装饰器要返回一个接受一个函数参数并包装它的函数。为了这样做，我
    们使用了一个技巧，就是利用functools.partial 。它会返回一个未完全初始化自
    身，除了被包装函数外其他参数都已经确定下来了。
    """
    print('Spam!')

利用装饰器强制函数上的类型检查

 问题：

 　　作为某种编程规约，你想在对函数参数进行强制类型检查

解决方案：

　　在演示实际代码前，先说明我们的目标：能对函数参数类型进行断言，类似下面这样：

from inspect import signature
from functools import wraps


def typeassert(*ty_args, **ty_kwargs):
    def decorate(func):
        if not __debug__:
            return func

        sig = signature(func)
        bound_types = sig.bind_partial(*ty_args, **ty_kwargs).arguments

        @wraps(func)
        def wrapper(*args, **kwargs):
            bound_values = sig.bind(*args, **kwargs)
            for name, value in bound_values.arguments.items():
                if name in bound_types:
                    if not isinstance(value, bound_types[name]):
                        raise TypeError(
                                'Argument {} must be {}'.format(name, bound_types[name])
                                )
            return func(*args, **kwargs)
        return wrapper
    return decorate


@typeassert(int, z=int)
def spam(x, y, z=42):
    print(x, y, z)

spam(1, 2, 3)
spam(1, 'hello')
'''
报错
spam(1, 'hello', 'world')
TypeError: Argument z must be <class 'int'>
'''

以上代码的执行结果为:

1 2 3
1 hello 42

其次， 这里还对被包装函数的参数签名进行了检查， 我们使用了inspect.signature() 函数。简单来讲，它运行你提取一个可调用对象的参数签名信息。例如：

from inspect import signature


def spam(x, y, z=42):
    return x + y

sig = signature(spam)
print('sig:', sig)
print('sig parameters:', sig.parameters)
print('sig paramenters z:', sig.parameters['z'].name)
print('sig paramenters name:', sig.parameters['z'].default)
print('sig paramenters kind:', sig.parameters['z'].kind)

以上代码的执行结果为:

sig: (x, y, z=42)
sig parameters: OrderedDict([('x', <Parameter "x">), ('y', <Parameter "y">), ('z', <Parameter "z=42">)])
sig paramenters z: z
sig paramenters name: 42
sig paramenters kind: POSITIONAL_OR_KEYWORD

将装饰器定义为类的一部分

 问题：

　　你想在类中定义装饰器，并将其作用在其他函数或方法上

解决方案：

　　在类里面定义装饰器很简单，但是你首先要确认它的使用方式。比如到底是作为一个实例方法还是类方法。下面我们用例子来阐述它们的不同：

from functools import wraps


class A:
    def decorator1(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            print('Decorator 1')
            return func(*args, **kwargs)
        return wrapper

    @classmethod
    def decorator2(cls, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            print('Decorator 2')
            return func(*args, **kwargs)
        return wrapper

a = A()

@a.decorator1
def spam():
    pass

@A.decorator2
def grok():
    pass

为类和静态方法提供装饰器

问题：

　　你想给类或静态方法提供装饰器

解决方案：

　　给类或静态方法提供装饰器是很简单的，不过要确保装饰器在@classmethod 或@staticmethod 之前。例如：

import time
from functools import wraps


def timethis(func):
    @wraps(func)
    def wrapped(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(end-start)
        return result
    return wrapped


class Spam:
    @timethis
    def instnce_method(self, n):
        print(self, n)
        while n > 0:
            n -= 1

    @classmethod
    @timethis
    def class_method(cls, n):
        print(cls, n)
        while n > 0:
            n -= 1

s = Spam()
s.instnce_method(100000)
Spam.class_method(100000)

以上代码的执行结果为:

<__main__.Spam object at 0x101445630> 100000
0.011115074157714844
<class '__main__.Spam'> 100000
0.009546995162963867

装饰器为被包装函数增加参数

问题：

　　你想在装饰器中给被包装函数增加额外的参数，但是不能影响这个函数现有的调用规则

解决方案：

　　可以使用关键字参数来给被包装函数增加额外参数。考虑下面的装饰器：

from  functools import wraps


def optional_debug(func):
    @wraps(func)
    def wrapper(*args,debug=False, **kwargs):
        if debug:
            print('Calling', func.__name__)
        return func(*args, **kwargs)

    return wrapper

@optional_debug
def spam(a, b, c):
    print(a, b, c)

spam(1, 2, 3)
spam(1, 2, 3, debug=True)

以上代码的执行结果为:

1 2 3
Calling spam
1 2 3

使用装饰器扩充类的功能

问题：

　　你想通过反省或者重写类定义的某部分来修改它的行为，但是你又不希望使用继承或元类的方式

解决方案：

　　这种情况可能是类装饰器最好的使用场景了。例如，下面是一个重写了特殊方法getattribute 的类装饰器，可以打印日志：

def log_getattribute(cls):
    orig_getattribute = cls.__getattribute__

    def new_getattribute(self, name):
        print('getting:', name)
        return orig_getattribute(self, name)

    cls.__getattribute__ = new_getattribute
    return cls


@log_getattribute
class A:
    def __init__(self, x):
        self.x = x

    def spam(self):
        pass

a = A(50)
print(a.x)
a.spam()

以上代码的执行结果为:

getting: x
50
getting: spam

使用元类控制实例的创建

问题：

　　你想通过改变实例创建方式来实现单例、缓存或其他类似的特性

解决方案：

　　你可以定义一个元类并自己实现call () 方法。为了演示，假设你不想任何人创建这个类的实例：

class NoInstances(type):
    def __call__(self, *args, **kwargs):
        raise TypeError("Can't instantiate directly")


class Spam(metaclass=NoInstances):
    @staticmethod
    def grok(x):
        print('不允许实例化~')
        print('Spam.grok')

Spam.grok(50)

'''
s = Spam()
s.grok()
实例化这种不能调用，报错~
'''

#实现单例模式
class Singleton(type):
    def __init__(self, *args, **kwargs):
        self.__instance = None
        super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self.__instance is None:
            self._instance = super().__call__(*args, **kwargs)
            return self.__instance
        else:
            return self.__instance


class Spam(metaclass=Singleton):
    def __init__(self):
        print('Creating Spam')

a = Spam()
b = Spam()
c = Spam()
print(a is b and b is c)

以上代码的执行结果为:

不允许实例化~
Spam.grok
Creating Spam
Creating Spam
Creating Spam
True

定义有可选参数的元类

问题：

　　你想定义一个元类，允许类定义时提供可选参数，这样可以控制或配置类型的创建过程

解决方案：

　　在定义类的时候，Python 允许我们使用‘‘metaclass‘‘关键字参数来指定特定的元类。例如使用抽象基类：

from abc import ABCMeta, abstractclassmethod


class IStream(metaclass=ABCMeta):
    @abstractclassmethod
    def read(self, maxsize=None):
        pass

    @abstractclassmethod
    def write(self, date):
        pass


class MyMeta(type):
    @classmethod
    def __prepare__(cls, name, bases, *, debug=False, synchronize=False):
        pass
        super().__prepare__(name, bases)

    def __new__(cls, name, bases, ns, *, debug=False, synchronize=False):
        pass
        return super().__new__(cls, name, bases, ns)

    def __init__(cls, name, bases, ns, *, debug=False, synchronize=False):
        pass
        super().__init__(name, bases, ns)


class Spam(metaclass=MyMeta, debug=True, synchronize=True):
    pass

*args 和**kwargs 的强制参数签名

问题：

　　你有一个函数或方法，它使用*args 和**kwargs 作为参数，这样使得它比较通用，但有时候你想检查传递进来的参数是不是某个你想要的类型

解决方案： 

　　对任何涉及到操作函数调用签名的问题，你都应该使用inspect 模块中的签名特性。我们最主要关注两个类：Signature 和Parameter 。下面是一个创建函数前面的交互例子： 

from inspect import Signature, Parameter


parms = [
        Parameter('x', Parameter.POSITIONAL_OR_KEYWORD),
        Parameter('y', Parameter.POSITIONAL_OR_KEYWORD, default=42),
        Parameter('z', Parameter.KEYWORD_ONLY, default=None)
        ]

sig = Signature(parms)
print(sig)


def func(*args, **kwargs):
    bound_values = sig.bind(*args, **kwargs)
    for name, value in bound_values.arguments.items():
        print(name, value)

func(1, 2, z=3)
print(''.center(30, '*'))
func(1)
print(''.center(30, '*'))
func(1, z=3)
print(''.center(30, '*'))
func(y=2, x=1)
print(''.center(30, '-'))
'''
报错鸟，为啥，因为只能传递三个参数呀，你四不四傻~
'''
#func(1, 2, 3, 4)



'''
另外一种写法
'''
print('另外一种写法'.center(30, '*'))

from inspect import Signature, Parameter,signature
def make_sig(*names):
    parms = [Parameter(name,Parameter.POSITIONAL_OR_KEYWORD) for name in names]
    return Signature(parms)


class Structure:
    __signature__ = make_sig()

    def __init__(self, *args, **kwargs):
        bound_values = self.__signature__.bind(*args, **kwargs)
        for name, value in bound_values.arguments.items():
            setattr(self, name, value)


class Stock(Structure):
    __signature__ = make_sig('name', 'shares', 'price')


class Point(Structure):
    __signature__ = make_sig('x', 'y')


print(signature(Stock))
s1 = Stock('ACME', 100, 490.1)
'''
报错
'''
#s2 = Stock('ACME', 100)
#s3 = Stock('ACME', 100, 490.1, shares=50)

以上代码的执行结果为:

(x, y=42, *, z=None)
x 1
y 2
z 3
******************************
x 1
******************************
x 1
z 3
******************************
x 1
y 2
------------------------------
************另外一种写法************
(name, shares, price)

避免重复的属性方法

问题：

　　你在类中需要重复的定义一些执行相同逻辑的属性方法，比如进行类型检查，怎样去简化这些重复代码呢？

解决方案：

　　考虑下一个简单的类，它的属性由属性方法包装：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if not isinstance(value, str):
            raise TypeError('name must be a string')
        self._name = value

    @property
    def age(self):
        return self._age

    @name.setter
    def age(self, value):
        if not isinstance(value, int):
            raise TypeError('age must be an int')
        self._age = value


#针对上面的问题，我们需要改良一下
def typed_property(name, expected_type):
    storage_name = '_' + name

    @property
    def prop(self):
        return getattr(self, storage_name)

    @prop.setter
    def prop(self, value):
        if not isinstance(value, expected_type):
            raise TypeError('{} must be a {}'.format(name, expected_type))
        setattr(self, storage_name, value)

    return prop


#测试实例
class Person:
    name = typed_property('name', str)
    age = typed_property('age', int)

    def __init__(self, name, age):
        self.name = name
        self.age = age

'''
报错
p = Person('这尼玛的是大佬', '18')
'''

#正常显示输出
p = Person('这尼玛的是大佬', 18)

在局部变量域中执行代码

问题：

　　你想在使用范围内执行某个代码片段，并且希望在执行后所有的结果都不可见

解决方案： 

　　为了理解这个问题，先试试一个简单场景。首先，在全局命名空间内执行一个代码片段：

a = 13
exec('b = a + 10')
print('b的结果为为：', b)

'''
#执行下面的函数会报错NameError: name 'c' is not defined
def test():
    a = 13
    exec('c = a + 5')
    print(c)
test()
'''

#解决方法,local()可以获取函数内部的所有变量并以字典的方式返回，
# 变量名称是字典的key，变量的赋值是value,通过获取local中的c的局部变量在赋值给变量即可
def test():
    a = 13
    loc = locals()
    print('before:', loc)
    exec('c = a + 5')
    c = loc['c']
    print('c:', c)
    print('after:', loc)
test()

以上代码的执行结果为:

b的结果为为： 23
before: {'a': 13}
c: 18
after: {'a': 13, 'loc': {...}, 'c': 18}