9.15 定義有可選引數的元類

• 問題：想要定義一個元類，它的引數是可選的，這樣可以控制或者配置型別的建立過程
• 方案：使用“metaclass”關鍵字引數指定特定的元類

from abc import ABCMeta,abstractmethod
class IStream(metaclass=ABCMeta):
    @abstractmethod
    def read(self,maxsize=None):
        pass
    @abstractmethod
    def write(self,data):
        pass

• 也可以使用其它關鍵字，但是必須在__prepare__()和__new__()、__init__()中都是用強制關鍵字引數：

class MyMeta(type):
    @classmethod
    def __prepare__(cls, name, bases, *, debug=False, synchronize=False):
        pass
        return 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, *, debug=False, synchronize=False):
        pass
        super().__init__(name, bases, ns)

• __prepare__():在所有類定義開始執行之前首先被呼叫，用來建立類名稱空間
• __new__():用來例項化類物件，他在類的主體被執行完後開始執行
• __init__()：最後被呼叫，用來給物件進行初始化
• 當我們要定義元類時，只需要定義new（）或者init()方法，但並不是都定義。但是當要接受其它關鍵字引數的時候，就需要兩個都定義並提供對應的引數簽名。預設的 prepare
  () 方法接受任意的關鍵字引數，但是會忽略它們，所以只有當這些額外的引數可能會影響到類名稱空間的建立時你才需要去定義 prepare() 方法

9.16 * args 和** kwargs的強制引數簽名

• 問題：有一個函式或者方法，它的引數為 * args和** kwargs，這樣使得它比較通用，但是想要對傳進來的引數進行型別檢查
• 方案：對於任何涉及到操作函式呼叫簽名的問題，都應該使用inspect模組中的簽名特性

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)

(x, y=42, *, z=None)

• 一旦有了簽名物件，就可以使用它的bind()方法將它繫結到* args和** kwargs上去

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)

x 1
y 2
z 3

func(1)

x 1

func(1,z=3)

x 1
z 3

func(y=2,x=1)

x 1
y 2

• 下面的例子更加具體，首先在基類中定義一個通用的初始化方法，然後強制所有的子類必須提供一個特定的引數簽名。

from inspect import Signature,Parameter
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')

import inspect
print(inspect.signature(Stock))

(name, shares, price)

s1 = Stock('ACME', 100, 389.1)

s2 = Stock('ACME', 100)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-24-39f0ea31793d> in <module>()
----> 1 s2 = Stock('ACME', 100)


<ipython-input-20-8adc4a21dcf0> in __init__(self, *args, **kwargs)
      7     __signature__ = make_sig()
      8     def __init__(self, *args, **kwargs):
----> 9         bound_values = self.__signature__.bind(*args, **kwargs)
     10         for name, value in bound_values.arguments.items():
     11             setattr(self,name,value)


