量化投资之工具篇一：Backtrader从入门到精通（3）-Cerebro源代码解读

前面两篇文章已经一步一步展示了如何使用backtrader以及使用backtrader的一些重要概念和注意事项。但是你要真正灵活地使用backtrader实现自己的策略，还需要了解backtrader各个组成部分。本文开始，对backtrader的类进行详细的说明。为了让大家更能深入了解backtrader的运行机制，咱们基于源代码进行解读。

代码架构中，会用到元类，我们先了解元类在backtrader中的应用。

元类

在backtrader的类定义中，经常出现如下定义：

class Cerebro(with_metaclass(MetaParams, object)):
    
class MetaLineRoot(metabase.MetaParams):

class WriterBase(with_metaclass(bt.MetaParams, object))

里面经常出现的metaclass，就是元类的意思。

在backtrader中，基本上所有类从元类继承。我们从顶往下看，先看metabase类。

class MetaBase(type):
    def doprenew(cls, *args, **kwargs):
        return cls, args, kwargs

    def donew(cls, *args, **kwargs):
        _obj = cls.__new__(cls, *args, **kwargs)s
        return _obj, args, kwargs

    def dopreinit(cls, _obj, *args, **kwargs):
        return _obj, args, kwargs

    def doinit(cls, _obj, *args, **kwargs):
        _obj.__init__(*args, **kwargs)
        return _obj, args, kwargs

    def dopostinit(cls, _obj, *args, **kwargs):
        return _obj, args, kwargs

    def __call__(cls, *args, **kwargs):
        cls, args, kwargs = cls.doprenew(*args, **kwargs)
        _obj, args, kwargs = cls.donew(*args, **kwargs)
        _obj, args, kwargs = cls.dopreinit(_obj, *args, **kwargs)
        _obj, args, kwargs = cls.doinit(_obj, *args, **kwargs)
        _obj, args, kwargs = cls.dopostinit(_obj, *args, **kwargs)
        return _obj

这个元类类继承type，前面实例中还有object。这些是啥区别？这个就得从python的特性说起。在python中，一切皆为对象。甚至数据类型，以及数值都是对象。不信看看：

print(type(2))

<class ‘int’>

print(isinstance(2, object))

True

print(isinstance(2, int))

True

数值2是int类的实例，也是int超类object的实例。记住：所有类的最顶层基类是object。

print(isinstance(object, type))
True

print(isinstance(int, type))
True

这个看出来啥呢？object类是type的实例，所有的类都继承自object，也就是所有类都是type生成的。type就是Python在背后用来创建所有类的元类。是总结一句话：实例由类生成，类由type生成。

那元类又是啥？元类就是用来创建这些类（对象）的，元类就是类的类。

这些关系如下代码即可明了：

name = 'bob'
print("name.__class__ is %s"%name.__class__)
print("name.__class__.__class__ is %s"%name.__class__.__class__)

class Bar(object): pass

print("Bar.__class__ is %s"%Bar.__class__)
print("Bar.__class__.__class__ is %s"%Bar.__class__.__class__)

mybar=Bar()
print("mybar.__class__ is %s"%mybar.__class__)
print("mybar.__class__.__class__ is %s"%mybar.__class__.__class__)

结果如下：

name.__class__ is <class ‘str’>
name.__class__ .__class__is <class ‘type’>
Bar.__class__ is <class ‘type’>
Bar.__class__ .__class__.class is <class ‘type’>
mybar.__class__ is <class ‘main.Bar’>
mybar.__class__ .__class__.class is <class ‘type’>

总之一句话：实例的类是类（创建它的类），类的类是type。

普通类和元类创建类啥区别？比较复杂，我们这里关注影响backtrader架构的的特点。

普通类和元类创建的类的一个重要区别就是：

普通类实例化的时候，先用__new__构造新的空对象，然后调用__init__方法,去初始化这个对象。如果要调用__call__,需要使用实例后加一个括号显式调用。

元类创建类实例化的时候，首先调用元类的__call__，然后才是__new__和__init__，这样有啥好处？由于要先调用__call__，我们可以控制类的生成，比如说，我们可以控制生成类的参数（普通类代码中固定死了）。实际上99%的没啥用。就是构造架构的时候简化下代码，代价是代码太难读了。

