Progrmmation Python

Master 3I [Link]
Programmation Orientée Objet
 Dictionnaire et OO
 Descriptors
 Protection des attributes
 Méthodes POO
 Méthodes de classe :Classmethod
 Méthodes statiques : Staticmethod
 Concepts POO : Héritage, Composition, Polymorphisme
 Abstract Base Classes
 Inner Class
 Metaclass
 Iterator & Generator
 Exceptions
 Class as Decorator

2
Abstract Base Classes
 Les classes de base abstraites sont une forme de contrôle d'interface plus
stricte que les contrôles individuels de hasattr () pour des méthodes
particulières.
 En définissant une classe de base abstraite, vous pouvez définir une API
commune pour un ensemble de sous-classes.
 Version 1:
from abc import ABC
class PluginBase(ABC):
@abstractmethod
def Methode(self, *args):
return

 Version 2: from abc import ABC Meta

class PluginBase(metaclass=ABCMeta):
@abstractmethod
def Methode(self, *args):
return
Abstract Base Classes
 Exemple :
import abc
class PluginBase(__metaclass__ =[Link] ):
@[Link]
def load(self, input):
"""Retrieve data from the input source and return an object."""
return
@[Link]
def save(self, output, data):
"""Save the data object to the output."""
return

 Exécution:
>>> y=PluginBase()
Traceback (most recent call last):
File "<ipython-input-8-a87bf2409844>", line 1, in <module> y=PluginBase()
TypeError: Can't instantiate abstract class PluginBase with abstract methods load, save
Abstract Base Classes:
Registering a Concrete Class
 Il existe deux façons d'indiquer qu'une classe concrète implémente une
abstraite : c’est d’enregistrer la classe avec l'abc ou la sous-classe
directement à partir de l'abc.
1-Register subclass as a “virtual subclass” of this ABC.
 Exemple :
import abc from abc_base
import PluginBase
class RegisteredImplementation(object):
def load(self, input): return [Link]()
def save(self, output, data): return [Link](data)
[Link](RegisteredImplementation)
if __name__ == '__main__':
print ('Subclass:', issubclass(RegisteredImplementation, PluginBase))
print ('Instance:', isinstance(RegisteredImplementation(), PluginBase))
 Exécution:
Subclass: True
Instance: True
Abstract Base Classes:
Implementation Through Subclassing
2-En subclassant directement à partir de la base, nous pouvons
éviter la nécessité d'enregistrer la classe explicitement.(Register)
 Exemple :
import abc
from abc_base import PluginBase
class RegisteredImplementation(PluginBase):
def load(self, input): return [Link]()
def save(self, output, data): return [Link](data)
if __name__ == '__main__':
print ('Subclass:', issubclass(RegisteredImplementation, PluginBase))
print ('Instance:', isinstance(RegisteredImplementation(), PluginBase))

 Exécution:

Subclass: True
Instance: True
Abstract Base Classes
 Les classes de base abstraites sont une forme de contrôle d'interface plus
stricte que les contrôles individuels de hasattr () pour des méthodes
particulières.
 Par la définition d’une classe de base abstraite, on peut définir une API
commune pour un ensemble de sous-classes.
 Version 1:
from abc import ABC
class PluginBase(ABC):
@abstractmethod
def Methode(self, *args):
return

 Version 2: from abc import ABC Meta

class PluginBase(metaclass=ABCMeta):
@abstractmethod
def Methode(self, *args):
return
7
Abstract Base Classes
 Exemple :
import abc
class PluginBase(__metaclass__ =[Link] ):
@[Link]
def load(self, input):
"""Retrieve data from the input source and return an object."""
return
@[Link]
def save(self, output, data):
"""Save the data object to the output."""
return

 Exécution:
>>> y=PluginBase()
Traceback (most recent call last):
File "<ipython-input-8-a87bf2409844>", line 1, in <module> y=PluginBase()
TypeError: Can't instantiate abstract class PluginBase with abstract methods load,
save

8
Abstract Base Classes: Registering a Concrete Class
 Il existe deux façons d'indiquer qu'une classe concrète implémente une
abstraite : c’est d’enregistrer la classe avec l'abc ou la sous-classe
directement à partir de l'abc.
 Register subclass as a “virtual subclass” of this ABC.
 Exemple :
import abc from abc_base
import PluginBase
class RegisteredImplementation(object):
def load(self, input): return [Link]()
def save(self, output, data): return [Link](data)
[Link](RegisteredImplementation)
if __name__ == '__main__':
print ('Subclass:', issubclass(RegisteredImplementation, PluginBase))
print ('Instance:', isinstance(RegisteredImplementation(), PluginBase))
 Exécution: Subclass: True
Instance: True
9
Abstract Base Classes: Implementation Through Subclassing

 En subclassant directement à partir de la base

 Exemple :
import abc
from abc_base import PluginBase
class RegisteredImplementation(PluginBase):
def load(self, input): return [Link]()
def save(self, output, data): return [Link](data)
if __name__ == '__main__':
print ('Subclass:', issubclass(RegisteredImplementation, PluginBase))
print ('Instance:', isinstance(RegisteredImplementation(), PluginBase))

 Exécution:
Subclass: True
Instance: True

10
 Interface vs Abstract class
Python interface Python abstract class
An interface is a set of methods and We can use an abstract base class to
attributes on that object. define and enforce an interface.

