Java是我专业使用的第一种语言，也是我后来学习其他语言时的衡量标准。它是一种面向对象的静态类型语言。因此，Python的动态类型方法让我感到有些奇怪。

例如，Object提供了equals()、hashCode()和toString()方法。因为所有其他类都直接或间接地继承自Object，所以所有对象在定义上都具有这些方法。

相反，Python最初并不是建立在面向对象的原则上，而是动态类型的。然而，任何语言都需要处理无关对象的交叉特性。在Python中，这些是特别命名的方法：运行时以特定方式解释的方法，但你需要了解它们。你可以称它们为魔术方法。

文档非常详尽，但对于初学者来说，需要一些示例。本文的目标是列出大部分这些方法，并提供这些示例，以便我能记住它们。我将其分为两部分，以便更容易理解。

生命周期方法

本节中的方法与新对象的生命周期有关。

object.__new__(cls[, ...])

__new()__方法是静态的，尽管不需要明确标记为静态。该方法必须 返回类型为cls的新对象实例；然后，运行时将在新实例上调用__init__()方法（见下文）。

__new__()旨在自定义不可变类的子类的实例创建。

class FooStr(str):                                     #1

    def __new__(cls, value):
        return super().__new__(cls, f'{value}Foo')     #2

print(FooStr('Hello'))                                 #3

1. 继承自str。
2. 创建一个新的str实例，其值为传递给构造函数的值，后缀为Foo。
3. 打印HelloFoo。

object.__init__(self[, ...])

__init__()是常规的初始化方法，如果你读过任何基本的Python教程，你可能已经了解它。与Java最显著的区别是，没有隐式调用超类的__init__()方法。一个人只能想象有多少bug是因为有人忘记调用超类方法而引入的。

__init__()与构造函数的区别在于对象已经被创建。

class Foo:

  def __init__(self, a, b, c):                         #1
    self.a = a                                         #2
    self.b = b                                         #2
    self.c = c                                         #2

foo = Foo('one', 'two', 'three')
print(f'a={foo.a}, b={foo.b}, c={foo.c}')              #3

1. 第一个参数是实例本身。
2. 初始化实例。
3. 打印a=one, b=two, c=three。

object.__del__(self)

如果__init()__类似于初始化程序，那么__del__()就是终结程序。与Java一样，终结程序是不可靠的，例如，没有保证解释器在关闭时会终结实例。

表示方法

Python提供了两种主要表示对象的方式：一种是用于调试目的的“官方”方式，另一种是“非正式”的方式。你可以使用前者来重建对象。

官方表示是通过object.__repr__(self)表达的。文档规定表示必须是“信息丰富且明确的”。

class Foo:

  def __init__(self, a, b, c):
    self.a = a
    self.b = b
    self.c = c

  def __repr__(self):
    return f'Foo(a={foo.a}, b={foo.b}, c={foo.c})'

foo = Foo('one', 'two', 'three')
print(foo)                                             #1

1. 打印Foo(a=one, b=two, c=three)。

我的实现返回一个string，尽管这不是必需的。然而，你可以使用显示的信息重建对象。

object.__str__(self)处理非正式表示。顾名思义，它必须返回一个string。默认调用__repr__()。

除了上述两种方法，object.__format__(self, format_spec)方法返回对象的string表示。第二个参数遵循格式规范迷你语言的规则。注意，该方法必须 返回一个string。这有点复杂，所以我不会实现它。

最后，object.__bytes__(self)返回对象的字节表示。

from pickle import dumps                              #1

class Foo:

  def __init__(self, a, b, c):
    self.a = a
    self.b = b
    self.c = c

  def __repr__(self):
    return f'Foo(a={foo.a}, b={foo.b}, c={foo.c})'

  def __bytes__(self):
    return dumps(self)                                #2

foo = Foo('one', 'two', 'three')
print(bytes(foo))                                     #3

1. 使用pickle序列化库。
2. 委托给dumps()方法。
3. 打印foo的字节表示。

比较方法

让我们从与Java相似之处开始：Python有两种方法，object.__eq__(self, other)和object.__hash__(self)，它们的工作方式相同。如果为一个类定义了__eq__()，那么必须 也定义__hash__()。与Java相反，如果你没有定义前者，就不得 定义后者。

class Foo:

  def __init__(self, a, b):
    self.a = a
    self.b = b

  def __eq__(self, other):
    if not isinstance(other, Foo):                    #1
      return false
    return self.a == other.a and self.b == other.b    #2

  def __hash__(self):
      return hash(self.a + self.b)                    #3

foo1 = Foo('one', 'two')
foo2 = Foo('one', 'two')
foo3 = Foo('un', 'deux')

print(hash(foo1))
print(hash(foo2))
print(hash(foo3))

