Introduction au Python

Partie 1
Historique

• Le python est un langage de programmation apparu pour la première

fois en 1991
• Son créateur Guido Van Rossum travaillait à l’époque au Centrum
voor Wiskunde en Informatica (le centre de recherche en
mathématique et informatique) aux Pays-Bas. Il a ensuite été associé à la
Python Software Foundation créée en 2001.
• Le langage a été baptisé en hommage à la troupe commique les “Monty
Python”
Qu’est-ce que Python?

• Python fait partie de la catégorie des langages interprétés. Pour

fonctionner on a besoin d’un fichier de script (contenant les
instructions) et d’un interpréteur.
• L’interpréteur traduit les instructions contenues dans le script en
langage machine.
• Python est un langage puissant, il dispose dès l’installation de
nombreuses fonctionnalités. Il est possible d’étendre ces fonctionnalités
en installant des bibliothèques (library).
 Langage interprété vs langage compilé

Conversion en Exécution (mise en

Développement
langage machine production)

Java

Runtime
Code Compilateur Machine
Environment

Python

Code Interpréteur Machine

Les avantages et inconvénients de python

Rapidité de mise en Lenteur à l’exécution:

production l’interpréteur doit traduire
Portabilité le script à chaque
exécution
Facilité d’apprentissage
Nombreuses
fonctionnalités supportées
Nombreux champs
d’application
Prise en main de l’IDE

• Installation de VisualStudio Code Insiders

• Téléchargez python pour windows ( pour vos premiers pas!) et installez-le.
https://www.python.org/downloads/
• Téléchargez ensuite le setup vscode en cliquant sur le lien suivant:
• https://code.visualstudio.com/insiders/
• Installez l’IDE
• Ensuite cliquez sur le lien:
https://marketplace.visualstudio.com/items?itemName=ms-python.python
pour installer l’extension python pour VisualStudio.
Mon premier programme en python

• Dans vscode ouvrez un dossier (File / Open Folder…)

• C’est dans ce dossier que vous allez stocker vos scripts python:
• Créez un nouveau fichier que vous nommez lab1.py
• Saisissez ensuite le code suivant:

• Maintenant enfoncez les touches Ctrl+f5 pour lancer votre programme.

• Si vous n’avez aucune erreur vous obtiendrez ceci:
Applications python

• Le code source d’un programme est contenu dans un ou

plusieurs fichiers ayant pour extension .py
• Idéalement le nom sera en minuscules
• Le fichier peut contenir des instructions, des fonctions et des
classes python
• Un fichier python est un module.
Commentaires

• Pour faciliter la lecture et la compréhension du code nous