An abstract class can have abstract

All methods of an interface are
methods as well as concrete
abstract
methods.
We use an interface if all the
Abstract classes are used when there
features need to be
is some common feature shared
implemented differently for
by all the objects as they are.
different objects.
The interface is slow as compared to
Abstract classes are faster.
the abstract class.

11
Inner Classe
 Les classes internes (ou "inner classes") sont des classes définies à l'intérieur d'une
autre classe. Elles sont souvent utilisées pour encapsuler une logique spécifique à la
classe parente et pour créer des classes qui n'ont de sens que dans le contexte de
la classe parente.
 Exemple:
 Une classe (Human) avec une classe interne (Head).
 Une instance est créée qui appelle une méthode dans la classe interne:
class Human:
def __init__(self):
[Link] = 'Guido'
[Link] = [Link]()
class Head:
def talk(self):
return 'talking...'

if __name__ == '__main__':
guido = Human() Guido
print ([Link]) talking...
print ([Link]())
Inner Classe
 Les classes internes sont souvent utilisées pour les raisons
suivantes :
1. Encapsulation : Les classes internes permettent d'encapsuler une
logique spécifique à la classe parente, ce qui permet de rendre le code
plus clair et plus facile à comprendre.
2. Modèle de classe unique : Les classes internes peuvent être utilisées
pour définir des classes qui n'ont de sens que dans le contexte de la
classe parente.
3. Héritage : Les classes internes peuvent hériter de la classe parente ou
d'une autre classe interne, ce qui leur permet d'étendre ou de
personnaliser le comportement de la classe parente.
4. Organisation : Les classes internes peuvent aider à organiser le code
en groupant les classes et les méthodes qui sont liées entre elles. Cela
peut également faciliter la compréhension et la maintenance du code.
Inner Classe
[Link] :
Inner Classe
2. Modèle de classe unique :
Inner Classe
3. Héritage :
 Inner Classe
4. Organisation : ( Multiple inner classes)
Programmation Orientée Objet
 Object Concept :
 __new__ Method
 Metaclass
 Abstract Base Classes
 Interface Class
 Inner Class

18
Création de l’objet : __new__
 __new__ est le vrai constructeur.
 Pour cette raison, elle doit retourner un objet.
 Exemple:
class Premiere(object):
def __new__(cls, prix):
print ("%s euros" % prix)
return super(Premiere, cls).__new__(cls)
>>> c = Premiere(10000)
10000 euros

 __new__ est appelée AVANT la création de l’objet, car c’est son boulot de
créer l’instance et de la retourner.
 On appelle super() pour utiliser la méthode __new__ de object et créer
une instance pour cette classe.
 L’objet créé sera ensuite passé à __init__ automatiquement par Python.

19
Création de l’objet : __new__
 La valeur de retour de __new __ () devrait être la
nouvelle instance d'objet (habituellement une instance
de cls).
 Les implémentations typiques créent une nouvelle
instance de la classe en invoquant la méthode
__new __ () de la superclasse en utilisant:
super (currentclass, cls) .__ new __ (cls [, ...])
Object.__new__(cls)
 avec les arguments appropriés, puis en modifiant
l'instance nouvellement créée comme nécessaire
avant de la retourner.
20
 Création de l’objet : __new__
 La valeur de retour de __new __ () devrait être la
nouvelle instance d'objet (habituellement une instance
de cls).

Syntax:
class class_name:
def __new__(cls, *args, **kwargs):
statements
. .
return super(class_name, cls).__new__(cls, *args, **kwargs)

21
Création de l’objet : __new__
 En résumé: __new__ est le vrai constructeur, il est appelé
pour créer l’objet, et l’objet ainsi instancié est passé
à __init__. class Premiere(object):
 Exemple: def __new__(cls, prix):
