最近在使用 peewee 来做数据库 ORM，期间遇到一些疑问便查了下源码，结果发现好多以前没有好好理解并整理的知识。

参考视频：https://www.bilibili.com/video/BV1uA411V7dW?p=1

关于 Python 中类的基本用法，参考以前写的文章 《python 小技巧与坑 - python 的类》

总结：

对象（obj）是类（class）的一个实例，而类（class）本身其实也是一个对象，它是元类（metaclass）的实例。

在 Python 中，默认情况下，所有类的元类都是 type，所有类的基类都是 object。

规定术语：

我们先来规定下几个术语在本文中的特定意思，以免混淆。

类对象，用来特指类本身这个对象，而不是由类生成的对象实例。

类实例，用来特指由类生成的对象实例。

类属性（类变量），指在类定义体内部，__init__() 方法之外，定义的属性。类属性可以通过 Class.attr 调用也可以通过 instance.attr 调用。

实例属性（实例变量），指在类的 __init__() 方法中，或类定义体外部，通过 instance.attr 定义的属性。实例属性只能通过 instance.attr 调用。

一、特殊函数与特殊属性

1.1 如何区分对象

is 操作符用来判断两个对象是否为同一个。

id() 函数返回对象的唯一标识，在 CPython 实现中，返回的就是该对象的内存地址。可以使用 hex(id(obj)) 将其转换成16进制。

type() 函数返回对象的类型。

1.2 可重写(override)的类方法

1.2.1 __new__(cls[, ...])

object.__new__(cls[, ...]) 方法用来创建 cls 类的对象实例。其中第一个参数 cls 代表当前类，其余参数应该与构造器表达式保持一致，或者使用可变参数囊括构造器表达式的参数（构造器表达式指 x = ClassName(args) 这种语法）。它的返回值应该是一个新的对象实例（cls 类的实例）。__new__() 实际上是一个静态方法，不过不需要加 @staticmethod 进行声明

当你使用构造器表达式 x = ClassName(args) 来创建对象的时候，Python 解释器会先调用 ClassName.__new__(cls) 创建一个对象实例，然后再对该对象调用 __init__(self[, ...]) 进行初始化。

如果 __new__() 方法没有返回一个对象实例，那么后续就不会调用 __init__(self[, ...]) 方法。

__new__(cls[, ...]) 的默认实现是调用父类的 __new__() 方法 spuer().__new__(cls, )，你可以在此之后对创建出来的对象实例进行修改。

1.2.2 __init__(self[, ...])

__init__(self[, ...]) 的调用发生在 __new__(cls) 方法创建完对象实例之后，该对象实例返回给用户之前。self 参数代表该对象实例，其余参数应该与构造器表达式保持一致，或者使用可变参数囊括构造器表达式的参数。__init__() 不需要有返回值，构造器表达式返回的对象实例是由 __new__() 生成的。

在派生类的 __init__() 方法中，必须主动调用父类的 __init__() 方法， super().__init__([args...])，以确保对象实例中父类部分初始化成功。

1.2.3 __del__(self)

__del__() 方法会在对象实例即将销毁之前自动调用。注意 __del__() 方法实际上并不执行销毁对象、回收内存的操作，这些都是由 Python 垃圾回收机制完成的。所以即使你手动显式调用 x.__del__()，实际上只是运行了一次 __del__() 方法，并不会销毁对象，甚至连对象的引用计数都不会减少。

要想显式删除一个对象，需要使用 del 语句。del x 并不会直接调用 x.__del__()，而是将对象 x 的引用计数减1。当对象的引用计数为0的时候，Python 的 GC 机制会自动为其调用 __del__()。（很诡异，del 在 Python 中是一个 statement，而不是一个 function）

派生类的 __del__() 方法，必须主动调用父类的 __del__() 方法。

Python 并不保证在解释器退出时，会对所有还存活的对象调用 __del__() 方法。

1.2.4 __repr__(self)

Python 的内建函数 repr(x) 会自动调用对象的 x.__repr__() 方法。 __repr__() 必须返回一个“正式的”字符串（相比于 __str__() 而言）。如果可以的话，返回的字符串应该是一个有效的 Python 表达式，能够用来重建对象实例；如果做不到的话，应该返回类似<...some useful description...> 这样格式的字符串。

1.2.5 __str__(self)

