Programmation Python VF
Programmation Python VF
Déroulement du cours
Généralités
• Chapitre 1 : Bases de la programmation Python - TD1
- Instructions de base : lecture/écriture/affectation
- Structure conditionnelle
- Structure itérative / boucle
- L’instruction : break
- L’instruction : continue
• Chapitre 2 : Fonctions & Modules - TD2
• Chapitre 3 : Chaines de caractères - TD3
• Chapitre 4 : Structures de données - TD4
• Les types séquentiels : listes, tuples
• Les types de correspondance : dictionnaire
• Chapitre 5 : Fichiers - TD5
• Chapitre 6 : Programmation orienté objet (POO) - TD6
• Chapitre 7 : Tableaux - TD7
Projet de fin de module
Généralités
Généralités
Exemple d’un
Début
Exemple d’un pseudocode
organigramme
Algorithme Division ;
Entrer la valeur de A et B
Variables A, B : réel ;
Faux Vrai Début
B=0 Ecrire (‘Entrer les deux valeurs : ‘) ;
Lire (A,B);
Calculer A/B if (B=0)
Afficher un
message d’erreur Ecrire (‘impossible de diviser par 0 ‘) ;
Afficher le résultat else
Ecrire (‘le résultat est : ‘, A/B) ;
Fin
Fin
Généralités
Généralités
Langage de
C’est une notation conventionnelle destinée à formuler des
programmation
algorithmes afin de produire des programmes informatiques.
Un langage de programmation est construit à partir d'une
grammaire formelle, qui inclut des symboles et des règles
syntaxiques.
Généralités
Ex : Langage
Langage binaire
C 0 et 1
Généralités
Interprétation
C’est l’analyse et l’exécution de chaque ligne du code source (rédigé en
utilisant un langage de programmation) sans la génération du code objet
Ex :
Langage
python
Généralités
Interpréteur Compilateur
• Convertit le programme en prenant une • Analyse l’ensemble du programme et le
seule ligne à la fois. traduit dans son ensemble en code machine.
• L’analyse du code source prend moins • L’analyse du code source prend beaucoup de
de temps, mais le temps d’exécution temps, mais le temps d’exécution global est
global est plus lent. comparativement plus rapide.
Généralités
Type de
programmation Généralement, on distingue entre deux types de programmation :
programmation procédurale et programmation orienté
objet
Programmation procédurale
• La programmation procédurale est un paradigme de programmation qui
repose sur le concept de procédures ou fonctions.
• Dans la programmation procédurale, un programme est divisé en petites
unités autonomes appelées procédures contenant des séquences
d'instructions à exécuter. Ces procédures peuvent être appelées dans un
ordre spécifique pour accomplir une tâche plus complexe.
Exemple :
Ada, FoxPro, Modula-2, BASIC, Pascal, C, ALGOL, COBOL, Fortran
Généralités
Type de
programmation Généralement, on distingue entre deux types de programmation :
programmation procédurale et programmation orienté
objet
Exemple :
C++, C, Java, Python, Ruby, Javascript, etc.
Généralités
Classe
• Un type d’une variable complexe
• Un modèle ou un plan pour créer des objets. Elle dé nit les
propriétés (attributs) et les comportements (méthodes) communs à
tous les objets créés à partir de cette classe.
def afficher_informations(self):
print (f "Nom: {[Link]}")
print (f "Âge: {[Link]}")
print((f "Note: {[Link]}")
fi
Module : Algorithmique avancée & Programmation python
Généralités
Objet
• Une instance concrète d’une classe
• Il représente une entité du monde réel et possède des
caractéristiques (attributs) et des actions (méthodes) associées à la
classe à partir de laquelle il a été créé.
Généralités
Généralités
Généralités
• 1991 : Guido van Rossum travaille aux Pays-Bas sur le projet AMOEBA : un
système d’exploitation distribué. Il conçoit Python à partir du langage ABC et
publie la version 0.9.0 sur un forum Usenet
• 1996 : sortie de Numerical Python, ancêtre de numpy
• 2001 : naissance de la PSF (Python Software Fundation)
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...
Généralités
Pour af cher l’aide sur un keyword ou une fonction python, il suf t de taper la
commande :
>>>> help(nom du keyword ou nom de la fonction)
fi
Module : Algorithmique avancée & Programmation python
Ex:
a=
print(type(a)
<class 'int'>
Opérateurs arithmétiques
x+y Somme de x et y
x**y x à la puissance y
Opérateurs de comparaison
< inférieur à
<= inférieur ou égal à
Opérateurs de conversion
> supérieur à
>= supérieur ou égal à Convertir x vers un
int(x)
== égal à nombre entier
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)
NB :
a=b=c=3 Lorsque les types des deux opérandes sont différents il y’a
x,y,z=1,2,3 conversion implicite vers le type de la variable résultante.
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
Syntaxe générale
Exemple
• 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
Résultat d’exécution
iden_var = input ()
*** Choisir une valeur pour R
iden_var = input ( ″message ″) 2.4
Exemple
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
L’instruction : if
if expression logique :
Instruction 1
Instruction 2 Instructions à exécuter si
… l’expression logique est
Instruction n vraie
Exemple
if X > 0 :
print ( ″ c’est un nombre positif ″ )
L’instruction : if … else
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
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 mentions affichée est : Bien
- Si 12 <= moyenne <14, la mentions affichée est Assez Bien
- Si 10 <= moyenne <12, la mentions 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.
Exercices : Série N1
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
# Définition de la fonction afficher_numeros ()
def afficher_numeros () :
n=int(input("entrer le nombre des valeurs à afficher : "))
for i in range(n) :
print(i)
# appel de la fonction afficher_numeros ()
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
# Définition de la fonction afficher_numeros ()
def afficher_numeros (n) :
for i in range(n) :
print(i)
# appel de la fonction afficher_numeros ()
N=int(input("entrer le nombre des valeurs à afficher : "))
afficher_numeros (N)
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
def somme (x, y) :
s =x+y
print ( "la somme des deux valeurs est : ", s )
Résultat d’exécution
12
10
La somme des deux valeurs est : 22
Chapitre 2 : Fonctions
Exemple 5
def somme (x, y) :
s =x+y
return (s)
Résultat d’exécution
12
10
La somme des deux valeurs est : 22
Chapitre 2 : Fonctions
Chapitre 2 : Fonctions
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
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
Module [Link]
def addition (x, y) : Script principal
return (x+y)
from calcul import *
Exercices : Série N2
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’
print (ch3[-12:-1] )
# permet d’afficher les caractères ayant indice de -2 à -12 : ‘programmeur’
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’
Exercices : Série N3
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
Exemple
Liste_1 = [13, 11] #permet de définir une liste vide
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), on peut utiliser la méthode
sort() 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]
Exercice d’application
On considère une liste Notes 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 7.
Le menu contient les éléments suivants :
1. Ajouter une note
2. Afficher la liste des notes des étudiants
3. Afficher la note maximale
4. Afficher la note minimale
5. Afficher la note moyenne du groupe
6. Trier la liste des notes d’une manière décroissante
7. Terminer l’exécution du programme
Solution
case 1:
L=[]
note=float(input("entrer votre note : "))
def menu(): [Link](note)
print("\n1: Ajouter une note") print("note ajoutée avec succès")
print("2: Afficher la liste des notes des étudiants") case 2:
print("3: Afficher la note maximale ") if len(L)==0 :
print("Liste vide ")
print("4: Afficher la note minimale")
else :
print("5: Afficher la note moyenne du groupe")
print("Liste des notes : ")
print("6: Trier la liste des notes d’une manière afficher_liste(L)
décroissante") case 3:
print("7: Terminer l’exécution du programme") print("la note maximale est ", max(L))
ch=int(input("Entrer votre choix : ")) case 4:
print("la note minimale est ", min(L))
return(ch)
case 5:
def afficher_liste(nom_liste):
print("la note moyenne est ", sum(L)/len(L))
for x in nom_liste : case 6:
print(x, end=" ") [Link](reverse=True)
choix=0 print("Liste triée avec succès")
while choix!=7 : case 7:
print("Fin du programme")
choix=menu()
case other :
match choix :
print("Veuillez saisir une valeur comprise entre 1 et 7 ")
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 4 : 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 4 : 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 4 : 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 4 : 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 4 : 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 4 : 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](2)) # permet d’afficher : None
print(dico) # permet d’afficher : {1: 'un', 3: 'trois', 4: ‘quatre'}
Chapitre 4 : le dictionnaire
Exercice d’application
Chapitre 4 : 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 4 : 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 4 : 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 4 : 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 N4
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
)
Exercices : Série N5
• La programmation orientée objet (POO) est une méthode pour concevoir des
programmes informatiques d’une manière organisée et bien structurée.
• La programmation orientée objet est un paradigme de programmation basé sur deux
notions extrêmement puissants : objet et Classe.
- Objet : instantiation d’une classe (représentation concrète)
- Classe : Modèle abstrait qui regroupe une famille des objets ayant même structure et même actions
(représentation abstraite)
• Ex : modèle d’une voiture, modèle d’un ordinateur, modèle d’un appartement. Etc.
Représentation
graphique d’une classe Exemple d’une classe
NomClasse Voiture
Représentation
Exemple des objets V1: Voiture
graphique d’un objet
Matricule = "1234A"
Marque = "Kia"
Instantiation Modèle=2020
NomObjet : NomClasse Voiture Couleur="Rouge"
Attribut1 = Valeur
Attribut2 = Valeur
Attribut3 = Valeur
…
} Attributs
Matricule
Marque
Modèle
Couleur
AfficherInfos ()
V2: Voiture
Methode1 ()
Méthode2 ()
…
} Mèthodes AfficherInfos ()
Instantiation
Matricule = "1234B"
Marque = "Ford"
Modèle=2022
Couleur="Gris"
AfficherInfos ()
Encapsulation
NomClasse Stagiaire
Représentation # Attribut1 Exemple — CINStagiaire
graphique d’une — Attribut2
d’une classe + NomStagiaire
… # AgeStagiaire
classe
+ Methode1 ()
AfficherInfos ()
…
fi
fi
Héritage
• L'héritage est un concept fondamental de la programmation orientée objet (POO) qui permet à une
classe, appelée « classe dérivée », « sous-classe » ou « classe lle », d'hériter des attributs et des
méthodes d'une autre classe, appelée « classe de base », « superclasse » ou « classe mère ».
- Classe de base (classe mère) donne TOUT aux classes lles (méthodes et attributs
- Classes dérivées (classes lles) :
- héritent TOUT de ses classes mères ( méthodes et attributs
- peuvent avoir D’AUTRES attributs et méthodes
- peuvent MODIFIER ce qu’elles ont hérité
• On distingue entre deux types d’heritage :
- Heritage simple : une classe qui hérite des attributs et des méthodes d’une seule super class
- Heritage multiple : une classe qui hérite des méthodes et des attributs de plusieurs super classes
fi
)
fi
)
Héritage simple
Les méthodes
Représentation graphique de l’héritage simple
Classe mère AfficherInfos() des
ClasseMère classes filles doivent
Personne
Attribut1 être redéfinies
Attribut2 Exemple NomPersonne
… pour qu’elles affichent
PrePersonne
AgePersonne tous les attributs des
Methode1 ()
… AfficherInfos() classes filles
ClasseFille1 ClasseFille2
Exemple
Attribut1 Attribut1
Attribut2 Attribut2
… … Doctorant
Departement
Methode1 () Methode1 () AnneeInscription
… …
AfficherInfos()
Classe fille
Polymorphisme
• Le polymorphisme est un concept très important dans la POO, elle consiste à dé nir des
méthodes portant même nom mais ayant des comportements différents
• On distingue entre trois types de polymorphisme
- Redé nition des méthodes : lorsqu’on redé nit les mêmes méthodes d’une classe mère dans ses
classes lles (cas de l’héritage)
- Surcharge des méthodes : appelé aussi « overloading », c’est dé nir deux ou plus des méthodes
dans une même classe mais avec des paramètres différent
- Surcharge des opérateurs : lorsqu’on redé nit le code des méthodes magiques liées aux
opérateurs arithmétiques tels que __add__, __mul__ ou logiques tels que __lt__ :
fi
fi
s
fi
.
fi
Module : Algorithmique avancée & Programmation python
Abstraction
• L’abstraction est un concept très important dans la POO, elle consiste à simpli er la
complexité d’un système. L’abstraction est souvent mise en œuvre à l'aide de classes
abstraites ou d'interfaces
• Une classe abstraite est une classe qui ne peut pas être instantiée directement, mais qui
sert de base pour d'autres classes concrètes.
• Une classe est dite abstraite si au moins elle contient une méthode abstraite
• Une méthode abstraite est une méthode qui ne contient aucun traitement. Pourtant on
dé nit juste son prototype.
fi
Module : Algorithmique avancée & Programmation python
• Pour dé nir une classe ayant des attributs et des méthodes en python, on utilise la syntaxe suivante
class NomClasse
def __init__(self, Parametre1, Parametre2, …)
self.Attribut1=Parametre
self.Attribut2=Parametre
fi
:
class Etudiant:
def __init__(self, nom, age, note):
[Link] = nom
[Link] = age
[Link] = note
Exemple d’instantiation d’un objet
def AfficherInformations(self):
print (f "Nom: {[Link]}") # Création d'une instance de la classe Etudiant
print (f "Age: {[Link]}") E1 = Etudiant("Ali", 23, 18)
print((f "Note: {[Link]}")
# Affichage des informations initiales
def ModifierNote(self, NouvelleNote): print("Informations initiales de l'étudiant : ")
[Link] = NouvelleNote [Link]()
Exercice d’application
Question
• Dé nir une classe Stagiaire contenant les attributs suivants : num, nom, age et une méthode
af cher_infos() qui af che les informations d’un stagiaire donné
• Créer un stagiaire puis af cher ses informations
Question
• Ajouter aux attributs de la classe Stagiaire les attributs suivants : note_1 et note_2
• Ajouter également une méthode calculer_moyenne() qui permet de calculer puis af cher la moyenne
générale des notes obtenues pour un stagiaire donné
• Créer deux stagiaires puis af cher le nom de celui qui a obtenu la moyenne générale maximale.
fi
fi
fi
.
fi
Module : Algorithmique avancée & Programmation python
Solution
Question 1
Solution
Question 2
Solution
Question 2 (suite)
• Tous les attributs et les méthodes d’une classe sont publiques (accessibles en dehors de leur classe
• Pour rendre un attribut ou une méthode privée (private), il suf t de précéder son nom par __ :
__NomAttribut ou __ NomMethode(
• Pour rendre un attribut ou une méthode protégée (protected), il suf t de précéder son nom par _ :
_NomAttribut ou _NomMethode()
• Pour accéder aux attributs privés en dehors de leur classe, on peut utiliser deux méthodes : get et set.
- getNomAttribut() : méthode qui renvoie l’attribut privé ou protégé en dehors de sa classe
- setNomAttribut() : méthode qui permet de modi er la valeur de l’attribut privé ou protégé en
dehors de la classe où il a été crée
Définition des attributs privés et protégés Définition des méthodes get et set
def __init__(self, p1, p2, …): def getNomAttribut(self):
self.__NomAttribut1= p1 # attribut privé return (self.__NomAttribut)
self._NomAttribut2= p2 # attribut protégé def setNomAtribut(self, NouvelleValeur):
…. self.__NomAttribut = NouvelleValeur
fi
fi
fi
.
Exercice d’application
fi
.
fi
Solution
Solution (suite)
Solution (suite)
class SuperClasse :
Dans le constructeur de
# attributs et méthodes la classe fille
class SousClasse (SuperClasse) : __init__(), il faut
appeler le constructeur
# attributs et méthodes
de la classe mère avec l’une des
méthodes suivantes :
Syntaxe de définition d’un héritage multiple
super().__init__(p1, p2, ..)
class SuperClasse1 :
SuperClasse.__init__(self, p1,
# attributs et méthodes p2, ..)
class SuperClasse2 : Avec
# attributs et méthodes p1, p2, … sont les paramètres de la
classe mère
class SousClasse (SuperClasse1, SuperClasse2) :
# attributs et méthodes
Classe mère 1
Classe mère 2
Classe fille
Classe fille
Syntaxe d’utilisation
d’une classe abstraite
La redéfinition des
méthodes abstraites
est obligatoire dans
les classes filles
Exemple d’abstraction
?
C’est quoi la différence entre les attributs et les
méthodes des objets et les attributs et les
méthodes des classes ?
Exercice 1
Ecrire un script python qui permet de calculer puis afficher la surface des formes géométriques suivantes : disque,
rectangle et Triangle ( les dimensions de ces formes sont choisies par l’utilisateur)
Le script à rédiger devrait contenir une classe mère nommée « Forme » et trois sous classes filles : « Rectangle »,
« Triangle » et « Disque ».
Chaque classe devrait contenir les attributs et les méthodes nécessaires.
NB : L’utilisateur n’a pas le droit de créer d’autres formes autre que Disque, Rectangle et Triangle
Exercice 2
L’objectif de cet exercice est de rédiger un script python qui implémente les concepts clés de la programmation orienté objet.
L’exercice consiste à appliquer un certain nombre de traitement sur des livres.
Chaque livre est caractérisé par les attributs privés suivants : son ISBN, son titre, le nom de son auteur (ou les noms des ses
auteurs), date de sa publication, son prix et le non de sa maison d’édition.
1. Développer la classe Livre qui devrait contenir en plus de ses attributs, les méthodes suivantes :
- ComparerLivres(..) qui permet de comparer deux livres en fonction de leurs ISBN
- AfficherInfos(…) qui permet d’afficher les informations d’un livre.
- AppliquerPromotion(…) qui permet de réduire le prix d’un livre selon un taux de réduction.
2. Enregistrer les informations de 10 livres. Puis afficher les livres d’un auteur donné.
Exercices : Série N6
……..
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 manimale : "))
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 N7