Python3 orienté objet

Python est un langage orienté objet depuis le tout début de sa conception. Pour cette raison, il est très facile de créer des classes et des objets en Python. Ce chapitre présentera en détail la programmation orientée objet de Python.

Si vous n'avez encore jamais été exposé à des langages de programmation orientés objet, vous devrez peut-être d'abord comprendre certaines caractéristiques de base des langages orientés objet et vous forger une notion de base de l'orientation objet, ce qui vous aidera à apprendre plus facilement la programmation orientée objet de Python.

Voyons maintenant brièvement quelques caractéristiques de base de l'orienté objet.

Introduction à la technologie orientée objet

  • Classe :Utilisée pour décrire un ensemble d'objets ayant les mêmes attributs et méthodes. Elle définit les attributs et méthodes communs à chaque objet de l'ensemble. Un objet est une instance d'une classe.
  • Méthode :Une fonction définie dans une classe.
  • Variable de classe :Une variable de classe est partagée entre tous les objets instanciés. Les variables de classe sont définies dans la classe et en dehors de tout corps de fonction. Les variables de classe ne sont généralement pas utilisées comme variables d'instance.
  • Membres de données :Les variables de classe ou variables d'instance sont utilisées pour traiter les données liées à la classe et à ses objets d'instance.
  • Redéfinition de méthode :Si une méthode héritée de la classe parente ne peut pas satisfaire les besoins de la sous-classe, elle peut être redéfinie. Ce processus est appelé redéfinition de méthode.
  • Variable locale :Une variable définie dans une méthode, qui n'affecte que la classe de l'instance actuelle.
  • Variable d'instance :Dans la déclaration d'une classe, les attributs sont représentés par des variables. Ces variables sont appelées variables d'instance. Une variable d'instance est une variable modifiée avec self.
  • Héritage :C'est-à-dire qu'une classe dérivée hérite des champs et méthodes d'une classe de base. L'héritage permet également de traiter un objet d'une classe dérivée comme un objet de la classe de base. Par exemple, il existe une conception de ce type : un objet de type Dog dérivé de la classe Animal, qui simule une relation « is-a » (par exemple, Dog est un Animal).
  • Instanciation :Créer une instance d'une classe, l'objet concret de la classe.
  • Objet :Une instance d'une structure de données définie par une classe. Les objets comprennent deux membres de données (variables de classe et variables d'instance) et des méthodes.

Par rapport aux autres langages de programmation, Python a ajouté le mécanisme de classe en ajoutant aussi peu que possible de nouvelle syntaxe et de nouvelle sémantique.

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

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

Définition de classe

Le format de la syntaxe est le suivant :

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

Après qu'une classe est instanciée, ses attributs peuvent être utilisés. En fait, après avoir créé une classe, ses attributs sont accessibles via le nom de la classe.

Objets de classe

Les objets de classe prennent en charge deux opérations : la référence aux attributs et l'instanciation.

Les références aux attributs utilisent la même syntaxe standard que toutes les références aux attributs en Python :obj.name。

Après qu'un objet de classe est créé, tous les noms dans l'espace de noms de la classe sont des noms d'attributs valides. Donc si la définition de classe est comme ceci :

Exemples (Python 3.0+)

#!/usr/bin/python3 class MyClass: """Un exemple simple de classe""" i = 12345 def f(self): return 'hello world' # Instancier la classe x = MyClass() # Accéder aux attributs et méthodes de la classe print("L'attribut i de la classe MyClass est :", x.i) print("La méthode f de la classe MyClass affiche :", x.f())

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

La sortie de l'exécution du programme ci-dessus est :

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

La classe possède une méthode spéciale nommée __init__() (méthode constructeur), qui est automatiquement appelée lorsque la classe est instanciée, comme ceci :

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

Si une classe définit la méthode __init__(), l'opération d'instanciation de la classe appellera automatiquement la méthode __init__(). Comme montré ci-dessous, lors de l'instanciation de la classe MyClass, la méthode __init__() correspondante sera appelée :

x = MyClass()

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

Exemples (Python 3.0+)

#!/usr/bin/python3 class Complex: def __init__(self, realpart, imagpart): self.r = realpart self.i = imagpart x = Complex(3.0, -4.5) print(x.r, x.i) # Résultat de sortie : 3.0 -4.5

self représente l'instance de la classe, pas la classe

La seule différence particulière entre les méthodes d'une classe et les fonctions ordinaires est qu'elles doivent avoir unnom du premier paramètresupplémentaire, qui par convention est nommé self.

class Test: def prt(self): print(self) print(self.__class__) t = Test() t.prt()