回到咱们的MetaBase类，该类定义了doprenew/donew/dopreinit/doinit/dopostinit,其中donew中调用类的__new__创建对象和doinit函数对__init__对对象进行初始化。特别注意__call__函数，直接完成预处理、实例化、初始化，后处理一系列动作，而且这个处理不需要显式调用，在类进行实例化的时候就会完成。所有MetaBase（或者其子类）创建的类都会先调用这个函数，包括Cerebro、lineseries、strategies、broker、indicator等等。

这些功能类并没有继承MetaBase，而是继承MetaBase的子类MetaParams：

class MetaParams(MetaBase):
    def __new__(meta, name, bases, dct):
        # Remove params from class definition to avoid inheritance
        # (and hence "repetition")
        newparams = dct.pop('params', ())

        packs = 'packages'
        newpackages = tuple(dct.pop(packs, ()))  # remove before creation

        fpacks = 'frompackages'
        fnewpackages = tuple(dct.pop(fpacks, ()))  # remove before creation

        # Create the new class - this pulls predefined "params"
        cls = super(MetaParams, meta).__new__(meta, name, bases, dct)

        # Pulls the param class out of it - default is the empty class
        params = getattr(cls, 'params', AutoInfoClass)

        # Pulls the packages class out of it - default is the empty class
        packages = tuple(getattr(cls, packs, ()))
        fpackages = tuple(getattr(cls, fpacks, ()))

        # get extra (to the right) base classes which have a param attribute
        morebasesparams = [x.params for x in bases[1:] if hasattr(x, 'params')]

        # Get extra packages, add them to the packages and put all in the class
        for y in [x.packages for x in bases[1:] if hasattr(x, packs)]:
            packages += tuple(y)

        for y in [x.frompackages for x in bases[1:] if hasattr(x, fpacks)]:
            fpackages += tuple(y)

        cls.packages = packages + newpackages
        cls.frompackages = fpackages + fnewpackages

        # Subclass and store the newly derived params class
        cls.params = params._derive(name, newparams, morebasesparams)

        return cls

    def donew(cls, *args, **kwargs):
        clsmod = sys.modules[cls.__module__]
        # import specified packages
        for p in cls.packages:
            if isinstance(p, (tuple, list)):
                p, palias = p
            else:
                palias = p

            pmod = __import__(p)

            plevels = p.split('.')
            if p == palias and len(plevels) > 1:  # 'os.path' not aliased
                setattr(clsmod, pmod.__name__, pmod)  # set 'os' in module

            else:  # aliased and/or dots
                for plevel in plevels[1:]:  # recurse down the mod
                    pmod = getattr(pmod, plevel)

                setattr(clsmod, palias, pmod)

        # import from specified packages - the 2nd part is a string or iterable
        for p, frompackage in cls.frompackages:
            if isinstance(frompackage, string_types):
                frompackage = (frompackage,)  # make it a tuple

            for fp in frompackage:
                if isinstance(fp, (tuple, list)):
                    fp, falias = fp
                else:
                    fp, falias = fp, fp  # assumed is string

                # complain "not string" without fp (unicode vs bytes)
                pmod = __import__(p, fromlist=[str(fp)])
                pattr = getattr(pmod, fp)
                setattr(clsmod, falias, pattr)
                for basecls in cls.__bases__:
                    setattr(sys.modules[basecls.__module__], falias, pattr)

        # Create params and set the values from the kwargs
        params = cls.params()
        for pname, pdef in cls.params._getitems():
            setattr(params, pname, kwargs.pop(pname, pdef))

        # Create the object and set the params in place
        _obj, args, kwargs = super(MetaParams, cls).donew(*args, **kwargs)
        _obj.params = params
        _obj.p = params  # shorter alias

        # Parameter values have now been set before __init__
        return _obj, args, kwargs

需要重点关注的是donew函数，在这个函数里面分别提取package，frompackage和params并赋值，前面两个对我们影响不大，关键是params（最后几行代码）。

如何提取参数了？比如在Cerebro类中，参数定义为元组：

params = (
        ('preload', True),
        ('runonce', True),
        ('maxcpus', None),
        ('stdstats', True),
        ('oldbuysell', False),
        ('oldtrades', False),