print ("__new__“)
return super(Premiere, cls).__new__(cls)
def __init__(self, *args):
print ("__init__“)
 >>> c = Premiere(10000)
__new__
__init__

 Les deux cas principaux pour utiliser __new__ sont:

 Dans l’héritage d’un type immutable (str, int, tuple,
etc), __new__ est le seul endroit où on puisse
initialiser l’objet.
 Dans le cas des métaclasses.

22
 Métaclasse
 Une classe est un objet, et comme tout autre objet, c'est une
instance de quelque chose: une métaclasse.
 La métaclasse par défaut est type.
 Le type est un peu confus: il peut également être utilisé comme
une fonction qui renvoie la classe d'un objet:
>>> class Foobar: >>> isinstance(foo, Foobar)
... pass True
... >>> isinstance(Foobar, type)
>>> type(Foobar)
True
<class 'type'>
>>> foo = Foobar()
>>> type(foo)
<class '__main__.Foobar'>

23
 Metaclass : Type Simple use
 L'énoncé de la classe n'est pas seulement du sucre syntaxique, il fait
certaines choses supplémentaires, comme le réglage d'une __qualname__
et __doc__ propriétés adéquates ou l'appel __prepare__.
>>> MyClass = type('MyClass', (), {})
>>> MyClass
<class '__main__.MyClass'>

 La classe type prend trois arguments pour se construire :

 Nom de la classe à créer ;
 Tuple contenant les classes dont notre nouvelle classe va hériter ;
 Dictionnaire contenant les attributs et méthodes de notre classe.
 Exemple : une métaclasse personnalisée:
>>> class Complex(metaclass=Meta):
>>> class Meta(type):
... pass
... pass
>>> type(Complex)
<class '__main__.Meta'>
24
Metaclass : Type Simple use

25
Metaclass: __prepare__ method
 La méthode prepare est appelée avant que le corps de classe
soit exécuté et il doit renvoyer un objet de type
dictionnaire qui est utilisé comme espace de noms local pour
tout le code du corps de classe.
 La méthode prepare a été ajouté en Python 3.0, (PEP-3115).
 Si __prepare__ renvoie un objet x, alors:
class Class(metaclass=Meta):
a=1
b=2
c=3

 Fera les modifications suivantes à x:

x['a'] = 1
x['b'] = 2
x['c'] = 3
26
Metaclass: __new__ method
 L'un des points de confusion les plus fréquents avec les classes et les
métaclasses est la méthode __new__. Il a des conventions très
spéciales.
 La méthode __new__ est le constructeur (elle renvoie la nouvelle
instance) tandis que __init__ est juste un initialisateur (l'instance est
déjà créée quand __init__ est appelée).
class Foobar:
def __new__(cls):
return super().__new__(cls)

 Foobar .__ new__ est utilisé pour créer des instances de Foobar
 Type .__ new__ est utilisé pour créer la classe Foobar (une
instance de type dans l'exemple)
27
Metaclasses : object creation
 Diagramme de la façon dont les instances sont
construites:

28
 Metaclasses : class creation
Diagramme de la façon dont les classes sont construites:
 MetaClass .__ prepare__ renvoie simplement
l'objet namespace (un objet de type dictionnaire).
 Une fois la métaclasse appropriée identifiée,
l'espace de noms de classe est préparé.
 Si la métaclasse a un attribut __prepare__, elle est
appelée comme
namespace = metaclass .__ prepare __ (nom, bases, **
kwds)
 La méthode __prepare__ doit être implémentée
comme méthode de classe ().
 L'espace de noms retourné par __prepare__ est
passé à __new__, mais lorsque l'objet de classe final
est créé, l'espace de noms est copié dans un nouveau
dict.
29
 Metaclasses : class creation
Diagramme de la façon dont les classes sont construites:
 MetaClass .__ prepare__ renvoie
simplement l'objet namespace (un
objet de type dictionnaire ).
 Metaclass .__ new__ retourne
l'objet Class.
 MetaMetaclass .__ call__ renvoie
tout ce que Metaclass .__ new__
a retourné (et s'il renvoie une
instance de Metaclass, il appellera
également Metaclass .__ init__ sur
celui-ci)

30
Metaclasses : Methods
 __prepare__(metacls, name,
bases, **kwargs)  dict
Lors de l'initialisation de l'espace
de noms de la classe
 __new__(mcs, classname, bas
es, attrs)  cls
Avant la création de la classe
__init__(self, name, bases, att
rs)  None
Apres la création de la classe
 __call__(self, *args, **kwargs)
permet un comportement
personnalisé lorsque la classe
est appelée

31
Metaclasses : Methods
 Une fois que la métaclasse appropriée a été identifiée, l'espace de
noms de classe est préparé.
 Si la métaclasse a un attribut __prepare__ , elle est
appelée namespace = metaclass.__prepare__(name, bases, **
kwds) (où les arguments de mot clé supplémentaires, le cas
échéant, proviennent de la définition de classe).
 La méthode __prepare__ doit être implémentée en tant
que classmethod().
 L'espace de noms renvoyé par __prepare__ est transmis
à __new__, mais lorsque l'objet de classe final est créé, l'espace de
noms est copié dans un nouveau dict.
 Si la métaclasse n'a pas d'attribut __prepare__ , alors l'espace de
noms de classe est initialisé en tant que mappage ordonné vide .

32
Metaclasses : Heritage Class vs MetaClass

33
 Metaclasses : class creation
Exemple :

Class MTC(type):
def __new__(metacls,n,b,dict):
print( "Crétion de la classe {}".format(n))
return type.__new__(metacls,n,b,dict)

Class Maclass(metaclass=MTC):
pass
34
 Metaclasses : class creation
 The metaclass is called when the system encounters the class definition:
1) The __prepare__ method is called, if there is one, to supply the data structure for
the namespace.
2) The class body is evaluated and stored in the namespace.
3) __new__ is called to create the class instance usually delegating to
super().__new__.
4) __init__ is called to initialize the class.
Exemple :

35
 Metaclasses
Exemple :
class Meta(type):
def __new__(cls, name, bases, dct):
x = super().__new__(cls, name, bases, dct)

[Link] = 100

return x

class Bar(metaclass=Meta):
[Link], [Link]
pass
(100, 100)
class Qux(metaclass=Meta):

pass

36
 Metaclasses
# our metaclass
Exemple2 : class MultiBases(type):
# overriding __new__ method
def __new__(cls, clsname, bases, clsdict):
# if no of base classes is greator than 1
# raise error
if len(bases)>1:
raise TypeError("Inherited multiple base classes!!!")

# else execute __new__ method of super class, ie.

# call __init__ of type class
return super().__new__(cls, clsname, bases, clsdict)

class Base(metaclass=MultiBases):
pass

