Introduction à Python

N. TSOPZE
Intro. (historique)

 inspiré d’ABC et Créé à la fin des années 80 par

Guido, fan de de la série Monty Python's Flying Circus
 1991, première version publique, le 0.9.0, postée sur
le forum Usenet alt.sources
 1995, sortie du navigateur Tk pour exécuter les
applets Python avec modules de la bibliothèque
standard rexec, htmllib,…
 1999, création de l'environnement de
développement IDLE
 2000, publication de Python 2,0 par l’équipe
PythonLabs de BeOpen.
 2001, création de Python Software Foundation
Intro. (historique)

 Arrêt de l’évolutivité de Python 2 en janvier

2020 par la PSF
 Cohabitation de Python 2 et Python 3
 Plusieurs ajouts dans Python 3 non
supportés par python 2:
 Division: / (réelle); // (entière)
 Fonction d’affichage : print(arg) vs print arg
 …
Intro.

 Totalement gratuit et téléchargeables;

 langage de programmation objet interprété,
multiparadigme (objet, fonctionnel,
procédural)
 disponibilité sur la grande majorité des
plates-formes courantes (BeOS, Mac OS X,
Unix, Windows).
 intégrations faciles avec les langages C et
C++
Premier pas
 langages de script:
 mode interactif
 mode script / programme
 Exécution de chaque commande saisie à
l’invite de commande (>>>);
 Affichage immédiat du résultat
 Création des variables à la première
utilisation
 Manipulation des boucles
 Regroupement des commandes dans un
fichier et appel du fichier
Premier pas

Mode interactif
 Instructions sont directement interprétées et les résultats
affichés
 réaliser des prototypes,

 tester tout ou partie d’un programme ou plus simplement

 interagir aisément et rapidement avec des structures de

données complexes
 Exemple
>>> print (’hello world!’)
hello world!
Premier pas

Mode script / programme,

 saisir l’intégralité des instructions qu’il
souhaite voir évaluer à l’aide de son éditeur
de texte favori,
 demander leur exécution à l’interprète.

 extension .py.
Structures de base
 Commentaires
 Commence par #
 Variables
 Objets dont les classes sont définies par l’usager, ou
par l’environnement Python (types de base).
 manipulation les données au travers de références
(qui donnent accès aux fonctionnalités des instances).
 typage dynamique
 >>> x = 1 # x reference un entier
 >>> x = ’toto’ # x reference desormais une chaine
 >>> x = Foo() # x reference desormais une instance de Foo
Instructions de base
 Affectation: =
 X=2
 a,b=b,a #Permuter a et b
 Affichage: print
 print(a)
 print(‘’ la valeur de a est :’’ a)
 Saisie: input # la valeur saisie est prise comme
une chaine de caractères
 a=input()
 a = input (" Entrer la valeur de a: ")
 a=int(a) ##conversion
Opérations
 Opérations arithmétiques
 Addition :
 Addition : +
 Soustraction : -
 Multiplication :
 Multiplication : *
 Division : / (réelle); // (entière)
 Modulo : %
 Forme contractée: +=, -=, *=, /=
 Affichage : print # Tenir compte des descripteurs
 Exemple
 >>> x = 2
 >>> x = x + 1
 >>> x += 2
Chaines de caractères
 Constante chaine de caractères sont placées entre les
guillemets (simple ou double)
 Opérations:
 Concaténation : +
 Affichage : print
 Accès aux éléments: ch[ i ], # i<0 pour commencer à la fin
 Sous chaines : ch[deb:fin]
 Exemples
 >>>x = ’hello ’
 >>> y = "world! ’’
 >>> z=x+y
 >>>x[2:4]
Variables
 donnée du programme, stockée dans
l’ordinateur.
 code alpha-numérique lié à une donnée de votre
programme, permettant de l'utiliser à plusieurs
reprises et faire des calculs un peu plus
intéressants avec.
 Permet de stocker le résultat
 mémoire : « grosse armoire » avec plein de
tiroirs.
 Chaque tiroir peut contenir une donnée ; certaines de ces