Le résultat d'exécution de l'exemple ci-dessus est :

<__main__.Test instance at 0x100771878>
__main__.Test

Il ressort clairement du résultat d'exécution que self représente l'instance de la classe, représentant l'adresse de l'objet actuel, tandis que self.class pointe vers la classe.

self n'est pas un mot-clé Python. Si nous le remplaçons par example, il s'exécutera toujours normalement :

class Test: def prt(example): print(example) print(example.__class__) t = Test() t.prt()

Le résultat d'exécution de l'exemple ci-dessus est :

<__main__.Test instance at 0x100771878>
__main__.Test

En Python, self est un nom conventionnel utilisé pour représenter l'instance (objet) d'une classe elle-même. C'est une référence à l'instance, permettant aux méthodes de la classe d'accéder aux attributs de l'instance et de les manipuler.

Lorsque vous définissez une classe et définissez des méthodes dans la classe, le premier paramètre est généralement nommé self. Bien que vous puissiez utiliser d'autres noms, il est fortement recommandé d'utiliser self pour maintenir la cohérence et la lisibilité du code.

Exemple

class MyClass:
    def __init__(self, value):
        self.value = value

    def display_value(self):
        print(self.value)

# Créer une instance d'une classe
obj = MyClass(42)

# Appeler une méthode de l'instance
obj.display_value() # Sortie 42

Dans l'exemple ci-dessus, self est une référence pointant vers l'instance de la classe. Il est utilisé dans le constructeur__init__pour initialiser les attributs de l'instance, et aussi dans les méthodesdisplay_valuepour accéder aux attributs de l'instance. En utilisant self, vous pouvez accéder aux attributs de l'instance et les manipuler dans les méthodes de la classe, mettant ainsi en œuvre le comportement de la classe.

Méthodes de classe

À l'intérieur de la classe, utilisez le mot-clédefpour définir une méthode. Contrairement aux définitions de fonctions générales, les méthodes de classe doivent inclure le paramètre self, et il doit être le premier paramètre. self représente l'instance de la classe.

Exemples (Python 3.0+)

#!/usr/bin/python3 # Définition de classe class people: # Définir les attributs de base name = '' age = 0 # Définir des attributs privés. Les attributs privés ne peuvent pas être directement accessibles en dehors de la classe. __weight = 0 # Définir la méthode constructeur def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s dit : J'ai %d ans." %(self.name,self.age)) # Instancier la classe p = people('example',10,30) p.speak()

La sortie de l'exécution du programme ci-dessus est :

example 说: 我 10 岁。

Héritage

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

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

Une sous-classe (classe dérivée DerivedClassName) héritera des attributs et des méthodes de la classe parente (classe de base BaseClassName).

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

class DerivedClassName(modname.BaseClassName):

Exemples (Python 3.0+)

#!/usr/bin/python3 # Définition de classe class people: # Définir les attributs de base name = '' age = 0 # Définir des attributs privés. Les attributs privés ne peuvent pas être directement accessibles en dehors de la classe. __weight = 0 # Définir la méthode constructeur def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s dit : J'ai %d ans." %(self.name,self.age)) # Exemple d'héritage simple class student(people): grade = '' def __init__(self,n,a,w,g): # Appeler le constructeur de la classe parente people.__init__(self,n,a,w) self.grade = g # Redéfinir la méthode de la classe parente def speak(self): print("%s dit : J'ai %d ans, et je suis en classe de %d"%(self.name,self.age,self.grade)) s = student('ken',10,60,3) s.speak()

La sortie de l'exécution du programme ci-dessus est :

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

Héritage multiple

Python prend également en charge, de manière limitée, l'héritage multiple. La définition de classe pour l'héritage multiple est la suivante :

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

Notez l'ordre des classes parentes entre parenthèses. Si les classes parentes ont une méthode portant le même nom et que la sous-classe ne précise pas laquelle utiliser, Python effectue une recherche de gauche à droite. Autrement dit, lorsque la méthode n'est pas trouvée dans la sous-classe, il vérifie les classes parentes de gauche à droite pour voir si elles contiennent la méthode.

Exemples (Python 3.0+)

