python 解释器是如何工作的呢?

python 解释器是如何工作的呢?
不管在哪种框架下写程序，都会花费大量时间去实现那些会被框架本身调用的方法， Python 也不例外。Python 解释器碰到特殊的句法时，会使用特殊方法去激活一些基本的对 象操作，这些特殊方法的名字以两个下划线开头，以两个下划线结尾
比如 obj[key] 的背后就是 __getitem__ 方法,

import collections
from random import choice
import pysnooper


Card = collections.namedtuple('Card', ['rank', 'suit'])


class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        self._cards = [Card(rank, suit) for suit in self.suits for rank in self.ranks]

    @pysnooper.snoop()
    def __len__(self):
        return len(self._cards)

    @pysnooper.snoop()
    def __getitem__(self, position):
        return self._cards[position]

    @pysnooper.snoop()
    def __contains__(self, item):
        if item:
            return True


if __name__ == '__main__':
    deck = FrenchDeck()
    print(len(deck))
    print(deck[1])

首先明确一点，特殊方法的存在是为了被 Python 解释器调用的，你自己并不需要调用它 们。也就是说没有 my_object.__len__() 这种写法，而应该使用 len(my_object)。在执行 len(my_object) 的时候，如果 my_object 是一个自定义类的对象，那么 Python 会自己去调 用其中由你实现的 __len__ 方法。但是，如果是 Python 内置的类型，比如列表（list）、字符串（str）、字节序列（bytearray） 等，那么CPython 会抄个近路，__len__ 实际上会直接返回PyVarObject 里的ob_size 属 性。PyVarObject 是表示内存中长度可变的内置对象的 C 语言结构体。直接读取这个值比 调用一个方法要快很多。

很多时候，特殊方法的调用是隐式的，比如for i in x: 这个语句，背后其实用的是 iter(x)，而这个函数的背后则是 x.__iter__() 方法。当然前提是这个方法在 x 中被实现了。

通常你的代码无需直接使用特殊方法。除非有大量的元编程存在，直接调用特殊方法的频 率应该远远低于你去实现它们的次数。唯一的例外可能是 __init__ 方法，你的代码里可能 经常会用到它，目的是在你自己的子类的 __init__ 方法中调用超类的构造器。

下面在介绍一些特殊方法的实现
__repr__、__abs__、 __add__ 和 __mul__

from math import hypot
import pysnooper


class Vector:

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    @pysnooper.snoop()
    def __repr__(self):
        return 'Vector(%r, %r)' % (self.x, self.y)

    @pysnooper.snoop()
    def __str__(self):
        return '对象字符串化%r' % self

    @pysnooper.snoop()
    def __abs__(self):
        return hypot(self.x, self.y)

    @pysnooper.snoop()
    def __bool__(self):
        return bool(abs(self))

    @pysnooper.snoop()
    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Vector(x, y)

    @pysnooper.snoop()
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    @pysnooper.snoop()
    def __len__(self):
        return True if self else False


if __name__ == "__main__":
    vector = Vector(3, 4)
    vector_1 = Vector(5, 12)
    print(vector.__repr__())
    print(abs(vector))
    vector_3 = vector + vector_1
    print(vector_3)
    print(vector_3*3)
    print(str(vector_3))
    print(vector_3.__len__())
    print(bool(vector_3))
    bool()

__repr__ 和 __str__（都是打印输出的作用） 区别在于，后者是在 str() 函数被使用，或是在用 print 函数打印 一个对象的时候才被调用的，并且它返回的字符串对终端用户更友好。
如果你只想实现这两个特殊方法中的一个，__repr__ 是更好的选择，因为如果一个对象没 有 __str__ 函数，而 Python 又需要调用它的时候，解释器会用 __repr__ 作为替代。

其他的python 特殊方法


这里对于__len__ 方法做一个特殊说明：对于用户自定义的方法，Python 会自己去调 用其中由你实现的__ len__ 方法, 但对于python内置的类型 ，比如列表（list）、字符串（str）、字节序列（bytearray） 等，那么CPython 会抄个近路，len 实际上会直接返回PyVarObject 里的ob_size 属 性。PyVarObject 是表示内存中长度可变的内置对象的 C 语言结构体。直接读取这个值比 调用一个方法要快很多。