# no error is raised
class A(Base):
pass
Traceback (most recent call last):
# no error is raised File "[Link]", line 29, in <module>
class B(Base): class C(A, B):
pass File "[Link]", line 8, in __new__
raise TypeError("Inherited multiple base classes!!!")
# This will raise an error!
class C(A, B):
TypeError: Inherited multiple base classes!!!
pass

37
 MetaClass :
__subclasscheck__&__subclasshook__
 __subclasscheck__est l’une des méthodes pour
personnaliser le résultat de la fonction intégrée
issubclass() .
 C’est une méthode pour vérifier si une classe est une
sous-classe ou non.
 La fonction retourne True si la classe est considérée
comme une sous-classe (directe ou indirecte) d’une autre
classe, sinon, retourne False.
 La fonction ne peut pas être définie comme une méthode
de classe dans la classe réelle/réelle. Il est implémenté
dans la métaclasse, car ce n’est pas pour les classes
ordinaires.
38
 MetaClass :
__subclasscheck__&__subclasshook__
 Exemple:

39
 MetaClass :
__subclasscheck__&__subclasshook__
 Exemple:

40
 MetaClass :
__subclasscheck__&__subclasshook__
 La classe abstraite peut remplacer la __subclasshook__()
méthode à personnaliser issubclass().
 Il retourne True lorsqu’une classe s’avère être une sous-
classe d’une classe ABC, il retourne False si ce n’est pas le
cas et renvoie NotImplemented si la vérification de sous-
classe se poursuit avec le mécanisme habituel.
 La méthode est définie dans la classe ABC avec certaines
conditions.
 Les classes qui respectent ces conditions sont considérées
comme une sous-classe.
 Remarque: il doit être défini comme une méthode de
classe.
41
 MetaClass :
__subclasscheck__&__subclasshook__

42
 MetaClass :
__subclasscheck__&__subclasshook__
Aspect __subclasscheck__ __subclasshook__
Disponible dans les versions
Introduction Introduit dans Python 3.10 et supérieurs
antérieures à Python 3.10
Méthode de Oui (doit être décorée avec
Non (méthode normale)
classe @classmethod)
Appel Requiert un appel explicite avec Appelé automatiquement par
explicite issubclass(cls, subclass) issubclass(subclass, cls)

Hiérarchie Méthode peut être définie à différents Un seul __subclasshook__ est considéré, le
de résolution niveaux de la hiérarchie de classe plus proche dans la hiérarchie

@classmethod
Signature def __subclasscheck__(cls, subclass):
def __subclasshook__(cls, subclass):

Utilisé pour personnaliser la Utilisé pour fournir une méthode de classe

Utilisation vérification de sous-classe pour une générique pour la vérification de sous-
méta-classe spécifique classe, partagée par plusieurs méta-classes

43
Exceptions: Introduction
 Les exceptions fournissent un mécanisme de contrôle de flot de haut
niveau. Une exception peut être déclenchée soit par l'interpréteur
(python) soit par un programme.
 Les exceptions sont utilisables dans les cas suivants :
 Gestion des erreurs ; python déclenche les exceptions dès qu'il détectent des
erreurs dans l'exécution des programmes.
 Deux cas sont envisageables lorsqu'une exception est levée [to raise an exception] :
 Elle est interceptée pour être traitée de manière interne par le programme.
 Elle est ignorée, ce qui déclenche le comportement par défaut, i.e. l'interruption du programme et
l'affichage d'un message d'erreur explicitant l'endroit où elle s'est produite.
 Notification d'évènements ; penser à une fonction de recherche qui lèverait une
exception en cas de succès plutôt que de renvoyer un code standard (du
genre 1 ou True).
 Gestion de cas particulier ; ce qui permet de conserver un code sans les
lourdeurs associées à des cas rares.
 Contrôle de flot inhabituel ; pour remonter en quelque sorte dans le programme
en cours d'exécution pour défaire par exemple certaines affectations.
Exceptions: try/except/else
 La syntaxe est la suivante :
try:
<statementlist>
except[:| <label>[, <data>]:]
<anotherstatementlist>
else:
<anotherstatementlist2>

 Les règles sont les suivantes :

 Si une exception est levé pendant l'exécution du bloc encapsulé par
le try, python exécute la première clause except correspondante (en fait, le
code associé à ce bloc) si elle existe. Le contrôle continue au delà du
bloc try après l'exécution du bloc d'exception (clause except), sauf si le code
associé (à ce dernier bloc) lève lui même une exception.
 Si aucune clause except ne correspond, l'exception est propagée dans
les blocs try de plus haut niveau, jusqu'à la limite du top-level,
où python interrompt le programme et affiche l'erreur.
 Si aucune exception n'est levée, le bloc d'instructions associé à la
clause else est exécuté. Le contrôle reprend au delà du try tout entier.
Exceptions: try/except/else
try:
<statementlist>
except[:| <label>[, <data>]:]
<anotherstatementlist>
else:
<anotherstatementlist2>
 Exemple: try/except/else
