Was ist das Objektmodell von Python?

In der objektorientierten Theorie gibt es zwei Kernkonzepte: Klassen und Instanzen. Eine Klasse kann als Vorlage betrachtet werden, und Instanzen sind Objekte, die auf Grundlage dieser Vorlage erstellt werden. In Python werden sowohl Klassen als auch Instanzen als Objekte betrachtet, nämlich Klassenobjekte (oder Typobjekte) und Instanzobjekte.

Um spätere Unklarheiten zu vermeiden, unterteilen wir hier Objekte in drei Typen:

• Eingebaute Klassenobjekte: wie int, str, list, type, object usw.;

• Benutzerdefinierte Klassenobjekte: durch Klassenschlüssel Eine durch ein Wort definierte Klasse, natürlich werden wir sie und die oben genannten integrierten Klassenobjekte auch als Klassenobjekte (oder Typobjekte) bezeichnen

• Instanzobjekte: von Klassenobjekten erstellte Instanzen (erstellt); in Klassenobjekten oder benutzerdefinierten Klassenobjekten). is-instance-of: Entspricht der Beziehung zwischen Instanzobjekten und Klassenobjekten in der objektorientierten Theorie. , Girl (benutzerdefiniertes Klassenobjekt), girl (Instanzobjekt).

Offensichtlich gibt es eine Art Beziehung zwischen Mädchen und Objekt, das heißt, Mädchen ist eine Unterklasse des Objekts. Es ist erwähnenswert, dass alle Klassen in Python3 (außer Objekt) standardmäßig vom Objekt erben. Auch wenn wir das Objekt hier nicht explizit erben, werden wir es standardmäßig erben, aber der Erklärung halber werden wir es schreiben.

Zusätzlich dazu, dass Girl eine Unterklasse des Objekts ist, können wir auch sehen, dass es eine Ist-Instanz-von-Beziehung zwischen Mädchen und Mädchen gibt, das heißt, Mädchen ist eine Instanz von Mädchen. Wenn wir noch einen Schritt weiter gehen, gibt es natürlich auch eine Ist-Instanz-von-Beziehung zwischen Mädchen und Objekt, und Mädchen ist auch eine Instanz von Objekt.

class Girl(object):

    def say(self):
        return "古明地觉"

girl = Girl()
print(girl.say())  # 古明地觉

Girl erhält nach der Instanziierung eine Girl-Instanz, sodass der Aufruf von type(girl) das Girl-Klassenobjekt zurückgibt. Girl ist ein Instanzobjekt der Object-Klasse, da es die Object-Klasse erbt. Was das Prinzip betrifft, werden wir es langsam einführen.

• Python bietet auch einige Möglichkeiten, diese Beziehungen zu erkennen. Zusätzlich zum oben genannten Typ können Sie auch das __class__-Attribut des Objekts verwenden, um die Ist-Instanz-Beziehung zwischen einem Objekt und anderen Objekten zu erkennen.

Das __bases__-Attribut des Objekts kann die Art-Beziehung zwischen einem Objekt und anderen Objekten erkennen. Darüber hinaus bietet Python zwei Funktionen, issubclass und isinstance, um zu überprüfen, ob die erwartete Beziehung zwischen zwei Objekten besteht.

• class Girl(object):
      pass
      
  girl = Girl()
  print(issubclass(Girl, object))  # True 
  print(type(girl))  # <class &#39;__main__.Girl&#39;>
  print(isinstance(girl, Girl))  # True
  print(isinstance(girl, object))  # True

  Zeichnen wir zur Zusammenfassung ein Bild:

Darüber hinaus müssen Sie auf den Typ und das darin enthaltene Objekt achten:

Typ und Objekt haben eine gewisse Beziehung, da der Typ ein ist Unterklasse von Objekt;

Objekt und Typ haben eine Ist-Instanz-von-Beziehung, da Objekt ein Instanzobjekt des Typs ist;

Einige Leute sind vielleicht neugierig, warum dies der Fall ist, und ich Ich habe diesen Artikel über den Streit zwischen Typ und Objekt geschrieben. Er ist sehr ausführlich. Wenn Sie interessiert sind, können Sie hier klicken, um ihn zu lesen.

