Python 3 : Différence entre versions
De TARENTINO
Aller à la navigationAller à la recherche| Ligne 1 : | Ligne 1 : | ||
| − | {{Menu_Python}}{{En_resume}}{{Coulpython}}{{ | + | {{Menu_Python}}{{En_resume}}{{Coulpython}}{{Pythonline3}}{{Sideperfection}}{{Sidebaradm}}{{Navigationp}}<p align="right" style="color: blue">'''{{CURRENTDAY}}/{{CURRENTMONTH}}/{{CURRENTYEAR}}'''</p><font color=black> |
__NOTOC__ | __NOTOC__ | ||
= <font size=6 color=red>'''Perfectionnement'''</font> = | = <font size=6 color=red>'''Perfectionnement'''</font> = | ||
Version actuelle datée du 12 novembre 2020 à 16:00
Array
(Opérateurs:Magenta) (Méthodes:Green) (Fonctions:Red)
Python Perfectionnement Objets Attributs Méthodes Propriétés Décorateurs Héritages de classe Classes & Instances Classes & Modules Affectations
par références Variables
et méthodes de classes
et d'instances Gestion des erreurs
5/11/2025
Perfectionnement
Introduction
- Python est un langage de programmation inventé par Guido van Rossum. La première version de python est sortie en 1991.
C'est un langage de programmation interprété, c'est-à-dire qu'il n'est pas nécessaire de le compiler avant de l'exécuter.
Les Objets
- Pour pouvoir créer des objets dans un programme, il faut avant tout avoir défini une classe.
- Il s'agit en quelque sorte d'un plan , qui décrit les caractéristiques de l'objet.
- En particulier, une classe définit les deux éléments constitutifs des objets que sont ses attributs et fonctionnalités.
- Un objet est une instance d'une classe, qui possède son propre état, défini par les valeurs de ses différents attributs.
- On peut créer autant d'objets que l'on désire avec une classe.
Les attributs
- Les attributs de classe permettent de stocker des informations au niveau de la classe. Elle sont similaires aux variables.
- Il est possible à tout moment de créer un attribut pour l'objet.
Les méthodes
- Les méthodes sont des fonctions définies dans une classe.
1 #!/usr/bin/python3
2 # coding: utf-8
3 class Voiture:
4 def __init__(self):
5 self.nom = "Ferrari"
6 def donne_moi_le_modele(self):
7 return "250"
>>> ma_voiture=Voiture() >>> ma_voiture.donne_moi_le_modele() '250'
Les propriétés
- Il est de préférable de passer par des propriétés pour changer les valeurs des attributs.
- Il existe une convention pour changer la valeur d'un attribut, de passer:
- par des getter (ou accesseurs) en francais
- des setter ( mutateurs )
1 class Voiture(object):
2 def __init__(self):
3 self._roues=4
4 def _get_roues(self):
5 print("Récupération du nombre de roues")
6 return self._roues
7 def _set_roues(self, v):
8 print("Changement du nombre de roues")
9 self._roues = v
10 roues=property(_get_roues, _set_roues)
>>> ma_voiture=Voiture() >>> ma_voiture.roues=5 Changement du nombre de roues >>> ma_voiture.roues Récupération du nombre de roues 5
Les décorateurs
1 class Voiture(object):
2 def __init__(self):
3 self._roues=4
4 @property
5 def _get_roues(self):
6 print "Récupération du nombre de roues"
7 return self._roues
8 @roues.setter
9 def _set_roues(self, v):
10 print "Changement du nombre de roues"
11 self._roues = v
12 roues=property(_get_roues, _set_roues)
L'héritage de classe
- Permet de créer de nouvelles classes mais avec une base existante.
1 class Voiture:
2 roues = 4
3 moteur = 1
4 def __init__(self):
5 self.nom = "A déterminer"
6 class VoitureSport(Voiture):
7 def __init__(self):
8 self.nom = "Ferrari"
- On a indiqué que VoitureSport a hérité de classe Voiture, elle récupère toutes ses méthodes et ses attributs.
- Instanciation de la classe voiture
>>> ma_voiture=Voiture() >>> ma_voiture.nom 'A déterminer' >>> ma_voiture.roues 4
- Instanciation de la classe VoitureSport
>>> ma_voiture_sport=VoitureSport() >>> ma_voiture_sport.nom 'Ferrari' >>> ma_voiture_sport.roues 4
- On parle de surcharge de méthode.
Classes et Instances
- Notion de classe (Class) d'objet est un type (type)
- Elle comprend 2 parties: Attribut, Méthode
- Une classe regroupe des fonctions et des attributs qui définissent un objet.
- On appelle par ailleurs les fonctions d'une classe des " méthodes ".
1 '''Définission d'une classe'''
2 >>> class X:
3 def __init__(self,val):
4 self.attribut_1=val
5 def methode_1(self):
6 return self.attribut_1
7 '''Instanciation'''
8 >>> instance_1=X(3)
9 '''Exécution d'une méthode'''
10 >>> print( instance_1.methode_1())
=> 3
- Notion d'objet, d'instanciation et de constructeur
- Une instance d'objet est un objet concret.
- La création d'un objet est une instanciation.
- La méthode qui la réalise est le constructeur.
- La méthode __init__() est appelée lors de la création d'un objet.
- self.attribut_1 est une manière de stocker une information dans la classe. On parle d'attribut de classe. Dans notre cas, on stocke le nom dans l'attribut attribut_1.
Classes et Modules
- La classe est un concept de base de la programmation orientée objet.
- En langage Python, on peut très bien écrire un script sans définir de classes.
Cependant, On manipule forcément des objets (ou instances de classes):
une variable entière est une instance de la classe int, une chaîne de caractères est une instance de la classe str...
Définition d'une classe
- Exemple:
1 #!/usr/bin/python3
2 # -*- coding: utf-8 -*-
3 # CompteBancaire.py
4 # définition de la classe Compte
5 class Compte:
6 """Un exemple de classe :
7 gestion d'un compte bancaire"""
8 # définition de la méthode spéciale __init__
9 def __init__(self, soldeInitial):
10 """Initialisation du compte avec la valeur soldeInitial."""
11 # assignation de l'attribut d'instance solde
12 self.solde = float(soldeInitial)
13 # définition de la méthode NouveauSolde()
14 def NouveauSolde(self, somme):
15 """Nouveau solde de compte avec la valeur somme."""
16 self.solde = float(somme)
17 # définition de la méthode Solde()
18 def Solde(self):
19 """Retourne le solde."""
20 return self.solde
21 # définition de la méthode Credit()
22 def Credit(self, somme):
23 """Crédite le compte de la valeur somme. Retourne le solde."""
24 self.solde += somme
25 return self.solde
26 # définition de la méthode Debit()
27 def Debit(self, somme):
28 """Débite le compte de la valeur somme. Retourne le solde."""
29 self.solde -= somme
30 return self.solde
31 # définition de la méthode spéciale __add__ (surcharge de l'opérateur +)
32 def __add__(self, somme):
33 """x.__add__(somme) <=> x+somme
34 Crédite le compte de la valeur somme.
35 Affiche 'Nouveau solde : somme'"""
36 self.solde += somme
37 print("Nouveau solde : {:+.2f} €".format(self.solde))
38 return self
39 # définition de la méthode spéciale __sub__ (surcharge de l'opérateur -)
40 def __sub__(self, somme):
41 """x.__sub_(somme) <=> x-somme
42 Débite le compte de la valeur somme.
43 Affiche 'Nouveau solde : somme'"""
44 self.solde -= somme
45 print("Nouveau solde : {:+.2f} €".format(self.solde))
46 return self
47 if __name__ == '__main__':
48 # Ce bloc d'instructions est exécuté si le module est lancé en tant que programme autonome
49 # Instanciation de l'objet cb1 de la classe Compte
50 cb1 = Compte(1000)
51 # formatage des données pour afficher deux chiffres après la virgule et le signe
52 print("{:+.2f}".format(cb1.Solde()))
53 print("{:+.2f}".format(cb1.Credit(200)))
54 print("{:+.2f}".format(cb1.Debit(50.23)))
55 print("{:+.2f}".format(cb1.Solde()))
56 cb1.NouveauSolde(5100)
57 print("{:+.2f}".format(cb1.Solde()))
58 cb1+253.2
59 cb1-1000+100
60 cb1-cb1.Solde()
- File → Save As
- Répertoire : C:\PythonXX
- Nom du fichier : CompteBancaire.py
1 >>>
2 +1000.00
3 +1200.00
4 +1149.77
5 +1149.77
6 +5100.00
7 Nouveau solde : +5353.20 €
8 Nouveau solde : +4353.20 €
9 Nouveau solde : +4453.20 €
10 Nouveau solde : +0.00 €
11 >>>
Affectation par références
laVoitureDeMaFemme = maVoiture
- Ici, je crée une nouvelle référence à un seul et même objet (moi et mon épouse n'avons qu'une voiture).
- Ce n'est pas une instanciation !
- Si je repeins ma voiture en vert la voiture de ma femme sera donc verte.
1 >>> class Personne:
2 ... def __init__(self, age ):
3 ... self.age = age
4 ... def vieillir(self):
5 ... self.age += 1
6 ...
7 >>> docteurJekyll = Personne(40)
8 >>> misterHyde = docteurJekyll
9 >>> docteurJekyll.vieillir()
10 >>> print( misterHyde.age )
=> 41
Variables et méthodes de classe et d’instance
- Variables et méthodes d’instance
- Chaque attribut est propre à sa classe, c'est une variable d’instance.
- Une méthode qui reçoit en paramètre l’adresse de l’instance via la référence « self » est dite méthode d’instance.
- Variables et méthodes de classe
- Une variable commune à toutes les instances, par exemple le nombre de voitures est appelée variable de classe.
- Une méthode qui ne reçoit pas en paramètre la référence « self » ne peut pas manipuler les variables d’instances. Elle a accès par contre aux variables de classe.
Exemple
1 >>> class X:
2 ... variable_de_classe = 5
3 ... def __init__(self, valeur ):
4 ... self.variable_d_instance = valeur
5 ... def methode_d_instance( self ):
6 ... self.variable_d_instance += 1
7 ... @classmethod
8 ... def methode_de_classe( cls ):
9 ... cls.variable_de_classe += 1
10 ...
11 >>> une_instance = X(3)
12 >>> une_instance.methode_d_instance()
13 >>> X.methode_de_classe()
14 >>> print( une_instance.variable_d_instance)
15 4
16 >>> print( X.variable_de_classe )
17 6
18 >>> print( une_instance.variable_de_classe )
19 6
20 >>> class X:
21 ... variable_de_classe = 4.
22 .. def methode_de_classe():
23 ... print( X.variable_de_classe )
24 ...
25 >>> X.methode_de_classe()
26 4
