Python - Cours1 1 92

Cours Python
2023/2024
Présenté par AMAL TARIFA
Plan
• Introduction Générale (python+ data science)
• Types de variables , les boucle, les fonctions, les décorateurs
• POO , les exceptions, les tests unitaires
• Numpy + TP
• Pandas + TP
• Matplotlib+ analyse exploratoire +TP
• Préparation de la data
• ML:Supervisé
• ML:Non supervisé
• Traitement des données textuelles, embedding
• deep learning
• Mini Projet
Presented By PhD Amal TRIFA

Introduction
générale

Introduction générale
Il a été créé par Guido van Rossum en 1991 et développé par la “Python Software
Foundation”. Il a été conçu en mettant l'accent sur la lisibilité du code et sa syntaxe. Il
permet aux programmeurs d'exprimer leurs concepts en moins de lignes de code.
Python est un langage de programmation qui vous permet de travailler rapidement et
d'intégrer des systèmes plus efficacement.
Deux versions principalement:

• Python 2
• Python 3

Particularités:
1. Libre et open source

2. Orienté objets
3. Mode Interactif
4. De haut niveau
5. Des librairies standards
6. Scalable (évolutif)
7. Extensible
8. Portable

Particularités:
1. ‘Garbage Collector’ automatique
2. Programmation GUI (interfaces) [ PyQt5, PyQt4, wxPython, Tk in
Python]
3. Intégré
4. Interprété

Particularités:
Rappel: Interprété??
L'interpréteur va exécuter les lignes du code une

par une.
(+) Dans un langage interprété, le même code

source fonctionne directement sur tout ordinateur.
Avec un langage compilé, on doit tout recompiler à
chaque fois, ce qui pose parfois des soucis.
Exemple: PhP, Javascript, python, Java

Particularités:
Rappel: Compilé??
(+)Dans un langage compilé, le

programme est directement exécuté sur
l'ordinateur, donc il sera en général plus
rapide que le même programme dans un
langage interprété.
exemple: C, C++, C#

Particularités: Interprété et
portabilité Si pas d’erreurs
Code machine
La portabilité !!

Particularités:
Tout est objet en python!!!

x=1
NB: x n’est pas une simple valeur mais un pointeur vers un objet (Pyobject)!!!
Un entier, en C, est essentiellement une étiquette pour une position en mémoire dont les octets codent une
valeur entière.
Un entier Python est un pointeur vers une position en mémoire contenant toutes les informations de l'objet
Python, y compris les octets qui contiennent la valeur entière.

Particularités:
Une large communauté

Pour pouvoir exécuter du python , il faut avoir un interpréteur et un IDE:

• Eclipse with PyDev Plugin
• Python Tools for Visual Studio (for Windows users)
• PyCharm
• Spyder
• Komodo IDE
Anaconda: est un outil en distribution libre et open source destiné à la programmation Python et R. Il contient
plusieurs packages.
Jupyter notebook: C'est un outil puissant pour développer et présenter de manière interactive des projets de
science des données.

Les interpréteurs:
CPython : le plus utilisé, l'interpréteur original écrit en langage C . Utilisé par anaconda.
Jython: fonctionne dans une machine virtuelle Java, permet l'interaction, au sein de la même machine
virtuelle Java, de code écrit en Java avec du code écrit en Python .du code écrit en Java avec du code
écrit en Python.
PyPy: écrit en python, offre une portabilité extrême.