Einfach ausgedrückt ist die Struktur, die dem Typ auf der untersten Ebene entspricht, PyType_Type, und die Struktur, die dem Objekt auf der untersten Ebene entspricht, ist PyBaseObject_Type. Legen Sie beim Erstellen eines Objekts den internen ob_type auf &PyType_Type fest; beim Erstellen eines Typs legen Sie den internen tp_base auf &PyBaseObject_Type fest.

Die beiden Definitionen sind also voneinander abhängig und erscheinen gleichzeitig, wie wir später sehen werden.

Darüber hinaus ist der Typtyp der Typ selbst, also:

• Der Typ des Instanzobjekts ist Typobjekt und der Typ des Typobjekts ist Metaklasse;

• Die Basisklasse aller Typobjekte konvergiert Objekt;

Die Typen aller Objekte konvergieren zum Typ;

Daher kann Python als das Konzept angesehen werden, dass alles ein Objekt im Extremfall ist so hervorragende dynamische Eigenschaften.

• Aber es ist noch nicht vorbei. Werfen wir einen Blick auf das Verhalten des Klassenobjekts Girl. Zunächst unterstützt es die Attributeinstellung:

  class Girl(object):
      pass 
  
  girl = Girl()
  print(girl.__class__)  # <class &#39;__main__.Girl&#39;>
  print(Girl.__class__)  # <class &#39;type&#39;>
  # __class__是查看自己的类型是什么，也就是生成自己的类
  # 而在介绍 Python 对象的时候，我们就看到了
  # 任何一个对象都至少具备两个东西: 一个是引用计数、一个是类型
  # 所以 __class__ 是所有对象都具备的
  
  # __base__只显示直接继承的第一个类
  print(Girl.__base__)  # <class &#39;object&#39;>
  # __bases__ 会显示直接继承的所有类，以元组的形式
  print(Girl.__bases__)  # (<class &#39;object&#39;>,)

  In anderen statischen Sprachen können Sie nach der Definition einer Klasse keine Attribute mehr hinzufügen, aber in Unsere Sprache können Sie. Wie implementiert Python das dynamische Hinzufügen von Attributen? Im Allgemeinen denken wir an ein Wörterbuch. Wir gehen davon aus, dass eine Klasse auch ein eigenes Attributwörterbuch haben sollte. Das Festlegen von Attributen in einer Klasse entspricht dem Hinzufügen von Schlüssel-Wert-Paaren zum Wörterbuch sind ähnlich.

class Girl(object):
    pass

print(hasattr(Girl, "name"))  # False
Girl.name = "古明地觉"
print(hasattr(Girl, "name"))  # True
print(Girl.name)  # 古明地觉

