Eine Klasse ist ein benutzerdefinierter Typ, den Entwickler instanziieren können, um eine Instanz zu erhalten, die ein Objekt dieses Typs darstellt. In Python sind Klassen Objekte und Entwickler können Funktionen wie andere Objekte behandeln. Sie können eine Klasse als Parameter übergeben, wenn sie eine Funktion aufrufen, oder sie können eine Klasse als Ergebnis eines Funktionsaufrufs zurückgeben. Jedes Objekt, auch ein Klassenobjekt, hat einen Typ. In Python sind Typen und Klassen ebenfalls erstklassige Objekte. Der Typ eines Klassenobjekts wird auch als Metaklasse der Klasse bezeichnet. Das Verhalten eines Objekts wird in erster Linie durch den Objekttyp dieser Klasse bestimmt. Dies gilt auch für Klassen: Auch das Verhalten einer Klasse wird in erster Linie durch ihre Metaklasse bestimmt.
Die Klassenanweisung ist die am häufigsten verwendete Methode zum Erstellen eines Klassenobjekts. Wie folgt:
class classname(base_classes): statement(s)
classname ist ein Bezeichner. Der Bezeichner ist eine Variable, die nach Ausführung der Klassenanweisung an das Klassenobjekt gebunden wird. base_classes ist eine durch Kommas getrennte Folge von Ausdrücken, deren Werte Klassenobjekte sein müssen. Zum Beispiel:
class C（B1，B2）： #B1和B2都是类 statement(s)
Bitte beachten Sie abschließend, dass die Klassenanweisung keine Instanz der neuen Klasse direkt erstellt, sondern den Satz von Attributen definiert, die allen Instanzen gemeinsam sind, wenn diese Klasse zum Erstellen einer Instanz aufgerufen wird in der Zukunft (d. h. Klassenobjekteigenschaften).
Sie können normalerweise ein Attribut eines Klassenobjekts (d. h. ein Klassenattribut) angeben, indem Sie einen Wert an einen Bezeichner im Klassenkörper binden. Beispiel:
class C1(object): x = 23print C1.x #print:23
Das Klassenobjekt C1 enthält eine Eigenschaft namens x, die an den Wert 23 gebunden ist. Wir sollten wissen, dass jedes Klassenattribut implizit von allen Instanzen dieser Klasse gemeinsam genutzt wird, wenn eine Instanz erstellt wird.
Klassenobjekte legen implizit bestimmte Klassenattribute fest. Das Attribut __name__ ist eine Klassennamen-ID-Zeichenfolge. Das Attribut __bases__ ist ein Tupel von Klassenobjekten der Basisklasse der Klasse. Zum Beispiel:
print C1.__name__, C1.__bases__ #print: C1, (<type>)</type>
Das Klassenobjekt enthält auch ein Attribut __dict__, das ein Wörterbuchobjekt der Klasse ist und zum Speichern aller anderen Attribute verwendet wird. Für jedes Klassenobjekt C, jedes Objekt x und jeden Bezeichner S (außer __name__, __bases__ und __dict__) ist C.S gleich C.__dict__[‘S’] = x. Beispiel:
C1.y = 45C1.__dict__['z']= 67print C1.y,C1z #print: 45, 67
Eine Instanz einer Klasse ist ein Python-Objekt mit Eigenschaften beliebigen Namens, das Entwickler binden und referenzieren können. Um eine Instanz einer Klasse zu erstellen, rufen Sie das Klassenobjekt auf, als wäre das Objekt eine Funktion. Jeder Aufruf gibt eine neue Instanz des Typs zurück:
anInstance = C1()
Entwickler können die integrierte Funktion isinstance(I, C) mit einem Klassenobjekt als Parameter C aufrufen. Die Instanz gibt „True“ zurück, wenn Objekt I eine Instanz der Klasse C oder einer Unterklasse der Klasse C ist, andernfalls gibt sie „False“ zurück.
Wenn eine Klasse eine Methode namens __init__ definiert oder erbt, führt der Aufruf des Klassenobjekts implizit die __int__-Methode auf der neuen Instanz aus, um alle erforderlichen instanzbezogenen Initialisierungen durchzuführen. Die in diesem Aufruf übergebenen Parameter müssen bis auf den Parameter self den Parametern von __init__ entsprechen. Zum Beispiel:
class C6（objec）: def __init__(self, n); self.x = n
Erstellen Sie eine Instanz der Klasse C6:
anInstance = C6(42)
Der Hauptzweck von __init__ besteht darin, die Eigenschaften der neu erstellten Instanz zu binden und somit zu erstellen. Die Methode __init__ kann keinen Wert zurückgeben, andernfalls löst Python eine TypeError-Ausnahme aus.
Für jede Instanz z ist z..__class__ das Klassenobjekt, zu dem z gehört, und z..__dict__ ist das Wörterbuch, das von z zum Speichern anderer Attribute verwendet wird. Beispiel:
print anInstance.__classs__.__name__, anInstance .__dict__ #print: C6, {'x' : 42}Für jede Instanz z, jedes Objekt x und jeden Bezeichner S (außer __classs und __dict__) ist z.S = x gleich z.__dict__[‘S’] = x. Zum Beispiel:
z.y = 45z.__dict__['z'] = 67print z.y, z.z #print: 45, 67
Jeder neue Bibliothekstyp hat (oder erbt) eine statische Methode namens __new__. Wenn ein Entwickler C(*args, **kwds) aufruft, um eine Instanz der Klasse C zu erstellen, ruft Python zuerst C.__new__(C,*args, **kwds) auf. Python verwendet den Rückgabewert x von __new__ als neu erstellte Instanz. Dann ruft Python C.__init__(x,*args, **kwds) auf, aber diese Methode wird nur aufgerufen, wenn bestätigt wird, dass x eine Instanz von C oder eine Unterklasse von C ist. Beispiel: Die Anweisung x = C(23) entspricht:
x = C.__new__（C, 23）if isinstance(x, C): type(x).__init__(x, 23)
object.__new__ erstellt eine neue und nicht initialisierte Instanz der Klasse, die sie als erstes Argument akzeptiert. Wenn diese Klasse eine __init__-Methode enthält, ignoriert die Methode andere Parameter. Wenn die Methode jedoch zusätzlich zum ersten Parameter weitere Parameter akzeptiert und die Klasse des ersten Parameters keine __init__-Methode enthält, löst diese Methode eine Ausnahme aus. Der obige Inhalt wird unten durch die Implementierung des Singleton-Entwurfsmusters demonstriert.
class Singleton(object): ## @var __Instance __Instance = None @staticmethod def GetInstance(): if Singleton.__Instance == None: Singleton.__Instance = Singleton() return Singleton.__Instance def __new__(cls, *args, **kv): print "__new__" if Singleton.__Instance == None: Singleton.__Instance = object.__new__( cls ) print "Singleton.__Instance:", Singleton.__Instance return Singleton.__Instance def __init__(self, x): print "__init__" print "self:", self self.x = x print x def PrintX(self): print self.x anInstance = Singleton(23) anotherInstance = Singleton(32)
从上面运行结果我们可以看出，创建一个新实例时，先调用new方法，再调用init方法。单实例通过重写new方法，第二次实例化时，new返回上次的实例，然后该实例再次调用init方法。
类(class)是一个用户自定义类型，开发者可以将其实例化以获得实例（instance），实例表示这种类型的对象。在Python中，类就是对象，开发者可以像对其他对象那样处理函数，可以在调用函数时传递一个类作为参数，也可以返回一个类作为函数调用的结果。任何对象，即使是一个类对象，都有一个类型。在Python中，类型和类也都是第一类对象。类对象的类型也被称为该类的元类（metaclass）。对象的行为主要是由该类对象的类型确定的。这也适用于类：类的行为也是主要由该类的元类确定的。
class语句是创建一个类对象最常用的方法。如下：
class classname(base_classes): statement(s)
classname是一个标识符。该标识符是一个在执行完class语句之后被绑定到类对象的变量。base_classes是一个使用逗号分隔的表达式序列，这些表达式的值必须是类对象。例如：
class C（B1，B2）： #B1和B2都是类 statement(s)
最后，请注意，class语句并不直接创建新类的任何一个实例，而是定义了在以后调用这个类创建实例时，所有实例共有的属性集（即类对象属性）。
通常可以通过将一个值绑定到类体中的一个标识符上来指定类对象的一个属性（即类属性）。例如：
class C1(object): x = 23print C1.x #print:23
类对象C1包含一个名为x的属性，该属性被绑定为值23。我们应该知道，在实例被创建时，任何类属性都由该类的所有实例隐式共享。
类对象会隐式设置某些类属性。属性__name__是类名标识符字符串。属性__bases__是类的基类的类对象的元组。例如：
print C1.__name__, C1.__bases__ #print: C1, (<type>)</type>
类对象还包含一个属性__dict__，这个属性是该类的字典对象，被用来保存所有其他属性。对于任何类对象C、任何对象x，以及任何标识符S（除了__name__、__bases__和__dict__），C.S等于C.__dict__[‘S’]=x。例如：
C1.y = 45C1.__dict__['z']= 67print C1.y,C1z #print: 45, 67
类的实例是一个带有任意名称的属性的Python对象，开发者可以绑定和引用这些属性。要想创建一个类的实例，可以调用类对象，就像该对象是一个函数一样。每个调用都将返回一个类型为该类的新实例：
anInstance = C1()
开发者可以调用内置函数isinstance(I, C)，并使用一个类对象作为参数C。如果对象I是类C或类C的任何子类的一个实例，则instance将返回True，否则返回False。
当一个类定义或继承了一个名为__init__的方法时，调用该类对象将对新实例隐式执行__int__方法以执行任何需要的与实例相关的初始化。该调用中传递的参数必须对应于__init__的参数，除了参数self。例如：
class C6（objec）: def __init__(self, n); self.x = n
创建类C6的一个实例：
anInstance = C6(42)
__init__的主要目的就是绑定，并因此创建新创建的实例的属性。__init__方法不能返回一个值，否则，Python将引发一个TypeError异常。
对于任何实例z，z..__class__是z所属的类对象，而z..__dict__是z用来保存其他属性的字典。例如：
print anInstance.__classs__.__name__, anInstance .__dict__ #print: C6, {'x' : 42}对于任何实例z，任何对象x和任何标识符S（除了__classs和__dict__），z.S = x等于z.__dict__[‘S’] = x。例如：
z.y = 45z.__dict__['z'] = 67print z.y, z.z #print: 45, 67
每个新型累都有（或者继承了）一个名为__new__的静态方法。当开发者调用C(*args, **kwds)来创建类C的一个实例时，Python将首先调用C.__new__(C,*args, **kwds)。Python使用__new__的返回值x作为新创建的实例。然后，Python将调用C.__init__(x,*args, **kwds)，但是只有在x确认是C的一个实例，或者C的任何一个子类时才会调用该方法。例如:语句x = C(23)等同于：
x = C.__new__（C, 23）if isinstance(x, C): type(x).__init__(x, 23)
object.__new__可以创建其接受为第一个参数的类的一个新的和未初始化的实例。如果这个类包含一个__init__方法，则该方法将忽略其他参数，但是，如果除了第一个参数，该方法还接受了其他参数，并且第一个参数的类不包含__init__方法，则该方法将引发一个异常。下面通过实现Singleton设计模式来演示上面内容。
class Singleton(object): ## @var __Instance __Instance = None @staticmethod def GetInstance(): if Singleton.__Instance == None: Singleton.__Instance = Singleton() return Singleton.__Instance def __new__(cls, *args, **kv): print "__new__" if Singleton.__Instance == None: Singleton.__Instance = object.__new__( cls ) print "Singleton.__Instance:", Singleton.__Instance return Singleton.__Instance def __init__(self, x): print "__init__" print "self:", self self.x = x print x def PrintX(self): print self.x anInstance = Singleton(23) anotherInstance = Singleton(32)
从上面运行结果我们可以看出，创建一个新实例时，先调用new方法，再调用init方法。单实例通过重写new方法，第二次实例化时，new返回上次的实例，然后该实例再次调用init方法。
Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von Beispielen für Python-Klassen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