import sys
# résultat #
try:
./[Link] toto
filename = [Link][1]
1 : toto
fhi = open( filename, "r" )
2 : tutu
indx = 1
3 : titi fermeture du fichier...
for line in [Link]():
fin du traitement
print (indx, ":", line)
indx = indx + 1
print ("fermeture du fichier..." )
[Link]()
except IndexError:
print ("pas d'argument sur la ligne de commande !")
[Link](1)
except IOError:
print ("Le fichier", filename, " n'existe pas !")
[Link](2)
else:
print ("fin du traitement")
Exceptions: try/finally
 Cette variante permet de spécifier dans la clause finally des
actions de terminaison.
 Le bloc d'instructions associé à la clause finally est exécuté à la
sortie par python qu'une exception ait été levé ou non dans
le bloc try, plus précisément le bloc associé au try est exécuté
et si :
 Une exception survient, python exécute le code de la
clause finally puis propage l'exception à un bloc try de plus
haut niveau.
 Aucune exception ne survient, python exécute le code de
la clause finally puis poursuit son exécution au delà du try.
 Attention, la clause finally ne peut être utilisée dans
l'instruction try/except/else, il faut l'imbriquer.
Exceptions: try/finally
 Exemple : try/finally
Exceptions: try/finally
 Exemple : try/except/else/finally
 Exceptions : raise
 Cette instruction permet au programmeur de lever lui même une
exception.
 Python va lever des exceptions de lui-même, par exemple en cas d’erreurs,
mais on peut aussi lever soi-même des exceptions en faisant:
raise NomDeLException("Message").
 Exemple : Une fonction qui n’accepte en paramètre que comme valeur 1,
2 ou 3.
def votre_super_fonction(param):
if param not in (1, 2, 3):
raise ValueError("'param' can only be either 1, 2 or 3")

>>> votre_super_fonction(4) Traceback (most recent call last):

