Une classe est un type défini par l'utilisateur que les développeurs peuvent instancier pour obtenir une instance, qui représente un objet de ce type. En Python, les classes sont des objets et les développeurs peuvent traiter les fonctions comme les autres objets. Ils peuvent transmettre une classe en tant que paramètre lors de l'appel d'une fonction, ou ils peuvent renvoyer une classe comme résultat d'un appel de fonction. Tout objet, même un objet de classe, possède un type. En Python, les types et les classes sont également des objets de première classe. Le type d’un objet classe est également appelé métaclasse de la classe. Le comportement d'un objet est principalement déterminé par le type d'objet de cette classe. Cela s'applique également aux classes : le comportement d'une classe est également principalement déterminé par sa métaclasse.

instruction de classe

L'instruction de classe est la méthode la plus couramment utilisée pour créer un objet de classe. Comme suit :

class classname(base_classes):
    statement(s)

classname est un identifiant. L'identifiant est une variable liée à l'objet de classe après l'exécution de l'instruction de classe. base_classes est une séquence d'expressions séparées par des virgules dont les valeurs doivent être des objets de classe. Par exemple :

class C（B1，B2）：  #B1和B2都是类
   statement(s)

Enfin, veuillez noter que l'instruction class ne crée directement aucune instance de la nouvelle classe, mais définit l'ensemble des attributs communs à toutes les instances lorsque cette classe est appelée pour créer une instance dans le futur (c'est-à-dire les propriétés des objets de classe).

Attribut d'objet de classe

Vous pouvez généralement spécifier un attribut d'un objet de classe (c'est-à-dire un attribut de classe) en liant une valeur à un identifiant dans le corps de la classe. Par exemple :

class C1(object):
    x =  23print C1.x                 #print:23

L'objet de classe C1 contient une propriété nommée x, qui est liée à la valeur 23. Nous devons savoir que tout attribut de classe est implicitement partagé par toutes les instances de cette classe lorsqu'une instance est créée.
Les objets de classe définiront implicitement certains attributs de classe. L'attribut __name__ est une chaîne d'identification de nom de classe. L'attribut __bases__ est un tuple d'objets de classe de la classe de base de la classe. Par exemple :

print C1.__name__, C1.__bases__            #print: C1, (<type>)</type>

L'objet de classe contient également un attribut __dict__, qui est un objet dictionnaire de la classe et est utilisé pour enregistrer tous les autres attributs. Pour tout objet de classe C, tout objet x et tout identifiant S (sauf __name__, __bases__ et __dict__), C.S est égal à C.__dict__['S'] = x. Par exemple :

C1.y = 45C1.__dict__['z']= 67print C1.y,C1z                 #print: 45, 67

Instance

Une instance d'une classe est un objet Python avec des propriétés de n'importe quel nom que les développeurs peuvent lier et référencer. Pour créer une instance d'une classe, vous appelez l'objet classe comme si l'objet était une fonction. Chaque appel renverra une nouvelle instance du type :

anInstance = C1()

Les développeurs peuvent appeler la fonction intégrée isinstance(I, C) avec un objet de classe comme paramètre C. l'instance renverra True si l'objet I est une instance de la classe C ou de toute sous-classe de la classe C, sinon elle renvoie False.

__init__

Lorsqu'une classe définit ou hérite d'une méthode nommée __init__, l'appel de l'objet de classe exécutera implicitement la méthode __int__ sur la nouvelle instance pour effectuer toute initialisation requise liée à l'instance. Les paramètres passés dans cet appel doivent correspondre aux paramètres de __init__, à l'exception du paramètre self. Par exemple :

class C6（objec）:
    def __init__(self, n);          self.x = n

Créer une instance de classe C6 :

anInstance = C6(42)

Le but principal de __init__ est de lier, et donc de créer, les propriétés de l'instance nouvellement créée. La méthode __init__ ne peut pas renvoyer de valeur, sinon Python déclenchera une exception TypeError.
Pour toute instance z, z..__class__ est l'objet de classe auquel z appartient, et z..__dict__ est le dictionnaire utilisé par z pour enregistrer d'autres attributs. Par exemple :

print anInstance.__classs__.__name__, anInstance .__dict__              #print: C6, {'x' : 42}

Pour toute instance z, tout objet x et tout identifiant S (sauf __classs et __dict__), z.S = x est égal à z.__dict__['S'] = x. Par exemple :

z.y = 45z.__dict__['z'] = 67print z.y, z.z        #print: 45, 67

__new__

Chaque nouveau type de bibliothèque possède (ou hérite) d'une méthode statique nommée __new__. Lorsqu'un développeur appelle C(*args, **kwds) pour créer une instance de classe C, Python appellera d'abord C.__new__(C,*args, **kwds). Python utilise la valeur de retour x de __new__ comme instance nouvellement créée. Ensuite, Python appellera C.__init__(x,*args, **kwds), mais cette méthode ne sera appelée que lorsqu'il sera confirmé que x est une instance de C ou toute sous-classe de C. Par exemple : l'instruction x = C(23) est équivalente à :

x = C.__new__（C, 23）if isinstance(x, C):    type(x).__init__(x, 23)

object.__new__ crée une nouvelle instance non initialisée de la classe qu'elle accepte comme premier argument. Si cette classe contient une méthode __init__, la méthode ignorera les autres paramètres, mais si la méthode accepte d'autres paramètres en plus du premier paramètre et que la classe du premier paramètre ne contient pas de méthode __init__, alors cette méthode lèvera une exception. Le contenu ci-dessus est démontré ci-dessous en implémentant le modèle de conception 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)

Résultat de l'exécution :

分析：

从上面运行结果我们可以看出，创建一个新实例时，先调用new方法，再调用init方法。单实例通过重写new方法，第二次实例化时，new返回上次的实例，然后该实例再次调用init方法。

类

　　类(class)是一个用户自定义类型，开发者可以将其实例化以获得实例（instance），实例表示这种类型的对象。在Python中，类就是对象，开发者可以像对其他对象那样处理函数，可以在调用函数时传递一个类作为参数，也可以返回一个类作为函数调用的结果。任何对象，即使是一个类对象，都有一个类型。在Python中，类型和类也都是第一类对象。类对象的类型也被称为该类的元类（metaclass）。对象的行为主要是由该类对象的类型确定的。这也适用于类：类的行为也是主要由该类的元类确定的。

class语句

　　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__

　　当一个类定义或继承了一个名为__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__

　　每个新型累都有（或者继承了）一个名为__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方法。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!