utiliserons des commentaires.
• Les commentaires de ligne seront précédés de #
• Pour les commentaires sur plusieurs lignes nous utiliserons '''
• Le texte en commentaire sera ignoré par l’interpréteur
Exercice

• Modifiez votre code pour ajouter une ligne qui affiche « Au

revoir et à bientôt »
• Ajoutez un commentaire pour indiquer ce que fait cette ligne.
• Exécutez votre programme.
Nommage

• Variables:
• Notation camelCase ex: numeroEmploye
• Constantes:
• En majuscules séparées par _ ex: TAUX_TVQ
• Convention de nommage peut varier d’une entreprise à l’autre.
Instructions, fonctions et méthodes

• Un script python est constitué d’une suite d’instructions

• Une instruction peut être sur une ou plusieurs lignes

• Une fonction regroupe un certain nombre d’instructions pour réaliser

une fonctionnalité.
• Pour déclarer une fonction on utilise le mot clé def
def additionnerAB(a, b):
return a+b
• Une méthode est similaire à une fonction sauf qu’elle appartient à une
classe
Bloc d’instructions et indentation

• Un bloc d’instructions sera délimité en utilisant une indentation

• Contrairement à PL/SQL qui utilise BEGIN et END;
• On augmente l’indentation après certaines instructions telles que if
• Ex:
if age > 18:
print ("Cet individu peut consommer de l'aclool")
Délimiteurs

• Ce sont des marqueurs spécifiant la limite entre plusieurs régions dans

le code.
( ) [ ] { }
, : . ' = ;
+= -= *= /= //= %=
<= |= ^= >>= <<= **=
' " \ @
• Ils sont utiles dans la construction d’expressions, chaines de caractères,
dictionnaires, liste, etc…
Les mots clés de python

• Ils ne peuvent pas être utilisés comme nom de variable.

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
Les variables

• Reprenez votre fichier lab1.py et remplacez l’instruction

print ("Mon premier programme en python!") par:

#ceci est une variable:

message = "Bienvenue au cours de sécurité des applic
ations!"
print(message)
• Exécutez votre programme, que remarquez-vous?
Déclaration

• Une variable peut contenir

• Une chaine
• Un type numérique
• Objet ou fonction de classe
• Les noms de variables peuvent être composés de caractères
alphanumériques et de _
• Le nom doit commencer par une lettre
• La casse est importante (nom, Nom et NOM sont 3 variables distinctes)
• Il n’y a pas de constante à proprement parler en python, nous allons
donc déclarer des pseudo-constantes:
• NOM_CONST = valeur1
Types de données
Types de données

• Booléen
• Ex: test = False
• None
• Est un type spécial qui signifie vide ou inconnu (qui n’existe pas)
• Numérique
• Représente des nombres entiers, nombres réels, nombres complexes
• String
• Représente des chaines de caractères, on les crée en utilisant: ', ", """
• Pour insérer des " dans une chaine il faut les échapper avec \
• On utilise \n pour les retours à la ligne
• On peut concaténer ou multiplier les chaines de caractères de différentes
façons:
print ("test "*5)
print ('ceci est ' 'un test')
print('ceci '+ 'est '+ 'un test')
Tuples

• Type qui peut contenir des types mixtes

• Ce type est immuable
• on crée un tuple en utilisant ( )
• Fonctions (len(), max(), min()…)
tupleUn=(1, 2, 3, 4)
tuple2=(5, 6, 7)

print("Longueur: ", len(tupleUn))

print("Maximum: ", max(tupleUn))
print("Minimum: ", min(tupleUn))
print("Combinaison de 2 tuples: ", tupleUn + tuple2)
print("2fois tuple_un: ", tupleUn*2)
print("1 se trouve dans tuple_un: ", 1 in tupleUn)
print("2 ne se trouve pas dans tuple_2: ", 2 not in tuple2)
Indexation des tuples

• Pour indexer un tuple on utilise [ ]

• L’indice commence à 0
• Un indice négatif permet d’indexer le tuple à partir de la fin
• Exemple: -1 retourne le dernier élément
• On peut obtenir des sous-ensembles de tuple en utilisant le délimiteur :
• Exemple: [0:4]
• Dans ce cas le dernier élément n’est pas inclus
• Indexation de tuples mixtes:
tupleUn=(1, 2, "test", (3, 4, 5))
print(tupleUn[1],
tupleUn[2],
tupleUn[3],
tupleUn[3][2])
=> 2 test (3, 4, 5) 5
Lists

• Une liste est modifiable

• Elle peut contenir des types mixtes
• Similaire au tuple mais différente car modifiable
• List est créée avec [ ] ou list()
liste = [2, 4, 6, 8, 10, 12]
print(liste[0],
liste[3:],
len(liste),
liste+[8,9])
=> 2 [8, 10, 12] 6 [2, 4, 6, 8, 10, 12, 8, 9]
Opérations sur les listes

• sort() : trie les éléments d’une liste

• reverse() : renverse la liste
• count() : compte le nombre d’occurrence d’un élément
• append() : ajoute un élément à la fin
• insert() : insère un élément à un emplacement spécifique
• remove() : enlève un élément de la liste
• extend() : append une liste à une autre
• pop() : prend un élément de la liste et le retourne
• index() : recherche un index dans la liste
Sets

• Un set est une collection non ordonnée d’éléments uniques

• Opérations: différence, union, intersection
set1 = set(['A', 'b', 'c', 'd', 'a'])
set2 = set(['A', 'b', 'l', 'm', 'n', 'm'])
print(set1,
set2,
'\n intersection:', set1 & set2,
'\n union:', set1 | set2,
'\n différence:', set1 - set2)
=> {'c', 'a', 'A', 'd', 'b'} {'A', 'n', 'm', 'l', 'b'}
intersection: {'b', 'A'}
union: {'c', 'a', 'A', 'n', 'm', 'l', 'd', 'b'}
différence: {'a', 'd', 'c'}
Dictionnaires

• Collection de type key-value

• Indexation par la clé (qui est unique)
• items() : retourne la liste des paires key-value sous forme de tuples
animaux = {'a':'Chien', 'b':'Chat', 'c':'Souris'}
print (animaux['a'],
animaux.keys(),
animaux.values(),
animaux.items())
print(animaux.pop('b'))
print(animaux)
=> Chien dict_keys(['a', 'b', 'c']) dict_values(['Chien', 'Chat',
'Souris']) dict_items([('a', 'Chien'), ('b', 'Chat'), ('c', 'Souris')])
Chat
{'a': 'Chien', 'c': 'Souris'}
Transtypage explicite

• Il est possible de convertir un type de données en un autre:

• type(expression)
• Ex:
val = 1
test1 = bool(val)
Exercice

• Types de données:
• Créez le fichier types.py
• Affectez les valeurs suivantes à des variables: 10, 100000000000, -10, 10.10, ‘10’,
True
• Identifiez le type de ces variables en utilisant la fonction
isinstance(votre_variable, type_recherché) pour vérifier si une variable est d’un
type spécifique
• Opérateurs:
• Créez le fichier division.py
• Utiliser les variables var1 et var2 avec les valeurs 20 et 8
• On utilisera les variables div, reste et divEntiere pour stocker les résultats de la
division, modulo et division entière.
• Écrire le code qui effectue ces opérations et affichez le contenu de toutes les
variables.
Tests et Boucles
Structures de test

• Une structure de test nous permet de choisir quelles instructions dans

une partie de code peuvent être exécutées. Les structures
conditionnelles nous permettent de gérer ces décisions
• Les structures de test en python sont:
• if
• if-else
• if-elif-else
• Expression conditionnelle
Structure simple avec if

• Dans le cas d’un test simple on utilisera la structure suivante:

if condition :
bloc à exécuter quand la condition est True
• On utilise le mot réservé if pour débuter notre structure de test
• La condition est une expression booléenne qui sera utilisée pour
déterminer si le bloc sera exécuté:
• Si condition est True, le bloc est exécuté
• Si condition est False, le bloc n’est pas exécuté
Structure if - else

• Dans certains cas on veut exécuter des instructions lorsque la condition

n’est pas vérifiée, on peut alors ajouter une clause else à la structure if
existante:
if condition :
bloc à exécuter quand la condition est True
else :
bloc à exécuter quand la condition est False
• La condition est une expression booléenne qui sera utilisée pour
déterminer quel bloc sera exécuté:
• Si condition est True, le bloc if est exécuté
• Si condition est False, le bloc else est exécuté
• Chaque bloc doit contenir au moins une instruction python valide. Un
commentaire n’est pas considéré comme une instruction.
Structure complexe if-elif-else

• Dans le cas où on a plusieurs possibilités et qu’on voudrait exécuter des

opérations selon la catégorie, on fera appel à la structure complexe: if-
elif-else
if condition1 :
bloc à exécuter quand la condition1 est True
elif condition2 :
bloc à exécuter quand la condition2 est True
else :
bloc à exécuter quand aucune condition n’est True
Expression conditionnelle

• Python dispose d’un opérateur conditionnel qui utilise une condition

booléenne pour choisir laquelle des 2 expressions est affectée à une
variable.
val = expr1 if condition else expr2
• Est équivalent à:
if condition :
val = expr1
else :
val = expr2
Boucle while

• Les structures répétitives permettent d’exécuter des instructions un certain

nombre de fois
• On utilise des expressions booléennes pour le contrôle
• Syntaxe:
while condition:
bloc d'instructions
• Si la condition est True, les instructions sont exécutées.
• La condition est évaluée à chaque passage et l’exécution se poursuit jusqu’à ce
que la condition devienne False.
• Exemple:
var = 7
while var > 0:
print(var)
var-=1
Boucle for

• Syntaxe:
for value in range(init,fin,inc):
instructions
• Où init est la valeur d’initialisation,
• fin la valeur de fin,
• Et inc l’incrément
• Exemples:
for count in range(1,5):
print (count)

for count in range(1,5, 2):

print (count)
Break et continue

• break peut être utilisé dans une boucle pour terminer la boucle
immédiatement:
for count in range(1,5):
print (count)
break

print ('suite du programme')

• continue peut être utilisé dans une boucle pour terminer l’itération courante
et ramène l’exécution au début de la boucle:
while count < 5:
count+=1
if (count == 3):
continue
print ('val:',count)
Fonctions usuelles

• Print
• Sert à afficher du texte sur la sortie standard
• Input
• Sert à la saisie par l’utilisateur sur l’entrée standard
• Exemple:
nom = input("Entrez votre nom: ")
• Format
• Sert à formater une chaine de caractères
• Exemple:
print ("Bonjour {0}, comment allez-vous?".format(nom))
Exercice

• Écrivez un petit programme qui procède à la saisie d'une chaîne de

caractères et d'un entier correspondants respectivement au nom et à
l'âge de deux personnes. Vous devrez seulement saluer la personne la
plus jeune des deux. En cas d'égalité, aucune salutation n'est requise.
Pour la saisie utilisez la fonction input()
• Vous devrez faire une conversion d'une chaîne de caractères en entier.
La fonction int() doit être utilisée à cette fin. De plus, utilisez la
fonction format() pour afficher mais en utilisant une variable de type
entier.
• Entrez le premier nom: John Snow
Entrez l'âge de John Snow : 17
Entrez le deuxième nom: Brandon Stark
Entrez l'âge de Brandon Stark : 12
Le plus jeune est Brandon Stark et il a 12 ans.
Fonctions

• Pourquoi utiliser des fonctions?

• Permettre la réutilisation du code
• Minimiser la redondance
• Réduire le nombre de bugs potentiels en réduisant la redondance
• Décomposition du problème en sous-problèmes plus faciles à gérer.

• Qualités d’une fonction

• Cohérente : une fonction ne devrait faire qu’une seule tâche
• Indépendante : Le résultat d’une fonction ne dépend que de ses arguments
• Concise : Le code ou suite d’instructions dans une fonction doit être facilement
compris.
• Documentée : des commentaires doivent décrire le comportement de la
fonction et les valeurs attendues pour ses paramètres.
Fonctions

• Entrée et Sortie
• Une fonction est un ensemble d’instructions
• Elle reçoit des données en entrée
• Elle produit des données en sortie

Entrée Fonction Sortie

• Syntaxe:
• On utilise le mot clé def dans la signature de la fonction:
def nom_fonction(param1, param2, ... paramn):
# bloc d'instructions
return valeur # optionnel
• On peut définir une fonction n’importe où dans le module.
• On peut omettre le mot clé return (la fonction retourne none)
• La fonction est considérée comme un objet
Appels de fonctions

• L’appel de la fonction se fait de la façon suivante:

nom_fonction(param1, param2,... ,paramn)
• Le passage de paramètres se fait selon la position dans la signature.
• Parfois l’ordre des paramètres peut ne pas être intuitif, on peut alors
utiliser des mots-clés pour le passage de paramètres
• Exemple:
def addition ( oper1, oper2):
resultat = oper1 + oper2
return resultat

print (addition(oper2=4, oper1=6))

Valeurs par défaut

• On peux définir des valeurs par défaut (qui remplacent le paramètre s’il
n’est pas spécifié)
• Exemple:
def calcul_exposant ( operateur, exposant=2):
resultat = operateur ** exposant
return resultat

print (calcul_exposant(3))
print (calcul_exposant(8, 7))
• Dans ce cas operateur est obligatoire car il n’a pas de valeur par défaut
• Il faut respecter un ordre dans la définition:
1. Paramètres normaux
2. Paramètres avec valeur par défaut
3. Forme *
4. Forme **
Forme * dans la signature

• La forme * permet de collecter les paramètres dans un tuple

• Exemple:
def somme_serie(*oper):
resultat=0
for itOper in oper:
resultat += itOper
return resultat

print (somme_serie(1, 2, 3, 4, 5, 6, 7, 8))

• Transformer une liste en paramètres de fonction:
list1=[2,4,6,8,10,12]
print (somme_serie(*list1))
Forme ** dans la signature

• La forme ** permet de collecter dans un dictionnaire un certain

nombre de valeurs nommées
• Exemple:
def afficher_details(**param):
for k,v in param.items():
print(k + ":" + v)

afficher_details(nom="Pierre", prenom="Prades")
Portée des variables
Variable locale

• Elle est définie à l’intérieur d’une fonction

• Les paramètres de la fonction font partie des variables locales
• Une variable locale cache les variables de niveau supérieur portant le
même nom
• Elle existe seulement pendant l’exécution de la fonction
• Attention lors de la déclaration d’une fonction dans une fonction!
• La fonction interne récupère les variables de la fonction qui l’englobe.
• Exemple:
def addition ( oper1, oper2):
resultat = oper1 + oper2
return resultat
• resultat, oper1 et oper2 sont des variables locales.
Variable globale

• Variables définies dans le module mais en dehors de fonctions ou de

classe
• Disponibles à toutes les fonctions du module ou de la classe
• A éviter!!

• Exemple:
biais = 4
def addition ( oper1, oper2):
resultat = oper1 + oper2 + biais
return resultat
• biais et addition sont des variables globales (souvenez-vous, la fonction est un
objet)
• resultat, oper1 et oper2 sont des variables locales.
Utilisation de modules externes

• Pour appeler un module externe, on utilise le mot clé import:

• Prenons pour exemple 2 fichiers : mon_module.py et prog1.py
• mon_module.py contient 2 fonctions fct1 et fct2
• Je peux réutiliser ces fonctions dans prog1.py en insérant la ligne suivante:
import mon_module
• Ensuite j’appelle ma fonction comme ceci:
mon_module.fct1()
• Je peux aussi utiliser la forme:
from mon_module import *
• Je n’ai plus qu’à appeler la fonction directement (sans utiliser
"mon_module."):
fct1()
Exercice fonctions

• Dans le fichier module_math.py:

• Écrire une fonction qui calcule le carré d’un entier
• Écrire une fonction qui calcule le cube d’un entier
• Écrire un programme (prog1.py) qui donne le carré d’un entier en utilisant la
fonction créée précédemment, on demandera la valeur à l’utilisateur
• Dans le fichier module_saisie.py:
• Écrire une fonction qui affiche un message, lit une valeur introduite par un
utilisateur et renvoie cette valeur convertie en int
• Écrire un programme (prog2.py) qui calcule soit le carré soit le cube d’une
valeur saisie, on devra demander à l’utilisateur s’il veut le carré ou le cube.
Pour cela utiliser les fonctions précédentes.
• Écrire un programme (prog3.py) qui permet à l’utilisateur de saisir des valeurs
dans une liste. Une fois la liste saisie on effectuera la moyenne des valeurs
stockées dans la liste et on affichera le résultat.
Important: avant d’afficher la moyenne on affichera les valeurs stockées dans la
liste. On utilisera une fonction pour le calcul de la moyenne, une fonction
pour la saisie des valeurs et une fonction pour l’affichage des valeurs de la liste.
Ces fonctions devront être créées dans module_saisie.py
Manipulation de fichiers
Manipulation de fichiers

• Est effectuée en utilisant un objet de type File

• Permet d’utiliser ses méthodes
• Permet d’avoir des informations sur le contenu du fichier

• Ouverture du fichier : objet_fichier = open("nomFichier")

• Lecture du contenu : objet_fichier.read()
• Lecture ligne par ligne: objet_fichier.readline()

• Lecture le contenu d’un fichier sous forme d’une liste de lignes:

maliste = objet_fichier.readlines()
Écriture dans un fichier

• Ouvrir le fichier en mode écriture:

objet_fichier = open("nomFichier", "w")
• Ouvrir le fichier en mode ajout (append)
objet_fichier = open("nomFichier", "a")

• Écrire dans le fichier :

objet_fichier.write("ceci est un test")
Boucle for…in pour fichier

• Il est possible d’utiliser un objet file dans une structure de boucle for …
in:
for ligne in open("nomFichier"):
instructions
• Exemple:
for ligne in open("poeme.txt"):
print(ligne.strip()) # strip() supprime les espaces en
début et en fin de chaine
Fermeture de fichier

• Après avoir manipulé un fichier il est important de le fermer:

• Cela permet de libérer les ressources du système
• Permet à d’autres scripts de manipuler le fichier
• Les objets file sont automatiquement fermés à la fin du script python
• Pour fermer un fichier on utilise la méthode close():
objet_fichier.close()
• Ouverture avec with:
• Lorsqu’on manipule des fichier il est fréquent d’avoir des erreurs, si on a une
erreur à la lecture ou l’écriture le fichier peut rester ouvert. Un moyen de
s’assurer de sa fermeture est de l’ouvrir comme suit:
with open (' fichier.txt ', 'r ') as mon_fichier :
texte = mon_fichier . read ()
• À la fin du bloc with le fichier est automatiquement fermé.
Exercices

• Dans le fichier liste.py définir la liste : liste =[17, 38, 10, 25, 72], puis
effectuez les actions suivantes :
• triez et affichez la liste ;
• ajoutez l’élément 12 à la liste et affichez la liste ;
• renversez et affichez la liste ;
• affichez l’indice de l’élément 17 ;
• enlevez l’élément 38 et affichez la liste ;
• affichez la sous-liste du 2e au 3e élément ;
• affichez la sous-liste du début au 2e élément ;
• affichez la sous-liste du 3e élément à la fin de la liste ;
• affichez la sous-liste complète de la liste ;
• affichez le dernier élément en utilisant un indiçage négatif.
Exercices

• Dans le module module_fic.py:

• Créer une fonction nbrLigne qui a pour paramètre le nom d'un fichier (texte) et
qui retourne le nombre de lignes de ce fichier.
• Créez une fonction creerFic qui a pour paramètre le nom d'un fichier (texte) et
une chaine de caractères et qui crée le fichier et y enregistre la chaine de
caractères passée en paramètre. Le paramètre chaine peut être omis pour créer
un fichier vide.
• Créez une fonction catFic qui concatène 2 fichiers dont les noms sont passés en
paramètres
• Créez une fonction afficheFic qui a pour paramètre le nom d'un fichier (texte)
et qui affiche son contenu
• Créez une fonction ligneMaxFic qui retourne la ligne la plus longue d’une
fichier
Exercices

• Dans le programme prog_fic.py (en utilisant les fonctions créées

précédemment:
• Créez le fichier Alchimie.txt et y écrire la chaine de caractères suivante:
citation="Alchimie de la douleur\n\nL'un t'éclaire avec son ardeur,\nL'autre en
toi met son deuil, Nature !\nCe qui dit à l'un : Sépulture !\nDit à l'autre :
Vie et splendeur !\n\nHermès inconnu qui m'assistes\nEt qui toujours m'intimida
s,\nTu me rends l'égal de Midas,\nLe plus triste des alchimistes ;\n\nPar toi j
e change l'or en fer\nEt le paradis en enfer ;\nDans le suaire des nuages\n\nJe
découvre un cadavre cher,\nEt sur les célestes rivages\nJe bâtis de grands sar
cophages.\n\n"
• Écrivez le contenu du fichier Info.txt à la suite du fichier Alchimie.txt.
• Affichez le nombre de lignes et le contenu du fichier Alchimie.txt
• Affichez la ligne la plus longue du fichier
Manipulations des chaines de
caractères
Découpage de chaine

• La classe str possède plusieurs méthodes de manipulation puissantes,

nous verrons ici les plus utilisées. Pour une référence complète:
https://www.w3schools.com/python/python_ref_string.asp
• La méthode split() permet de découper une chaine en tokens
chaine.split() # par espace vide
chaine.split(delimiteur) # par délimiteur

• La méthode join() fait l’opération inverse:

delimiteur.join(liste de tokens)
• Si on connait le nombre de tokens on peut faire un split directement
dans des variables:
var1, var2, ..., varn = chaine.split()
Recherche dans une chaine de caratères

• Pour chercher une chaine dans une autre on peut utiliser les méthodes:
str.find(), str.endswith(), str.startswith()
• Exemple:
text = 'yeah, but no, but yeah, but no, but yeah’
# correspondence exacte
text == 'yeah'
=>False
# le début ou la fin correspondent
text.startswith('yeah')
=>True
text.endswith('no')
=>False
# Rechercher la position de la 1ère occurrence
text.find('no')
=>10
Expressions régulières

• Pour une correspondance plus compliquée, on utilisera des expressions régulières et

le module re. Pour illustrer la mécanique de base de l’utilisation d’expressions
régulières, supposons que l’on souhaite faire correspondre les dates spécifiées sous
forme de chiffres, telles que « 27/11/2019 ». Voici un exemple de la façon de faire:
text1 = '27/11/2019'
text2 = 'Nov 27, 2019'
import re
# Correspondance simple: \d+ signifie correspond à un ou plusieurs chiffres
if re.match(r'\d+/\d+/\d+', text1):
print('yes')
else:
print('no')
=> yes
if re.match(r'\d+/\d+/\d+', text2):
print('yes')
else:
print('no')
=> no
• Si on effectue beaucoup de correspondances en utilisant le
même modèle, il est généralement payant de précompiler le
modèle d’expression régulière dans un objet de modèle
d’abord. Par exemple :
datepat = re.compile(r'\d+/\d+/\d+')
if datepat.match(text1):
• match() essaie toujours de trouver la correspondance au début
d’une chaîne. Si on souhaite rechercher du texte pour toutes
les occurrences d’un modèle, on utilisera la méthode findall().
Par exemple :
text = 'Aujourd\'hui nous sommes le 27/11/2019. PyCon commence
le 13/3/2020.'
datepat.findall(text)
=> ['27/11/2019', '13/3/2020']
• Lors de la définition d’expressions régulières, il est courant
d’introduire des groupes de capture en englobant des parties du
modèle entre parenthèses. Par exemple :
datepat = re.compile(r'(\d+)/(\d+)/(\d+)’)

• Les groupes de capture simplifient souvent le traitement ultérieur du

texte correspondant car le contenu de chaque groupe peut être
extrait individuellement. Par exemple :
m = datepat.match('27/11/2019')
# Extract the contents of each group
m.group(0)
=>'27/11/2019'
m.group(1)
=>'27'
m.group(2)
=>'11'
m.group(3)
=>'2019'
m.groups()
=>('11', '27', '2019')
jours, mois, annee = m.groups()
• La méthode split() de la classe str est vraiment destinée aux cas
très simples, et ne permet pas de multiples délimiteurs ou de
tenir compte de l’espace blanc possible autour des délimiteurs.
Lorsqu’on a besoin de plus de flexibilité, on utilise la méthode
re.split() :
line = 'asdf fjdk; afed, fjek,asdf, foo'
import re
re.split(r'[;,\s]\s*', line)
=> ['asdf', 'fjdk', 'afed', 'fjek', 'asdf', 'foo']
Exercice

• Prenez le fichier liste.txt et lisez-le ligne par ligne en créant des

fonctions dans le module analyse_fic.py:
1. N’affichez que les lignes contenant une date
2. N’affichez que les fichiers modifiés aujourd’hui, utilisez
datetime.datetime.now() du module datetime pour récupérer la date courante
et filtrer les fichiers
3. N’affichez que les fichiers modifiés dans la dernière semaine.
4. N’affichez que les fichiers modifiés le mois dernier
5. Afficher les fichiers qui ont l’extension .txt