Python3 orienté objet

Introduction à la technologie orientée objet

• Classe (Class) : est utilisé pour décrire une collection d'objets avec les mêmes propriétés et méthodes. Il définit les propriétés et méthodes communes à chaque objet de la collection. Les objets sont des instances de classes.

• Variables de classe : Les variables de classe sont communes dans tout l'objet instancié. Les variables de classe sont définies dans la classe et en dehors du corps de la fonction. Les variables de classe ne sont généralement pas utilisées comme variables d'instance.

• Données membres : Les variables de classe ou les variables d'instance sont utilisées pour traiter les données liées à la classe et à ses objets d'instance.

• Réécriture de méthode : Si la méthode héritée de la classe parent ne peut pas répondre aux besoins de la sous-classe, elle peut être réécrite. Ce processus est appelé remplacement de méthode). , également connu sous le nom de remplacement de méthode.

• Variables d'instance : Les variables définies dans les méthodes n'agissent que sur la classe de l'instance actuelle.

• Héritage : C'est-à-dire qu'une classe dérivée hérite des champs et des méthodes d'une classe de base. L'héritage permet également à un objet d'une classe dérivée d'être traité comme un objet de classe de base. Par exemple, il existe une telle conception : un objet de type Dog est dérivé de la classe Animal, qui simule la relation "est-un" (par exemple, Dog est un animal).

• Instanciation : Créer une instance d'une classe, un objet spécifique de la classe.

• Méthode : Fonction définie dans la classe.

• Objet : Une instance d'une structure de données définie par une classe. Les objets incluent deux données membres (variables de classe et variables d'instance) et des méthodes.

Par rapport à d'autres langages de programmation, Python ajoute des mécanismes de classe sans ajouter autant que possible de nouvelles syntaxes et sémantiques.

Les classes en Python fournissent toutes les fonctions de base de la programmation orientée objet : le mécanisme d'héritage des classes autorise plusieurs classes de base, les classes dérivées peuvent remplacer n'importe quelle méthode de la classe de base et la méthode peut appeler le même nom dans la méthode de la classe de base.

Les objets peuvent contenir n'importe quelle quantité et n'importe quel type de données.

Définition de la classe

Le format de syntaxe est le suivant :

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Après l'instanciation d'une classe, ses propriétés peuvent être utilisées. En fait, après la création d'une classe, elle est utilisée. les propriétés sont accessibles via le nom de la classe.

Objet de classe

L'objet de classe prend en charge deux opérations : la référence d'attribut et l'instanciation.

Les références de propriété utilisent la même syntaxe standard que toutes les références de propriété en Python : obj.name.

Après la création d'un objet de classe, tous les noms dans l'espace de noms de classe sont des noms d'attribut valides. Donc, si la définition de la classe ressemble à ceci :

#!/usr/bin/python3

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'

# 实例化类
x = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

Instanciez la classe :

# 实例化类
x = MyClass()
# 访问类的属性和方法

Ce qui précède crée une nouvelle instance de classe et attribue l'objet à la variable locale x, où x est un objet vide .

Le résultat de l'exécution du programme ci-dessus est :

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

De nombreuses classes ont tendance à créer des objets avec un état initial. Par conséquent, la classe peut définir une méthode spéciale (constructeur) nommée __init__(), comme la suivante :

def __init__(self):
    self.data = []

Si la classe définit la méthode __init__(), l'opération d'instanciation de la classe sera automatiquement appelée_ _init__( ) méthode. Ainsi, dans l'exemple suivant, vous pouvez créer une nouvelle instance comme celle-ci :

x = MyClass()

Bien sûr, la méthode __init__() peut avoir des paramètres, et les paramètres sont transmis à l'opération d'instanciation de la classe via __init__(). Par exemple :

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

Méthode de classe

Au sein de la classe, vous pouvez utiliser le mot-clé def pour définir une méthode pour la classe. Différente de la définition générale de la fonction, la méthode de classe doit contenir le. paramètre self, et c'est le premier paramètre One :

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('php',10,30)
p.speak()

