1-03. Programmation objets

Vocabulaire

Exemple concret

Imaginons que vous travaillez sur le développement d’une application qui doit gérer ses utilisateurs. Afin que toute la logique propre à la gestion des utilisateurs soit regroupée au même endroit, vous décidez de créer une classe User.

Dans cette classe, vous commencez par définir trois attributs : id, pseudo, et credit.

Puis vous définissez une méthode modifyCredit() qui accepte un entier en paramètre et qui met à jour le crédit de l’utisateur.

Ben on pourrait faire ça avec un dictionnaire et une function toute simple, non  ? 😑

Bien sûr ! Sauf que :

1. On n’aura pas la garantie qu’une variable utilisateur possède bien un id, un pseudo et un crédit.
2. On ne pourra pas attribuer de valeur par défaut à certaines propriétés
3. Même si la variable possède ces données, on n’aura pas la garantie qu’elles soient cohérentes.
4. Il faudra définir la fonction modifyUserCredit() si on veut s’assurer que le crédit ne soit jamais incohérent. Elle ne sera pas regroupée avec la notion d’utilisateur et elle sera dans l’espace globale de mémoire.
5. Le code sera moins lisible et donc moins maintenable.

Voici un exemple sans utilisation de classe :

		
			user1 = { "id" : 24, "pseudo": "toto", "credit" : 2 }

			# on veut changer le pseudo de l’utilisateur
			user1["pseudo"] = "titi"

			# fonction qui va faire quelques contrôles lors d’une modification de crédits
			def modifyUserCredit(user, credit) :
				if (type(credit) != int) :
					print("Erreur de format du crédit")
				elif (user["credit"] + credit < 0):
					print("variation de crédit impossible")
				else:
					user["credit"] += credit
				
				return user

			user1 = modifyUserCredit(user1, -10)
		
	

La même chose, mais en utilisant une classe (on reviendra plus loin sur la syntaxe des classes).

		
			class User:
				def __init__(self, id, pseudo = "new user", credit = 0):
					self.id = int(id) # on est sûr que l’id existe et est un int
					self.pseudo = str(pseudo)
					self.credit = int(credit)

				def modifyCredit(self, credit) :
					if (type(credit) != int) :
						print("Erreur de format du crédit")
					elif (self.credit + credit < 0):
						print("variation de crédit impossible")
					else:
						self.credit += credit

			#––– code à exécuter –––––––––
			user1 = User(24, "toto", 2) # on crée un user
			user1.pseudo = "titi" # on modifie son pseudo
			user1.modifyCredit(-1) # on modifie son crédit
		
	

• Écrire la définition d’une classe.
• Accéder aux attributs et méthodes d’une classe.

Définir une classe

				class MyClass: # annonce la définition de la classe
					BAR = "Hello" # propriété commune à les objets de cette classe
					def __init__(self, foo): # méthode lancée à l’instanciation
						self.foo = foo
		

Garder le self contrôle

C’est quoi ce self dans le code ? 😐

C’est une notion pas immédiatement évidente mais extrêmement important quand on fait de la POO. Le self renvoie à l’instance de la classe en cours.

Heuuu… OK. Et ça veut dire quoi, concrètement ? 😣

Imaginons qu’avec la classe définie ici, on exécute la ligne suivante :

		
			a = MyClass("Coucou") # l’objet a est une instance de MyClass
		
	

À ce moment, la fonction __init()__ va se lancer. Elle prend en argument la variable a elle-même (via le self), et le "Coucou", qui est la valeur de la variable foo. Le propriété foo de l’objet qui est en train d’être instancié se verra donc attribuer la valeur "Coucou".

Accéder ou modifier un attribut

Rien de plus simple 😊

		
			a = MyClass("Coucou") # l’objet a est une instance de MyClass
			print(a.foo) # affiche "Coucou" – on accède à l’attribut foo de l’objet a
			a.foo = "Ciao" # on modifie l’attribut foo de l’objet a
		
	

Les méthodes

Les méthodes « magiques »

Toutes les classes possèdent des méthodes qui sont automatiquement appelées dans certaines conditions. __init()__ en est un exemple, mais il y en a d’autres. En voici deux qui peuvent vous être utiles :