Syntaxe:
Python utilise l'indentation pour indiquer un bloc de code.
Par exemple:
a=5
if a > 2:
print(“a est sup!")
a=5
erreur
if a > 2:
print(“a est sup!")

Notions basiques

Notions basiques
Les variables
Le type est attribué dynamiquement.
Les variables n’ont pas besoin d’une déclaration à l’avance, on assigne une valeur et le type est
automatiquement assigné et la vérification se fait à chaque lecture ou utilisation de celle ci:
z = -325552 print(type(z))
z = -35.59 print(type(z))
z = -5j print(type(z))

Notions basiques
Les variables
Pour la declaration des variables, il faut éviter les mots clés, liés à python:
and del from None True as elif global

nonlocal try assert else if not while break
except import or with class False in pass yield
continue finally is raise def for lambda return

Notions basiques
Les variables: types
Texte : str
Numérique: int, long, float, complex
Séquences: list, tuple
Mappage: dict
ensemble: set, frozenset

Boolean: bool

Notions basiques
Les variables: mutables Vs non mutables

Notions basiques
Les variables: mutables Vs non mutables
Immutable VS mutable:
Immuable --→ pas de mise à jour:
Exemple:.
b=5
b += 2 ---→nous ne mettons pas à jour 5 à 7, mais le pointeur est déplacé vers 7.
Par contre les variables mutables comme les listes sont mis à jour localement et on
ne créé pas de nouvelles listes.

Notions basiques
Les variables: numériques
Forcer la conversion en un type spécifique (casting): Créer un nombre aléatoire:

Random
float(x)
int(y) import random
complex(z) print(random.randrange(6, 15))
long() #randrange ([start,] stop [,step])
Faire des operations multiples: +, -, *, / , **

a= 10 x5= a//b Choice(seq), uniform(x,y)
b = 20 Seed(x), shuffle(list)
x=a+b
x2=a-b à essayer!!
x3=a*b
x4= a/b (avec virgule flottante)
x5=a**2+ b**2
Notions basiques
Les variables: boolean
>>> 3>4
Valeurs: False --→ false
True
Vous pouvez tester d’autres exemples

Opérations: >>> (3>1) and (0>1)
not, and, or
Comparaison: bool(b) -→ forcer une variable b à être

==, !=, >, >=, < et <= booléenne.
:

Notions basiques
Les variables: texte
a= ‘administration’ Longueur: len(a)

a= ‘’administration’’ Parcourir:
For x in a:
print(x)
Si plusieurs lignes:
a=‘ ‘ ‘L’administration………………………
………………………………………………… On peut verifier la presence d’un mot:
………………. if “administration" in a:
………………………………’ ‘ ‘ print("oui")
Ou ‘’ ‘’ ‘’ …………’’ ‘’ ‘’

Notions basiques
a= ‘administration’ b=‘amal , imen’ format() pour inserer un int dans un string

L’indexation d’une liste commence par 0:
H=60
print(a[2:5]) =>‘min’ txt = "My name is Amal, and I am {}"
print(txt.format(H))
print(a[:5]) => ‘admin’
print(a[-5:-2]) => ‘io’ txt = 'It\'s alright.’ # caractère spécial
print(txt)
a.strip()=> élimine les espaces du début et du fin
a.replace(“m", “b")=> ‘adbinistration’ \t: tabulation
\n: nouvelle ligne
b.split(",") => [‘amal’, ‘imen’]
c=a+b
print(c) =>?
Notions basiques
a= ‘administration’ b=‘amal , imen’ myDict = {"name": "John", "country":

L’indexation d’une liste commence par 0: "Norway"}
mySeparator = " "
x = mySeparator.join(myDict)
isnumeric(): vérifie s’il y a un nombre dans le
string
myTuple = ("John", "Vicky")

x = "#".join(myTuple)

Notions basiques
Exercices :
Inverser le texte suivant en éliminant les caractères spéciaux et en les remplaçant par des espaces:
animaux = "girafe:tigre:singe::souris“.
Calculer le nombre d’apparition du caractère i.

Notions basiques Changer la valeur d’un item:
L1[0]=2
Les variables: séquences -> List
Pour insérer un item:
L1.insert(1, 88)=>[12,88,5,0,11,13]
L1.remove(88)=>[12, 5, 0, 11, 13] #valeur
Un ensemble d’items possédant chacun une L1.pop(1)=>[12,0,11,13] #index
indexation.
la duplication des valeurs est permise, À partir d’une liste vide:
Type d’items pour une liste: int, str, boolean, list L1=[ ]
Une liste peut contenir plusieurs types L1.append(88)
L1=[12, 5, 0, 11, 13]
List() est le constructeur de création d’une liste: Associer deux listes:
L1= List((12,5,0,11,13)) L2=[0,0,0,0]
L1[0]=>12 L1.extend(L2) )=>[12,88,5,0,11,13,0,0,0,0]
L1[:2]=>[12,5]
L1[-1]=>13
del L1 => supprime la liste
L1.clear() => liste vide
Notions basiques
Pour parcourir une liste: [x+2 for x in thislist]

L1 =[12,5,0,3,13] La méthode la plus courte et efficace
for x in L1:
print(x)
for i in range(len(L1)): Exercice:

print(L1[i]) L1=[‘karim’,’salma’,’hamdi’, ‘Youssef’,’lili’]
Afficher les noms qui intègrent la letter ‘a’
i=0
while i < len(L1):
print(L1[i])
i=i+1

Notions basiques
sort() est utilisé pour ordonner les items Pour copier une liste:
(ascendant), s’il s’agit de string, c’est l’ordre L1.copy()
alphabétique qui est considéré. Ou
L1=[‘karim’,’salma’,’hamdi’, ‘Youssef’,’lili’] L2=List(L1)
print(L1.sort()) Pour joindre deux listes:

L3=L1+L2
Ou
Ordre descendant : for x in L2:
L1.sort(reverse=True) L1.append(x)
Ou
L1.extend(L2)
L1.reverse()=> renverser l’ordre des items
L1.index(‘karim’)=>0

Notions basiques
Les variables: séquences -> Tuple
Pour forcer la modification:
Tuple ->list -> tuple:
C’est un ensemble d’éléments qui ne peuvent pas x = ("apple", "banana", "cherry")
changer après la création, pas d’ajout d’éléments ni y = list(x)
de suppression. y[1] = "kiwi"
Duplication possible. x = tuple(y)
Len()
Un tuple peut inclure plusieurs types à la fois:
L1=tuple((‘karim’, 100, 20, ‘aicha’)) Possibilité d’ajouter tuple1 à tuple 2:
L1[0]=>’karim’ L1 = ("apple", "banana", "cherry")
L1[-1]=>’aicha’ L2= ("orange",)
L1 += L2
if “aicha" in L1:
print("Yes") Del L1=> supprime L1

Notions basiques
Les variables: séquences -> Tuple
Subdiviser le tuple: Pour dupliquer le contenu d’un tuple plusieurs fois:

pers = (“amine", “karime", “salma") n=2
(a, b, c) = pers pers = (“amine", “karime", “salma")
print(a) L1 = pers * n
print(b)
print(c)
Le matching n’est pas equitable:* count():Renvoie le nombre de fois qu'une valeur
pers = (“amine", “karime", “salma“, “imen”) apparaisse dans le tuple.
(a,b,*c)=pers index (): Recherche l’indexe une valeur spécifiée
c=>[“salma”, “imen”] liste

Notions basiques
Les variables: séquences -> Set
Pour supprimer un élément d'un ensemble, utilisez la
méthode remove () ou discard().
Un ensemble est une collection non ordonnée, non pers.remove(“taha")
modifiable* et non indexée.
Pas de duplication.
1 et True sont considérés une duplication et ne
peuvent pas figurer dans un set Pour éliminer le 1er item on utilise pop().
pers.pop() -> élimine amine
pers = {“amine", “karime", “salma“}
pers.add(“taha")
set3 = set1.union(set2) #union
Pour ajouter plusieurs élements: set3=set1.update(set2) #union
Pers1={“nada”,”jamel”} set4= set1.intersection(set2) #intersection
pers.update(pers1) set1.issubset(set2)=> true si tt elt ds set1 existent ds
set2

Notions basiques
my_dict = {
1: "Hello",
Les variables: mappage -> Dict
(1, 2): "Hello Hi",
3: [1, 2, 3] }
len(my_dict)=>3
Un dictionnaire est une collection ordonnée,
modifiable et qui n'autorise pas les doublons. Accéder à une Valeur à travers key:
Composé de :key et value. my_dict[1]=>”Hello”
my_dict[1]= “amal”
Les clés (key) de dictionnaire doivent être
inchangeables, telles que les tuples, les chaînes,
les entiers, etc. Nous ne pouvons pas utiliser Ajouter un élément au dictionnaire en attribuant une
d'objets mutables (changeables) tels que les valeur à une nouvelle clé:
listes comme clés. my_dict[2]=2
Ou
Les valeurs :values: sont mutables. dict2={5:”rim”}
my_dict.update(dict2)

Notions basiques Un dict peut contenir un dict:
Les variables: mappage -> Dict myfamily = {

"child1" : {
"name" : "Emil",
"year" : 2004
for x in my_dict.values(): },
Try itprint(x)
Yourself » "child2" : {
"name" : "Tobias",
"year" : 2007
for x in my_dict.keys(): },
print(x) "child3" : {
"name" : "Linus",
"year" : 2011
for x, y in my_dict.items(): }
print(x, y)
myfamily["child2"]["name"]=>”Tobias”

Notions basiques
Créer un dict:
myfamiy.keys()=>[child1, child2, child3]
Try it Yourself »
Myfamily.get[‘child1’]=> {
"name" : "Emil", nombre_de_pneus = {}
"year" : 2004 nombre_de_pneus["voiture"] = 4
} nombre_de_pneus["vélo"] = 2
myfamily.popitem()=> supprime le dernier

item
myfamily.pop(“child1”)=> supprime cet item

Notions basiques
myfamily = {
"child1" : {
"name" : "Emil",
myfamiy.keys()=>[child1, child2, child3] "year" : 2004
Try it Yourself »
Myfamily.get[‘child1’]=> { },
"name" : "Emil", "child2" : {
"year" : 2004 "name" : "Tobias",
} "year" : 2007
},
myfamily.popitem()=> supprime le dernier "child3" : {
item "name" : "Linus",
myfamily.pop(“child1”)=> supprime cet item "year" : 2011
}

Notions basiques
Les boucles: WHILE, FOR
Semblable à java for x in range(6):
i=1 if x == 3:
while i < 6: print(x)
Tryprint(i)
it Yourself » break
if (i == 3): else:
break print("Finally finished!")
i += 1
i=1 adj = ["red", "big", "tasty"]

while i < 6: fruits = ["apple", "banana", "cherry"]
print(i)
i += 1 for x in adj:
else: for y in fruits:
print("i is no longer less than 6") print(x, y)

Notions basiques
Exercices:
• Générer la liste de Fibonacci à partir d’un entier donné en input :90
0 1 1 2 3 5 8 13 21 34 55 89
Try it Yourself »
Utiliser jupyter notebook

Notions basiques
Les Fonctions Vs Méthodes
Une méthode est définit au sein d’une

Try it Yourself
classe: »
class nomClasse:
def nom_methode(parameters):
# Statements…
Nom_objet.nom_methode(arguments)

Notions basiques def test():
b=5
Les Fonctions
print(a, b)
a=2 Variables globales, visibles dans ma
def nom_fonction(liste de paramètres):
b=7 fonction mais le contraire n’est pas vrai
bloc d'instructions
test()
TryFaire appel à»la function:
it Yourself Fait appel à la fonction
nom_function(paramètres)
def compteur_complet(start, stop, step): li = [1,2,3]
i = start new = list(map(lambda x:x+1, li))
print(new)
while i < stop:
print(i) Une fonction dite
i = i + step anonyme
compteur_complet(1, 7, 2)

Notions basiques
Les Fonctions
Nous pouvons inclure une fonction dans une autre, appelée fonction imbriquée.
Nous pouvons passer une fonction comme argument à une autre fonction en Python.
Try itPar exemple:
Yourself »
def add(x, y):
return
return x ++ yy
def calculate(func, x, y):
y):
return
return func(x, y)y) greeting(name):
def greeting(name):
result = calculate(add, 4, 6) def hello():
print(result) # prints
prints 10
10 return "Hello,
return "Hello, " + name
name + "!"
"!"
return hello
return hello
Nous pouvons retourner une fonction greet
greet == greeting(“Amal")
greeting(“Amal")
print(greet()) # prints
prints "Hello, Amal!“
Amal!“

Notions basiquesdef make_pretty(func):
# define the inner function
def inner():
Les Fonctions: @decorateur # add some additional behavior to the decorated function
print("I got decorated")
Un décorateur Python est une fonction # call original function
qui prend une fonction et la renvoie en func()
ajoutant des fonctionnalités: # return the inner function
Try it Yourself » return inner
# define ordinary function
def ordinary():
print("I am ordinary")
# decorate the ordinary function
C’est le décorateur decorated_func = make_pretty(ordinary)
# output???

Notions basiques
Exemples: @decorateur def smart_divide(func):
def inner(a, b):
def make_pretty(func):
print("I am going to divide", a, "and", b)
def inner():
if b == 0:
print("I got decorated")
print("Whoops! cannot divide")
func()
Return
return inner
Try it Yourself » return func(a, b)
@make_pretty
return inner
def ordinary():
@smart_divide
print("I am ordinary")
def divide(a, b):
ordinary()
print(a/b)
divide(2,5)
=Smart_divide(divide(2,5))

Notions basiques
L'opérateur * utilisé lors de la définition d'une fonction
signifie que tous les arguments de position
Fonction: args, kargs supplémentaires passés à la fonction se retrouvent dans
la variable précédée d'un *
def multiply(*args): On peut considérer les kwargs comme un dictionnaire

z=1 qui mappe chaque mot-clé à la valeur que nous lui
for num in args: transmettons.
Try it Yourself »
z *= num
print(z)
multiply(4, 5)
def myFun(**kwargs):
multiply(10, 9)
for key, value in kwargs.items():
multiply(2, 3, 4)
print("%s == %s" % (key, value))
multiply(3, 5, 10, 6)
# Driver code
myFun(first='Geeks', mid='for', last='Geeks')

Notions basiques map(function, iterable)
Fonction: lambda def square(n):
filter, map, reduce return n ** 2
squares = list(map(square, range(1, 10, 2)))
Fonction très utilisée:
Exemple: def find_odd(x):
x = lambda a : a + 10 if x % 2 != 0:
Try it Yourself » return x
print(x(5))
nums = [1, 34, 23, 56, 89, 44, 92]
Elle peut prendre plusieurs arguments mais une seule odds = list(filter(find_odd, nums))
expression: filter(function, iterable)
x = lambda a, b, c : a + b + c
print(x(5, 6, 2)) from functools import reduce
nums = [1, 2, 3, 4, 5]
summ = reduce(lambda x, y: x + y, nums)

Notions basiques
Programmation orientée objets

Try it Yourself »

Notions basiques
La programmation orientée objet (POO) est un paradigme de programmation dans lequel

nous pouvons considérer des problèmes complexes comme des objets. Une classe est
comme un modèle. Elle permet de créer des objets personnalisés en fonction des attributs
Try it Yourself » et des méthodes que vous définissez. Il s'agit d'un plan pour créer des instances concrètes
dans la mémoire.
Une instance est une implémentation concrète d'une classe : tous les attributs d'une
instance ont une valeur fixe. Concrètement, une instance est un objet individuel d’une
classe, qui possède une adresse mémoire unique. Chaque instance possède ses propres
attributs, indépendamment des autres instances. Notons que toutes les instances partagent
les mêmes variables de classe.

Notions basiques
POO: une classe? Un objet?
La programmation orientée objets se base sur la définition des objets:
Chaque objet possède: des propriétés, un comportement.
Un objet c’est une instance d’une classe qui possède des attributs et des méthodes.
Try Une
it Yourself » comme un template pour la creation des objets
classe est
class C:
Classe X x=12
Les attributs c=2
Les méthodes
def affich1():
print(’amal’)
objet1 objet2 objet3

Notions basiques
POO: instantiation Attribut class: partagés par
toutes les instances
class C: C1=C() #instance objet C1
x=12 C1.affich1()
y=2 C1.e=list[0,1,2,3]
print(C1.x) # attributs instance C1
Try it Yourself » def affich1(self):
print(self.x+self.y) Attribut instance: lié à

l’instance
il est possible d’ajouter de nouveaux attributs d’instance

(ici le C1.z = 44) ou même de nouveaux attributs de
classe (ici C.z = 6).

Notions basiques
POO telephone_portable
Instanciation d’objets id
Via init() Couleur,
Prix,
Try it Yourself »
Id_marque
Prix, id_marque et Permet d’initialiser un objet avec
couleur sont des __init__() des valeurs
variables instances faireDesAppels()
Jouer() Tel1=telephone_portable(val1,
val2, val3)
def __init__(self, val1, val2, val3): À ce niveau la fonction init est
self.couleur = val1 appelée directement.
self.prix=val2
self.Id_marque=val3

class C :
Notions basiques ”””Documentation de la classe C.”””
x = 23 # attibut de classe
POO: variable classe : a = C()
print(a.x)
• Une variable classe est définit au niveau a.x = 12 # modifie son attribut d’instance
de la classe et non au niveau du (attention...)
constructeur
Try it Yourself » a.x # 12
C.x # 23 mais l’attribut de classe est
• Chaque instance peut modifier ses inchangé
variables localement. C.z = 6 # z : nouvel attribut de classe
a.y = 44 # y : nouvel attribut de l’instance a
• Une instance peut ajouter des variables qui b = C() # b est un autre objet de la classe C
sont propres à elle uniquement. (une autre instance)
b.x # 23 : b connaît bien son attribut de
classe, mais...
b.y # ... b n’a pas d’attribut y !

Notions basiques
POO: Fonctions spécifiques:
Fonctions spécifiques:
Try it Yourself »
La fonction dir() énumère la liste des méthodes relatives à l’objet p-->dir(p)
À chaque création d’une classe C, Python lui associe un dictionnaire (de
nom C.__dict__ ) contenant un ensemble d’informations.
__dict__ renvoie les valeurs de l’attribue de l’instance.
__dict__ contient les données stockées dans la mémoire du programme pour
cet objet spécifique.
dir(int): renvoie toutes les méthodes magiques de python (dunder)

Notions basiques
POO
Exercice:
Créer une fonction qui prend un argument n et crée n objets de la classe
Employé
Corriger l’erreur au niveau du code
Try it Yourself »
class Employee:
def __init__(self, emp_id):
self.emp_id = emp_id
def create_employees(n):
employee_list = []
for i in range(n):
employee_list.append(Employee(i))

Notions basiques
POO: types de
méthodes:
Try it Yourself »
Les exemples détaillés au niveau du

notebook
Notions basiques
POO: types de Méthode d'instance:

Elle a besoin d'accéder à l'instance de la classe. On ajoute self dans la définition de la méthode. Elle
méthodes: est la plus utilisée
Classe de méthode
Une méthode de classe (classmethod) est une méthode liée à la classe et non à l'objet de la classe.
Try it Yourself » Elle a accès à l'état de la classe car elle prend un paramètre de classe qui pointe vers la classe et non
vers l'instance de l'objet.
Elle peut modifier l'état d'une classe qui s'applique à toutes les instances de la classe. Par exemple,
elle peut modifier une variable de classe qui s'appliquera à toutes les instances (voir exemple).
Une méthode de classe prend cls comme premier paramètre, qui est uen référence vers la classe.
Nous utilisons le décorateur "@classmethod" en python pour créer une méthode de classe.
Méthode statique
Une méthode statique en Python est un type spécial de méthode qui est définie à l'intérieur d'une
classe mais qui n'a accès à aucune instance ou donnée de la classe. Nous utilisons le décorateur
"@staticmethod" pour créer une méthode statique en python.

Notions basiques
POO: encapsulation
L'encapsulation en python
Le principe d'encapsulation est un des concepts clés de la programmation objet. Cette technique
permet de
Try it Yourself » regrouper des données au sein d'une classe et de pouvoir les lire et les manipuler par le
biais de méthodes qui forment une interface pour les éléments environnant l'objet. De ce fait, les
variables et les méthodes contenues au sein d'une classe peuvent être placées dans trois niveaux de
visibilité en fonction de la portée que vous souhaitez :
•Public(par défaut):La variable ou fonction est accessible à tous.

•Protégé(_):Les attributs sont accessibles uniquement à la classe et les classes filles.
•Privé(__):Les attributs ne sont visibles que par la classe elle-même.
Python change le nom de la
variable:
En python on a réellement privée ou non privée _nomclasse__nonvariable

Notions basiques
POO: getters et setters

Pour les variables privées, il faut ajouter les getters et les setter pour pouvoir les manipuler en
lecture ou en écriture
Try it Yourself »
•Getter : Une méthode qui vous permet d'accéder à un attribut dans une classe donnée.
•Setter : Une méthode qui vous permet de définir ou de modifier la valeur d'un attribut dans une classe.

class Point:
Notions basiques def __init__(self, x, y):
self.__x = x
# les getters et setters des attributs
POO: getters et setters via property def get_x(self):
return self._x
def set_x(self, value):

Try it Yourself » self._x = value
L'utilisation de la fonction pré-définit
property() permet d'éviter de se référer à point_x = property(
chaque fois à get() et set() pour afficher fget=get_x,
ou mettre à jour l'attribut. fset=set_x,
C’est comme une interface qui manipule doc="x property."
implicitement l’appel à chaque getter ou )
setter selon le besoin.
Print(obj.point_x) -→ appel au getter

Obj.point_x=10 → appel au setter

Notions basiques
POO
Classe et instanciation d’objets: property property(fget=None, fset=None, fdel=None, doc=None)
la fonction property() offre une interface pour manipuler
les instances des attributs.
class Voiture():
def __init__(self):
Try it Yourself » Généralement on utilise les @property -> decorateur au
self._roues=4 lieu de cette
def _get_roues(self):
"Récupération du nombre de roues"
return self._roues
def _set_roues(self, v):
"Changement du nombre de roues"
self._roues = v ma_voiture=Voiture()
roues=property(_get_roues, _set_roues) ma_voiture.roues=5 # mise à jour
Print(ma_voiture.roues)
class Circle:
Notions basiques def __init__(self, radius):
self._radius = radius
@property
POO: property avec les décorateurs def radius(self):
"""The radius property."""
print("Get radius")
Le même process que précédemment mais return self._radius
Try moyennant
it Yourself »les décorateur property
@radius.setter
def radius(self, value):
print("Set radius")
self._radius = value
Obj.radius=10 → appel au setter
Print(Obj.radius) → appel au getter @radius.deleter
def radius(self):
print("Delete radius")
del self._radius

Notions basiques class Person:
def __init__(self, name):
POO self._name = name
Classe et instanciation d’objets:@property @property
def name(self):
Les décorateurs nous permettent d'envelopper une print('Getting name...’)
autre fonction afin d'étendre le comportement de la return self._name
Try itfonction
Yourselfenveloppée
» sans l'affecter de manière @name.setter
permanente. def name(self, value):
print('Setting name to:', value)
Au lieu d'utiliser Python property(), vous pouvez self._name = value
également assigner le getter, le setter et le deleter en @name.deleter
utilisant le décorateur Python @property def name(self):
print('Deleting name...’)
del self._name
p = Person('David’)
print(p.name)
p.name = 'Rocky’
del p.name
Notions basiques
Héritage te polymorphisme
•L’héritage est le mécanisme qui permet de se servir d’une classe préexistante pour en créer une
nouvelle qui possédera des fonctionnalités supplémentaires ou différentes. Une classe fille hérite
alors de tous les attributs (données et méthodes) de sa super classe.
Try it Yourself »
•Les méthodes de la classe fille et de la classe mère peuvent posséder le même nom mais effectuer
des traitements différents (surcharge) et l’objet s’adaptera dynamiquement, dès l’instanciation. En
proposant d’utiliser un même nom de méthode pour plusieurs types d’objets différents, le
polymorphisme permet une programmation beaucoup plus générique. Le développeur n’a pas à
savoir, lorsqu’il programme une méthode, le type précis de l’objet sur lequel la méthode va
s’appliquer. Il lui suffit de savoir que cet objet implémentera la méthode.
•L'accès à la méthode de la classe mère se fait en utilisant super(): super().méthode()

Notions basiques
L’héritage
La classe client hérite de la classe

utilisateur.
Try Pour la déclaration
it Yourself » de l’héritage:
Classe fille(nom de la classe mère)
Si la classe fille possède plusieurs

attributs à initialiser :
class MaClasseFille(MaClasseMere):
def __init__(self):
super().__init__() NB:L’accès au code de la classe mère se fait à travers
… super().
Notions basiques
L’héritage
La surcharge est possible: • isinstance(object, classinfo): demande si un objet

• Attributs est une instance d'une classe (ou d'un ensemble de
• Fonctions classes).
Try it Yourself » • issubclass(class, classinfo): demande si une classe
Pour un attribut, il suffit de remplacer sa valeur dans la est une sous-classe d'une autre classe (ou d'autres
classe fille: classes).
class Client(Utilisateur):
def __init__(self):
super().__init__(self)
self.user_name = ‘Karim'
Pour une fonction, il suffit de la réécrire.
Notions basiques
L’héritage multiple
Une classe
Try it Yourself » peut hériter de plusieurs. S'il y a des méthodes qui portent le même nom, la première
sera privilégié et l'autre sera ignorée. Sinon, si on souhaite les considérer toutes les deux, il faut
travailler comme l'exemple suivant:
class Client(Utilisateur, Enseignant):

def __init__(self, attribut1, attribut2):
super().__init__(attribut1)
super(Utilisateur, self).__init__(attribut2)
Notions basiques
L’héritage multi-niveaux
class Animals: #ordre 1 class donotSwim(Mammal): #ordre 3

def __init__(self, animalsName): def __init__(self, name):
print(animalsName, 'is an animal.'); print(name, "cannot swim.")
Try it Yourself » super().__init__(name)
class Mammal(Animals): # ordre 2

def __init__(self, Name): class Cat(donotSwim, donotFly):
print(Name, 'is a mammal.') def __init__(self):
super().__init__(Name) print('A cat.');
super().__init__('Cat')
class donotFly(Mammal): #ordre 3 #super().__init__('Cat')
def __init__(self, name):
print(name, "cannot fly.") cat = Cat()
super().__init__(name) #bat = donotSwim('Bat')
Notions basiques
Relations entre classes:
Agrégation
Pour ne pas confondre, l'agrégation est une forme de composition où les objets sont faiblement couplés.
Il n'y a pas d'objets ou de classes qui possèdent un autre objet. Il crée simplement une référence. Cela
Try it Yourself
signifie »
que si vous détruisez le conteneur, le contenu existe toujours.
Composition
Dans la composition, une classe agit comme un conteneur de l'autre classe (contenu). Si vous détruisez
le conteneur, le contenu n'existe plus. Cela signifie que si la classe du conteneur crée un objet ou détient
un objet du contenu. Il s'agit d'un type de relation forte. Elle peut être définie comme le fait qu'une classe
puisse référencer un ou plusieurs objets d'une autre classe à l'intérieur de sa variable d'instance. Dans la
composition, les objets ne peuvent pas exister indépendamment les uns des autres.
Notions basiques
Relations entre classes:
Composition Aggrégation
class Point : class Point :

def __init__(self, x, y) : def __init__(self, x, y) :
Try it Yourself
self.px,»self.py = x, y self.px, self.py = x, y
class Segment : class Segment :
def __init__(self, x1, y1, x2, y2) : def __init__(self, P1, P2) :
self.orig = Point(x1, y1) #composition self.orig = P1
self.extrem = Point(x2, y2)#composition self.extrem = P2
def __str__(self) : def __str__(self) :
return (str(self.orig.px)+' '+ str(self.orig.py)) return (str(self.orig.px)+' '+ str(self.orig.py))
s = Segment(1.0, 2.0, 3.0, 4.0) s = Segment(1.0, 2.0, 3.0, 4.0)
print(s) # Segment : [(1, 2), (3, print(s) # Segment : [(1, 2), (3,
Notions basiques
Interface en POO:
Une interface est un contrat : la personne qui écrit l'interface dit "hé, j'accepte que les choses se présentent
de cette manière", et la personne qui utilise l'interface dit "OK, la classe que j'écris se présente de cette
Try itmanière".
Yourself Une
» interface est une coquille vide. Il n'y a que les signatures des méthodes, ce qui implique que
les méthodes n'ont pas de corps. L'interface ne peut rien faire. Ce n'est qu'un modèle.
Une interface est une forme particulière de classe abstraites où toutes les méthodes sont abstraites.
Lorsqu’une classe implémente une interface, elle s’engage à fournir une implémentation (c’est-à-dire un
corps) pour chacune des méthodes abstraites de cette interface. Si une classe implémente plus d’une
interface, elle doit implémenter toutes les méthodes abstraites de chacune des interfaces. Voici un exemple:
Notions basiques
Classe abstraite en POO:
* Une classe abstraite peut être considérée comme un modèle pour d'autres classes.
* Elle permet de créer un ensemble de méthodes qui doivent être créées dans toutes les
Try it Yourself » enfants construites à partir de la classe abstraite.
classes
* Une classe qui contient une ou plusieurs méthodes abstraites est appelée classe abstraite.
* Une méthode abstraite est une méthode qui a une déclaration mais qui n'a pas
d'implémentation.
Les classes abstraites ressemblent beaucoup aux interfaces, mais elles ont quelque chose de
plus : Vous pouvez leur définir un comportement. Il s'agit plutôt d'une personne qui dit "ces
classes devraient ressembler à ça, et elles ont ça en commun, alors remplissez les blancs !".
Notions basiques
# les classes qui implémentent l'interface :
class Personne(Comparable):
Classe abstraite en POO: def __init__(self,nom,age):
self.__nom=nom
self.__age=age
from abc import ABC, abstractmethod def CompareTo(self,p):# l’implémentation
class Comparable(ABC): if self.__age==p.__age:
Try it @abstractmethod
Yourself » return True
def CompareTo(): else:
pass return False #objets
class Outils(Comparable): p1=Personne("n1",20)
def __init__(self, long, prix): p2=Personne("n2",20)
self.__longueur=long if (p1.CompareTo(p2)):
self.__prix=prix print("ont le meme age")
def CompareTo(self,o):# l’implémentation else:
if self.__longueur==o.__longueur: print("ages différents")
return True if (o1.CompareTo(o2)):
Python en terme de syntaxe ne différencie pas else: print("meme longueur")
entre une classe abstraite et une interface. return False else:
print("longueurs différents")
Notions basiques
POO: exercice
Try it Yourself »
Notions basiques
Méta-classes
Méta-classe classes objets

créer créer
Try it Yourself »
Une classe est également un objet et, comme tout autre objet, c'est une instance d’une métaclasse. Une
classe « type » représente la métaclasse par défaut des objets de type classe.
Nous pouvons créer des classes en utilisant directement la fonction type(). Elle peut être appelée de la
manière suivante Lorsqu'elle est appelée avec un seul argument, elle renvoie le type.
Lorsqu'elle est appelée avec trois paramètres, elle crée une classe. Les arguments suivants lui sont
transmis
• Nom de la classe
• Tuple contenant les classes de base héritées par la classe
• Dictionnaire de classe : Il sert d'espace de noms local pour la classe et contient les méthodes et les
variables de la classe.
Notions basiques
Méta-classes
def test_method(self): # Creating instance of Test class
print("This is Test class method!") test_obj = Test()
print("Type of test_obj: ", type(test_obj))
# creating a base class
# calling inherited method
Tryclass Base: »
it Yourself
def myfun(self): test_obj.myfun()
print("This is inherited method!")
# calling Test class method
# Creating Test class dynamically using test_obj.my_method()
# type() method directly
Test = type('Test', (Base, ), dict(x="atul", my_method=test_method)) # printing variable
print(test_obj.x)
# Print type of Test
print("Type of Test class: ", type(Test))
Notions basiques
Méta-classes
def test_method(self): # Creating instance of Test class
print("This is Test class method!") test_obj = Test()
print("Type of test_obj: ", type(test_obj))
# creating a base class
# calling inherited method
Tryclass Base: »
it Yourself
def myfun(self): test_obj.myfun()
print("This is inherited method!")
# calling Test class method
# Creating Test class dynamically using test_obj.my_method()
# type() method directly
Test = type('Test', (Base, ), dict(x="atul", my_method=test_method)) # printing variable
print(test_obj.x)
# Print type of Test
print("Type of Test class: ", type(Test))
Notions basiques
Try it Yourself »
Les expressions régulières

Notions basiques
Les expressions
régulières
Les expressions régulières représentent un langage puissant pour faire correspondre des motifs
de texte; c’est une méthode standardisée pour rechercher, remplacer et analyser des textes
Try it Yourself » des motifs complexes de caractères.
contenant
La plupart des langages modernes disposent de bibliothèques pour les expressions régulières.
Par exemple, Python dispose du module re intégré.
D'autres langages de programmation populaires disposent de fonctionnalités Regex, notamment
: Perl, JavaScript, Ruby, Tcl, C++, Java, C#, etc.
Notions basiques
Les expressions
régulières
Try it Yourself »
• Rechercher une chaîne de caractères (search et match, findall)
• Remplacer des parties d'une chaîne (sub)
• Décomposer une chaîne en petits morceaux (split)
Notions basiques
Les expressions
régulières
Opérateur Intérpretation
Try it Yourself » | Alternative
() Grouping
? * + {m, n} Quantification
^$ Délimitateur
.[][-][^] Meta- caractères
\d \D \w \W….. Classe de caractères
Notions basiques
Les expressions
régulières
But: extraire toutes les adresses e-mails.

Comment
Try it Yourself » reconnaître les adresses électroniques ?
………@........
une séquence de caractères, suivie du symbole @, suivie d'un nom d'hôte.
Une expression régulière est un moyen formel de décrire un modèle de chaîne de caractères
est une chaîne composée de caractères et d'opérateurs d'expression régulière.
Notions basiques
Les expressions . Correspond à n'importe quel caractère à l'exception du caractère de retour à la ligne
régulières (\n)
* Correspond à répéter l’expression 0 à n fois avec n>0
+ Correspond à 1 ou plusieurs répétitions de l'expression régulière qui la précède

immédiatement
? Correspond à 0 ou 1 répétitions de l'expression régulière qui la précède
Try it Yourself » immédiatement
[] Correspond à n'importe quel caractère de l'ensemble des caractères énumérés entre
les crochets ; une plage de caractères peut être spécifiée en utilisant le premier et le
dernier caractère de la plage et en mettant - entre les deux.
^ [^S] correspond à tout caractère ne figurant pas dans S
| A|B correspond à toute chaîne de caractères qui correspond à A ou à B
{} Nombre d'occurrences d'un RE précédent à faire correspondre
() Envelopper un groupe d'ER
$ Correspond à la fin
\ Utilisé pour supprimer la signification spéciale du caractère qui le suit
Notions basiques Opérateur
[Pp]ython
Interprétation
Correspond à "Python" ou "python"
Les expressions [aeiou] Correspond à toutes les voyelles miniscules
régulières [0-9] Correspond à tout caractère numérique
[a-z] Correspond à toute lettre miniscule
Exemples: [A-Z] Correspond à toute lettre mjiscule
[a-zA-Z0-9] Correspond à toute letter miniscule, majuscule ou numérique
[âeiou] Correspond à tout caractère qui n’est pas voyelle et miniscule
Try it Yourself »
[^0-9] Correspond à tout caractère qui n’est pas némérique
Opérateur Interprétation
\d{3} Correspond exactement à 3 Opérateur Interprétation
caractères numériques . Match any character except newline
\d{3,} Correspond à 3 caractères \d Correspond à tout caractère numérique
numériques ou plus
\D Correspond à tout caractère non numérique [^0-9]
\d{3,5} Correspond à 3 , 4 ou 5
caractères numériques \s Correspond à des espaces: [ \t\r\n\f]
\S Correspond à des caractères qui ne présentent pas d’ espaces [^
\t\r\n\f]
\w Correspondre à un seul caractère d'un mot: [A-Za-z0-9_]
\W Le contraire de \w: [Â-Za-z0-9_]
Notions basiques
Les expressions
régulières
Regular expression Matching strings
be[ls]t belt, best
[ ]
Try it Yourself »be[l-o]t belt, bemt, bent, beot
be[a-cx-z]t beat, bebt, bect, bext, beyt, bezt

be[^0-9]t belt, best, be#t, ... (but not be4t)
[^]
be[^xyz]t belt, be5t, ... (but not bext, beyt, and bezt)
be[â-zA-Z]t be!t, be5t, be t, ... (but not beat)
Notions basiques
Les expressions
régulières
. Regular expression Matching strings

Try it Yourself »be.t best, belt, beet, bezt, be3t, be!t, be t, ...

be*t bt, bet, beet, beeet, beeeet, ...
+,*,?
be+t bet, beet, beeet, beeeet, ...
bee?t bet, beet
Notions basiques
Les expressions
régulières
|
hello|Hello hello, Hello.
Try it Yourself »
a+|b+ a, b, aa, bb, aaa, bbb, aaaa, bbbb, ...
ab+|ba+ ab,abb,abbb,...,andba,baa,baaa,...
Notions basiques
Les expressions
régulières
les fonctions:
Les expressions
Try it Yourself » régulières possèdent des méthodes pour diverses opérations telles que la
recherche de correspondances de motifs ou la substitution de chaînes de caractères:
Compile(): Le RE est compilé dans un objet modèle selon le pattern

findall(): Recherche toutes les sous-chaînes auxquelles le RE correspond et les renvoie sous forme de liste.
finditer(): Recherche toutes les sous-chaînes auxquelles le RE correspond et les renvoie en tant qu'itérateur.
split(): Fractionner la chaîne par les occurrences d'un caractère ou d'un modèle
Notions basiques
Les expressions
régulières
les fonctions: findall()
re.findall(pattern, string, flags = 0)
• Cette fonction tente de faire correspondre un modèle RE à une chaîne de sujet avec des indicateurs
Try it Yourself »
facultatifs.
• Renvoie toutes les correspondances sans chevauchement du pattern dans la chaîne, sous forme de
liste de chaînes.
• La chaîne est analysée de gauche à droite et les correspondances sont renvoyées dans l'ordre trouvé.
• Si un ou plusieurs groupes sont présents dans le modèle, renvoie une liste de groupes ; ce sera une
liste de tuples si le modèle a plus d'un groupe.
• Les correspondances vides sont incluses dans le résultat.
Rq: Les flags sont utilisés pour changer le comportement des expressions régulières, et ils sont optionnels.
(re.MULTILINE, re.IGNORECASE)
Notions basiques
Les expressions
régulières
les fonctions: findall()
re.findall(pattern, string, flags = 0)
findall('be.t', 'beetbtbelt?bet, best’)
Try it Yourself »
->['beet', 'belt', 'best']
findall('be?t', 'beetbtbelt?bet, best’)
->['bt', 'bet']
findall('be*t', 'beetbtbelt?bet, best’)
->['beet', 'bt', 'bet']
findall('be+t', 'beetbtbelt?bet, best’)
->['beet', 'bet']
Notions basiques
Les expressions
régulières
les fonctions: finditer()
re.finditer(pattern, string, flags = 0)
Try it Yourself
Renvoie»un itérateur produisant des objets de correspondance sur toutes les correspondances qui ne se
chevauchent pas pour le modèle RE dans la chaîne.
import re
s = 'Readability counts.’
pattern = r'[aeoui]’
matches = re.finditer(pattern, s)
for match in matches:
print(match)
Notions basiques
Les expressions
régulières
les fonctions: split()
re.split(pattern, string, maxsplit=0, flags=0)
Try it Yourself » chaîne en une liste délimitée par le modèle transmis.

Divise une
Cette méthode est inestimable pour convertir des données textuelles en structures de données pouvant
être facilement lues et modifiées par Python.
p = re.compile(r'\W+’)
p.split(‘This is my first split example string')
[‘This', 'is', 'my', 'first', 'split', 'example’]
p.split(‘This is my first split example string', 3)
[‘This', 'is', 'my', 'first split example']
Notions basiques
Les expressions
régulières
les fonctions: split()
re.split(pattern, string, maxsplit=0, flags=0)
Try it Yourself » chaîne en une liste délimitée par le modèle transmis.

Divise une
Cette méthode est inestimable pour convertir des données textuelles en structures de données pouvant
être facilement lues et modifiées par Python.
p = re.compile(r'\W+’)
p.split(‘This is my first split example string')
[‘This', 'is', 'my', 'first', 'split', 'example’]
p.split(‘This is my first split example string', 3)
[‘This', 'is', 'my', 'first split example']
Notions basiques
Les expressions
régulières
import re
p = re.compile('[a-z]+’)
group(): Renvoie la chaîne correspondant au m = p.match('tempo’)
Try it Yourself » Renvoie la position de départ du match
start():
end(): Renvoie la position finale du match m.group()
span(): Renvoie un tuple contenant les positions (début, fin) de
m.span()
la correspondance
m.start(), m.end()

Python - Cours1 1 92

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Python - Cours1 1 92

Transféré par

Droits d'auteur :

Formats disponibles

Cours Python

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Deux versions principalement:

Presented By PhD Amal TRIFA

1. Libre et open source

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

L'interpréteur va exécuter les lignes du code une

(+) Dans un langage interprété, le même code

Exemple: PhP, Javascript, python, Java

Presented By PhD Amal TRIFA

(+)Dans un langage compilé, le

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Tout est objet en python!!!

Presented By PhD Amal TRIFA

Une large communauté

Presented By PhD Amal TRIFA

Pour pouvoir exécuter du python , il faut avoir un interpréteur et un IDE:

Presented By PhD Amal TRIFA

PyPy: écrit en python, offre une portabilité extrême.

Presented By PhD Amal TRIFA

Python utilise l'indentation pour indiquer un bloc de code.

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Le type est attribué dynamiquement.

Presented By PhD Amal TRIFA

and del from None True as elif global

Presented By PhD Amal TRIFA

Séquences: list, tuple

ensemble: set, frozenset

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Forcer la conversion en un type spécifique (casting): Créer un nombre aléatoire:

Faire des operations multiples: +, -, *, / , **

Vous pouvez tester d’autres exemples

Comparaison: bool(b) -→ forcer une variable b à être

Presented By PhD Amal TRIFA

a= ‘administration’ Longueur: len(a)

Presented By PhD Amal TRIFA

a= ‘administration’ b=‘amal , imen’ format() pour inserer un int dans un string

a= ‘administration’ b=‘amal , imen’ myDict = {"name": "John", "country":

myTuple = ("John", "Vicky")

Presented By PhD Amal TRIFA

Calculer le nombre d’apparition du caractère i.

Presented By PhD Amal TRIFA

Pour parcourir une liste: [x+2 for x in thislist]

for i in range(len(L1)): Exercice:

Presented By PhD Amal TRIFA

print(L1.sort()) Pour joindre deux listes:

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Subdiviser le tuple: Pour dupliquer le contenu d’un tuple plusieurs fois:

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA

Les variables: mappage -> Dict myfamily = {

Presented By PhD Amal TRIFA

myfamily.popitem()=> supprime le dernier

Presented By PhD Amal TRIFA

Presented By PhD Amal TRIFA