Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
Dieses Repo ist archiviert. Du kannst Dateien sehen und es klonen, kannst aber nicht pushen oder Issues/Pull-Requests öffnen.
 
 
 
 
 
 

4.9 KiB

% Programmation avec Python (chapitre 6) % Dimitri Merejkowsky

\center \huge Les classes

Paradigmes

Une façon d’envisager le code. Pour l’instant on n’a vu que le paradigme procédural (ou (impératif).

Il y en a plein d’autres! (fonctionnel notamment, dont on parlera un jour)

Détails du procédural

  • des types simples (entiers, booléens)
  • des structures de données (dictionnaires, listes ...)
  • des fonctions qui manipulent des types simples ou des structures
  • les fonctions sont appelées les unes après les autres

Aujourd’hui on va parler de l’orienté objet.

Un petit détour

Un nouveau built-in: id()

L’adresse de l’objet pointé par la variable:

>>> a = 42532
>>> id(a)
94295009035968
>>> b = a
>>> id(b)   # même objet
94295009035968
>>> c = 42532  # objet différent, même valeur
>>> id(c)

Orienté objet - 1ère définition

Mettre au même endroit:

  • des données
  • des fonctions qui opèrent sur ces données

L’important c’est que les deux aillent ensemble

OOP en Anglais (ou juste OO)

Orienté objet - 2ème définition

Des “cellules” qui s’envoient des “messages”.

Notamment, les cellules ne “voient” que leur état interne.

On peut envoyer un message d’une cellule à une autre sans connaître beaucoup de détails à propos du destinataire du message

Les classes

On va parler d’une façon de faire de l’orienté objet: avec des classes.

Mais notez bien qu’on peut faire de l’orienté objet sans classes!

Le plan de construction

La seule chose dont on a besoin, c’est le mot-clé class et un nom.

class MyObject:
    pas

La classe est le plan de construction de notre objet.

Créons des objets

>>> object_1 = MyObject()
>>> object_2 = MyObject()

Python ne sait rien de l’objet à part son adresse on mémoire et son nom:

print(object_1)
 <__main__.MyObject at 0x7f52c831e2b0>

On appelle object_1 et object_2 des instances de la classe MyObject.

Méthodes

Une fonction dans une classe

class MyObject:
    def my_method(the_object):
        print("hello", the_object)

C’est tout!

Méthodes - 2

La méthode n’existe pas en dehors de la classe (souvenez vous des cellules !)

>>> my_method()
NameError
>>> object = MyObject()
>>> object.my_method()
Hello, <MyObject at 0x7f52c9f6d6d8>

Notez que my_method a pris en premier argument ce qu’il y avait à gauche du point:

D’ailleurs, ce code fonctionne aussi et retourne la même chose:

>>> MyObject.my_method(object)
Hello, <MyObject at 0x7f52c9f6d6d8>

Méthodes - 3

Il faut passer l’objet en cours en paramètre:

class MyObject:
    def broken():
        print("You cannot call me!")
>>> o = MyObject()
>>> o.broken()
TypeError: broken() takes 0 positional arguments but 1 was given

Conventions

  • Les classes sont en CamelCase
  • Tout le reste (méthodes, etc...) en snake_case
  • L’objet en cours s’appelle toujours self
class MyObject:
    def my_method(self):
        print("hello", self)

Attributs

  • Des variables dans un objet.
  • On peut ajouter un attribut quand on veut à qui on veut, et toujours avec le point au milieu:
>>> object = MyObject()
>>> object.attribute   # ici l'attribut n'existe pas
AttributError
>>> object.attribute = 42  # maintenant oui
>>> object.attribute
42

Attributs dans les méthodes

Avec self, bien sûr:

class MyObject:
    def print_attribute(self):
        print(self.attribute)

    def change_attribute(self, new_value)
        self.attribute = new_value

Accéder aux attributs

>>> object = MyObject()
>>> object.print_attribute()  # ici l'attribut n'existe pas
AttributError
>>> object.attribute = 42
>>> object.print_attribute() # ça marche
42
>>> object.change_attribute(43)
>>> object.attribute
43

Initialisation des attributs

Avec __init__:

  • méthode “spéciale”
  • appelée automatiquement
  • notez les deux underscores avant et après (‘dunder’ en Anglais)
class MyObject:
    def __init__(self):
        self.attribute = 42
>>> object = MyObject()
>>> object.attribute
42

Construire des objets différents

__init__() et MyObject() sont des appels de fonctions comme les autres

class Car:
    def __init__(self, color_to_use="black"):
        self.color = color_to_use

>>> ford = Car()
>>> ford.color
"black"
>>> ferrari = Car(color_to_use="red")
>>> ferrari.color
"red"

Notes

En vrai, on nomme souvent les paramètres du constructeur et les attributes de la même façon.

class Car:
    def __init__(self, color="black"):
        self.color = color

Récapitulatif

  • Classe: plan de construction
  • Object: ce qu’on crée avec le plan
  • Instance: objet issue d’une classe
  • Méthode: fonction dans une classe (qui prend self en premier argument)
  • Attribut: variable dans un objet