données seront des variables de votre programme.
Listes
 ensemble ordonné et dynamique d’éléments pouvant
être de différents types
 Création de listes vides avec les deux manières
possibles: [ ] ou list()
 >>> l1 = []
 >>> l2 = list()
 Exemple.
>>> x = True
>>> foo = [’bar’, 12345, x]
>>> foo
[’bar’, 12345, True]
Listes
 Accès aux éléments :
 Préciser l’index entre crochets
 méthodes
 append (val): ajout de val en fin de liste,
 Insert(ind,val) : pour ajouter val à un index donné ind.
 extend (l1): ajoute le contenu de la liste l1 passé en
paramètre à la fin de la liste.
 index (val): index de la première occurrence d’un
élément dans une liste // exception ValueError en
absence.
 in : True si l’élément est présent dans la liste et False
sinon.
Listes
 remove permet de supprimer la première occurrence
d’un élément d’une liste en le désignant
 del (delete) détruire une référence à un objet Python,
ou à une partie d’une liste.
>>> del foo[1:3]
 + : concaténation
 Multiplication par un entier n : crée n copies de la liste
Listes
>>> foo.append(’new’)
>>> foo
[’bar’, 12345, 1, ’new’]
>>> foo.insert(2, ’new’)
>>> foo
[’bar’, 12345, ’new’, 1, ’new’]
>>> foo.extend([67, 89])
>>>foo.index(’new’)
>>>foo.index(34)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ValueError: list.index(x): x not in list
>>> 34 in foo
False
Tableau (array)
 Package array
 Création
 Import array
 var=array.array(type, liste d’éléments)