• __str__ : permet de définir ce qui est affiché lorsqu’on passe l’objet comme argument de print() ou qu’on souhaite le convertir en str.
• __eq__ : permet de définir à quelle(s) condition(s) l’assertion a == b renvoie True quand a et b sont des objets de la même classe.

		class MyClass:

			def __init__(self, foo):
				self.foo = foo

			def __str__ (self) : # exécutée via print() ou str()
				return f"foo: {self.foo}"
			
			def __eq__(self, other): # exécutée lors d’un test a == b
				return self.foo == other.foo
			
		# ––––
		a = MyClass("Coucou")
		print(a) # affiche "foo: Coucou"

		b = MyClass("Coucou")
		print( a == b) # affiche True

		c = MyClass("Salut")
		print( a == c) # affiche False
	

Les autres méthodes

Définir une méthode pour une classe se fait exactement comme une fonction classique. Il suffit de la définir à l’intérieur de la classe. 🖐️ N’oubliez pas que le premier argument de la méthode est toujours le mot-clé self qui fait référence à l’instanciation courante de la classe (l’objet via lequel est utilisé la méthode).

				class Circle:
				
					def __init__(self, radius):
						if isinstance(radius,(int, float)) and radius > 0:
							self.radius = radius
					
					PI = 3.1415927
					
					def getSurface(self):
						return self.PI*self.radius**2
				
					def getPerimeter(self):
						return 2*self.PI*self.radius
				
					def __eq__(self, other):
						return round(self.radius, 3) == round(other.radius, 3)
			

Ce qui suit est hors programme. Mais il me semble important que vous ayez au moins connaissance de l’existence de ces notions.

Ce qu’on vient de voir sur la POO, c’est vraiment la base de la base… 😅 Ça permet de faire beaucoup de chose, mais en général, on ne s’arrête pas là.

Voici deux notions qui permettent d’aller plus loin en POO.

Héritage

Il est possible de créer une classe en étendant une classe existante et en lui rajoutant des attributs et méthodes.

		class User:
			
			def __init__(self, id, name):
				self.id = id
				self.name = name
				self.isConnected = False
				self.isBanned = False
					
			def __str__(self):
				string = f"{self.getStatus()} {self.name} ({self.id})"
				if self.isConnected: string += " is connected"
				if self.isBanned: string += " is banned"
				return string
				
			def getAccess(self):
				if not self.isBanned: self.isConnected = True
			
			def getStatus(self):
				return "User"

		# Admin hérite de User
		class Admin(User):
			
			def getStatus(self):
				return "Admin"
			
			def banUser(self, user: User):
				user.isBanned = True
				user.isConnected = False

		user = User(43, "Toto")
		admin = Admin(1, "Boss") # Admin s’instancie comme user (hérité)

		user.getAccess()
		admin.getAccess() # Admin a hérité de la méthode getAccess

		user.banUser(admin) # erreur, User ne dispose pas de cette méthode
		admin.banUser(user)

		print(user)
		print(admin)
	

L'héritage est un mécanisme fondamental de la POO qui permet à une classe (appelée classe enfant) d'acquérir les attributs et méthodes d'une autre classe (appelée classe parent), tout en ayant la possibilité d'ajouter ses propres fonctionnalités ou de redéfinir celles héritées (polymorphisme).

C'est un concept qui favorise la réutilisation du code et permet de créer une hiérarchie organisée de classes partageant des caractéristiques communes.

Polymorphisme

Le polymorphisme, c’est le fait que, dans deux classes différentes, une méthode peut avoir le même nom et pourtant avoir une action différente.

Dans l’exemple des classes User et Admin du paragraphe précédent, la méthode getStatus() est un exemple de polymorphisme : elle renvoie une valeur différente pour chaque classe.

La méthode __str__() est un exemple de polymorphisme natif en Python. En Python, de nombreuses classes intégrées (built-in) implémentent leur propre version de __str__() :

• Les chaînes de caractères (str) retournent simplement elles-mêmes
• Les listes (list) affichent leurs éléments entre crochets
• Les dictionnaires (dict) montrent leurs paires clé-valeur
• Vos classes personnalisées peuvent définir leur propre représentation textuelle

Quand vous appelez print(objet), Python appelle en coulisses str(objet), qui lui-même invoque la méthode __str__() de l'objet. Selon le type réel de l'objet, une implémentation différente de __str__() est exécutée.

C'est la définition du polymorphisme : une même interface (ici __str__()) avec différentes implémentations selon le type d'objet, et le système choisit automatiquement la bonne implémentation à l'exécution.

D'ailleurs, Python utilise abondamment ce principe avec ses "méthodes magiques" (__len__, __add__, __eq__, etc.) qui permettent à différentes classes de réagir différemment aux mêmes opérations (comme +, ==, len(), etc.).