File "<ipython-input-3-bcd6e8653c83>", line 1, in <module>
votre_super_fonction(4)
File "<ipython-input-2-46fc7cd18c42>", line 3, in
votre_super_fonction raise ValueError("'param' can only be either 1,
2 or 3") ValueError: 'param' can only be either 1, 2 or 3
 Clauses de l'instruction try
Clause Interprétation
except: intercepte tous les types d'exceptions

except <exceptionType>: intercepte l'exception spécifique du type précisé

except <exceptionType>, intercepte l'exception spécifique du type précisé avec sa

<value>: donnée supplémentaire
except (<exceptionType1>,
intercepte n'importe laquelle des exceptions listées
<exceptionType2>):
else: exécute ce bloc si aucune interception n'est levée

finally:
applique toujours ce bloc

Raise Exception personalisée

Iterators : Introduction
 Des séquences infinies surviennent fréquemment en
informatique.
 Par exemple, la séquence de tous les nombres naturels
est une séquence infinie, parce qu'il n'y a pas de «dernier»
nombre naturel.
 Cependant, il est impossible de stocker physiquement une
quantité infinie de données. Comment contourner ce
problème?
 les itérateurs, les générateurs chacune de ces
constructions est conçue pour représenter des
séquences infinies dans une quantité infinie de mémoire.

53
Iterators : Introduction
 Les itérateurs sont des objets qui permettent de parcourir des séquences
d'éléments (tels que des listes, des tuples, des chaînes, etc.). Ils sont créés en
utilisant des fonctions d'itération telles que iter() et iterable() ou les méthodes
de l'objet lui-même.
 Un itérateur possède une méthode __next__() qui permet de récupérer l'élément
suivant dans la séquence à chaque appel. Une fois que tous les éléments ont été
parcourus, une exception StopIteration est levée.
 Exemple : d'utilisation d'un itérateur pour parcourir une liste :

54
Iterators
 Un itérateur est un objet qui représente une séquence de valeurs.
 Exemple: Une classe qui implémente l'interface iterator de
Python. Cet itérateur calcule tous les nombres naturels un par un,
à partir de zéro:
class Naturals():
def __init__(self):
[Link] = 0
def __next__(self):
result = [Link]
[Link] += 1
return result
def __iter__(self):
return self

 Il existe deux composants de l'interface itérateur Python: la

méthode __next__et __iter__.

55
Iterators: __next__ Method
 La méthode __next__ fait deux choses:
1. Calcule la valeur suivante
2. Vérifie s'il reste des valeurs à calculer
 Pour retourner la valeur suivante dans la séquence,
l'itérateur effectue un calcul défini dans la méthode
next.
 Lorsqu'il ne reste plus de valeurs à calculer, la méthode
suivante doit élever un type d'exception appelé
StopIteration. Cela signale la fin de la séquence.
 Remarque: la méthode suivante définie ci-dessus ne
soulève aucune exception StopIteration.

56
 Iterators: Exemple
 Les itérateurs sont des objets qui ont des toujours les méthodes __next__
et __iter__:
class CountDown(object): >>> i = iter(range(5, 0, -1))
def __init__(self, start): >>> next(i)
[Link] = start + 1 5
def __next__(self): >>> next(i)
[Link] -= 1 4
if [Link] <= 0 >>> next(i)
raise StopIteration 3
return [Link] >>> next(i)
def __iter__(self): 2
return self >>> next(i)
1
>>> next(i)
>>> cd = CountDown(5) Traceback (most recent call
>>> for x in cd: last):
... print(x) File "<interactive input>",
5 4 3 2 1 0 line 1, in <module>
StopIteration

57
Iterators: __iter__ Method
 Le but de la méthode __iter__ est de renvoyer un objet
itérateur.
 Par définition: un Iterator est un objet qui a implémenté
les deux méthodes __next__ et __iter__.
 Cela a une conséquence intéressante. Si une classe
implémente une méthode next et Une méthode iter, sa
méthode iter peut simplement retourner self (comme
dans l'exemple).
 Puisque la classe implémente à la fois next et iter, elle
est techniquement un objet iterator, donc sa méthode
iter peut simplement revenir elle-même.

58
Iterators

59
Iterators
 Les itérateurs ne peuvent être parcourus qu'une seule
fois, une fois que tous les éléments ont été récupérés, il n'est
plus possible de récupérer les éléments restants.
 Pour parcourir à nouveau la séquence, il faut créer un
nouvel itérateur.
 Il est également important de noter que les itérateurs ne
prennent pas en compte les modifications apportées à
la séquence d'origine après la création de l'itérateur.
 Les itérateurs sont des objets efficaces pour parcourir des
séquences d'éléments en Python, mais il est important de
comprendre leurs limites et de les utiliser correctement pour
éviter les erreurs.
60
Iterators: itertools
 la bibliothèque itertools fournit des outils supplémentaires pour les
itérateurs en Python, en permettant des opérations telles que la
combinaison, la répétition, la filtration et l'agrégation des itérateurs.
 [Link](iterable, r) : génère toutes les combinaisons de longueur
r de l'itérateur donné.
 [Link](iterable, r=None) : génère toutes les permutations
possibles de l'itérateur donné.
 [Link](iterable, key_func) : regroupe les éléments consécutifs d'un
itérateur qui ont la même valeur de clé en utilisant la fonction de clé donnée.
 [Link](iterable, start, stop[, step]) : retourne un itérateur qui retourne
des éléments spécifiques de l'itérateur donné en utilisant des arguments start, stop et
step.
 [Link](start=0, step=1) : retourne un itératerateur qui génère une série
de nombres en utilisant les arguments start et step. Il est similaire à range(), mais il
retourne un itérateur plutôt qu'une liste.
 Il existe également d'autres outils tels que [Link](), [Link](),
itertools.zip_longest()

61
Iterators: itertools
 Exemple :

62
Iterators: itertools
 Exemple :

63
 Generator Functions
 Les générateurs peuvent générer des itérateurs.
 Les générateurs constituent une classe spéciale de fonctions qui
simplifient la tache dans l'écriture des itérateurs. Les fonctions
régulières calculent une valeur et la retournent, mais les générateurs
retournent un itérateur qui retourne un flux de valeur.
 Une fonction de générateur est une fonction avec le rendement de
mot-clé yield dans son corps.
 La déclaration de yield est similaire à une déclaration de return .
 Cependant, alors qu'une instruction de return provoque la destruction
de l'environnement actuel après la sortie d'une fonction, une
instruction de yield amène l'environnement à être enregistré jusqu'à la
prochaine fois que __next__ est appelé, ce qui permet au
générateur de suivre automatiquement l'état d'itération.

64
Generator Functions
 Une fonction de générateur est une fonction avec le rendement de mot-clé
yield dans son corps: >>> def count_down(value):
... for x in range(value, 0, -1):
... yield x
...
>>> c = count_down(5)
>>> next(c)
5
>>> next(c)
4
>>> next(c)
3
>>> next(c)
2
>>> next(c)
1
>>> next(c)
Traceback (most recent call last):
File "<interactive input>", line 1, in
<module>
StopIteration
65
Generator Functions
 Les générateurs sont très utiles pour des tâches qui
nécessitent de générer des séquences infinies ou
de grandes quantités de données car ils ne
stockent pas toutes les données en mémoire
en même temps, mais les génèrent au fur et à mesure
qu'elles sont nécessaires.
 Les générateurs ne peuvent être parcourus qu'une
seule fois, une fois qu'ils ont généré toutes les
valeurs, ils ne peuvent plus être utilisés.
 Parcourir à nouveau les valeurs générées, Il faut
créer un nouveau générateur.
66
Generator Functions vs Iterators
 Un itérateur est un objet qui permet de parcourir un
ensemble de données, en retournant une valeur à chaque
itération. Les itérateurs sont utilisés pour parcourir les éléments
d'une collection (comme une liste ou un dictionnaire) de manière
séquentielle.
 Un générateur est une fonction spéciale qui permet de créer un
itérateur. Au lieu de retourner une valeur, une fonction génératrice
utilise le mot-clé yield pour retourner une valeur à chaque itération.
 Les générateurs permettent de créer des itérateurs
personnalisés et de générer des séquences de manière efficace en
termes de mémoire.
 Les générateurs sont utilisés pour créer des itérateurs, qui
sont utilisés pour parcourir des collections de données de manière
séquentielle.
67
Generator Functions vs Iterators

68
Class as decorator
 Les décorateurs sont un outil très puissant et utile en
Python, car ils permettent aux programmeurs de modifier
le comportement d'une fonction ou d'une classe.
 Les décorateurs permettent d’envelopper une autre
fonction afin d’étendre le comportement de la fonction
enveloppée, sans la modifier de façon permanente.
 un décorateur peut être définit en tant que classe.
 Le méthode de classes __call__.
 Lorsqu'un utilisateur doit créer un objet qui fonctionne
comme une fonction, il est nécessaire de revenir à cette
fonction pour qu'elle puisse être utile.

69
 Class as decorator
# Python program showing
# use of __call__() method

class MyDecorator:
def __init__(self, function):
[Link] = function

def __call__(self):
# We can add some code
# before function call
[Link]
# We can also add some code
# after function call.

# adding decorator to the class

@MyDecorator
def function():
print("Hallo Function")

function()

70
 Class as decorator
 Décorateur de classe avec * args et **kwargs:
 Pour utiliser le décorateur de classe avec les arguments *args
et **kwargs, il faut utiliser une fonction __call__ et les deux
arguments sont passés dans une fonction donnée.
# Python program showing class decorator with
*args and **kwargs
class MyDecorator:
def __init__(self, function):
[Link] = function

def __call__(self, *args, **kwargs):

# We can add some code
# before function call # adding decorator to the class
[Link](*args, **kwargs) @MyDecorator
# We can also add some code def function(name, message ='Hello'):
# after function call. print("{}, {}".format(message, name))

function("M3I", "hello")
71
 Class as decorator
 Décorateur de classe avec * args et **kwargs:
 Pour utiliser le décorateur de classe avec les arguments *args
et **kwargs, il faut utiliser une fonction __call__ et les deux
arguments sont passés dans une fonction donnée.
# Python program showing class
decorator with *args and **kwargs
class MyDecorator:
def __init__(self, function):
[Link] = function

def __call__(self, *args, **kwargs):

# We can add some code
# before function call # adding decorator to the class
@MyDecorator
[Link](*args, **kwargs) def function(name, message ='Hello'):
# We can also add some code print("{}, {}".format(message, name))
# after function call.
function("M3I", "hello")
72
 Class as decorator
 Exemple
from time import time
class Timer:
def __init__(self, func):
[Link] = func
def __call__(self, *args, **kwargs):
start_time = time()
result = [Link](*args, **kwargs)
end_time = time()
print("Execution took {} seconds".format(end_time-start_time))
return result
@Timer
def some_function(delay):
from time import sleep
sleep(delay) Execution took 3.003122091293335 seconds

some_function(3)
73
Class as decorator
 Exemple
class ErrorCheck:
def __init__(self, function):
[Link] = function
def __call__(self, *params):
if any([isinstance(i, str) for i in params]):
raise TypeError("parameter cannot be a string !!")
else:
return [Link](*params)

@ErrorCheck
def add_numbers(*numbers): 6
return sum(numbers)
# returns 6 TypeError: parameter cannot be a string !!
print(add_numbers(1, 2, 3))

# raises Error.
print(add_numbers(1, '2', 3))
74
Class as decorator
 Exemple

75
Class as decorator
 Exemple

76
TP : iterator
 Écrire une class qui nous donnera prochaine puissance de 2
dans chaque itération. L'exposant de puissance commence à
partir du zéro jusqu'à un numéro défini par l'utilisateur.
>>> a = PowTwo(4)
>>> i = iter(a)
>>> next(i) 1
>>> next(i) 2
>>> next(i) 4
>>> next(i) 8
>>> next(i) 16
>>> next(i)
Traceback (most recent call last): ...
StopIteration

 Écrire un Générateur qui inverse une chaîne.

Plan
 Metaclass
 Iterators
 Generators
 Exceptions
 Gestion des fichiers
 Connexion avec base de données
 Introduction au Programmation
GUI
78
Fichiers en python
Lecture et écriture dans un fichier
 Un fichier stocke des informations sur un support physique (disque
dur, clé USB, CD, DVD, carte mémoire SD...).
 Ouvrir un fichier consiste à le charger dans la mémoire vive
(RAM) de l'ordinateur (c'est une mémoire volatile : elle s'efface
quand on éteint l'ordinateur).
 Enregistrer un fichier consiste à l'écrire sur un support
physique de stockage (l'information est alors conservée de
manière permanente).
 Il existe deux types de fichiers :
 Les fichiers textes : l'information est stockée sous forme de
caractères lisibles par un éditeur de texte (principalement des lettres et
des chiffres).
 Les fichiers binaires : l'information est stockée en binaire (une suite
d'octets dont la valeur est comprise entre 0x00 et 0xFF).
Ecriture dans un fichier
 Le mode write : L'écriture dans un fichier se fait avec la
fonction open() en mode écriture :

 Le fichier [Link] est créé dans le répertoire courant (sous

Windows c'est normalement le répertoire C:/PythonXX.
 On peut aussi choisir un emplacement quelconque en spécifiant le
chemin absolu, par exemple NomFichier = 'F:/Mon dossier/[Link]').
Ecriture dans un fichier
 Le mode append: Pour écrire à la fin d'un fichier, on utilise la
fonction open() en mode ajout.
 Exemple:
Lecture en mode binaire
 En mode texte, un fichier est lu caractère par caractère.
 En mode binaire, un fichier est lu octet par octet : c'est un peu
différent !
 Exemple: si on veut la taille d'un fichier, il faut utiliser la
lecture en mode binaire 'rb' (read binary) :
Sérialisation avec Pickle
 Le module Pickle est extrêmement pratique pour sauvegarder dans un fichier des
structures de données comme les listes (type list) ou les dictionnaires (type dict).
 Pickling: Un exemple de sauvegarde d'un dictionnaire :

 Unpickling: L'opération inverse est tout aussi simple :

TP: Gestion de fichier
 Que fait la commande suivante:
>>> import os
 ****

>>> from os import chdir

>>> rep= [Link]()
>>>chdir("/home/jules/exercices")
>>> print (rep)

 Exécutez les commande suivantes:

>>> obFichier = open('Monfichier','a')
>>> [Link]('Bonjour, fichier !')
>>> [Link]("Quel beau temps, aujourd'hui !")
>>> [Link]()
1) Affichez le contenu du fichier
2) Que donne l’instruction: t = [Link](15)
3) Que fait les fonctions readline() et readlines()
4) Ecrire une focntion copieFichier('Monfichier','Tonfichier')
TP: Gestion de fichier
 Fonction copie: def copieFichier(source, destination):