Python 的内建函数 str(x), print(x) 会自动调用 x.__str__() 方法。该方法必须返回一个“非正式的”字符串，用来代表该对象实例。与 __repr__() 不同的是，__str__() 并不期望返回一个可重建对象的 Python 表达式字符串，可以更随意进行定制。

默认的__str__(self) 方法其实调用的就是 self.__repr__()。

1.2.6 __call__(self[, ...])

当对象 x 被以函数形式 x() 使用的时候，就会自动调用 x.__call__() 方法（x.__call__() 等价于 Class_of_x.__call(x) ）。

1.2.7 示例代码

class User(object):

    def __new__(cls, *args, **kwargs):
        # __new__ 方法用于创建 cls 类的对象
        print('\n===== 调用 User.__new__() 方法')
        print('cls: ', cls)
        print('type(cls): ', type(cls))
        print('args: ', args)
        print('kwargs: ', kwargs)

        obj = super().__new__(cls)
        print('id(obj): ', hex(id(obj)))
        return obj

    def __init__(self, name):
        # 对 self 这个对象进行初始化
        print('\n===== 调用 User.__init__() 方法')
        print('id(self): ', hex(id(self)))
        
        super(User, self).__init__()
        self.name = name
        pass

    def __del__(self):
        # __del__（） 方法并不能销毁对象，它只是在对象即将被 GC 销毁之前会被系统自动调用
        print('\n===== 调用 User.__del__() 方法')
        pass
    
    def __call__(self, *args, **kwds):
        # 当你在对象后面加上括号，像函数一样调用的时候，形如：u1()，就会自动调用该方法。
        print('\n===== 调用 User.__call__() 方法')
        pass

    def __str__(self) -> str:
        # 当在外部 print(user) 或者 str(user) 的时候，
        print('\n===== 调用 User.__str__() 方法')
        # return super().__repr__()
        return '这是 __str__() 的输出: ' + self.__repr__()

    def __repr__(self) -> str:
        print('\n===== 调用 User.__repr__() 方法')
        return super().__repr__()

# 创建类的对象实例，实际上执行了两个步骤：
# 1. 调用 __new__() 方法 创建对象
# 2. 调用 __init__() 方法 初始化对象
u1 = User('funway')

print(u1)

u1()

1.2.8 __get__, __set__, __delete__

如果一个类 Class_A 定义了这三个方法，只有当这个类的实例 obj_a 是作为另一个类的类变量（Class_B.a = Class_A()）的时候才有可能调用这三个方法。

这时候，赋值语句 obj_b.a = xxx，调用的就是 a.__set__()，取值语句 obj_b.a 或 Class_B.a 调用的就是  a.__get__()。

我们将定义了这三个方法的类叫做 “描述符”（Descriptors）。

class CharField(object):
    def __init__(self, text):
        super(CharField, self).__init__()
        self.__text = text
    
    def __get__(self, instance, owner):
        print('MyDict.__get__: %s, %s, %s' % (self, instance, owner))
        if instance is None:
            return self
        else:
            return self.__text
        pass

    def __set__(self, instance, value):
        print('MyDict.__set__: %s, %s, %s' % (self, instance, value))
        self.__text = value
        pass

class User(object):
    name = CharField('funway')
    def __init__(self):
        super().__init__()
        # self.name = 'john'
        pass
    pass

u1 = User()
print('test 1 =======================')
print(User.name)  # 调用 CharField.__get__(name, ...)
print(u1.name)    # 调用 CharField.__get__(name, ...)
print('test 2 =======================')
u1.name = 'zoe'   # 调用 CharField.__set__(name, ...)
print(u1.name)    # 调用 CharField.__set__(name, ...)
print('test 3 =======================')
User.name = 'nobody'  # 直接覆盖 User.name 类属性
print(User.name, type(User.name))
print(u1.name)

peewee 库的 FieldAccessor 类就是一种描述符类，它使得用户可以通过 Model.field 或 model.field 来访问这个类属性底层的真实字段。

1.2.9 __get**__, __set**__

用来实现 obj[key] 语法，当用户使用 obj[key] 时候会自动调用该方法。

用来实现 obj[key] 语法，当用户使用 obj[key] = value 时候会自动调用该方法。

只要用户使用 obj.attr 语法，就会无条件调用该方法。默认的 __getattribute__ 只负责获取已有属性。

尽量不要重写该方法，否则很容易陷入无限循环中然后抛出 RecursionError 异常。

