Objets et classes Python

Dans ce didacticiel, vous découvrirez les fonctionnalités de base des objets et des classes Python. Vous apprendrez ce qu'est une classe, comment la créer et l'utiliser dans votre programme.

Vidéo :Classes et objets Python

Objets et classes Python

Python est un langage de programmation orienté objet. Contrairement à la programmation orientée procédure, où l'accent est mis sur les fonctions, la programmation orientée objet met l'accent sur les objets.

Un objet est simplement une collection de données (variables) et de méthodes (fonctions) qui agissent sur ces données. De même, une classe est un modèle pour cet objet.

Nous pouvons considérer une classe comme un croquis (prototype) d'une maison. Il contient tous les détails sur les sols, les portes, les fenêtres, etc. Sur la base de ces descriptions, nous construisons la maison. La maison est l'objet.

Comme de nombreuses maisons peuvent être fabriquées à partir du plan d'une maison, nous pouvons créer de nombreux objets à partir d'une classe. Un objet est également appelé une instance d'une classe et le processus de création de cet objet est appelé instanciation .

Définir une classe en Python

Comme les définitions de fonction commencent par le mot-clé def en Python, les définitions de classe commencent par un mot-clé de classe.

La première chaîne à l'intérieur de la classe est appelée docstring et contient une brève description de la classe. Bien que non obligatoire, cela est fortement recommandé.

Voici une définition de classe simple.

class MyNewClass:
    '''This is a docstring. I have created a new class'''
    pass

Une classe crée un nouvel espace de noms local où tous ses attributs sont définis. Les attributs peuvent être des données ou des fonctions.

Il contient également des attributs spéciaux qui commencent par des traits de soulignement doubles __ . Par exemple, __doc__ nous donne la docstring de cette classe.

Dès que nous définissons une classe, un nouvel objet de classe est créé avec le même nom. Cet objet de classe nous permet d'accéder aux différents attributs ainsi que d'instancier de nouveaux objets de cette classe.

class Person:
    "This is a person class"
    age = 10

    def greet(self):
        print('Hello')


# Output: 10
print(Person.age)

# Output: <function Person.greet>
print(Person.greet)

# Output: "This is a person class"
print(Person.__doc__)

Sortie

10
<function Person.greet at 0x7fc78c6e8160>
This is a person class

Créer un objet en Python

Nous avons vu que l'objet class pouvait être utilisé pour accéder à différents attributs.

Il peut également être utilisé pour créer de nouvelles instances d'objet (instanciation) de cette classe. La procédure pour créer un objet est similaire à un appel de fonction.

>>> harry = Person()

Cela créera une nouvelle instance d'objet nommée harry . Nous pouvons accéder aux attributs des objets en utilisant le préfixe du nom d'objet.

Les attributs peuvent être des données ou une méthode. Les méthodes d'un objet sont les fonctions correspondantes de cette classe.

Cela veut dire, depuis Person.greet est un objet fonction (attribut de classe), Person.greet sera un objet méthode.

class Person:
    "This is a person class"
    age = 10

    def greet(self):
        print('Hello')


# create a new object of Person class
harry = Person()

# Output: <function Person.greet>
print(Person.greet)

# Output: <bound method Person.greet of <__main__.Person object>>
print(harry.greet)

# Calling object's greet() method
# Output: Hello
harry.greet()

Sortie

<function Person.greet at 0x7fd288e4e160>
<bound method Person.greet of <__main__.Person object at 0x7fd288e9fa30>>
Hello

Vous avez peut-être remarqué le self paramètre dans la définition de la fonction à l'intérieur de la classe mais nous avons appelé la méthode simplement comme harry.greet() sans aucun argument. Cela fonctionnait toujours.

En effet, chaque fois qu'un objet appelle sa méthode, l'objet lui-même est passé comme premier argument. Alors, harry.greet() se traduit en Person.greet(harry) .

En général, appeler une méthode avec une liste de n arguments équivaut à appeler la fonction correspondante avec une liste d'arguments créée en insérant l'objet de la méthode avant le premier argument.

Pour ces raisons, le premier argument de la fonction dans la classe doit être l'objet lui-même. Ceci est conventionnellement appelé self . Il peut être nommé autrement mais nous vous recommandons fortement de suivre la convention.

Vous devez maintenant être familiarisé avec l'objet de classe, l'objet d'instance, l'objet de fonction, l'objet de méthode et leurs différences.

Constructeurs en Python

Fonctions de classe commençant par un double trait de soulignement __ sont appelées fonctions spéciales car elles ont une signification particulière.

Le __init__() présente un intérêt particulier fonction. Cette fonction spéciale est appelée chaque fois qu'un nouvel objet de cette classe est instancié.

Ce type de fonction est également appelé constructeur en programmation orientée objet (POO). Nous l'utilisons normalement pour initialiser toutes les variables.

class ComplexNumber:
    def __init__(self, r=0, i=0):
        self.real = r
        self.imag = i

    def get_data(self):
        print(f'{self.real}+{self.imag}j')


# Create a new ComplexNumber object
num1 = ComplexNumber(2, 3)

# Call get_data() method
# Output: 2+3j
num1.get_data()

# Create another ComplexNumber object
# and create a new attribute 'attr'
num2 = ComplexNumber(5)
num2.attr = 10

# Output: (5, 0, 10)
print((num2.real, num2.imag, num2.attr))

# but c1 object doesn't have attribute 'attr'
# AttributeError: 'ComplexNumber' object has no attribute 'attr'
print(num1.attr)

Sortie

2+3j
(5, 0, 10)
Traceback (most recent call last):
  File "<string>", line 27, in <module>
    print(num1.attr)
AttributeError: 'ComplexNumber' object has no attribute 'attr'

Dans l'exemple ci-dessus, nous avons défini une nouvelle classe pour représenter les nombres complexes. Il a deux fonctions, __init__() pour initialiser les variables (par défaut à zéro) et get_data() pour afficher correctement le numéro.

Une chose intéressante à noter dans l'étape ci-dessus est que les attributs d'un objet peuvent être créés à la volée. Nous avons créé un nouvel attribut attr pour l'objet num2 et lisez-le également. Mais cela ne crée pas cet attribut pour l'objet num1 .

Supprimer des attributs et des objets

Tout attribut d'un objet peut être supprimé à tout moment, en utilisant le del déclaration. Essayez ce qui suit sur le shell Python pour voir la sortie.

>>> num1 = ComplexNumber(2,3)
>>> del num1.imag
>>> num1.get_data()
Traceback (most recent call last):
...
AttributeError: 'ComplexNumber' object has no attribute 'imag'

>>> del ComplexNumber.get_data
>>> num1.get_data()
Traceback (most recent call last):
...
AttributeError: 'ComplexNumber' object has no attribute 'get_data'

Nous pouvons même supprimer l'objet lui-même, en utilisant l'instruction del.

>>> c1 = ComplexNumber(1,3)
>>> del c1
>>> c1
Traceback (most recent call last):
...
NameError: name 'c1' is not defined

En fait, c'est plus compliqué que ça. Quand on fait c1 = ComplexNumber(1,3) , un nouvel objet instance est créé en mémoire et le nom c1 se lie avec elle.

Sur la commande del c1 , cette liaison est supprimée et le nom c1 est supprimé de l'espace de noms correspondant. L'objet continue cependant d'exister en mémoire et si aucun autre nom ne lui est lié, il est ensuite automatiquement détruit.

Cette destruction automatique d'objets non référencés en Python est également appelée ramasse-miettes.

Programmation orientée objet Python Héritage Python

Python