"copie intégrale d'un fichier«
fs = open(source, 'r')
fd = open(destination, 'w')
txt = [Link]()
if txt =="":
break
[Link](txt)
[Link]()
[Link]()
return
Base de données avec Python
Connection à MySQL avec Connector/Python
 Le constructeur connect () crée une connexion au serveur MySQL et retourne une
objet MySQLConnection.

 il est également possible de créer des objets de connexion à l'aide de la Classe

connexion. MySQLConnection () :

 Les deux méthodes, en utilisant le constructeur connect() de connexion, ou la classe

directement, sont valables et fonctionnellement égale, mais en utilisant le connector ()
est préféré .
Connection à MySQL avec Connector/Python
 Pour gérer les erreurs de connexion, utilisez l'instruction try
et catch toutes les erreurs en utilisant l'exception [Link]
Connection à MySQL avec Connector/Python
 Si vous avez beaucoup d'arguments de connexion, il est
préférable de les garder dans un dictionnaire et utiliser
l'opérateur ** :
Interrogation de données par Connector / Python
 Nous ouvrons d'abord une connexion au serveur MySQL et stockons l'objet de
connexion dans le cnx variable. Nous créons alors un nouveau curseur, par défaut
un objet Cursor MySQL, l'aide de la méthode de connexion du curseur () .
TP MYSQL/Python
 Connexion vers Serveur:

import sys import MySQLdb

# connect to the MySQL server
try:
conn = [Link] (host = "localhost",
user = "testuser",
passwd = "testpass",
db = "test")
except [Link], e:
print ("Error %d: %s" % ([Link][0], [Link][1]))
[Link] (1)
TP MYSQL/Python
 Création de table animal:
# create the animal table
try:
cursor = [Link] ()
[Link] ("DROP TABLE IF EXISTS animal")
[Link] ("""
CREATE TABLE animal
(
name CHAR(40),
category CHAR(40)
)
""")
TP MYSQL/Python
 Insertion :
[Link] ("""
INSERT INTO animal (name, category)
VALUES
('snake', 'reptile'),
('frog', 'amphibian'),
('tuna', 'fish'),
('racoon', 'mammal')
""")
print ("%d rows were inserted" % [Link])
TP MYSQL/Python
 Extraction:
# perform a fetch loop using fetchone()

[Link] ("SELECT name, category FROM animal")

while (1):
row = [Link] ()
if row == None:
break
print ("%s, %s" % (row[0], row[1]) )
print ("%d rows were returned" % [Link])

# perform a fetch loop using fetchall()

[Link] ("SELECT name, category FROM animal")

rows = [Link] ()
for row in rows:
print ("%s, %s" % (row[0], row[1]) )
print ("%d rows were returned" % [Link])
TP MYSQL/Python
 Update:
# issue a query that includes data values literally in
# the query string, then do same thing using placeholders

[Link] ("""
UPDATE animal SET name = 'turtle'
WHERE name = 'snake'
""")
print ("%d rows were updated" % [Link] )

cur_name = "snake"
new_name = "turtle"
[Link] ("""
UPDATE animal SET name = %s
WHERE name = %s """, (new_name, cur_name))
print ("%d rows were updated" % [Link])
TP MYSQL/Python
 Création d’un dictionnaire a partir de données:
#create a dictionary cursor so that column values
# can be accessed by name rather than by position
[Link] ()
cursor = [Link] ([Link])
[Link] ("SELECT name, category FROM animal")
result_set = [Link] ()
for row in result_set:
print ("%s, %s" % (row["name"], row["category"]) )
print ("%d rows were returned" % [Link] [Link] ())
 Interfaces graphiques
Graphical User Interface (GUI)
TP1
TP2
TP3
Plus d’exemples
 [Link]
Exemple
1. Crée un classe Personne qui contient juste le
nom et l’âge.
2. Protéger la classe avec __slots__
3. instancie un objet joe avec age 30
4. taper la commande joe.__slots__
5. ajouter une attribut ville avec la commande :
1. [Link]= ‘ Casablanca’
2. joe.__class__.city=‘Casblance’
3. Protéger la classe avec la notion méta-classe
TP : correction
class PersonMeta(type):
def __new__(mcs,name,bases,class_dict):
class_dict[‘__slots’__]=(‘name’,’age’,)
return type.__new__(mcs,name,bases,class_dict)

def__setattr__(cls,key,value):
if(hasattrib(cls,key):
return();__setattrib(key,value)
raise AttributeError(‘’ N’est pas definie’)

class Person(metaclass=PersonMeta):
pass