1.3 特殊属性

instance.__class__

对象实例 instance 所属的类

class.__bases__

包含该类 class 所有父类的元组

definition.__name__ 

definition 的名字，definition 可以是类 class, 函数 function, 方法 method, 描述符 descriptor, 生成器 generator instance。

definition.__qualname__

qualified name 指的是比普通 __name__ 更详细的名字，包含层级信息。

object.__dict__

对象 object 的属性字典，包含该对象的所有属性信息。注意！这里的 object 可以是一个对象实例 instance，也可以是一个类 class！

对于 instance.__dict__，只包含该对象实例自己的对象属性（在 __init__() 方法中定义以及在类体外部定义的），不包含类属性。

对于 class.__dict__，则只包含该类的类属性。

二、元类 metaclass

2.1 类也是对象，是元类的对象

我们常说的对象，是指由类创建的对象实例。在 Python 中，类本身也是一个对象（下文中，我们将「类对象」这个术语用来特指类这个对象，用「类实例」特指由类创建出来的对象实例）。我们将用来创建类对象的类叫做元类（metaclass）。默认情况下，Python 中的所有类都是 type 类的实例。（同时，Python 中的所有类都是 object 类的派生。这确实绕 =。=#）

当使用 class ClassNmae(): 语句定义一个类的时候，其实 python 解释器是通过元类 type 生成了一个类对象，并赋值给这个 ClassName 变量。

# 1、用 class 语句定义一个类 Dog
class Dog(object):
    name = 'nuanuan'
    def bark(self):
        print('woof!')
        pass

# 2、用 type 类的构造器表达式定义一个类，类名也是 Dog，赋值给变量 Puppy
# type(类名, (父类元组), {定义类成员的字典})
Puppy = type('Dog', (object, ), {'name': '暖暖', 'bark': lambda self: print('汪!')})

d = Dog()
# d = Puppy()
print(d.name)
d.bark()
    
print('d.__class__: ', d.__class__)           # 对象 d 所属的类
print('Dog.__class__: ', Dog.__class__)       # 对象 Dog 所属的类
print('Dog.__bases__: ', Dog.__bases__)       # 类 Dog 的所有父类
print('Puppy.__class__: ', Puppy.__class__)   # 对象 Puppy 所属的类
print('Puppy.__bases__: ', Puppy.__bases__)   # 类 Puppy 的所有父类
print('type.__class__: ', type.__class__)     # 对象 type 所属的类（也是 type）
print('type.__bases__: ', type.__bases__)     # 类 type 的所有父类（也是 object）
print('object.__class__: ', object.__class__) # 对象 object 所属的类（还是 type）
print('object.__bases__: ', object.__bases__) # 类 object 的所有父类（object 不再有父类）

元类 type 的构造器表达式形式如此：type(class_name, bases_tuple, attrs_dict)。其中 class_name 表示类名，bases_tuple 是包含所有父类的元组，attrs_dict 是一个包含类变量和类方法的字典。现在我们已经确认 type() 可以用来动态创建一个类，但实际上它不是很方便。因为在 attrs_dict 参数中，我们很难使用 lambda 表达式写一个复杂函数然后赋值给一个 attr。当然你也可以将某个 attr 关联到一个外部函数，但我觉得这样并不太好。

于是，Python 提供了可自定义的元类，只要一个类派生自 type 类，那么它就是一个元类。

2.2 自定义元类

① 定义元类时，元类必须派生自 type 类。 class MyType(type):

② 在常规类定义中使用元类时，需要使用 metaclass 关键字。 class ClassName(object, metaclass=MyType):

# 1、定义一个元类 MyType
class MyType(type):
    pass

# 2、定义一个常规类，继承自 object（可省略不写），元类是 MyType
# class User(object, metaclass=MyType):
class User(metaclass=MyType):
    pass

u = User()
print(User.__class__)
print(User.__bases__)

2.2.1 反向思考，元类如何生成常规类

在上面的代码中，我们定义了 User 类的元类是 MyType。也就是说，User 类是 MyType 类的对象实例！

那么我们回顾下上文 1.2 中所说的 __new__() 与 __init__() 方法。类要生成对象，需要先调用 __new__() 生成对象实例，然后调用 __init__() 对这个实例进行初始化，最后才返回。

而用户调用 u = User() 这个语句的时候，如果把 User 看作一个对象，那么 obj() 调用的其实是 obj.__class__.__call__()！在这里就是 MyType.__call__() 方法。