a = arr.array('d', [1.1, 3.5, 4.5])
 Accès aux éléments:
 var[i]; ## avec i commençant à 0
 var[n1:n2] #éléments de n1 à n2
 var[:-n] #éléments de 0 à n
 var[n:] #éléments de n à la fin
 var[:] # du début à la fin
 Ajout d’éléments
 var.append(x) #ajout de x à la fin
 var.extend([liste de valeurs] # ajout de la liste de valeurs à la fin
 var.insert(i,x) ## insèrer x à la position i
Tableau (array)

 Concaténer : +
 var1+var2
 Suppression d’éléments: remove
 var.remove(x) # supprimer x
 del var[i] # supprime l’élément N° i
 Taille d’un élément : var. itemsize
 nombre d'occurrences de x dans le tableau: var.count(x)
 index de la première occurrence de x : var.index(x)
 inverse l'ordre des éléments: var.reverse()
Tableau (array)
Code d'indication du Taille minimum en
Type C Type Python
type octets

'b' signed char int 1

'B' unsigned char int 1

'u' Py_UNICODE Caractère Unicode 2

'h' signed short int 2

'H' unsigned short int 2

'i' signed int int 2

'I' unsigned int int 2
'l' signed long int 4
'L' unsigned long int 4

'q' signed long long int 8

'Q' unsigned long long int 8

'f' float float 4

'd' double float 8
Tuples

 Ensemble d’éléments de types (différents)

 Création
 En précisant les éléments entre les parenthèses
 En terminant la liste par une virgule
 Accès aux éléments: par indexation
 Opérateur in: pour vérifier l’appartenance
d’un élément à la liste
Dictionnaires

 tableaux associatifs,
 ensembles non ordonnés d’éléments indexés
par des clés.
 Une clé doit obligatoirement être immuable (chaîne,
entier ou tuple).
 une clé est toujours unique.
 Déclaration
 deux accolades : {} ; {cle: 1, 23: ‘ABS’}
 utilisant le type dict : dict (cle=valeur, cle=valeur)
 ajout + accès aux éléments par indexation sur la
clé associé à l’élément.
Dictionnaires

 Méthodes
 Keys () : liste de toutes les clés du dictionnaire
 has_key () : True si la clé donné en paramètre est
présente dans le dictionnaire et False sinon.
 opérateur in : vérifier l’appartenance
 Values () : liste des valeurs contenues dans le
dictionnaire
 Items() : liste de tuples : (clé, valeur)
 opérateur del : supprimer une association du
dictionnaire
Construction

 La structuration d’un programme définie par son indentation.

 Le début d’un bloc défini par un ‘:‘,

 la première ligne considérée comme un en-tête (test, boucle,

définition, etc.).
 la fin du bloc délimitée par le retour à l’indentation de l’en-tête.

 La convention en Python est d’utiliser quatre espaces pour chaque

niveau d’indentation.
 Imbrications possibles des bloc.

<en-tete>:
<instructions>
<en-tete>: <instruction> ## Bloc sur une seule ligne
Construction - Conditions booléennes
 tout ce qui n’est pas faux est vrai.
 Les données «vide» sont évaluées à FAUX :
 False, None, 0, “ ", [], list(), {}, dict(), (), tuple()
 opérateurs de comparaison
 <, <=, >, >=, !=, ==, is

 opérateurs booléens :
 and, or, not
 Exemple
>>> l1 = [1, 2, 3]
>>> l2 = [1, 2, 3]
>>> l1 == l2
True
>>> l1 is l2
False
Construction - If

 Si condition alors instructions finsi

<instructions avant le test>
if <condition> :
<instructions du bloc "alors">
<instructions après le test>
 Si condition alors instructions sinon instructions finsi
<instructions avant le test>
if <condition> :
<instructions du bloc "alors">
else :
<instructions du bloc "sinon">
<instructions après le test>
// présence de « : » pour délimiter les blocs
Construction - If

 Si condition1 alors instructions sinon si condition2

instructions sinon instructions finsi

<instructions avant le test>

if <condition1> :
<instructions du bloc "alors">
elif <condition2>:
instructions
else :
<instructions du bloc "sinon">
<instructions après le test>
// présence de « : » pour délimiter les blocs,
// possibilité d’imbriquer plusieurs « elif »
Boucle pour

 Syntaxe
for <var> in <sequence>:
<instructions>
[else:
<instructions, séquence épuisée sans break> ]
// […] indique l’aspect optionnel
 exemple
X=0
For i in range(10,20):
x=x+i
Boucle pour

Séquences
 range()
 range(n): entiers de 0 à n
 range(n1,n2) : entiers de n1 à n2
 range(n1,n2,p) : entiers de n1 à n2 avec pour pas
p.
 Liste de valeurs
 liste=(4,1, 0, 5, -1)
 Chaine de caractères
 Décomposition caractère par caractère
Boucle pour

liste=(5, 10, 15, 23, 13, 29)

for nombre in liste:
print(’Le nombre est’,nombre)
for lettre in ’Hello World’:
print(lettre)
for i,l in enumerate(’Hello World’) :
print(i, l)
for mot in ’Hello World’.split():
print(mot)
Boucle while

 Forme1 : sans alternative

<instructions avant la boucle>
while <condition>:
<corps de la boucle>
<instructions après la boucle>
 Forme 2 : avec alternative
while <condition>:
<instructions>
else:
<instructions, condition fausse>
Boucle while

while n!= 10:

n = int(input(’Entrez un nombre ’))
if n< 10: print(’Trop petit’)
if n> 10: print(’Trop grand’)
else:print(’Bravo’)
Mots clés break et continue

 break: arrêter une boucle quelle que soit la

condition de la boucle
while 1: # 1 est toujours vrai -> boucle infinie
lettre = input (" Tapez 'Q' pour quitter : ")
if lettre == "Q":
print ("Fin de la boucle ")
break
 continue: permet de continuer l’exécution
d’une boucle, en repartant directement à la
ligne du while ou for
conditions

 Opérateurs de comparaison
 Égalité: ==
 Différence: !=
 Inégalité: <; <=; >; >=
 Est (ou n’est pas): is (is not)
 Opérateurs logiques
 ET : and
 Ou: or
 Négation : not
Conditions (exemple)

 programme est de déterminer si une année

saisie par l'utilisateur est bissextile
Une année est dite bissextile si c'est un
multiple de 4, sauf si c'est un multiple de 100.
Toutefois, elle est considérée comme bissextile
si c'est un multiple de 400
Fonction
 définie avec le mot clé def.
 Retourne toujours une valeur (return).

 valeur None est alors retournée si pas de return

dans la fonction.
 Syntaxe

def nom_fonction(paramètres) :
instructions
[ return liste des résultats]
Ou
f=lambda par1, par2,…parn : instruction de retour
Exemple : f = lambda x: x * x
Fonction

>>> def fib(n=5): # suite de fibonacci jusque n

a, b = 0, 1
while b < n:
print (b)
a, b = b, a + b
Fonction (commentaire - docstring)
 Description affichée lorsque l’utilisateur veut
l’aide sur la fonction à travers la commande
help(nom_fonction)
 se fait sur la première ligne après la déclaration
en utilisant des chaînes de caractères multi-
lignes, en utilisant des guillemets doubles
>>> def exemple():
"""Commentaires…
…
commentaires."""
pass
Fonction (paramètres)

 objet mutable => en sortant de la fonction,

la modification est conservée
 listes, dictionnaires, sets, objets custo, etc
 objet immutable => en sortant de la
fonction, modification pas conservée
 strings, int, floats, tuples, etc
Fonction (paramètres)

 paramètres par défaut

 Les valeurs valeurs val1, val2 sont utilisées si
à l’appel ces paramètres manquent
def ma_fonction (paramètres non initialisés
par1 =val1, par2=val2…):
 Paramètres facultatifs
 Permet de faire varier le nombre de
paramètres
def ma_fonction(obligatoires, * faciltatifs):
Fonction (portée des variables)
 variables locales
 accessibles seulement dans la fonction où elles sont
déclarées
 variables globales
 définies à l'extérieur d'une fonction
 visibles de l'intérieur d'une fonction, mais la fonction
ne peut pas le modifier
 Utiliser « global » pour la rendre modifiable
 Exemple
a=2
def incrementer():
global a
a = a+1
manipulation de séquences

 Filtre
 filter applique la fonction passée en premier argument
sur chacun des éléments de la séquence passée en
second argument et retourne une nouvelle liste qui
contient tous les éléments de la séquence pour
lesquels la fonction a retourné une valeur vrai
 Syntaxe
 filter(fonction,liste)
 Exemple
>>> def impair(x):
return x % 2
>>> list(filter(impair, range(20)))
Fonction (portée des variables)
 variables globales – cas des objets mutables
 Possibilité de les modifier dans une fonction
 Exemple
def mafonction():
liste[1] = -127
liste = [1,2,3]
mafonction()
liste
[1, -127, 3]
Modules

 permet de fournir des bibliothèques de fonctions,

structures de données, classes, à intégrer dans les
programmes
 produire un module est identique à produire un
programme : faire un fichier.
 définitions contenues dans un fichier utilisables
globalement ou unitairement
 offrir l’accès aux fonctions à tout programme en ayant l’utilité
 Ce fichier doit être dans le même répertoire que le programme
principal (ou bien se trouver dans le « path » de Python)’’. Utiliser
import os, os.chdir(‘repertoire de de travail’)
Modules

 Précision du chemin (nécessaire sous linux)

#! Chemin
 Exemple : #! /usr/bin/python3.2.

 Précision du type d’encodage

# -*- coding :Encodage
 Exemple : # -*- coding :Latin -1 -*
 Test du module hors importation
 if __name__ == " __main__ ":
 Nom_du_module(paramètres)# lancement si le module est
#exécuté sans être importé
 os. system (" pause ") -Optionel
Modules (exemple)
 Nom du module ‘’calcul.py’’
’’ ’’ ’’ Petit commentaire pour l’aide ’’ ’’ ’’

def carre(valeur,n):
resultat = valeur**n
return resultat

def cube(valeur):
resultat = valeur**3
return resultat
Modules (importation)

 Après l’enregistrement du module, on peut

importer
 importe une seule fonction
from calcul import carre
 importe explicitement les fonctions

from calcul import carre, cube

 importe toutes les fonctions sauf les privés (commençant

par « _ »
from calcul import *
 importe le module

import calcul ou import calcul as cal

Utilisation: cal.carre(), évite les conflits en modules
Modules (standard)

Module sys
 paramètres et fonctions liées à l’environnement
d’exécution
 Constantes
 argv :paramètres passé sur la ligne de commande
 argv[0] : nom du script.
 stdin, stdout, stderr : Objets de type file (fichier) représentant les
entrées et sorties standard.
 path : Séquence contenant les chemins de la variable
d’environnement PYTHONPATH.
 Fonctions
 exit([arg]) : fin à l’exécution d’un programme avec pour satut de
sortie arg
Modules (standard)
Module string
 traitement des chaines de caractère
 Constantes
 string.ascii_letters : ensembles des lettres
 string.ascii_lowercase : lettres minuscules
 string.ascii_uppercase : lettres majuscules
 string.digits : chaîne '0123456789'.
 string.hexdigits : chaîne '0123456789abcdefABCDEF'.
 string.octdigits: chaîne '01234567.
 string.punctuation : caractères ASCII de ponctuation
 string.printable: Chaîne de caractères ASCII affichables.
 string.whitespace : chaîne comprenant tous les caractères ASCII
considérés comme espaces.
Modules (standard)

Module string
 Conversion en majuscules : txt.upper()
 Conversion en minuscules : txt.lower()
 Découpage avec un séparateur : txt.split(car)
 Remplacement de caractère:
txt.replace(‘’old", ’’ new")
 Recherche de caractères : txt.find(‘car’)
 ‘car’ peut être une chaine
Modules (standard)

Module os
 Manipulation des fonctions du système
 Quelques fonctions
 os.getcwd() : nom du répertoire courant
 os.chdir(chemin):changer de repertoire courant
 os.system(cmd) : exécution de la commande « cmd »
 os.walk(chemin)
 os.path.exists(chemin): existence du fichier
 os.path.isdir(’rep’) : existence du répertoire « rep »
 os.path.isfile(’chemin’): si chemin est un fichier
python3 -m pip install

Packages
 Regroupement de plusieurs modules
 Accès en fournissant un chemin vers le module
 Installation de nouveaux packages, en ligne de
commande dos
 Python –m pip install nomPackage
 En pratique, ce sont des répertoires où peuvent se
trouver d'autres répertoires (d'autres packages) ou des
fichiers (des modules).
 Importer des packages
 import nom_du_package
 import nom_du_package.nom_du_package
 import nom_du_package as alias
Exceptions

 Arrivent que Python rencontre une erreur

 Forme minimale
try :
# Bloc à essayer
except :
# Bloc qui sera exécut é en cas d'erreur
 try indique le bloc d'instructions à essayer.

 except indique le bloc d'instructions qui sera exécuté si une

erreur est trouvée dans le premier bloc
Exceptions

try :
# Bloc de test
except type_de_l_exception
Pour une division:
 NameError : l'une des variables numerateur ou denominateur
n'existe pas
 TypeError : l'une des variables numerateur ou denominateur ne peut
diviser ou être divisée
 ZeroDivisionError : Si denominateur vaut 0, cette exception sera
levée.
L’instruction « pass » dans un « except » indique de ne rien faire en
cas d'erreur
Exceptions (else)

Préciser de préciser les instructions à exécuter pour les types

d’exceptions dont le traitement n’est pas précisé avec except
try
resultat = numerateur / denominateur
except NameError :
print ("une des variables n’est pas dé finie .")
except TypeError :
print ("une des variables possède un type incompatible avec la
division .")
except ZeroDivisionError :
print ("La variable denominateur est é gale à 0.")
else :
print ("Le résultat obtenu est", resultat )
Exceptions (finally)
exécuter du code après un bloc try, quelle que soit le résultat de
l'exécution dudit bloc.
try :
# Test d'instruction (s)
except TypeDInstruction :
# Traitement en cas d'erreur
finally :
# Instruction (s) exécutée(s) qu'il y ait eu des erreurs ou non
manipulation de fichiers

 Répertoire de travail
>>> import os
os.chdir("C:/dossier") où “dossier” existe sur le disque C
 Connaitre le répertoire de travail
os.getcwd()
 Ouverture du fichier
 Fonction: open(‘’chemin du fichier’’, ‘’mode’’)
>>> mon_fichier = open("fichier.txt", "r") ## objet de classe TextIoWrapper
>>> mon_fichier
 Mode
 'r': lecture (Read).
 'w': écriture (Write). Écrase si existe, crée sinon.
 'a': ajout (Append).
 ‘b’ : pour une ouverture en mode binaire.
 t, pour une ouverture en mode texte.
 x, crée un nouveau fichier et l'ouvre pour écriture
manipulation de fichiers

 Fermeture du fichier
 Méthode close()
>>>Mon_fichier.close()
 Lecture
 Méthode: read()
>>> contenu = mon_fichier.read()
>>> print(contenu)
 Ecriture
 Méthode: write
 Ne prend en paramètre que des chaines de caractères
>>>mon_fichier = open("fichier.txt", "w") # effacement du contenu!
>>> mon_fichier.write(« Hello World")
>>> mon_fichier.close()
manipulation de fichiers

 Mot clé with

 with open(mon_fichier, mode_ouverture) as variable:
 Utiliser « variable » comme le fichier dans le programme
 Fermeture du fichier à la fin, même si oubli
 Sauvegarde des objets manipulés dans la session
 importer le module pickle
 Création du fichier de sauvegarde
>>> with open('donnees', 'wb') as fichier:
... mon_pickler = pickle.Pickler(fichier)
 Sauvegarde d’un objet
>>>... mon_pickler.dump(objet)
 Récupérer nos objets enregistrés
>>> with open('donnees', 'rb') as fichier:
... mon_depickler = pickle.Unpickler(fichier)
.. objet_recupere = mon_depickler.load()
manipulation de fichiers (CSV)
import csv
with open('test.txt') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for ligne in csv_reader:
if line_count == 0:
print(f' {", ".join(ligne)}')
line_count += 1
else:
print(f'\t{ligne[1]} {ligne[2]} a {ligne[3]}ans.')
line_count += 1
print(f'Effectif : {line_count} personnes.')
manipulation de fichiers (CSV)
import csv

with open('etudiant.csv', mode=‘w') as fich:

etud = csv.writer(fich, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)

etud.writerow(['Embolo', 'Acturiat', 'M1'])

etud.writerow(['Ngassa', 'Big Data', 'M1'])
etud.writerow(['Dongmo', 'Ing Fin', 'M2'])
manipulation de bases de données

 Installer le connecteur au SGBD

 pip install mysql-connector (pour MYSQL – en ligne de commande)
 Établir la connexion
import mysql.connector
conn = mysql.connector.connect(host="",
user=" ", password=" ",
database=" ")
cursor = conn.cursor()

 Exécution d’une requète

cursor.execute(‘’ ‘’ ‘’ -- Corps de la requête – ‘’’’’’)
 Validation de la requête : conn.commit()
 Annulation de la requête: conn.rollback()
 Fermeture de la connexion : conn.close()
 manipulation de bases de données
conn = mysql.connector.connect(host="loclahost",
import mysql.connector user="root", password="", database="test")
import sys cursor = conn.cursor()
cursor.execute(sql_create)
sql_create = """ et= ("20T1257", "Toto", "pierre", 10)
CREATE TABLE IF NOT EXISTS cursor.execute("""INSERT INTO etudiant
etudiant( (matricule, nom, prenom, age) VALUES(%s, %s, %s,
matricule varchar(6) NOT NULL, %s)""", reference)
nom varchar(100) DEFAULT NULL, cursor.execute("""SELECT matricule, nom, prenom
prenom varchar(100) DEFAULT NULL, FROM Produits WHERE stock > %d """, (0, ))
age int DEFAULT NULL, rows = cursor.fetchall()
PRIMARY KEY(matricule), for row in rows:
CHECK (age>=18) ); """ print('{0} : {1} - {2}'.format(row[0], row[1], row[2]))
POO en Python
Classe

 modèle suivant lequel on va créer des objets

 Attributs: variables pour décrire des objets
 Méthodes: fonctions pour manipuler la classe
 syntaxe de déclaration :
class NomDeLaClasse:
 constructeur : méthode de l’objet qui se
chargent de créer les attributs
Classe
class nomDeLaClasse: # Définition de la classe
""" Docstring pour la classe """
def __init__ ( self ): # Notre méthode constructeur
""" méthode pour initialiser les attribtus
"""
nomDeLaClasse.attribut=valeur
Exemple
class Personne : # Définition de laclasse Personne
""" Classe dé finissant une personne caractérisée par : son nom,
son prénom, son âge, son lieu de ré sidence """
def __init__ ( self ): # Notre méthode constructeur
""" Pour l'instant , on ne va dé finir qu'un seul attribut
"""
self . nom = " Toto"
Classe

 Nom du constructeur: __init__()

 Paramètre : self
 Accès aux attributs: par la notation pointée (.)
 Utilisation de la classe:
>>>Pers= Personne ()
>>>Pers.nom
‘Toto’
>>>Pers ##erreur car Pers est un objet
 On peut aussi initialiser les autres attributs de
Personne dans le constructeur
Classe
class nomDeLaClasse: # Définition de la classe
""" Docstring pour la classe """
def __init__ ( self, parametre1, parametre2,…, parametren): # Notremé thode
constructeur
""" méthode pour initialiser les attribtus
"""
nomDeLaClasse.attribut1=parametre1
….
Exemple
class Personne : # Définition de la classe Personne
""" Classe dé finissant une personne caractérisée par : son nom, son prénom, son
âge, son lieu de résidence """
def __init__ ( self , nom, prenom): # Notre méthode constructeur
""" Pour l'instant , on ne va dé finir qu'un seul attribut"""
self . age= 33
self . nom = nom
self . nom = prenom
Classe

 Attribut de la classe: attribut défini directement

dans le corps de la classe juste après la
docstring
 Utilisation dans une méthode ou pas:
nomDeLaClasse.attribut
Exemple
class Compteur :
objets_crees = 0 # Le compteur vaut 0 au dé part
def __init__ ( self ):
Compteur . objets_crees += 1
Classe (méthodes)

class nomDeLaClasse :
…
def __init__ ( self ):
…
def methode1 (self, parametre1,parametre2,…)
…
def methode2 (self, parametre1,parametre2,…)
….
 Utilisation
nomDeLaClasse.methode1(parametre1, parametre2,…)
Classe (méthode de la classe)

 Méthode définie pour la classe, ne prend pas en

premier paramètre self, mais cls (classe de l’objet)
class Compteur :
""" attribut de classe qui s'incrémente à chaque 3 fois que l'on crée un objet de ce
type """
objets_crees = 0 # Le compteur vaut 0 au dé part
def __init__ ( self ):
""" À chaque fois qu'on crée un objet , on incrémente le compteur """
Compteur . objets_crees += 1
def combien (cls):
""" Méthode de classe affichant combien d'objets ont été créés """
print (" Jusqu 'à présent , {} objets ont été créés.".format (cls .
objets_crees ))
combien = classmethod ( combien ) #Python reconnaisse une méthode de classe
Classe (méthode statique)

 Semblable à la méthode de classe, mais

sans paramètre; indépendante de toute
donnée
class Test :
""" Une classe de test tout simplement """
def afficher ():
""" Fonction chargée d'afficher quelque chose """
print ("On affiche la même chose .")
print ("peu importe les données de l'objet ou de la classe .")
afficher = staticmethod ( afficher ) # Pour indiquer à Python que la méthode est
#statique
Classe (encapsulation)

 cacher ou protéger certaines données de l’objet

 Rendre inaccessibles les attributs depuis l'extérieur
de la classe
 Définir les accesseurs et les mutateurs pour y
accéder
 Python utilise la notion de property, pour indiquer ce
qu’il faut si un utilisateur souhaite modifier ou
accéder à un objet:
 la méthode donnant accès à l'attribut ;
 la méthode modifiant l'attribut ;
 la méthode appelée quand on souhaite supprimer l'attribut ;
 la méthode appelée quand on demande de l'aide sur
l'attribut
Classe (encapsulation)
class nomDeLaClasse:
def __init__ (self , parametres):
…
self . _attr = valeur # présence du caractère « _ » devant le nom de
l’attribut « attr »
def _get_attr ( self ):
""" Méthode qui sera appelée quand on souhaitera accéder en
lecture à l'attribut attr '"""
print ("On accède à l'attribut attr !")
return self . _attr
def _set_attr (self , valeur ):
""" Méthode appelée quand on souhaite modifier le lieu de
résidence """
print (" Attention , modification de la valeur de l’attribut attr »)
self . _attr = valeur
# Informer Python que l’attribut attr pointe vers une propriété
attr = property ( _get_attr , _set_attr )
Classe (méthode spéciale)
 Permet de contrôler la création et l’accès à l’objet
 Moyen d'exécuter des actions personnalisées sur certains
objets, dans un cas précis
 Forme du nom d'une méthode spéciale :
__methodespeciale__
 Méthode __repr__(self): définit la façon dont est affiché
l'objet quand on tape directement son nom.
 Méthode __str__(self) : utilisée pour afficher l'objet avec
print, __repr__ est utilisée si __str__ n’est pas définie
 méthode __getattr__(self, attr): définit l’accès en lecture à
l’attribut attr
 Méthode __setattr__ (self , attr , val_attr ) : définit l’accès
en écriture à l’attribut attr
Classe (héritage)

class A:
""" Classe A, classe parente"""
pass # laisser la définition vide ,
class B(A):
""" Classe B, classe fille qui hérite de A.
"""
pass
 Classe (héritage)
class AgentSpecial ( Personne ):
""" Classe définissant un agent
spécial . Elle hérite de la classe Personne
class Personne : """
""" Classe repr é sentant une def __init__ (self , nom , matricule
personne """ ):
def __init__ (self , nom ): """ Un agent se dé finit par son
""" Constructeur de notre classe """ nom et son matricule """
self . nom = nom self . nom = nom
self . prenom = " Martin " self . matricule = matricule
def __str__ ( self ): def __str__ ( self ):
""" Mé thode appel ée lors d'une """ Méthode appelée lors d'une
conversion de l'objet en cha îne "" conversion de l'objet en chaîne """
return "{0} {1}". format ( self .prenom return " Agent {0}, matricule {1}".
, self . nom) format ( self .nom , self.
matricule )
Classe (méthode)

 se servir de la notation
MaClasse.ma_methode(mon_objet) pour appeler une
méthode précise d'une classe précise
 Exemple Personne . __init__ (self , nom) peut être
appelé dans def __init__ (self , nom , matricule ):
 issubclass (B,A) : True si B est une sous classe de A et
False sinon
 isinstance(obj, A) : True si obj est un objet de la classe A
 Héritage multiple: class ClasseFille ( parent1, parent2 ):
Expressions régulières

 moyen de rechercher et d'isoler des expressions d'une

chaîne de caractères
 ^ch (ch$) : rechercher en début (resp. fin) de la chaine ch
 xt*y : chaine commençant par x, se terminant par y et
entre x et y 0 ou plusieurs t. + (à la place de *) : pour au
moins un t. ? pour 0 ou 1 fois
 E{n} pour n fois le caractère E; E{n, m} : n à m fois
 [abcd] : un des caractères parmi a, b, c et d.
 [x-y]:caractères de x à y
Expressions régulières (module re)

 Importer le module: import re

 Quelques méthodes:
 re.search(r ‘expr_reg’, ch): renvoie un objet de
classe _sre.SRE_Match si l’expression est
trouvée et None sinon
 re. match ( expression , chaine ): vérifier si
l’expression est dans chaine