Python 3

De TARENTINO
Révision datée du 12 novembre 2020 à 16:00 par Ange (discussion | contributions)
(diff) ← Version précédente | Voir la version actuelle (diff) | Version suivante → (diff)
Aller à la navigationAller à la recherche
Array

Ft.png

(Opérateurs:Magenta)
(Méthodes:Green)
(Fonctions:Red)

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

Class 01.png

  • 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

Gestion des erreurs
Récupérée de « https://tarentino.fr/index.php?title=Python_3&oldid=2389 »