现在我们扩展一下元类 MyType，让它打印出“工作流程”，但具体的生成操作还由父类 type 进行。

# 1、定义一个元类 MyType
# 暂时只打印工作流程，实际工作仍由父类 type 完成
class MyType(type):
    def __new__(cls, *args, **kwargs):
        print('MyType.__new__  创建对象（常规类）')
        
        new_cls = super().__new__(cls, *args, **kwargs)
        return new_cls
    
    def __init__(self, *args, **kwargs):
        print('MyType.__init__  初始化对象（常规类）')
        super().__init__(*args, **kwargs)
    
    def __call__(self, *args, **kwargs):
        print('MyType.__call__  用户调用了「对象()」这个表达式，亦即常规类的构造器表达式')
        return super().__call__(*args, **kwargs)
        # return None        # 你可以试试看返回 None 😏
    pass

# 2、定义一个常规类，继承自 object（可省略不写），元类是 MyType
class User(metaclass=MyType):
    name = 'funway'
    
    def greet(self):
        print('hello, my name is %s' % self.name)
        pass
    pass

print('User 类定义完成')
u = User()   # 将会执行 User.__class__.__call__() 方法，也就是 MyType.__call__() 方法！
u.greet()

print('User.__class__: ', User.__class__)
print('User.__bases__: ', User.__bases__)

另外，由于 MyType.__call__() 要执行的操作就是 User()，所以我们可以直接在其中自己生成 User 的对象实例，初始化后并返回。所以上面代码中的 MyType.__call__() 等价于如下：

def __call__(self, *args, **kwargs):
    print('MyType.__call__  用户调用了「对象()」这个表达式，亦即常规类的构造器表达式')
    
    # 这时候的 self，是元类 MyType 的对象实例，亦即常规类 User
    new_obj = self.__new__(self, *args, **kwargs)
    self.__init__(new_obj, *args, **kwargs)
    return new_obj

2.3 子类继承父类的元类

如果一个类，它的父类中定义了 metaclass，那么这个类也会继承该 metaclass，并由该 metaclass 进行创建。

如果一个类派生自多个父类，且每个父类各自有自己的 metaclass。这时候很可能会发生元类冲突 “ TypeError: metaclass conflict ”。需要用户自己想办法去解决，最简单的办法就是在子类定义中显式指定 metaclass。

三、使用元类实现单例模式

3.1 __new__() 实现

其实不使用元类，只用 __new__() 方法来实现更简单。。

class MyPrinter(object):
    # 类成员变量，通过类名调用 ClassName.class_virable
    _instance = None
    def __new__(cls):
        # 判断 _instance 类变量是否为空，空的话则新建一个实例并返回
        if cls._instance == None:
            cls._instance = object.__new__(cls)
            return cls._instance
        # 非空的话，则直接返回该实例
        else:
            return cls._instance
        pass

    def __init__(self):
        print('init')
        # 这时就尽量不要在 __init__ 中做什么修改单例对象的操作了，因为它也每次都会被调用
        pass

p1=MyPrinter()
print(p1)
p2=MyPrinter()
print(p2)

输出如下图所示：

注意：上述示例代码中的单例模式并非线程安全的！要想实现 thread-safe 的单例模式，请参考《Python 创建线程安全的单例》 一文。（同样，👇下面的 metaclass 实现方式也不是线程安全的）

3.2 metaclass 实现

class SingletonMeta(type):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self._instance = None  # 等价于定义了 MyPrinter._instance 类变量
        pass

    def __call__(self, *args, **kwargs):
        # 如果不存在该单例对象
        if not self._instance:
            # 新建对象
            self._instance = self.__new__(self, *args, **kwargs)
            # 初始化对象
            self.__init__(self._instance, *args, **kwargs)
            pass
        
        return self._instance
    pass

class MyPrinter(object, metaclass=SingletonMeta):
    pass

p1 = MyPrinter()
p2 = MyPrinter()
print(p1)
print(p2)
print(p1 is p2)

四、peewee 源码分析（Model 类）

元类赋予了我们可以动态创建类的能力，这样说很难以理解，我们用一个现实场景来解释一下。元类最常用的地方就是数据库的 ORM（对象关系映射）框架，我们可以很容易地定义表示数据库表的 Model 类，然后由元类为我们执行通用的数据库绑定、字段绑定等操作。