• ähnelt der Bedienung globaler Variablen, es gibt jedoch eine Sache zu beachten: Wir können Attribute nicht direkt über das Attributwörterbuch der Klasse festlegen.

  try:
      Girl.__dict__["name"] = "古明地觉"
  except Exception as e:
      print(e)  
  # 'mappingproxy' object does not support item assignment

  虽然叫属性字典，但其实是 mappingproxy 对象，该对象本质上就是对字典进行了一层封装，在字典的基础上移除了增删改操作，也就是只保留了查询功能。要给类增加属性，可以使用直接赋值的方式或调用 setattr 函数。

  但在介绍如何篡改虚拟机的时候，我们提到过一个骚操作，可以通过 gc 模块拿到 mappingproxy 对象里的字典。

  import gc
  
  class Girl(object):
      pass
  
  gc.get_referents(Girl.__dict__)[0]["name"] = "古明地觉"
  print(Girl.name)  # 古明地觉

  并且这种做法除了适用于自定义类对象，还适用于内置类对象。但是工作中不要这么做，知道有这么个操作就行。

  除了设置属性之外，我们还可以设置函数。

  class Girl(object):
      pass
  
  Girl.info = lambda name: f"我是{name}"
  print(Girl.info("古明地觉"))  # 我是古明地觉
  
  # 如果实例调用的话，会和我们想象的不太一样
  # 因为实例调用的话会将函数包装成方法
  try:
      Girl().info("古明地觉")
  except TypeError as e:
      print(e) 
  """
  <lambda>() takes 1 positional argument but 2 were given
  """    
  
  # 实例在调用的时候会将自身也作为参数传进去
  # 所以第一个参数 name 实际上接收的是 Girl 的实例对象
  # 只不过第一个参数按照规范来讲应该叫做self
  # 但即便你起别的名字也是无所谓的
  print(Girl().info())  
  """
  我是<__main__.Girl object at 0x000001920BB88760>
  """

  所以我们可以有两种做法：

  # 将其包装成一个静态方法
  # 这样类和实例都可以调用
  Girl.info = staticmethod(lambda name: f"我是{name}")
  print(Girl.info("古明地觉"))  # 我是古明地觉
  print(Girl().info("古明地觉"))  # 我是古明地觉
  
  # 如果是给实例用的，那么带上一个 self 参数即可
  Girl.info = lambda self, name: f"我是{name}"
  print(Girl().info("古明地觉"))  # 我是古明地觉

  此外我们还可以通过 type 来动态地往类里面进行属性的增加、修改和删除。

  class Girl(object):
  
      def say(self):
          pass
  
  print(hasattr(Girl, "say"))  # True
  # delattr(Girl, "say") 与之等价
  type.__delattr__(Girl, "say")
  print(hasattr(Girl, "say"))  # False
  # 我们设置一个属性吧
  # 等价于 Girl.name = "古明地觉"
  setattr(Girl, "name", "古明地觉")
  print(Girl.name)  # 古明地觉

  事实上调用 getattr、setattr、delattr 等价于调用其类型对象的__getattr__、__setattr__、__delattr__。

  所以，一个对象支持哪些行为，取决于其类型对象定义了哪些操作。并且通过对象的类型对象，可以动态地给该对象进行属性的设置。Python 所有类型对象的类型对象都是 type，通过 type 我们便可以控制类的生成过程，即便类已经创建完毕了，也依旧可以进行属性设置。

  但是注意：type 可以操作的类只能是通过 class 定义的动态类，而像 int、list、dict 等静态类，它们是在源码中静态定义好的，只不过类型设置成了 type。一言以蔽之，type 虽然是所有类对象的类对象，但 type 只能对动态类进行属性上的修改，不能修改静态类。

  try:
      int.name = "古明地觉"
  except Exception as e:
      print(e)
  """
  can't set attributes of built-in/extension type 'int'
  """
  
  try:
      setattr(int, "ping", "pong")
  except Exception as e:
      print(e)
  """
  can't set attributes of built-in/extension type 'int'     
  """

  内置类和扩展类的属性无法被设置，这是由于内置类在解释器启动后就已被初始化。可以通过报错信息观察到这点。我们所说的扩展类，是指我们使用 Python/C API 编写的扩展模块中的类，其与内置类具有相同的地位。

  因此内置类和使用 class 定义的类本质上是一样的，都是 PyTypeObject 对象，它们的类型在 Python 里面都是 type。不同的是，内置类在底层是以静态初始化方式实现的，因此我们无法通过动态设置属性的方式来操作它们（除非使用 gc 模块）。

  但是为什么不可以对内置类和扩展类进行属性设置呢？首先我们要知道 Python 的动态特性是虚拟机赐予的，而虚拟机的工作就是将 PyCodeObject 对象翻译成 C 的代码进行执行，所以 Python 的动态特性就是在这一步发生的。

  同理，扩展类和内置类在解释器启动后都已经被静态初始化，并直接指向 C 一级的数据结构。它们与解释执行绕开了相应过程，因此无法在其上动态添加属性。

  不光内置的类本身，还有它的实例对象也是如此。

  a = 123
  print(hasattr(a, "__dict__"))  # False

  我们发现它甚至连自己的属性字典都没有，因为解释器对于内置类对象的实例对象，其内部的属性和方法是已知的。由于底层代码已被固定且不允许修改，因此在实现虚拟机时无需创建属性字典，以节省内存。

Das obige ist der detaillierte Inhalt vonWas ist das Objektmodell von Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!