Programmation avancée en Python
Programmation avancée en Python
Déroulement du cours
Introduction
Chapitre 1 : Les bases de la programmation python
- Instructions de base : lecture/écriture
- Les variables
- Les opérateurs
- Structure conditionnelle
- Structure itérative / boucle
- L’instruction : break
- L’instruction : continue
Chapitre 2 : Fonctions & Modules
- Modules
- Fonctions
Chapitre 3 : Structures de données
- Les types séquentiels : chaines de caractères, listes, tuples
- Les types de correspondance : dictionnaire
Chapitre 4 : Manipulation des fichiers
Chapitre 5 : Gestion des tableaux avec la bibliothèque NumPy
Chapitre 6 : Gestion des graphiques avec le libraire Matplotlib
Chapitre 7 : Analyse de données avec la bibliothèque Pandas
Projet de fin de module
Introduction
Introduction
Les versions se succèdent... Un grand choix de modules est disponible, des colloques annuels sont
organisés, Python est enseigné dans plusieurs universités et est utilisé en entreprise...
Introduction
fi
fi
s
Introduction
La fonction : print
C’est une fonction qui permet d’afficher les éléments passés comme arguments de la fonction
Syntaxe générale
print (nom_variable)
print (nom_variable1, nom_variable2, …) Exemple
print (" texte ")
print ( " texte " , nom_variable) a=12
print ( f " texte { nom_variable } " ) b=200
print ( " texte {} " .format(nom_variable) ) print(a)
print(a, b)
print("c’est un exemple pour la fonction print ")
print("a=",a)
print(f"a={a} et b={b}")
print("a={} et b={}".format(a,b))
La fonction : input
• C’est une fonction qui permet à l’utilisateur d’un programme de saisir des valeurs à l’aide de son
clavier.
• La fonction input() renvoie une valeur de type chaine de caractères, pour faire des calculs sur la
valeur saisie, il faut la convertir à un entier avec la fonction int (nom_variable) ou un réel avec la
fonction float(nom_variable)
Syntaxe générale
nom_variable = input () Exemple
nom_variable = input (" texte ")
a=input("entrer une première valeur : ")
b=input("entrer une deuxième valeur : ")
a=int(a)
b=int(b)
print(f"la somme de {a} et {b} est {a+b} ")
Les variables
▪ Une variable est un emplacement mémoire dans lequel on peut mémoriser une valeur.
▪ Une variable est identifiée par son nom et son adresse.
▪ Le nom d’une variable doit :
‣ Etre formé des lettres (A - Z) (a - z), des chiffres (1 - 9) et des lignes de soulignement ( _ )
‣ Commencer par une lettre.
▪ En python, le typage des données est dynamique : le type d’une variable est déterminée selon la
valeur attribuée à cette variable.
‣ Pour savoir le type d’une variable, il suffit d’utiliser la fonction type (nom_variable)
Ex:
a=
print(type(a)
<class 'int'>
Opérateurs arithmétiques
x+y Somme de x et y
x-y Différence de x et y
Opérateurs de comparaison
x*y Produit de x et y
and ET logique
or OU logique
not Négation logique
Opérateurs d’affectation
• C’est l’opération qui permet d’attribuer à une variable une valeur simple ou résultante
d’une expression arithmétique :
- Identi cateur_variable = valeur simpl
- Identi cateur_variable = expression arithmétiqu
• Une affectation multiple c’est attribuer à plusieurs variables une seule valeur avec une
seule affectation.
- Identi cateur_variable1=Identi cateur_variable2= Valeur
• Une affectation parallèle c’est affecter des valeurs à plusieurs variables en parallèle.
- Identi cateur_variable1, Identi cateur_variable2= Valeur1, Valeur 2
Exemple :
s=p*(r**2)
a=b=c=3
x,y,z=1,2,3
Opérateurs d’assignation
Additionne les deux valeurs op1 et op2, le résultat est
op1+= op2 op1=op1 +op2 stocké dans op1
op1**=op2 op1=op1**op2 Calculer op1 à la puissance op2 et mettre le résultat dans op1
Exemple :
A+=2 #Ajouter 2 à A puis stocker la nouvelle valeur dans A
B//=5 # Diviser B sur 5 puis stocker la partie entière du résultat dans B
C**=3 # calculer C à la puissance 3 puis stocker le résultat dans C
Exemple
A==B
A<=4
Expression logique ▪ C’est une combinaison entre deux expressions logiques simples
complexe
en utilisant un opérateur logique.
▪ La valeur d’une expression logique complexe est de type booléen
(vrai ou faux)
Exemple
Opérateur de Opérateur Opérateur de
comparaison logique comparaison
(A + 3 < B * 2) and (A % B == 0)
Expression logique Expression logique
simple simple
La structure conditionnelle : if
if expression logique :
Instruction 1
Instruction 2 Instructions à exécuter si
… l’expression logique est
Instruction n vraie
Exemple
if X % 2 == 0 :
print ( ″ c’est un nombre pair ″ )
if expression logique_1 :
Instructions à exécuter si l’expression logique_1 est vraie
elif expression logique_2 :
Instructions à exécuter si l’expression logique_2 est vraie
…
Exemple
if X>0 :
print (″ C’est un nombre positif ″)
elif X < 0 :
print (″ C’est un nombre négatif ″ )
else :
print (″ C’est un nombre nul″ )
match IdentificateurVariable :
case Valeur1 :
Instructions à exécuter si IdentificateurVariable = Valeur1
…
case ValeurN :
Instructions à exécuter si IdentificateurVariable = ValeurN
case other :
Instructions à exécuter si IdentificateurVariable n’appartient pas à la liste
des valeurs {Valeur1, Valeur2, … , ValeurN}
Exemple
choix = input ("entrer votre choix : ")
match choix :
case "Lundi" :
print("1er jour de la semaine ")
case "Mardi" :
print("2ème jour de la semaine ")
case "Mercredi" :
print("3ème jour de la semaine ")
case "Jeudi" :
print("4ème jour de la semaine « )
case other :
print("choix introuvable ")
Exercice d’application
Ecrire un script python qui permet d’afficher les mentions suivantes selon la
valeur de la moyenne générale choisie par l’utilisateur.
- Si moyenne >=16, la mention affichée est : Très Bien
- Si 14 <= moyenne <16, la mention affichée est : Bien
- Si 12 <= moyenne <14, la mention affichée est Assez Bien
- Si 10 <= moyenne <12, la mention affichée est Passable
- Si moyenne <10, l’étudiant a échoué
Exercice d’application
Les boucles
La boucle for
Exemple
for x in [1, 2, 3, 4, 5] :
print (″ x prend la valeur ″, x)
La boucle for
for i in "Bonjour" :
print (i, end = " ") # le résultat d’exécution est l’affichage des caractères B o n j o u r
for x in [4, 5, 6] :
print (x, end = " ") # le résultat d’exécution est l’affichage des valeurs 4 5 6
for y in ["B", 15, 3.6, "Et"] :
print (y, end = " ") # le résultat d’exécution est l’affichage des valeurs B 15 3.6 Et
for j in range(5) :
print (j, end = " ") # le résultat d’exécution est l’affichage des valeurs 0 1 2 3 4
for k in range (1, 5) :
print (k, end = " ") # le résultat d’exécution est l’affichage des valeurs 1 2 3 4
for k in range (1, 10, 3) :
print (k, end = " ") # le résultat d’exécution est l’affichage des valeurs 1 4 7
La boucle while
Instruction 1 Exemple
à exécuter tant
Instruction 2 que l’expression
… x=1
logique est vraie
Instruction n while x < =5 :
print (″ x prend la valeur ″, x)
x=x+1
La boucle while
Exercice d’application
Ecrire un script python qui demande à l’utilisateur d’introduire un ensemble des
valeurs numériques puis calculer et afficher leur carré.
Le script s’arrête une fois l’utilisateur introduit la valeur 0.
Solution
N = int(input (″ Entrer une valeur :″))
while N != 0 :
Carre = N*N
print (f ″ le carré du nombre saisi est {Carre}″)
N = int(input (″ Entrer une valeur :″))
L’instruction break
L’instruction continue
Le mot-clé continue est utilisé pour terminer l'itération en cours dans une
boucle for (ou une boucle while), et passer à l'itération suivante.
Chapitre 2 : Fonctions
Définition
- Une fonction est un bloc d’instructions regroupées sous un même nom (le choix
du nom de la fonction doit répondre aux mêmes contraintes pour choisir un identificateur
d’une donnée).
- Une fonction peut avoir des paramètres/arguments
- Une fonction peut renvoyer une valeur avec le mot clé return
- Pour exécuter le code d’une fonction, il suffit d’écrire son nom avec ses paramètres
( dans le cas d’une fonction ayant des paramètres)
Chapitre 2 : Fonctions
Exemple 1
def afficher_numeros () :
n=int(input("entrer le nombre des valeurs à afficher : "))
for i in range(n) :
print(i)
afficher_numeros () # appel de la fonction afficher_numeros ()
Résultat d’exécution
Entrer le nombre des valeurs à afficher : 6
0
1
2
3
4
5
Chapitre 2 : Fonctions
Exemple 2
Résultat d’exécution
Entrer le nombre des valeurs à afficher : 6
0
1
2
3
4
5
Chapitre 2 : Fonctions
Exemple 3
def afficher_numeros (n =3 ) :
for i in range(n) :
print(i)
N=4
afficher_numeros (N) # appel de la fonction avec un paramètre
afficher_numeros () # appel de la fonction sans paramètre permet de prendre la valeur par défaut
Résultat d’exécution
0
1
2
3
0
1
2
Chapitre 2 : Fonctions
Exemple 4
Résultat d’exécution
12
10
La somme des deux valeurs est : 22
Chapitre 2 : Fonctions
Exemple 5
Résultat d’exécution
12
10
La somme des deux valeurs est : 22
Chapitre 2 : Fonctions
Chapitre 2 : Fonctions
Chapitre 2 : Modules
Définition
• Un projet Python est généralement composé de plusieurs fichiers sources ayant l’extension .py,
• Un module est un fichier script Python permettant de définir des éléments de programme
réutilisables dans d’autres scripts python. Ce mécanisme permet d’élaborer efficacement des
bibliothèques de fonctions ou de classes.
• L’utilisation des modules peut avoir plusieurs avantages à savoir :
- La réutilisation du code ;
- La possibilité d’intégrer la documentation et les tests au module ;
- La réalisation de services ou de données partagés ;
Chapitre 2 : Modules
Exemples
import math import math as mt from math import *
x=int(input(" x= ") x=int(input(" x= " ) x=int(input(" x= " )
print(" RC= " , [Link](x)) print(" RC= " , [Link](x)) y=int(input(" y= " )
print(" le pgcd des deux valeurs est :",
gcd(x, y)
Chapitre 2 : Modules
Module [Link]
def addition (x, y) : Script principal
return (x+y)
from calcul import *
Exercices : Série N1
Définition
- Les opérateurs mathématiques qui peuvent être appliqués sur une chaine de
caractères sont : * et +
- Pour la comparaison des chaines de caractères, on utilise les opérateurs : ==, != ,
<,>
Exemple
ch1 = "salut "
ch2 = "les programmeurs"
ch3 = ch1 + ch2
print (ch3) # permet d’afficher le texte : salut les programmeurs
ch4 = ch1*3
print (ch4) # permet d’afficher le texte : salut salut salut
print (ch1 == ch2 ) # renvoie la valeur False
print (ch1 > ch2 ) # renvoie la valeur True
Exemple
ch3 = "salut les programmeurs"
print (ch3[1] ) # permet d’afficher le caractère ‘a’
print (ch3[-5] ) # permet d’afficher le caractère ‘m’
print (ch3[: 5] ) # permet d’afficher les caractères ayant indice de 0 à 4 : ‘salut’
print (ch3[10:17] ) # permet d’afficher les caractères ayant indice de 10 à 16: ‘program’
print (ch3[-12:] ) # permet d’afficher les caractères ayant indice de -1 à -12 : ‘programmeurs’
Exemple
ch1 = ""
ch2 = "salut les programmeurs"
L1=len(ch1)
L2=len(ch2)
print (L1) # permet d’afficher la valeur 0
print (L2) # permet d’afficher la valeur 22
print(bool(ch1)) # permet d’afficher False
- Une méthode est une fonction associée à un type de données : str, int, float, etc.
- Pour afficher la liste des méthodes associées au type str
• print(dir(str)) ou bien print(dir("")
Exemple
print(dir(str)
[‘__add__’, '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__',
'__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format',
'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric',
'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix',
'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip',
'swapcase', 'title', 'translate', 'upper', 'zfill']
- La fonction startwith() est une fonction qui permet de vérifier si une chaine de
caractère commence par un ou plusieurs caractères, la méthode renvoie une
valeur de type booléen : True ou False.
- La fonction endswith() est une fonction qui permet de vérifier si une chaine de
caractère se termine par un ou plusieurs caractères, la méthode renvoie une valeur
de type booléen : True ou False.
Exemple
chaîne = "234567891"
if chaî[Link] ("2345") :
print("ok") # permet d’afficher ok
if chaî[Link] ("91") :
print("ok") # permet d’afficher ok
Exemple
chaine1 = "Coucou tout le monde"
print([Link]("t")) # permet d’afficher 7
print([Link]("u", 7, 19)) # permet d’afficher 9
print([Link]("o") # permet d’afficher 16
print([Link]("o", 7, 19) # permet d’afficher 16
La méthode : count ()
Exemple
chaine1 = "Coucou tout le monde"
chaine2 = "ou"
print([Link](chaine2)) # permet d’afficher 3
print([Link]("o", 3, 10)) # permet d’afficher 2
Exemple
chaine1 = "Salut tout le monde tout le monde"
chaine2 = "tout"
print([Link](chaine2)) # permet d’afficher 6
print([Link](chaine2)) # permet d’afficher 20
La méthode : replace ()
- La méthode replace() permet de remplacer des caractères d’une chaine par d’autres.
- La méthode replace(Ancienne, Nouvelle, nombre) prend trois paramètres:
- Ancienne(Obligatoire) : La chaîne à rechercher
- Nouvelle(Obligatoire) : La nouvelle chaîne par laquelle remplacer l’ancienne chaîne
- Nombre (Optionnel) : Un nombre spécifiant le nombre d’occurrences de l’ancienne chaîne souhaitant
remplacer. La valeur par défaut est toutes les occurrences
- La méthode replace() renvoie une copie de la chaîne dans laquelle l’ancienne chaîne est
remplacée par la nouvelle chaîne. La chaîne d’origine ne change pas.
- Si l’ancienne chaîne n’est pas trouvée, la méthode replace () renvoie la copie de la chaîne
d’origine.
Exemple
chaine1 = "Salut tout le monde"
chaine2="Bonjour"
print([Link]("Salut", chaine2)) # permet d’afficher ‘Bonjour tout le monde’
Exemple
string = "CE MATIN il fait beau"
print([Link]()) #permet d’afficher ‘CE MATIN IL FAIT BEAU ‘
string = "CE MATIN il fait beau"
print([Link]()) #permet d’afficher ‘ce matin il fait beau’
string = "ce mAtin IL Fait beau"
print([Link]()) #permet d’afficher ‘CE MaTIN il fAIT BEAU’
string = "ce matin il fait beau"
print([Link]()) #permet d’afficher ‘Ce matin il fait beau’
Exemple
chaine1 = " c’est un test pour la méthode strip "
print([Link]()) #permet d’afficher : c’est un test pour la méthode strip
chaine2 = "c’est un test pour la méthode rstrip :?!}#"
print([Link](":#?!}")) #permet d’afficher : c’est un test pour la méthode rstrip
chaine3 = "c’est un test pour la méthode rstrip"
print([Link]("c'est ")) #permet d’afficher : un test pour la méthode lstrip
Exercices : Série N2
Exemple
Liste_1 = [] # permet de définir une liste vide
Liste_2 = [1, 2, 3, 4] # permet de définir une liste des entiers
Liste_3 = ["A", "B", "C"] # permet de définir une liste de caractères
Liste_4 = ["Lundi", "Mardi", "Mercredi", "Jeudi"] # permet de définir une liste de jours
Liste_5 = ["Lundi", "M", 3, 4.5, "?"] # permet de définir une liste hétérogène
Exemple
Liste_1 = [13, 11] # permet de définir une liste des entiers
Liste_2 = ["A", "B", "C"] # permet de définir une liste de caractères
Liste_3 = Liste_1+Liste_2
print (Liste_3) # permet d’afficher : [13, 11,"A", "B", "C"]
Liste_3=Liste_3*2
print (Liste_3) # permet d’afficher : [13, 11, 'A', 'B', 'C', 13, 11, 'A', 'B', 'C']
▪ La fonction list() permet de convertir un ensemble des valeurs (string, tuple, set,
dictionnaire) vers une liste.
Exemple
Liste_1 = list(range (5)) # permet de définir une liste des entiers allant de 0 à 4
print (Liste_1) # permet d’afficher la liste : [0, 1, 2, 3, 4]
L=list("Bonjour")
print(type(L)) # permet d’afficher le type de L : <class 'list'>
print(L) # permet d’afficher la liste : ['B', 'o', 'n', 'j', 'o', 'u', 'r']
Exemple
chaine = "exemple de la fonction split" # permet de définir une chaine de caractères
L1 = [Link] ()
print(L1) # permet d’afficher la liste : [‘exemple', 'de', 'la', 'fonction', ‘split']
L2 = [Link] (" ", 2)
print(L2) # permet d’afficher la liste : ['exemple', 'de', 'la fonction split’]
▪ La méthode join() permet de créer des chaînes à partir d’un ensemble d’éléments
(liste, tuple, dictionnaire, etc…) en utilisant un séparateur de chaîne.
▪ La méthode join() prend un seul paramètre qui est l’ensemble d’éléments à
concaténer, et renvoie la chaîne concaténée.
Exemple
Liste = ["B", "O", "N", "J", "O", "U", "R"] # permet de définir une liste
chaine_1 = "/".join(Liste)
print(chaine_1) # permet d’afficher la chaine : ‘B/O/N/J/O/U/R’
chaine_2 = "".join(Liste)
print(chaine_2) # permet d’afficher la chaine : BONJOUR
Exemple
Liste = ["Lundi", "Mardi", "Mercredi", "Jeudi" ]
print (Liste [1] ) # permet d’afficher la valeur : Mardi
print (Liste [-2] ) # permet d’afficher la valeur : Mercredi
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print (x[:]) # permet d’afficher : [0 1 2 3 4 5 6 7 8 9]
print (x[::2]) # permet d’afficher : [0 2 4 6 8]
print (x[1:6:3]) # permet d’afficher : [1 4 ]
print (x[1:-1]) # permet d’afficher : [1 2 3 4 5 6 7 8]
▪ Pour parcourir une liste, il est possible d’utiliser la boucle for selon la syntaxe
suivante :
for nom_variable in nom_liste :
Instruction_1
…
Instruction_n
Exemple
Liste = ["Lundi", "Mardi", "Mercredi", "Jeudi"] Résultat d’exécution
for i in Liste :
Lundi
print (i)
Mardi
Mercredi
Jeudi
▪ La méthode enumerate() permet d’afficher les éléments d’une liste associés à des
index.
Exemple
Résultat d’exécution
Liste_1 = ["Lundi", "Mardi", "Mercredi", "Jeudi"]
for i, x in enumerate(Liste_1) : 0 Lundi
print (i, x) 1 Mardi
2 Mercredi
3 Jeudi
▪ La méthode zip() permet de lier les éléments d’une liste avec une deuxième liste ou
plus.
Exemple
Liste_1 = ["Lundi", "Mardi", "Mercredi", "Jeudi"] Résultat d’exécution
Liste_2 = [1, 2, 3, 4] Lundi 1
for i, x in zip(Liste_1, Liste_2) : Mardi 2
print (i, x) Mercredi 3
Jeudi 4
▪ La fonction len() permet de calculer la longueur d’une liste (le nombre d’éléments
d’une liste)
▪ La fonction count() permet de compter le nombre d’occurrence d’une valeur dans
une liste.
▪ La fonction clear() permet de supprimer tous les éléments d’une liste. Elle permet
de renvoyer une liste vide.
Exemple
L = ["Lundi", "Mardi", "Mercredi", "Jeudi" ]
print (len(L) ) # permet d’afficher la valeur : 4
print ([Link]("Lundi") ) # permet d’afficher la valeur : 1
[Link]() # permet de supprimer tous les éléments d’une liste
Exemple
L = [1, 2, 3, 4, 5, 6, 7, 8, 9]
[Link](5) # permet de supprimer l’élément 5 de la liste L
print (L) # permet d’afficher : [1, 2, 3, 4, 6, 7, 8, 9]
[Link](3) # permet de supprimer l’élément ayant l’indice 3 à partir de la liste L
print (L) # permet d’afficher : [1, 2, 3, 6, 7, 8, 9]
del L[5] # permet de supprimer l’élément ayant l’indice 5 à partir de la liste L
del L[1:4] # permet de supprimer les éléments ayant les indices : 1, 2, 3 à partir de la liste L
print (L) # permet d’afficher : [1, 7, 9]
Exemple
L = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print (max(L)) # permet d’afficher : 9
print (min(L)) # permet d’afficher : 1
print (sum(L)) # permet d’afficher : 45
Exemple
L = [1, 2, 3, 4, 5, 6, 7, 8, 9]
[Link](10)
print (L) # permet d’afficher : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[Link](4, 101)
print (L) # permet d’afficher : [1, 2, 3, 4, 101, 5, 6, 7, 8, 9, 10]
[Link] ([10, 11, 12])
print (L) # permet d’afficher : [1, 2, 3, 4, 101, 5, 6, 7, 8, 9, 10, 10, 11, 12]
▪ La fonction sort() permet de trier une liste selon un ordre croissant ou décroissant sans
renvoyer une nouvelle liste, les modifications sont appliquées sur la liste d’origine.
▪ Les listes contenant des chaines de caractères sont triées selon l’ordre alphabétique.
▪ Pour spécifier le type de tri à appliquer (croissant ou décroissant), la méthode est utilisée avec
un paramètre appelé reverse de type bool, sa valeur par défaut : False.
reverse= True ( Trie décroissant), reverse = False (Trie croissant)
Exemple
L = [11, 2, 43, 114, 25, 6, 27, 18, 19]
[Link](reverse=True)
print (L) # permet d’afficher :[114, 43, 27, 25, 19, 18, 11, 6, 2]
Exemple
L = ["S", "B", "A", "E", "AU", "ET"]
[Link]()
print (L) # permet d’afficher : ['ET', 'AU', 'E', 'A', 'B', ’S’]
print ([Link]("E")) # permet d’afficher : 2
▪ Une liste d’une liste est un ensemble d’éléments dont chaque élément est une
liste.
▪ Pour définir une liste, on utilise la syntaxe suivante :
nom_liste = [[element_1, element_2, …, element_n], [element_1, element_2, …,
element_n], …, [element_1, element_2, …, element_n]]
Exemple
Liste=[[12,"Janvier", 2000], [2,"Mai", 2005], [22,"Mars", 1999], [11,"Juin", 2002]]
print (Liste) # permet d’afficher : [[12, 'Janvier', 2000], [2, 'Mai', 2005], [22, 'Mars', 1999], [11, 'Juin',
2002]]
print(Liste[2]) # permet d’afficher : [22, 'Mars', 1999]
print(Liste[1][2]) # permet d’afficher : 2005
print(Liste[:][1]) # permet d’afficher : [2, 'Mai', 2005]
Compréhension de liste
▪ Il s’agit d’une méthode simplifiée de créations de listes dans le but d’optimiser les programmes
en python.
▪ Syntaxe générale :
nom_liste = [fonction(element) for element in nom_liste if condition]
Exemple 1 Exemple 2
liste_1=[1, 2, 3, 4, 5] L1=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
liste_2=[] L2=[]
for x in liste_1 : for x in L1 :
liste_2.append(x*x) if x%2==0 :
print (liste_2) # permet d’afficher : [1, 4, 9, 16, 25] [Link](x)
print (L2) # permet d’afficher : [2, 4, 6, 8, 10]
Equivalent à :
Equivalent à :
liste_1=[1, 2, 3, 4, 5]
liste_2=[x*x for x in liste_1] L1=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
L2=[x for x in L1 if x%2==0]
Exercice d’application
On considère une liste L contenant les notes d’un groupe d’étudiants inscrits dans une formation
donnée.
Écrire un script python qui permet de faire un ensemble de traitements selon un menu affiché à
l’utilisateur. L’utilisateur quitte l’exécution du programme lorsqu’il choisit la valeur 11.
Le menu contient les éléments suivants :
1. Ajouter une note
2. Afficher la liste des notes des étudiants
3. Inverses la liste des notes des étudiants
4. Rechercher une note
5. Afficher la note maximale
6. Afficher la note minimale
7. Afficher la note moyenne du groupe
8. Trier la liste des notes d’une manière décroissante
9. Supprimer une note
[Link] toutes les notes
[Link] l’exécution du programme
Exemple
tuple_1 = () # permet de définir un tuple vide
tuple_2 = (1, 2, 3, 4) # permet de définir un tuple des entiers
print(tuple_2) # permet d’afficher : (1, 2, 3, 4)
tuple_3 = 1, 2, 3, 4 # permet de définir un tuple des entiers
tuple_4 = ("Lundi", 22, "Janvier", 2000) # permet de définir un tuple
print(tuple_4) # permet d’afficher : ("Lundi", 22, "Janvier", 2000)
▪ Toutes les opérations appliquées sur les listes sont applicables sur les tuples : +, *
▪ Les méthodes utilisées pour manipuler les listes sont utilisées également avec les
tuples à condition qu’elles modifient pas les éléments du tuple (car un tuple est
une séquence immuable)
▪ Exemples des méthodes qui ne sont pas utilisées avec les tuples : remove(), del,
pop(), sort(), insert(), append, extend(), clear(), reverse(), etc.
Exemple
tuple1, tuple2 = ("a","b"), ("c","d","e")
tuple3 = tuple1*4 + tuple2
print(tuple3) # permet d’afficher : (‘a’, 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'c', 'd', ‘e')
for x in tuple3 :
print(x, end="-") # permet d’afficher : a-b-a-b-a-b-a-b-c-d-e-
La méthode tuple()
▪ La méthode tuple() est utilisée afin de convertir une liste ou une chaine de
caractères vers le type tuple
▪ La syntaxe utilisée est la suivante :
nom_tuple= tuple (nom_chaine)
nom_tuple=tuple(nom_liste)
Exemple
Liste_1 = [13, "B", 16.5, "AU", "et"]
Chaine_1 = "Bonjour"
tuple_1=tuple(Liste_1)
print(tuple_1) # permet d’afficher : (13, 'B', 16.5, 'AU', ‘et')
tuple_2=tuple(Chaine_1)
print(tuple_2) # permet d’afficher : (‘B’, ‘o', 'n', 'j', 'o', 'u', 'r')
Chapitre 3 : le dictionnaire
Exemple
dico_1 = {}# permet de définir un dictionnaire vide
dico_2 = {1: "un", 2: "deux", 3: "trois", 4: "quatre"} # permet de définir un dictionnaire
print(dico_2) # permet d’afficher : {1: 'un', 2: 'deux', 3: 'trois', 4: ‘quatre'}
dico_2[5] = "cinq" # permet d’ajouter l’élément 5 : "cinq" au dictionnaire dico_2
print(dico_2) # permet d’afficher : {1: 'un', 2: 'deux', 3: 'trois', 4: ‘quatre’, 5:’cinq’}
Chapitre 3 : le dictionnaire
Manipulation de dictionnaires
▪ Pour afficher les éléments d’un dictionnaire, trois méthodes sont utilisées :
items(), keys() et values().
▪ La méthode items() permet d’afficher les éléments d’un dictionnaire.
▪ La méthode keyes() permet d’afficher les clés d’un dictionnaire
▪ La méthode values() permet d’afficher les valeurs d’un dictionnaire
Exemple
dico = {1: "un", 2: "deux", 3: "trois", 4: "quatre"} # permet de définir un dictionnaire
print(dico) # permet d’afficher : {1: 'un', 2: 'deux', 3: 'trois', 4: ‘quatre'}
print([Link]()) # permet d’afficher : dict_items([(1, 'un'), (2, 'deux'), (3, 'trois'), (4, 'quatre')])
print([Link]()) # permet d’afficher : dict_keys([1, 2, 3, 4])
print([Link]()) # permet d’afficher : dict_values(['un', 'deux', 'trois', 'quatre'])
Chapitre 3 : le dictionnaire
Parcourir un dictionnaire
Exemple 3
Exemple 1
dico = {1: "un", 2: "deux", 3: "trois"}
dico = {1: "un", 2: "deux", 3: "trois"} for x in [Link] :
for x, y in [Link]() : print(x)
print(x, y)
un
1 un
deux
2 deux
trois
3 trois
Exemple 2
dico = {1: "un", 2: "deux", 3: "trois"}
for x in [Link] :
print(x)
1
2
3
Chapitre 3 : le dictionnaire
La méthode dict()
Exemple
D0=dict() # permet de définir un dictionnaire vide
L=[[1, "Janvier"], [2, "Février"], [3, "Mars"]]
T=((4, "Avril"), (5, "Mai"), (6, "Juin"))
D1=dict(L)
D2=dict(T)
print(D1) # permet d’afficher : {1: 'Janvier', 2: 'Février', 3: 'Mars'}
print(D2) # permet d’afficher : {4: 'Avril', 5: 'Mai', 6: 'Juin'}
Chapitre 3 : le dictionnaire
La méthode get()
▪ La méthode get() renvoie la valeur de la clé donnée si elle est présente dans le
dictionnaire. Sinon, il renverra None (si get() est utilisé avec un seul argument).
▪ La méthode get utilise la syntaxe suivante avec deux paramètres :
nom_dictionnaire.get(clef, valeur_renvoyée)
- Clef : le nom de clé de l’élément à renvoyer sa valeur
- Valeur_renvoyée : (facultatif) valeur à renvoyer si la clé n’est pas trouvée. La valeur par
défaut est None.
Exemple
dico = {1: "un", 2: "deux", 3: "trois", 4: "quatre"} # permet de définir un dictionnaire
print([Link](2)) # permet d’afficher : deux
print([Link](5,"Element introuvable")) # permet d’afficher : Element Introuvable
Chapitre 3 : le dictionnaire
La méthode pop()
Exemple
dico = {1: "un", 2: "deux", 3: "trois", 4: "quatre"} # permet de définir un dictionnaire
print([Link](2)) # permet d’afficher : deux
print([Link](5)) # permet d’afficher : None
print(dico) # permet d’afficher : {1: 'un', 3: 'trois', 4: ‘quatre'}
Chapitre 3 : le dictionnaire
Exercice d’application
Chapitre 3 : le dictionnaire
Solution
# Question 1 print("Les étudiants qui ont validé le module : ", V)
Notes={} print("Les étudiants qui n’ont pas validé le module : ", NV)
N=int(input("Nombre des étudiants : "))
for i in range (N) : # Question 4
print("Etudiant " , i+1) def max_notes(dict_notes):
nom=input("Nom = ") L=[]
note=float(input("Note = ")) for a,b in dict_notes.items() :
Notes[nom]=note if b==max(dict_notes.values()) :
# Question 2 [Link](a)
print("Liste des étudiants par ordre alphabétique : ") return L
for x in sorted([Link]()): print("Les étudiants ayant la note maximale sont : ")
print(x, Notes[x]) print(max_notes(Notes))
# Question 3
V={}
NV={}
for x,y in [Link]():
if y>=10:
V[x]=y
else :
NV[x]=y
Chapitre 3 : le dictionnaire
▪ Les valeurs d’un dictionnaire peuvent être des valeurs simples pour chaque clef ou
bien une structure de données (liste, tuple ou même un dictionnaire)
▪ La syntaxe utilisée pour créer un dictionnaire d’une structure de données
Exemple
dico_1 = {"Hiver": ["Décembre", "Janvier", "Février" ], "Printemps": ["Mars", "Avril", "Mai" ]}
dico_2={"Eté": ["Juin", "Juillet", "Août" ], "Automne": ["Septembre", "Octobre", "Novembre" ]}
dico_3={1: dico_1, 2 : dico_2}
print(dico_3)
""" permet d’afficher {1: {'Hiver': ['Décembre', 'Janvier', 'Février'], 'Printemps': ['Mars', 'Avril', 'Mai']}, 2: {'Eté': ['Juin',
'Juillet', 'Aôut'], 'Automne': ['Septembre', 'Octobre', ‘Novembre']}} """
Chapitre 3 : le dictionnaire
Exercice d’application
▪ Ecrire un script python qui permet de saisir N valeurs numériques puis les
classer dans un dictionnaire contenant deux listes : une liste des valeurs positives
et une deuxième liste des valeurs négatives.
▪ Dictionnaire={
"valeurs positives": [],
"valeurs négatives": []
}
▪ Le script affiche un message approprié dans le cas d’une valeur nulle
Chapitre 3 : le dictionnaire
Solution
Nombres={
"Positif" : [],
"Négatif" : []
}
N=int(input("Entrer le nombre des valeurs à classer : "))
for i in range(N) :
n=int(input ("entrer un nombre : "))
if n>0 :
Nombres["Positif"].append(n)
elif n<0 :
Nombres["Négatif"].append(n)
else :
print("Vous avez tapé une valeur nulle ")
print(Nombres)
Exercices : Série N3
Définition
Afin de vérifier l’existence d’un fichier ou non, on peut utiliser la fonction exists()
du module path qui appartient au module Python standard os.
Cette fonction renvoie :
• True si le chemin du fichier passé est un chemin qui existe
• False si le chemin n’existe pas.
Exemple
import os
if [Link]("/Users/sanakh/Desktop/exemples programmes python/[Link]")== True :
print("Le fichier existe")
else :
print("Le fichier n'existe pas ")
Exemple
import os
print([Link]()) # permet d'afficher : /Users/sanakh
[Link]("/Users/sanakh/Desktop/exemples programmes python")
print([Link]()) # permet d'afficher : /Users/sanakh/Desktop/exemples programmes python
Supprimer un fichier
Exemple
import os
if [Link]("/Users/sanakh/Desktop/exemples programmes python/[Link]") :
[Link]("/Users/sanakh/Desktop/exemples programmes python/[Link]")
print("Fichier supprimé avec succès ")
else :
print("Le fichier à supprimer n'existe pas ")
Mode Description
Exemple
id_fichier=open("/Users/sanakh/Desktop/exemples programmes python/[Link]", "r")
print (id_fichier)
""" Permet d’afficher <_io.TextIOWrapper name='/Users/sanakh/Desktop/exemples programmes python/
[Link]' mode='r' encoding=‘UTF-8'> « ""
id_fichier.close() # permet de fermer le fichier identifié par son descripteur id_fichier
Ouverture d’ un fichier
• Afin d’ouvrir un fichier, on peut utiliser la fonction open() associé avec le mot with
• La méthode open() utilise deux arguments : le chemin du ficher à ouvrir et le mode
d’ouverture
with open("nom_fichier", "mode_ouverture") as descripteur_fichier :
Avec :
nom_ fichier : une chaine de caractère constante ou bien une variable de type string
mode_ouverture : un paramètre servant à déterminer le mode d’ouverture de fichier
Exemple
with open("/Users/sanakh/Desktop/exemples programmes python/[Link]", "a") as d_fichier :
print (d_fichier) # permet d’afficher les informations sur le fichier identifié par d_fichier
Exemple
id_fichier=open("/Users/sanakh/Desktop/exemples programmes python/[Link]", "r")
for x in id_fichier :
print (x) # permet d’afficher le contenu du fichier [Link]
id_fichier.close()
Exemple
id_fichier=open("/Users/sanakh/Desktop/exemples programmes python/[Link]", "r")
print (id_fichier.read()) # permet d’afficher le contenu du fichier [Link]
id_fichier.close()
Résultat d’exécution
a=int(input("a="))
b=int(input("b="))
print(f"la somme de {a} et {b} est : {a+b} ")
Exemple
id_fichier=open("/Users/sanakh/Desktop/exemples programmes python/[Link] », "r")
Liste_1= id_fichier.readlines()
print (Liste_1)
# permet d’afficher : ['Lundi 28 Novembre 2022\n', 'Mardi 29 Novembre 2022\n', 'Mercredi 30 Novembre 2022\n',
'Jeudi 01 Décembre 2022\n', 'Vendredi 02 Décembre 2022\n', 'Samedi 03 Décembre 2022\n', 'Dimanche 04
Décembre']
id_fichier.close()
Exemple
id_fichier=open("/Users/sanakh/Desktop/exemples programmes python/[Link] ", "w")
v=id_fichier.write("c’est un texte à ajouter dans le fichier texte")
print (f"le nombre de caractères ajoutés au ficher est {v}")
id_fichier.close()
Exemple
import o
x=[Link]("exemple_ [Link]"
print("le chier que vous avez choisi est de taille ", x, "octets")
fi
fi
)
……..
La fonction array()
Exemple
from numpy import *
T1 = array ([1, 2, 3, 4, 5]) # permet de définir un tableau d’une seule dimension
print (T1) # permet d’afficher : [1 2 3 4 5]
print (type(T1)) # permet d’afficher <class ‘[Link]’>
T2= array ([[1, 2] , [ 3, 4]]) # permet de définir un tableau de deux dimensions
print (T2)
« "" permet d’afficher :
[1 2],
[ 3 4]
"""
La fonction arange()
Exemple
from numpy import *
T1 = arange (6) # permet de définir un tableau d’une seule dimension composé des valeurs 0, 1, 2, 3, 4 et 5
print (T1) # permet d’afficher : [0 1 2 3 4 5]
T2= arange (2, 10, 2)
print (T2) # permet d’afficher : [2 4 6 8]
print (type(T2)) # permet d’afficher : <class ‘[Link]'>
La fonction linspace()
Exemple
from numpy import *
T1 = linspace (1,6, 4) # permet de définir un tableau d’une seule dimension
print (T1) # permet d’afficher : [1. 2.66666667 4.33333333 6. ]
La fonction randn()
Exemple
from numpy import *
T1 = [Link] (2, 3) # permet de définir un tableau de 2 linges et 3 colonnes
print (T1)
"""permet d’afficher :
[[ 1.09666015 -1.46504893 1.73101646]
[-0.6840089 0.2359427 0.36864442]]"""
La fonction randint()
Exemple
from numpy import *
T1 = [Link] (1, 10, (2,6)) # permet de définir un tableau de 2 linges et 6 colonnes
print (T1)
"""permet d’afficher :
[[5 8 4 6 2 2]
[9 9 1 8 9 9]]"""
Exemple
from numpy import *
T1 = ones ((2, 3)) # permet de définir un tableau de 2 linges et 3 colonnes rempli par la valeur 1
T2 = zéros ((3, 5)) # permet de définir un tableau de 3 linges et 5 colonnes rempli par la valeur 0
T3 = full ((2, 3), 12) # permet de définir un tableau de 2 linges et 3 colonnes rempli par la valeur 12
Exemple
from numpy import *
T1 = array ([1, 2, 3, 4, 5]) 1 2 3 ndim(T2) = 2
T2= array ([[1, 2, 3] , [ 4, 5, 6]]) 4 5 6 shape(T2) = (2,3)
print(ndim(T1))# permet d’afficher 1 size(T2) = 6
T2
print(ndim(T2))# permet d’afficher 2
print(size(T2))# permet d’afficher 6
print (shape(T2)) # permet d’afficher : (2, 3) ndim(T1) = 1
1 2 3 4 5 shape(T1) = (1,)
print ([Link][0]) # permet d’afficher 2
print ([Link][1]) # permet d’afficher 3 T1 size(T1) = 5
Exercice d’application 1
• Ecrire un script qui permet de créer puis afficher les éléments d’un tableau rempli
par des valeurs aléatoires de type int.
- Les valeurs maximale et minimale du tableau ainsi que le nombre de lignes et de colonnes
sont déterminés par l’utilisateur.
Solution
from numpy import * v_min=int(input("Entrer la valeur minimale : "))
def afficher_tableau(Tab) : v_max=int(input("Entrer la valeur maximale : "))
for i in range([Link][0]) : n_lig=int(input("Entrer le nombre de lignes : "))
for j in range([Link][1]) : n_col=int(input("Entrer le nombre de colonnes : "))
print(Tab[i,j], end = " ") T=[Link](v_min, v_max, (n_lig, n_col))
print("") afficher_tableau(T)
Exemple
from numpy import *
T1 = array ([1, 2, 3, 4, 5]) # permet de définir un tableau d’une seule dimension
print (T1[1], T1[-2]) # permet d’afficher : 2 4
T2= array ([[1, 2, 3] , [ 4, 5, 6]]) # permet de définir un tableau de deux dimensions
print (T2[1, 1]) # permet d’afficher : 5
print (T2[0][2]) # permet d’afficher : 3
• La méthode de slicing est une méthode d’extraction d’une une tranche d’éléments à partir
d’un tableau
• La méthode de slicing appliquée pour un tableau est différente à celle appliquée aux listes et
aux chaines de caractères.
• La syntaxe générale utilisée est la suivante :
nom_tableau [début_l : fin_l , début_f : fin_f, pas ]
Exemple
from numpy import * 1 2 3 4 1 2 3 4
T= array ([[1, 2, 3, 4] , [ 5, 6, 7, 8], [ 9, 10, 11, 12]])
T1=T[1:2, 1:3] 5 6 7 8 5 6 7 8
T2= T[:, 2:] 9 10 11 12 9 10 11 12
T1 T2
La fonction append()
• La fonction append(…) permet d’ajouter des éléments à la fin d’un tableau en renvoyant une
copie de ce tableau.
• La fonction append(…) utilise un argument appelé axis qui prend soit la valeur 1 ou 0.
- axis =0 : pour ajouter une ligne
- axis =1 : pour ajouter une colonne
Exemple 1 Exemple 2
from numpy import * from numpy import *
T1 = ones((2,5)) T1 = ones((3,5))
T2=append(T1,[[1,2,3,4,5]], axis=0) T3=append(T2,[[1],[2],[3]], axis=1)
print(T2) print(T3)
1 1 1 1 1 1 1 1 1 1 1
T2 1 1 1 1 1 T3 1 1 1 1 1 2
1 2 3 4 5 1 1 1 1 1 3
La fonction insert()
• La fonction insert(…) permet d’insérer des éléments à une position donnée. La fonction
renvoie une copie du tableau.
• La fonction insert(nom_tableau, indice_position, valeur_insérer, axis) utilise un
argument appelé axis qui prend soit la valeur 1 ou 0.
- indice_position : l’indice de la position
- valeur_insérer : les valeurs à insérer dans le tableau
- axis =0 : pour insérer une ligne
- axis =1 : pour insérer une colonne
Exemple
from numpy import * 1 2 3 4
T= array ([[1, 2, 3, 4] , [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) T1 5 6 7 8
print(T) 1 1 1 1
T1=insert(T, 2, [1, 1, 1, 1], axis=0)
9 10 11 12
print(T1)
La fonction delete()
• La fonction delete(…) permet de supprimer des éléments à partir d’un tableau (lignes ou
colonnes) en renvoyant une copie du tableau.
• La fonction delete(nom_tableau, objet, axis) utilise trois arguments :
- objet : les indices des éléments à supprimer
- axis : indicateur pour préciser l’élément à supprimer.
- axis = 0 : pour supprimer une ligne
- axis = 1 : pour supprimer une colonne
Exemple
from numpy import *
1 3
T= array ([[1, 2, 3, 4] , [ 5, 6, 7, 8], [ 9, 10, 11, 12]])
5 7
T1=delete(T, [1, 3], axis=1) # permet de supprimer les colonnes ayant les indices 1 et 3
9 11
print(T1)
T1
• C’est possible d’appliquer les opérateurs mathématiques suivants sur les tableaux : +, -, *,
**, /, //, %
• Les dimensions des tableaux doivent être égales.
Exemple
from numpy import *
T1 = full((2, 4), 3) # permet de définir un tableau de 2 lignes et 4 colonnes rempli par 3
T2= ones((2, 4)) # permet de définir un tableau de 2 lignes et 4 colonnes rempli par 1
T3=T1+T2
print (T3)
"""permet d’afficher
[4. 4. 4. 4.]
[4. 4. 4. 4.]] """
Exemple
from numpy import *
T1 = [Link](1, 10, (4,5)) 3 3 4 1 7 [Link]()=102
print ([Link]()) [Link]()=5204415283200
7 8 7 7 1
print ([Link]()) [Link]()= 8
5 7 8 2 6
print ([Link]()) [Link]()=1
8 2 5 7 4
print ([Link]()) [Link]()=5.1
print ([Link]()) T1
Exercice d’application 2
• Ecrire un script python qui permet de créer un tableau T, de shape (n, m).
• Le script contient les fonctions suivantes :
- Une fonction somme() qui permet de calculer la somme des éléments de chaque ligne du
tableau T.
- Ecrire une fonction produit() qui permet de calculer le produit des éléments de chaque
colonne du tableau T
- Ecrire une fonction maximum() qui permet de chercher et afficher la valeur maximale
de chaque ligne du tableau T.
- Ecrire une fonction minimum() qui permet de chercher et afficher la valeur minimale de
chaque colonne du tableau T.
Exemple
from numpy import *
T=array([[1.24, 2.3, 16, 4, 5],[124, 12.3, 18, 2, 6], [24, 12, 19, 7, 3]])
T1=[Link](axis=0)
print(T1) axis = 1
T1 149.24 26.6 53 13 14
T2=[Link](axis=1)
axis = 0
1.24 2.3 16 4 5
print(T2) T2 16 124 24
124 12.3 18 2 6
T3=[Link](axis=0) 24 12 19 7 3
print(T3) T3 1.24 2.3 16 2 3
T4=[Link](axis=1)) T
print(T4) T4 5.708 32.46 13
Exercice d’application 3
Ecrire un script python qui permet de créer un tableau T, de shape (n, m). Après le remplissage
du tableau T, le script calcule et affiche sa variance et son écart type.
• Pour calculer la variance d’un tableau.
Exemple
from numpy import * 2 19 2 7 [Link]() = 29.555555555555557
T= [Link](1, 20, (4,5)) 12 14 13 12
[Link]() =5.436502143433364
print ([Link]()) 14 7 18 16
print ([Link]())
T
La fonction sort()
• La méthode sort(…) permet de trier les éléments d’un tableau. Elle permet de
renvoyer une copie du tableau trié.
• En ajoutant le paramètre axis, ça permet de trier le tableau selon les lignes ou les
colonnes (axis=0 : trier les éléments de chaque colonne - axis =1 : trier les éléments de
chaque ligne)
Exemple
from numpy import * 14 8 2 15 5 4 2 5
T1= [Link](1, 20, (3,4)) T1 5 8 16 5 11 8 4 15 T2
print (T1) 11 4 4 19 14 8 16 19
T2=sort(T1, axis=0)
2 8 14 15
print (T2)
T3 5 5 8 15
T3=sort(T1, axis=1)
4 4 11 19
print (T3)
Exercice d’application 4
Ecrire un script python qui permet de créer un tableau M de shape (n, m). Après le
remplissage du tableau M par n x m valeurs aléatoires de type int, le script calcule et affiche
son transposé Tr.
Exemple
3 6 4 9 3 4 12
M 4 3 8 2 => 6 3 9 Tr(M)
12 9 7 5 4 8 7
9 2 5
Exemple
import numpy as np
T=[Link]([[3, 6, 4, 5],[4, 3, 8, 2], [12, 9, 7, 3]])
T1=[Link](T)
print(T2)
3 4 12
3 6 4 5 6 3 9
T 4 3 8 2 => 4 8 7 T1
12 9 7 3 5 2 3
La fonction concatenate()
La fonction concatenate()
import numpy as np 6 6 6 6 6 6 6 6
T1=[Link]((3,4),6) T1 6 6 6 6 6 6 6 6
T2=[Link]((2,4),2) 6 6 6 6 6 6 6 6
T3=[Link]((T1,T2), axis=0) =>
2 2 2 2
print(T3) 2 2 2 2
T2 2 2 2 2
2 2 2 2
T3
M1 M2 M3
Exercice d’application 5
Ecrire un script python qui permet de créer deux tableaux T1 de shape (n, p) et T2 de shape
(p, m) . Après le remplissage des deux tableaux T1 et T2, le script calcule et affiche le produit
matriciel de deux tableaux.
3 x 4 + 6 x 12 + 4 x 24 + 5 x 7 —> 215
3 6 4 5 4 2 215 165
12 18 258 140
4 3 8 2 x =>
24 9 345 258
12 9 7 3
7 3
T3
T1
T2
Exercice d’application 5
Ecrire un script python qui permet de créer deux tableaux T1 de shape (n, p) et T2 de shape
(p, m) . Après le remplissage des deux tableaux T1 et T2, le script calcule et affiche le produit
matriciel de deux tableaux.
3 x 2 + 6 x 18 + 4 x 9 + 5 x 3 —> 165
3 6 4 5 4 2 215 165
12 18 258 140
4 3 8 2 x =>
24 9 345 258
12 9 7 3
7 3
T3
T1
T2
Exercice d’application 5
Ecrire un script python qui permet de créer deux tableaux T1 de shape (n, p) et T2 de shape
(p, m) . Après le remplissage des deux tableaux T1 et T2, le script calcule et affiche le produit
matriciel de deux tableaux.
4 x 4 + 3 x 12 + 8 x 24 + 2 x 7 —> 258
3 6 4 5 4 2 215 165
12 18 258 140
4 3 8 2 x =>
24 9 345 258
12 9 7 3
7 3
T3
T1
T2
Exercice d’application 5
Ecrire un script python qui permet de créer deux tableaux T1 de shape (n, p) et T2 de shape
(p, m) . Après le remplissage des deux tableaux T1 et T2, le script calcule et affiche le produit
matriciel de deux tableaux.
4 x 2 + 3 x 18 + 8 x 9 + 2 x 3 —> 140
3 6 4 5 4 2 215 165
12 18 258 140
4 3 8 2 x =>
24 9 345 258
12 9 7 3
7 3
T3
T1
T2
Exercice d’application 5
Ecrire un script python qui permet de créer deux tableaux T1 de shape (n, p) et T2 de shape
(p, m) . Après le remplissage des deux tableaux T1 et T2, le script calcule et affiche le produit
matriciel de deux tableaux.
12 x 4 + 9 x 12 + 7 x 24 + 3 x 7 —> 345
3 6 4 5 4 2 215 165
12 18 258 140
4 3 8 2 x =>
24 9 345 258
12 9 7 3
7 3
T3
T1
T2
Exercice d’application 5
Ecrire un script python qui permet de créer deux tableaux T1 de shape (n, p) et T2 de shape
(p, m) . Après le remplissage des deux tableaux T1 et T2, le script calcule et affiche le produit
matriciel de deux tableaux.
12 x 2 + 9 x 18 + 7 x 9 + 3 x 3 —> 258
3 6 4 5 4 2 215 165
12 18 258 140
4 3 8 2 x =>
24 9 345 258
12 9 7 3
7 3
T3
T1
T2
Exemple
import numpy as np
T1=[Link]([[3, 6, 4, 5],[4, 3, 8, 2], [12, 9, 7, 3]])
T2=[Link]([[4, 2],[12,18], [24,9], [7, 3]])
T3=[Link]((T1,T2)
print(T3)
4 2 215 165
3 6 4 5
12 18
4 3 8 2 x => 258 140
12 9 7 3 24 9
7 3 345 258
T1
T2 T3
Exercice d’application 6
Ecrire un script python qui permet de créer un tableau T de shape (n, n). Après le remplissage
du tableau T par n x n valeurs aléatoires de type int, le script calcule et affiche son
déterminant D.
Exemple
3 6 4
3 8 4 8 4 3
T 4 3 8 => 3x - 6x - 4x
9 7 12 7 12 9
12 9 7
D = 3 x ( 3 x 7 - 8 x 9) - 6 x ( 4 x 7 - 12 x 8 ) - 4 x ( 4 x 9 - 12 x 3 )
D = 254.99999999999991
Exemple
import numpy as np
T=[Link]([[3, 6, 4],[4, 3, 8], [12, 9, 7]])
D=[Link](T)
print(D)
3 6 4
T 4 3 8 => Det (T) = 254.99999999999991
12 9 7
Exercices : Série N5
Définition
Exemples de graphiques
Méthode 1
Résultat affiché
Méthode 2
La méthode plot ()
Résultat affiché
Résultat affiché
Exercice 1
1) Afficher la courbe repr sentative entre [−4, 4] de la fonction f : x → cos(x) + 3 sin(2x)
2) Afficher la courbe repr sentative entre [−10, 10] de la fonction f : x → e−x2
3) Sur un meme graphique, afficher la courbe repr sentative entre [−10, 10] des deux fonctions :
f : x —> sin(x) et g : x —> x
Exercice 2
On considère le dictionnaire suivant :
La figure doit contenir 4 zones (chaque zone sera consacrée à un élément de dictionnaire dataset.
Résultat à afficher
Solution
Cas de classification
Méthode scatter ()
Représentation graphique 3D
Représentation graphique 3D
Exemple 2
Résultat affiché
Définition
Définition
Syntaxe générale
Exemple 0 1
import pandas as pd 0 12 14
import numpy as np data_1 1 10 13
# créer un DataFrame vide 2 11 15
data_vide=[Link]()
print(data_vide) Mois Temp
# créer un DataFrame à partir d'un tableau
Jour 1 Jan 14
T=[Link]([[12, 14],[10, 13],[11, 15]])
Jour 2 Fev 17
data_1=[Link](T)
Jour 3 Mars 21
print(data_1)
Jour 4 Avr 22
# créer un DataFrame à partir d'une liste de listes
L=[[‘Jan’, 14],['Fev', 17],['Mars', 21],['Avr', 22]] data_2
data_2=[Link](L, columns=['Mois','Temp'], index=['Jour1','Jour2','Jour3','Jour4'])
CNE Age
print(data_2)
Etu1 C1 20
# créer un DataFrame à partir d'un dictionnaire
D={‘CNE':['C1','C2','C3','C4'],'Age':[20, 22, 23, 18]} Etu2 C2 22
print(data_3) Etu4 C4 18
data_3
Exemple
Statistiques
Nombre des éléments, moyenne,
variance, valeur minimale,
valeur maximale
• Pour supprimer des colonnes ou des lignes à partir d’un DataFrame, on utilise la
méthode :
drop([liste_elements], axis = … , inplace = … )
Avec :
- liste_elements : il peut être les étiquettes des colonnes ou des lignes à supprimer
- axis : un argument qui spécifie l’element à supprimer : ligne ou colonne
✴ axis=0 : supprimer des lignes
✴ axis=1 : supprimer des colonnes
- inplace : un argument qui permet de specifier si les changements seront effectués sur le
DataFrame original ou bien sur sa copie.
✴ Inplace = True : les changements seront appliqués sur le DataFrame original
✴ Inplace = False : les changements seront appliqués sur une copie du DataFrame original
Exemple
Résultat d’exécution
Afin de gérer les valeurs manquantes d’un DataFrame, deux techniques sont utilisées :
Technique 1
• Supprimer les lignes contenant des valeurs manquantes par utilisation de la
méthode :
dropna(axis=0, inplace=True)
Technique 2
• Compléter la valeur manquante par une valeur par défaut (moyenne, médiane,
mode) en utilisant la méthode :
fillna(nom_data[‘nom_colonne’].mean(), inplace=True)
Exemple 1
Résultat d’exécution
Exemple 2
Apprentissage supervisé
▪ Trouver un modèle qui relie les variables d’entrée (Variables à expliquer) avec les variables de
sortie (Variables explicatives) à partir des exemples
▪ La classe des données d'entraînement est connue
▪ Toutes les données sont étiquetées
▪ L’objectif de l’apprentissage supervisé est prédictif ou informatif
1 2 3
Algorithme
D’optimisation des 5
coefficients
Valeur Valeur
Réelle Prédite
4
Comparaison valeur
Réelle - Prédite
Ex :
Prédire si un email est un spam ( = 1)
Ex :
Prédire le prix d’un appartement ( )
ou non ( = 0) selon le nombre de liens
selon sa surface habitable ( )
présent dans l’email ( )
{
KNeighborsClassifier
DecisionTreeClassifier
nom_modele GaussianNB
SVC
Etc.
Modèles possibles
Neural Network
RandomForest
LinearRegression
KNN
DecisionTree SVM
[Link] (X, y)
[Link] (X, y)
Coefficient de détermination :
- proche de 1 : modèle performant
- Proche de 0 : modèle moins performant
[Link](X)
Exemple
Exemple
Exemple
L'objectif de cette étude consiste à analyser le jeu de données du Titanic afin de créer un modèle de
prédiction de la survie des passagers en fonction de leur âge, de leur sexe et de la classe de voyage
sélectionnée.
1) Importer le dataset « [Link] »
2) Eliminer les colonnes : name, sibsp, parch, ticket, fare, cabin, embarked, boat, body et [Link]
3) Choisir la méthode appropriée pour traiter des données manquantes.
4) Pour la colonne sex, remplacer la valeur male par 0 et female par 1
5) Appliquer les modèles de base de Machine Learning pour prédire la survie des passagers en fonction de leur
age, leur sexe et la classe de voyage choisie
6) Décrire les résultats obtenus