peewee 就是这么一个 ORM 库，我也是因为最近用到了 peewee，才萌生了写这篇文章的念头。

4.1 基本用法

import uuid, os

from peewee import *

db = SqliteDatabase(os.path.dirname(__file__) + '/my_app.db')

class User(Model):
    uid = CharField(unique=True, default=lambda: uuid.uuid4().hex)
    class Meta:
        database = db

db.connect()
db.create_tables([User,])
u1 = User()
u1.save()
print('u1: %s, id(u1)=%s' % (u1, hex(id(u1))))

我们从这一段简单的代码来看一下 peewee 库是怎么实现 ORM 的。

❶ User 继承自 Model 类。

❷ Model 类在 peewee 中的定义是 class Model(with_metaclass(ModelBase, Node))，也就是说 Model 类继承自 with_metaclass(ModelBase, Node) 。

❸ with_metaclass() 是一个函数，其函数定义是：

MODEL_BASE = '_metaclass_helper_'

def with_metaclass(meta, base=object):
    return meta(MODEL_BASE, (base,), {})

那么with_metaclass(ModelBase, Node) 等价于 ModelBase('_metaclass_helper_', (Node, ), {})。让我回忆下上文的 type(class_name, (bases_tuple), {attrs_dict})，它其实就是以 ModelBase 为元类，以 Node 为基类，创建了一个名为 '_metaclass_helper_' 的临时类。（注意，该函数返回一个类对象。多次调用该函数，返回的类对象类名是一样的，但实际地址是不一样的！所以可以说每次返回的是不同的类，只是类名一样 =。=#）

为什么要多此一举搞一个临时类出来呢？好像说是为了兼容 Python2 的语法。

OK，知道了 with_metaclass() 的本质，那么 Model 类的定义可以简化为 class Model(Node, metaclass=ModelBase)，它以 Node 类为基类，以 ModelBase 为元类。同样，User 类就是以 Model 为基类，以 ModelBase 为元类。

❹ 所以，当用户定义 User 类的时候，实际上调用的是元类 ModelBase 的 ModelBase.__new__() 与 ModelBase.__init__()  方法来创建并初始化这个类对象。

然后当用户使用 u1= User() 创建 User 类实例的时候，调用的是元类 ModelBase 的 ModelBase.__call__() 方法。

❺ 我们将 peewee 中的代码简化，其中最终要的几个类为：ModelBase、Metadata、FiledAccessor、Model。

import uuid, os

MODEL_BASE = '_metaclass_helper_'

def with_metaclass(meta, base=object):
    return meta(MODEL_BASE, (base,), {})

# ModelBase 是控制生成 Model 类的元类
class ModelBase(type):
    def __new__(cls, name, bases, attrs, **kwargs):
        print('\n@ ModelBase.__new__', cls, name)
        print('  bases: ', bases)
        print('  attrs: ', attrs)

        if name == MODEL_BASE or bases[0].__name__ == MODEL_BASE:
            print('  对于临时类 _metaclass_helper_ 或者它的第一级子类 Model，直接返回新建的类')
            return super(ModelBase, cls).__new__(cls, name, bases, attrs,
                                                 **kwargs)
        
        print('  对于 Model 的子类，执行自定义操作')
        print('    1、获取内部类 Meta 的定义（Meta 主要用来定义数据库名、表名、主键等信息）')
        meta_options = {}
        meta = attrs.pop('Meta', None)
        if meta:
            for k, v in meta.__dict__.items():
                if not k.startswith('_'):
                    meta_options[k] = v
        print('    meta: ', meta)
        print('    meta_options: ', meta_options)
        
        print('    2、新建类对象', name)
        cls = super(ModelBase, cls).__new__(cls, name, bases, attrs, **kwargs)
        
        # 这两个是自定义的类属性
        print('      2.1 添加 User.__data__ 类属性，但我没发现这个类属性有啥用，因为最终实际数据是存放在 user.__dat__ 这个实例属性中的！')
        cls.__data__ = cls.__rel__ = None
        
        print('      2.2 添加 User._meta 属性，并给它加入该类的元信息（数据库名、表名、主键等）')
        cls._meta = None
        # cls._meta = Metadata(cls, **meta_options)  # 代表元属性的对象

        print('      2.3 获取类的字段信息 fields')
        fields = []
        for key, value in cls.__dict__.items():
            # 会先通过 isinstance(value, Field) 判断是不是字段类型，是的才添加进 fields
            fields.append((key, value))
        
        print('      2.4 将字段信息 fields 通过 add_field() 添加到 cls._meta 中')
        print('          add_field() 还有一个很重要的作用！！')
        print('          就是调用 Field.bind() 方法，将 User.uid 这个原本定义为 CharField 类型的属性，替换为 FieldAccessor 类！')
        # for name, field in fields:
            # cls._meta.add_field(name, field)
        
        print('      2.5 执行其他操作，比如验证类对象、设置外键等')
        # ...

        print('    3、 返回类对象 %s' % name)
        return cls
    pass