Le résultat de l'exécution du programme ci-dessus est :

php 说: 我 10 岁。

Héritage

Python prend également en charge l'héritage de classe . Si une langue ne prend pas en charge l'héritage, les classes n'ont aucun sens. La définition d'une classe dérivée est la suivante :

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

Vous devez faire attention à l'ordre de la classe de base entre parenthèses s'il y a le même nom de méthode dans la classe de base, mais qu'il n'est pas spécifié. lors de l'utilisation de la sous-classe, Python recherche de gauche à droite. Autrement dit, lorsque la méthode n'est pas trouvée dans la sous-classe, elle recherche de gauche à droite si la méthode est incluse dans la classe de base.

BaseClassName (le nom de la classe de base dans l'exemple) doit être défini dans la même portée que la classe dérivée. En plus des classes, des expressions peuvent également être utilisées, ce qui est très utile lorsque la classe de base est définie dans un autre module :

class DerivedClassName(modname.BaseClassName):

Instance

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))



s = student('ken',10,60,3)
s.speak()

Le résultat de l'exécution du programme ci-dessus est :

ken 说: 我 10 岁了，我在读 3 年级

Héritage multiple

Python a également une prise en charge limitée pour les formes d'héritage multiples. La définition de classe de l'héritage multiple ressemble à l'exemple suivant :

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

Vous devez faire attention à l'ordre de la classe parent entre parenthèses s'il y a le même nom de méthode dans la classe parent et ce n'est pas le cas. spécifié lors de son utilisation dans la sous-classe, Python effectue la recherche de gauche à droite. Autrement dit, lorsque la méthode est introuvable dans la sous-classe, recherchez de gauche à droite si la classe parent contient la méthode.

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

Le résultat de l'exécution du programme ci-dessus est :

我叫 Tim，我是一个演说家，我演讲的主题是 Python

Réécriture de méthode

Si la fonction de votre méthode de classe parent ne peut pas répondre à vos besoins, vous pouvez La sous-classe remplace la méthode de votre classe parent. L'exemple est le suivant :

#!/usr/bin/python3

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

Le résultat de l'exécution du programme ci-dessus est :

调用子类方法

Attributs et méthodes de classe

Attributs privés de la classe

__private_attrs : Commençant par deux traits de soulignement, il est déclaré que l'attribut est privé et ne peut être utilisé ou directement accessible en dehors de la classe. Lorsqu'il est utilisé dans une méthode à l'intérieur d'une classe self.__private_attrs.

Méthodes de classe

Au sein de la classe, vous pouvez utiliser le mot-clé def pour définir une méthode pour la classe. Différente de la définition générale de la fonction, la méthode de classe doit contenir le paramètre self, qui est. le premier paramètre.

Méthodes privées de la classe

__private_method : Commençant par deux traits de soulignement, la méthode est déclarée comme méthode privée et ne peut pas être appelée en dehors de la classe. Appelez slef.__private_methods à l'intérieur de la classe. L'exemple de

est le suivant :

#!/usr/bin/python3

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

Le résultat de l'exécution du programme ci-dessus est :

1
2
2
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

Méthode propriétaire de la classe :

• __init__ : Constructeur, appelez

• __del__ : Destructeur, utilisez

<🎜 lors de la libération de l'objet >

• __repr__ : Imprimer, convertir

• __setitem__ : Attribuer une valeur en fonction de l'index

• __getitem__: Récupère la valeur en fonction de l'index

• __len__: Récupère la longueur

• __cmp__ :Opération de comparaison

• __call__:Appel de fonction

• __add__ : Opération d'addition

• __sub__ : Opération de soustraction

• __mul__ :Opération de multiplication

• __div__ :Opération de division

• __mod__: Opération restante

• __pow__: Calcul du carré

Surcharge d'opérateur

Python prend également en charge la surcharge d'opérateurs. Nous pouvons surcharger les méthodes propriétaires de la classe. L'exemple est le suivant :

#!/usr/bin/python3

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

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

Le résultat de l'exécution du code ci-dessus est le suivant :

Vector(7,8)