#!/usr/bin/python3 # Définition de classe class people: # Définir les attributs de base name = '' age = 0 # Définir des attributs privés ; les attributs privés ne sont pas directement accessibles en dehors de la classe __weight = 0 # Définir la méthode constructeur def __init__(self,n,a,w): self.name = n self.age = a self.__weight = w def speak(self): print("%s dit : J'ai %d ans." %(self.name,self.age)) # Exemple d'héritage simple class student(people): grade = '' def __init__(self,n,a,w,g): # Appeler le constructeur de la classe parente people.__init__(self,n,a,w) self.grade = g # Redéfinir la méthode de la classe parente def speak(self): print("%s dit : J'ai %d ans, et je suis en classe de %d"%(self.name,self.age,self.grade)) # Une autre classe, préparation avant l'héritage multiple class speaker(): topic = '' name = '' def __init__(self,n,t): self.name = n self.topic = t def speak(self): print("Je m'appelle %s, je suis un orateur et le sujet de mon discours est %s"%(self.name,self.topic)) # Héritage multiple 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() # Si les noms de méthodes sont identiques, la méthode de la classe parente dont la position dans les parenthèses est antérieure est appelée par défaut

La sortie du programme ci-dessus est :

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

Redéfinition de méthode

Si une méthode de la classe parente ne répond pas à vos besoins, vous pouvez redéfinir la méthode de la classe parente dans la sous-classe. Exemple :

Exemples (Python 3.0+)

#!/usr/bin/python3 class Parent: # Définir la classe parente def myMethod(self): print ('Appeler la méthode de la classe parente') class Child(Parent): # Définir la sous-classe def myMethod(self): print ('Appeler la méthode de la sous-classe') c = Child() # Instance de la sous-classe c.myMethod() # La sous-classe appelle la méthode redéfinie super(Child,c).myMethod() # Utiliser un objet de sous-classe pour appeler la méthode de la classe parente qui a été redéfinie

La fonction super()est utilisée pour appeler une méthode de la classe parente (superclasse).

La sortie du programme ci-dessus est :

Call subclass method
Call superclass method

Plus de documentation :

Explication de l'héritage du constructeur de la classe parente par une sous-classe Python

Attributs et méthodes de classe

Attributs privés d'une classe

__private_attrs: commence par deux traits de soulignement, ce qui déclare l'attribut comme privé. Il ne peut être ni utilisé ni directement accessible en dehors de la classe. Lorsqu'il est utilisé dans des méthodes à l'intérieur de la classe...self.__private_attrs。

Méthodes de classe

À l'intérieur d'une classe, utilisez le mot-clé def pour définir une méthode. Contrairement aux définitions de fonctions ordinaires, une méthode de classe doit inclure un paramètreself, et il doit être le premier paramètre,selfreprésentant l'instance de la classe.

selfSon nom n'est pas fixe ; vous pouvez aussi utiliserthis, mais il est préférable de suivre la convention.self。

Méthodes privées d'une classe

__private_method: commence par deux traits de soulignement, ce qui déclare la méthode comme privée. Elle ne peut être appelée qu'à l'intérieur de la classe, pas à l'extérieur de la classe.self.__private_methods。

Exemple

Voici un exemple d'attributs privés de classe :

Exemples (Python 3.0+)

#!/usr/bin/python3 class JustCounter: __secretCount = 0 # Variable privée publicCount = 0 # Variable publique def count(self): self.__secretCount += 1 self.publicCount += 1 print (self.__secretCount) counter = JustCounter() counter.count() counter.count() print (counter.publicCount) print (counter.__secretCount) # Erreur : l'instance ne peut pas accéder à la variable privée

La sortie 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'

Ce qui suit est un exemple de méthodes privées de classe :

Exemples (Python 3.0+)

#!/usr/bin/python3 class Site: def __init__(self, name, url): self.name = name # public self.__url = url # privé def who(self): print('name : ', self.name) print('url : ', self.__url) def __foo(self): # Méthode privée print('Ceci est une méthode privée') def foo(self): # Méthode publique print('Ceci est une méthode publique') self.__foo() x = Site('Exemple', 'www.example.com') x.who() # Sortie normale x.foo() # Sortie normale x.__foo() # Erreur

Le résultat d'exécution de l'exemple ci-dessus :

Méthodes spéciales d'une classe :

  • __init__ :Constructeur, appelé lorsqu'un objet est créé
  • __del__ :Destructeur, utilisé lors de la libération d'un objet
  • __repr__ :Affichage, conversion
  • __setitem__ :Affectation par index
  • __getitem__:Obtenir la valeur par index
  • __len__:Obtenir 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
  • __truediv__:Opération de division
  • __mod__:Opération modulo
  • __pow__:Puissance

Surcharge des opérateurs

Python prend également en charge la surcharge des opérateurs. Nous pouvons surcharger les méthodes spéciales d'une classe. Exemple :

Exemples (Python 3.0+)

#!/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 d'exécution du code ci-dessus est le suivant :

Vector(7,8)
Autres extensions