# Metadata 类是存放 Model 的元数据的类，包括 数据库名，表名，主键，字段信息
# 【很重要】的一点是，在 Metadata.add_field() 方法中，
# 它会将 User.uid 类属性，转移到自己的 self.fieds, self.columns 实例属性中
# 并且将原来类型为 CharField 类型的 User.uid 类属性，通过 Field.bind() 方法转换成 FieldAccessor 类型。
# FiledAccessor 类定义了 __get__, __set__ 方法，允许通过 u1.uid 直接访问该字段的真实值。
class Metadata(object):
    pass

# Node 类是用来作为查询语句的中间节点，暂且不讨论
class Node(object):
    pass

# Model 是该 ORM 中所有自定义 model_class 的基类
# 它的一大作用就是将元数据中的默认字段值放到 self.__data__ 实例属性中
class Model(with_metaclass(ModelBase, Node)):
    def __init__(self, *args, **kwargs):
        print('@ Model.__init__', args ,kwargs)

        print('  1. 设置 __data__ 属性，为 _meta 元数据中记录的字段默认值')
        # self.__data__ = self._meta.get_default_dict()
        
        print('  2. 设置 _dirty 属性，代表被修改过的 “脏字段”')
        # self._dirty = set(self.__data__)

        print('  3. 设置其他对象属性')
        for k in kwargs:
            setattr(self, k, kwargs[k])
    pass

# 自定义的 model_class 类
class User(Model):
    uid = uuid.uuid4().hex
    class Meta: 
        database = 'xx.db'
    pass

print('User 类定义完成')

u1 = User()

总结一下就是：

① 用户自定义的模型类 User 继承自 Model 类，Model 类的元类是 ModelBase。

② 所以 User 类也是 ModelBase 元类的对象实例，由 ModelBase.__new__() 负责创建。

③ 在创建 User 类的时候，ModelBase 会为其生成一个 User._meta 类属性，它是 Metadata 类型的对象实例。然后将 User 的数据名、表名、主键、字段信息等元数据保存到 User._meta 中。

④ 在 User._meta.add_field() 方法中，还会将用户定义的 User.uid 这些代表字段信息的类属性，转换成 FiledAccessor 类型。这样，用户就可以使用 user.uid 来访问真实的字段值（FiledAccessor.__get__(), FiledAccessor.__set__()）。而此时访问 User.uid 返回的则是 FiledAccessor.field 。

⑤ 在实例化 User 的时候，由 Model.__init__() 负责初始化 self.__data__ 这个实例属性，这里保存着 User 模型真实的字段值。

4.2 为什么 Model 实例打印出来会是 None？

peewee 中 Model 实例打印出来的时候显示为 None，其实是因为这段代码：

class Model(with_metaclass(ModelBase, Node)):
    # ...
    def __str__(self):
        return str(self._pk) if self._meta.primary_key is not False else 'n/a'

Model 类重写了 __str__(self) 方法，打印的是主键字段 self.pk。如果未设置主键，默认情况下就是 None，所以打印的是 str(None)。

只有像如下代码，在 Model 类中特别设置 _meta.primary_key = False 的，才会返回出 'n/a'。

class NoPrimaryKey(Model):
    # ...
    class Meta:
        primary_key = False

要想改变这个情况，变成原先预期的打印出对象类型与内存地址，我们可以在子类中重写 Model 的 __str__() 方法：

def __str__(self):
    # return self.__repr__()  # 这里不能使用 self.__repr__()。是因为在 peewee.py 中，ModelBase 基类在 __repr__() 方法中调用了 __str__()方法。
                              # 这时如果不重写 __repr__()，却又在 __str__() 中调用 __repr__()，就会导致调用死循环。
    return object.__repr__(self)