print(foo1 == foo2)                                   #4
print(foo2 == foo3)                                   #5

1. 不是相同类型的对象在定义上不相等。
2. 比较属性的相等性。
3. 哈希由两个属性的相加组成。
4. 打印True。
5. 打印False。

与Java一样，__eq__()__和__hash__()有很多陷阱。有些与Java相同，有些不同。我不会解释文档；你可以自行查看。

其他比较方法相当不言自明：

| 方法 | 运算符 | | --- | --- | | object.__lt__(self, other) | < | | object.__le__(self, other) | <= | | object.__ge__(self, other) | >= | | object.__ne__(self, other) | != |

class Foo:

  def __init__(self, a):
    self.a = a

  def __ge__(self, other):
    return self.a >= other.a                          #1

  def __le__(self, other):
    return self.a <= other.a                          #1

foo1 = Foo(1)
foo1 = Foo(1)
foo2 = Foo(2)

print(foo1 >= foo1)                                   #2
print(foo1 >= foo2)                                   #3
print(foo1 <= foo1)                                   #4
print(foo2 <= foo2)                                   #5

1. 比较单个属性。
2. 打印True。
3. 打印False。
4. 打印True。
5. 打印True。

请注意，比较方法可能返回除布尔值之外的其他值。在这种情况下，Python将使用bool()函数将该值转换为布尔值。我建议你不要使用这种隐式转换。

属性访问方法

如上所述，Python允许通过点符号访问对象的属性。如果属性不存在，Python会报错：'Foo' object has no attribute 'a'。然而，可以通过object.__getattr__(self, name)和object.__setattr__(self, name, value)方法在类上定义合成访问器。规则是它们是后备：如果属性不存在，Python会调用该方法。

class Foo:

  def __init__(self, a):
    self.a = a

  def __getattr__(self, attr):
    if attr == 'a':
      return 'getattr a'                              #1
    if attr == 'b':
      return 'getattr b'                              #2

foo = Foo('a')

print(foo.a)                                          #3
print(foo.b)                                          #4
print(foo.c)                                          #5

1. 如果请求的属性是a，则返回字符串。
2. 如果请求的属性是b，则返回字符串。
3. 打印a。
4. 打印getattr b。
5. 打印None。

另外，Python还提供了object.__getattribute__(self, name)。区别在于无论属性是否存在 ，它都会被调用，实际上会对其进行遮蔽。

class Foo:

  def __init__(self, a):
    self.a = a

  def __getattribute__(self, attr):
    if attr == 'a':
      return 'getattr a'                              #1
    if attr == 'b':
      return 'getattr b'                              #2

foo = Foo('a')

print(foo.a)                                          #3
print(foo.b)                                          #4
print(foo.c)                                          #5

1. 如果请求的属性是a，则返回字符串。
2. 如果请求的属性是b，则返回字符串。
3. 打印getattr a。
4. 打印getattr b。
5. 打印None。

dir()函数允许返回对象的属性和方法列表。你可以使用object.__dir__(self)方法设置列表。默认情况下，列表为空：你需要显式设置它。请注意，开发人员有责任确保列表包含实际的类成员。

class Foo:

  def __init__(self, a):
    self.a = 'a'

  def __dir__(self):                                  #1
    return ['a', 'foo']

foo = Foo('one')

print(dir(foo))                                       #2

1. 实现该方法。
2. 显示['a', 'foo']；Python对列表进行排序。请注意，没有foo成员。

描述符

Python描述符是访问器代理，类似于Kotlin的委托属性。其思想是在某处因子化行为，以便其他类可以重用它。因此，它们是有组合优先于继承的直接结果。它们适用于获取器、设置器和终结器，分别是：

• object.__get__(self, instance, owner=None)
• object.__set__(self, instance, value)
• object.__delete__(self, instance)

让我们实现一个惰性描述符，它缓存计算密集操作的结果。

class Lazy:                                           #1

  def __init__(self):
    self.cache = {}                                   #2

  def __get__(self, obj, objtype=None):
    if obj not in self.cache:
      self.cache[obj] = obj._intensiveComputation()   #3
    return self.cache[obj]

class Foo:

  lazy = Lazy()                                       #4

  def __init__(self, name):
    self.name = name
    self.count = 0                                    #5

  def _intensiveComputation(self):
    self.count = self.count + 1                       #6
    print(self.count)                                 #7
    return self.name

foo1 = Foo('foo1')
foo2 = Foo('foo2')

print(foo1.lazy)                                      #8
print(foo1.lazy)                                      #8
print(foo2.lazy)                                      #9
print(foo2.lazy)                                      #9

1. 定义描述符。
2. 初始化缓存。
3. 调用密集计算。

结论

这就是Python魔术方法的第一部分。第二部分将专注于与类、容器和数字相关的方法。