d:\program filles\python\lib\inspect.py in bind(*args, **kwargs)
   2966         if the passed arguments can not be bound.
   2967         """
-> 2968         return args[0]._bind(args[1:], kwargs)
   2969 
   2970     def bind_partial(*args, **kwargs):


d:\program filles\python\lib\inspect.py in _bind(self, args, kwargs, partial)
   2881                             msg = 'missing a required argument: {arg!r}'
   2882                             msg = msg.format(arg=param.name)
-> 2883                             raise TypeError(msg) from None
   2884             else:
   2885                 # We have a positional argument to process


TypeError: missing a required argument: 'price'

9.17在類上強制使用程式設計規約

• 問題：程式中包含很大的類繼承體系，希望強制執行某些程式設計規約
• 方案：入股想要監控類的定義，通常可以定義一個元類，一個基本元類通常是繼承自type並重新定義new方法或者init方法

class MyMeta(type):
    def __new__(self, clsname, bases, clsdict):
        return super().__new__(cls, clsname, bases, clsdict)

# 另一種是定義__ini__()
class MyMeta(type):
    def __init__(self, clsname, bases, clsdict):
        super().__init__(clsname,bases, clsdict)

# 為了使用上面的元類，通常把他放到一個頂級父類定義之中，然後其他的類繼承這個頂級父類
class Root(metaclass=MyMeta):
    pass
class A(Root):
    pass
class B(Root):
    pass

• 元類的一個關鍵特點是它允許在定義的時候檢查類的內容。下面的例子定義了一個元類，它會拒絕任何有混合大小寫名字作為方法的類定義

class NoMixCaseMeta(type):
    def __new__(cls, clsname, bases, clsdict):
        for name in clsdict:
            if name.lower() != name:
                raise TypeError(" Bad attribute name: ", name)
        return super().__new__(cls, clsname, bases,clsdict)
class Root(metaclass=NoMixCaseMeta):
    pass
class A(Root):
    def foo_bar(self):
        pass

class B(Root):
    def fooBar(self):
        pass

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-30-bc6fbee49cec> in <module>()
----> 1 class B(Root):
      2     def fooBar(self):
      3         pass


<ipython-input-29-e74c44098507> in __new__(cls, clsname, bases, clsdict)
      3         for name in clsdict:
      4             if name.lower() != name:
----> 5                 raise TypeError(" Bad attribute name: ", name)
      6         return super().__new__(cls, clsname, bases,clsdict)
      7 class Root(metaclass=NoMixCaseMeta):


TypeError: (' Bad attribute name: ', 'fooBar')

• 作為一個更加高階的例子，下面的元類用來檢測過載方法，確保他呼叫的引數和父類中原始方法有著相同的引數簽名。

from inspect import signature
import logging
class MatchSignatureMeta(type):
    def __init__(self,clsname, bases, clsdict):
        super().__init__(clsname, bases, clsdict)
        sup = super(self, self)
        for name, value in clsdict.items():
            if name.startswith('_') or not callable(value):
                continue
            pre_dfn = getattr(sup, name, None)
            if pre_dfn:
                prev_sig = signature(pre_dfn)
                val_sig = signature(value)
                if prev_sig != val_sig:
                    logging.warning("Signature mismatch in %s. %s != %s", value.__qualname__, prev_sig, val_sig)

class Root(metaclass=MatchSignatureMeta):
    pass
class A(Root):
    def foo(self,x, y):
        pass
    def spam(self,x,*,z):
        pass
class B(A):
    def foo(self, a, b):
        pass
    def spam(self,x,z):
        pass

WARNING:root:Signature mismatch in B.foo. (self, x, y) != (self, a, b)
WARNING:root:Signature mismatch in B.spam. (self, x, *, z) != (self, x, z)

• 在元類中選擇重新定義 __new__() 方法還是 __init__() 方法取決於你想怎樣使
  用結果類。 __new__() 方法在類建立之前被呼叫，通常用於通過某種方式（比如通過改
  變類字典的內容）修改類的定義。而 __init__() 方法是在類被建立之後被呼叫，當你
  需要完整構建類物件的時候會很有用。

• 程式碼中有一行使用了 super(self, self) ,當使用元類的時候，我們要時刻記住一點就是 self 實際上是一個類物件。因此，這條語句其實
  就是用來尋找位於繼承體系中構建 self 父類的定義。

9.18 以程式設計的方式定義類

• 問題：寫了一段程式碼，需要建立一個新的類物件。想將類的定義原始碼以字串的形式釋出出去。並且使用函式比如 exec() 來執行它，但是你想尋找一個更加優雅的解決方案。
• 方案：使用函式 types.new_class() 來初始化新的類物件。你需要做的只是提供
  類的名字、父類元組、關鍵字引數，以及一個用成員變數填充類字典的回撥函式。

def __init__(self, name, shares, price):
    self.name = name
    self.shares = shares
    self.price = price
def cost(self):
    return self.shares * self.price
cls_dict = {
    '__init__':__init__,
    'cost':cost,
}
import types
Stock = types.new_class('Stock',(),{},lambda ns:ns.update(cls_dict))
Stock.__module__ = __name__

s = Stock("ACME",50,91.1)

s

<__main__.Stock at 0xbfdeb0>

s.cost()

4555.0

• 如果你建立的類需要一個不同的元類，可以通過設定types.new_class()的第三個引數

import abc
Stock = types.new_class('Stock',(),{'metaclass': abc.ABCMeta},lambda ns: ns.update(cls_dict))
Stock.__module__ = __name__
Stock

__main__.Stock

type(Stock)

abc.ABCMeta

• 第三個引數還可以包含其他的關鍵字引數：

# class Spam(Base,debug=True, typecheck=False):
#     pass
# 上面的程式碼相當於
# Spam = types.new_class('Spam',Base,{'debug'= True, 'typecheck' = False},lambda ns:ns.update(cls_dict))

• new_class() 第四個引數是一個用來接受類名稱空間的對映物件的函
  數。通常這是一個普通的字典，但是它實際上是 __prepare__() 方法返回的任意物件，

• 也可以呼叫collections.namedtuple()

import collections

Stock = collections.namedtuple('Stock',['name', 'shares','price'])
Stock

__main__.Stock

import operator
import types
import sys

def named_tuple(classname, fieldnames):
    cls_dict = {name:property(operator.itemgetter(n)) for n, name in enumerate(fieldnames)}
    def __new__(cls, *args):
        if len(args) != len(fieldnames):
            raise TypeError("Excepted {} arguments".format(len(fieldnames)))
        return tuple.__new__(cls,args)
    cls = types.new_class(classname, (tuple,),{},lambda ns:ns.update(cls_dict))
    cls.__module__ = sys._getframe(1).f_globals['__name__']
    return cls

• 上面的程式碼中使用了一個所謂的“框架魔法”，通過sys._getframe() 來獲取呼叫者的模組名

Point  = named_tuple("point", ['x','y'])
Point

__main__.point

p = Point((4,5))
len(p)

2

p.x

4

p.y

5

p.x = 2

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-12-6bf7f157f4bc> in <module>()
----> 1 p.x = 2


AttributeError: can't set attribute

print('%s %s'%p )

4 5