Cours de

Programmation Python
Enseignant Responsable:
Maroua ABDELHAFIDH

Auditoire: LCE 2
2020-2021
 Chapitre 1:
Introduction
 Programmer?

 Programmer commence
d’abord par un algorithme et
finit par un code (écrit dans un
langage de programmation ) qui
est exécuté par la suite par
l’ordinateur pour fournir un
résultat.

3
 Langages de Programmation
 Pour l’Université, les entreprises et l’industrie (Data Science,
prototypes, mathématiques avancées,…) : Java, Python, R, Matlab,…

 Jeux Vidéo: C++, C#, …

 Sites Internet (développement Web): PHP, Javascript, HTML,

CSS, Python, …

 Intelligence Artificielle: Prolog, Python, Java, …

 Base de Données: SQL, …

4 Et autres….
 Langages de Programmation
Selon PYPL index: PopularitY of Programming Language

5
 Pourquoi Python?
 Portable: Unix, Windows, Mac OS

 Hautement Productif:
Open source: communauté de développeurs python est très productive et
fournit plusieurs extensions. .

 Langage Interprété.

 Orienté Objet

 Organisations utilisant Python: Google, Instagram, Youtube,

DropBox, …

6
 Domaines d’Application
 Machine Learning, Data science

 Administration système

 Prototypage Rapide des Applications.

 La recherche et le calcul scientifique

 Les applications de Gestion

 Les applications web

…
7
 Chapitre II:
Notions de Base de Python
 Les variables
 En programmation, les variables servent à mémoriser les données.

 Les variables sont des espaces de mémoire auquel ont donne un nom et une
valeur.
 Il existe plusieurs type de variables:

String = chaînes de caractères se place entre quotes (’) ou entre guillemets (")
Integer = Suite de chiffres éventuellement préfixé par un signe (+ou −).
Float = Nombre à virgule
Boolean = True/False

 Connaître le type d’un objet

type(nom_de_variable)
 Affiche le type d’une variable (ex. type(1.2) <class ‘float’>)

9
 Les variables
Identificateur de variable

 Un identificateur est utilisé pour désigner le nom de cette variable.

Règles à respecter pour les noms de variables

 Une séquence de lettres (a → z, A → Z) et de chiffres (0 à 9) qui doit toujours

commencer par une lettre. Le symbole _ est considéré comme une lettre.

 Ne doit pas contenir de caractères spéciaux hormis l’underscore (« _ »).

 Le langage est sensibles à la casse et les accentués sont autorisés en Python 3

(mais pas en Python 2). Ceci signifie que cout, Cout et COUT réfèrent trois mots
différents et coût est licite.

Exemple :

Variable_entiere, entier1, mot_en_francais sont valides mais 1er_entier,

10
nom.2, nom de variable, et a-b ne le sont pas.
 Les Opérateurs
Opérateur d’affectation =

Syntaxe : identificateur_de_variable = expression

>>> a= 2 (une valeur simple)

>>> b=a+(b*c) (une combinaison d’opérations)
>>> valeur_de_pi = 3.14159 (valeur constante)

 a est une variable, en interne elle a été automatiquement typée en entier.

N.B En Python, la déclaration d’une variable et son initialisation se font en même

temps.

1- Python a deviné que la variable était un entier.  Python possède donc

un typage dynamique et non un typage statique (C++, JAVA).
2- Python a alloué l’espace en mémoire pour y accueillir un entier, et a fait
en sorte qu’on puisse retrouver la variable sous le nom a
11 3- Python a assigné la valeur 2 à la variable a
 Les Opérateurs
Opérateur d’affectation =

Affectation simple #typage automatique

a = 1.0
#typage explicite
a = float(1)

Affectations multiples
#même valeur pour plusieurs variables
a = b=2.5
>>> print (a, b)
2.5 2.5

Affectations parallèles
a, b=2.5, 3.2
>>> print (a, b)
2.5 3.2
12
 Les Opérateurs
Opérateur d’affectation =

Une autre façon de réaliser l’affectation de plusieurs variables à la fois est de

placer la liste des variables à gauche de l’opérateur d’affectation et la liste des
expressions à droite de l’opérateur d’affectation.

>>> a = 5.0 >>> a, b = 10, 20

>>> b = 10.0 >>> print (a, b)
>>> a, b, c = a + b, a - b, 25 10 20
>>> print (a, b, c) >>> a, b = b, a
15.0 -5.0 25 >>> print (a, b)
>>> u = v = 1. 20 10
>>> u, v, w = u + w, v + w, 3.4 >>>
NameError: name 'w' is not defined

Permutation de variables sans

13 utiliser de variable temporaire.
 Les opérations sur les nombres (entier, réel)
 Les opérateurs Arithmétiques

>>> x = 3 / 4
N.B: En Python 3, la division de >>> x
nombres entiers renvoie par défaut >>> 0.75
un nombre réel (float) . >>> type (x)
14
>>> <class ‘float’>
 Les opérations sur les nombres (entier, réel)
 Priorité des opérateurs (PEMDAS)

P: Parenthèse
E: Exposant
M et D: Multiplication et division
A et S: Addition et soustraction

 A priorité égale, les opérations sont évaluées de la gauche à droite.

>>> x = 5
>>> y = 3
>>> print ((50-x*6)/y)
6.666
>>>

15
 Les opérations sur les nombres (entier, réel)

 Les opérateurs d’affectation +=, -=, *=, /=, %=, **=, //=

But : L’évaluation d’une expression et une affectation sont combinées.

Exemple >>> x = 5 >>> x %= 3 >>> x //= 2

>>> x **= 2 >>> x >>> x
>>> x 1 0
25

Note : Contrairement à C++, Python ne renferme pas les opérateurs ++ et --.

16
 Les opérations de Comparaison
 Les opérateurs de Comparaison
Opérateur Signification
== Est égal à
!= Est différent de
>>> a = 2 #Integer
>= Est plus grand ou égal que >>> b = 1.99 #Float
<= Est plus petit ou égal que >>> c = ‘2’ #String
> Est plus grand que >>> print (a>b)
True
< Est plus petit que
>>> print (a==c)
False
Opérateurs
>>> print ((a==c) and (a>b))
[Condition 1] and [Condition 2] False
AND
Si les deux conditions sont vraies => True >>> print ((a==c) or (a>b))
[Condition 1] and [Condition 2] True
OR
Si une des conditions est vraie => True
Not [Condition]
NOT
17
Si la condition est fausse => True
 Les opérations de Comparaison
 Les opérateurs de comparaison renvoient « True » ou « False ».

N.B. On utilisera principalement ces opérateurs dans les branchements

18
conditionnels.
 Les opérations sur les Chaînes de Caractères
>>> ‘‘Bonjour’’
>>> Bonjour >>> ‘ Aujourd\’hui’
>>> ‘Bonjour ’ >>> Aujourd’hui
>>> Bonjour >>> ‘ ‘‘ Oui ’’ il est correct ’
>>> ‘ Aujourd’hui’ >>> ‘‘ Oui ’’ il est correct
>>> SyntaxError: invalid syntax

Les opérations sur les chaines de caractères sont les suivantes:

L’addition (+) permet de concaténer deux string
La multiplication (*) permet de multiplier un string par un nombre entier
>>> ‘py’ ‘thon’ >>> texte= ‘‘ Je suis à ’’
>>> ‘python’ >>> texte ‘la maison’
>>> chaine_1 = ‘‘ Bonjour ’’ >>> SyntaxError: invalid syntax
>>> chaine_2 = ‘‘ Je m’appel Ali ’’ >>> texte + ‘la maison’
>>> chaine_1+chaine_2 >>> Je suis à la maison
>>> BonjourJe m’appel Ali >>> chaine_1*3
19
>>> BonjourBonjourBonjour
 Les opérations sur les Chaînes de Caractères
 Il est possible d’ajouter des variables dans une chaine de caractères.

Pour cela, il faut ajouter les balises suivantes:

 « %s » : Pour ajouter un string

 « %i » : Pour ajouter un nombre entier

 « %.5f » : Pour ajouter un nombre à virgule (ici, 5 correspond au nombre de

décimales voulues)

>>> nom=‘’a’’
>>> val= 5.6547
>>> message=‘’la valeur de %s est de %f mais on peut l’arrondir à %.2f.’’
%(nom,val,val)
>>>
la valeur de a est de 5.6547 mais on peut l’arrondir à 5.65.

20
 Saisie et affichage à la console
Saisie des données au clavier

input()
- permet d’effectuer une saisie au clavier
- La fonction renvoie toujours une chaîne, il faut convertir

 La fonction input avec un seul paramètre, une chaîne de caractères, lequel est
un message explicatif destiné à l’utilisateur.

a = input(« Saisir votre valeur »)

a = float (a)

21
 Saisie et affichage à la console
Saisie des données au clavier

Exemple : Programme qui saisit 2 entiers et affiche leur quotient.

>>> # Ce programme saisit deux valeurs entières au clavier,

>>> # calcule le quotient et
>>> # affiche le résultat.
>>>
>>> m= input("Entrez la 1er valeur :")
34
n= input("Entrez la 2eme valeur :")
6
>>> resultat = int(m ) // int(n)
>>> print ("Le quotient de ", m, " par ", n, " est : ", resultat)
Le quotient de 34 par 6 est : 5
>>>
22
 Saisie et affichage à la console
Affichage des données print()
>>> print (‘’ Bonjour’’)
>>> Bonjour
>>> print(4)
4
>>> print (‘c:\dossiers\nouha’)
C:\dossiers
ouha
>>> print (r ‘c:\dossiers\nouha’)
c:\dossiers\nouha
>>> print (3+3)
6
>>> print (‘’3+3 ’’)
3+3

 Un affichage multiple est possible

23 Ex. print(a,b) #affiche a et b

 Fonctions de types numériques
type() Retourne le type de l’argument.

>>> u = 1 + 3.4j
>>> type(u)
<type 'complex'>
>>> type(3 + 4.4)
<type 'float'>

bool() Retourne True si l’argument est différent de 0. False autrement.

>>> bool(3.14)
True
>>> bool(0)
False
>>> bool(-3.14)
True

repr() Convertit un objet x à une expression de type chaîne.

>>> repr(3)
24
‘3’
 Fonctions sur types numériques
int()
Prend en entrée comme argument une expression de valeur numérique
ou une chaîne de caractères représentant un entier et retourne le résultat
de l’expression où la partie fractionnaire a été omise ou la chaîne de
caractères convertie en entier. >>> int(3.14)
3
int() supprime le point décimal et toutes les décimales >>> int(-3.14)
qui suivent (le nombre est tronqué). -3
>>> int("3")
abs() Retourne la valeur absolue de l’argument. 3

>>> abs(-1 + 0.25)

0.75

divmod(x,y) Retourne le pair (x//y, x%y).

>>> divmod(18,6)
25 (3,0)
 Fonctions sur types numériques
pow(m, n) ou pow(m, n, p) >>> pow(4, 2)
Dans les 2 cas, mn est d’abord calculé; puis, 16
si le troisième argument est fourni, >>> pow(3, 2, 5)
alors (m ** n) % p est retourné; 4
sinon, m ** n est retourné.
>>> round(3.499)

round()/ round(nombre [,n_chiffres]) 3.499 round()

3

Arrondir un nombre à une précision

donnée en chiffre décimal (0 chiffre par >>> round(2.8)
défaut) 3
retourne: >>> round(253.3589, 2)
- Entier : lorsqu'il est appelé avec un seul
253.3589
argument
- sinon le même type que le nombre . 2 round() 253.36

26
 Fonctions sur type String
 Accès aux caractères d’une chaîne
mot = "apprendre" # Le premier caractère est en position 0.
print (mot[3], mot[4], mot[5], mot[6]) r e n d
 Concaténation de chaînes à l’aide de l’opérateur +
mot = "apprend"
mot = mot + "re"
print (mot[3] + mot[4] + mot[5] + mot[6]) rend
 Répétition de chaînes à l’aide de l’opérateur *
mot = "cher" * 2 chercher
print (mot)

 Longueur d’une chaîne

print (len(mot)) 9

 Convertir une chaîne qui représente un nombre en un nombre véritable

m = "12.3" n = '13‘ print (float(m) + int(n)) 25.3
 Fonctions sur type String

 Convertir un nombre en une chaîne de caractères

str() Convertir un nombre en chaîne de caractères.

>>> print ("On peut concaténer une chaîne et un nombre converti : " + str(1.14 + 3))
On peut concaténer une chaîne et un nombre converti : 4.14
>>>
 Fonctions sur le type String
Extraîre une sous-chaîne
 En déclarant l’indice de début (inclus) et l’indice de fin (exclu), séparés par (:)
 En déclarant l’indice de début (inclus) et l’indice de fin (exclu) et le pas , séparés
par (:) 0 1 2 3 4 5
P y t h o n
-6 -5 -4 -3 -2 -1
>>> mot = ”python” >>> mot[2:6]
>>> mot[0] ‘thon’
‘p’ >>> mot[0:2] + mot[2:6]
>>> mot[-1] ‘python’
‘n’ >>> mot[:2]
>>> mot[0]==mot[-1] ‘ py ‘
False >>> mot[-2:]
>>> mot[0:2] ‘on’
‘py’
>>> mot[2:5] >>> mot[1:5:2]
‘tho’ ‘yh’
 Fonctions sur type String
 Exemples d’Autres Fonctions
>>> mot = ”python”
>>> mot.capitalize() #1er lettre en Majuscule
‘Python’
>>> phrase=‘je suis à la maison’
>>> ‘’maison’’ in phrase #savoir si « maison » dans la phrase ou non
True
>>> ‘’Maison ‘’ in phrase
False
>>> phrase.find(‘’maison’’) >>> phrase.find(‘’Maison’’)
13 # « maison » commence à partir -1 # n’existe pas
de l’index 13
>>> phrase.count(‘’i’’) #renvoie le nombre de ‘’i’’ dans phrase
2
>>> phrase.upper() #convertit en majuscule
>>> phrase.lower() #convertit en miniscule
 Chapitre III:
Listes et Tuples
 Listes

 Une liste est une variable pouvant contenir plusieurs informations. Ces listes
peuvent contenir plusieurs type d’information.

info=[“Liz”,1.73,”Emna”,1.68,”man”,1.71, “dad”,1.89]

 Les listes peuvent également être ajoutées dans d’autres listes : (Liste de listes)

info2=[[“Liz”,1.73],[”Emna”,1.68],”man”,1.71, “dad”,1.89]

32
 Listes
 Pour manipuler les données des listes, nous devons faire appel à leurs
coordonnées:

0 1 2 3 4 5 6 7
info1=[“Liz”,1.73,”Emna”,1.68,”man”,1.71, “dad”,1.89]
-8 -7 -6 -5 -4 -3 -2 -1 index

>>> print (info1[1]) 1.73

>>> print(info1[4]) ‘man’
>>> print(info1[-5]) 1.68
>>> print(info1[-1]) 1.89

 Il est possible de modifier ces données de la même manière

info1[-1]=2 2
print(info1[-1])

33 info1=[“Liz”,1.73,”Emna”,1.68,”man”,1.71, “dad”,2]
 Listes
 Pour repérer des éléments présents dans une liste incluse dans une liste, il faut
faire comme suit:

info1=[“Liz”,1.73,”Emna”,1.68]
info2=[”man”,1.71, “dad”,2]
info3=[info1, info2]

>>> print (info3[1][0]) ‘man’

>>> print(info3[0][2]) ‘Emna’
>>> print(info3[1][1])
1.71

34
Listes
 Manipulation des Listes
>>>info=[‘Luis’, 1.74, ‘Sami’, 1.65, ‘Amal’, 88]
Changer les éléments de Liste:
>>>info[3]=7
[‘Luis’, 1.74, ‘Sami’, 7, ‘Amal’, 88]

Ajouter l’élément x à la fin de Liste:

>>> info.append(‘Mouna’)
>>>a .append(x)
[‘Luis’, 1.74, 1.65, ‘Amal’, 88, ‘Ali’, 1.79,’Mouna’]

Ajouter les élément d’une Liste en fin d’une autre liste:

>>>info= info + [‘Ali’, 1.79] Commande1 ; commande2
[‘Luis’, 1.74, ‘Sami’, 7, ‘Amal’, 88,’Mouna’, ‘Ali’, 1.79] =
>>>Commande1
>>>Commande 2
>>>info2= [‘Ali’, 1.79]; info.extend(info2)
[‘Luis’, 1.74, ‘Sami’, 7, ‘Amal’, 88,’Mouna’, ‘Ali’, 1.79]
Listes
 Manipulation des Listes
[‘Luis’, 1.74, ‘Sami’, 7, ‘Amal’, 88,’Mouna’, ‘Ali’, 1.79]
Supprimer des éléments de Liste à un indice déterminé:
>>>del (info [2])
>>> print(info)
[‘Luis’, 1.74, 7, ‘Amal’, 88, ‘Mouna’,‘Ali’, 1.79]

zones= [‘couloir’, 11.25, ‘cuisine’, 18.0, ‘chambre’, 20.0,’salon’, 15.45]

Supprimer la chambre et sa dimension:

>>>del (zones[-4:-2])
>>> print(zones)
[‘couloir’, 11.25, ‘cuisine’, 18.0,’salon’, 15.45]

N.B: Supprimer un élément d’une liste –> les index des autres éléments qui
viennent après celui supprimé sont tous modifiés.
 Listes
 Manipulation des Listes
[‘Luis’, 1.74, 7, ‘Amal’, 88,’Mouna’, ‘Ali’, 1.79]
Supprimer la première occurrence d’un élément à partir de sa valeur:
>>>info .remove(88)
>>>a .remove(x)
 [‘Luis’, 1.74, 7, ‘Amal’, ‘Mouna’,‘Ali’, 1.79]

Supprimer un élément d’indice i dans la liste et le renvoie:

>>>info .pop(1)
>>>a .pop(i)
1.74
 [‘Luis’, 7, ‘Amal’, ‘Mouna’,‘Ali’, 1.79]
Insérer un élément à un emplacement donné:
>>>info.insert(2,’Sami’)
>>>a .insert(i,x) >>> print(info)
[‘Luis’, 7, ‘Sami’, ‘Amal’, ‘Mouna’,‘Ali’, 1.79]
Listes
 Manipulation des Listes
[‘Luis’, 7, ‘Sami’, ‘Amal’, ‘Mouna’,‘Ali’, 1.79]
Inverser une liste:
info .reverse()
>>>a .reverse ()
[1.79, 'Ali', 'Mouna', 'Amal', 7, ‘Sami’, 'Luis']

Renvoyer l’indice de la première occurrence de l’élément x:

>>>info .index(‘Sami’)
>>>a .index(x)
5

Renvoyer le nombre d’occurrence de l’élément x dans la liste :

>>>info .count(7)
>>>a .count(x)
1
Listes
 Manipulation des Listes

Liste_num=[21,34,17,100,83,20,37,2]
Modifier la liste en la triant:
Liste_num .sort()
>>>a .sort()
[2,17,20,21,34,37,83,100]

Renvoyer le plus grand / petit élément de liste:

>>>max(a) >>>min(a)
>>>max(Liste_num) >>> min(Liste_num)
100 2

>>>x in a  renvoie True si la liste a contient l’élément x, False sinon

>>> x not in a  renvoie True si la liste a ne contient pas l’élément x, False
sinon
Listes
 Créer une liste avec une copie d’une autre liste
X crée une référence vers la liste
‘a’ X
X=[‘a’, ‘b’, ‘c’]
‘b’ Y
Y=X
‘c’

 Si X est une liste, la commande Y=X ne crée pas un nouvel objet Y mais
simplement une référence (pointeur) vers X –> Les deux listes pointent
sur le même objet.
 Tout changement effectué sur Y sera répercuté sur X aussi .

Y [1]=‘z’ X [1]=‘z’
‘a’
>>> print(Y) >>> print(X)
‘b’ ’z’
[‘a’, ’z’, ‘c’] [‘a’, ’z’, ‘c’]
>>> print(X) >>> print(Y) ‘c’
[‘a’, ’z’, ‘c’] [‘a’, ’z’, ‘c’]
 Listes
 Créer une liste avec une copie d’une autre liste
X=[‘a’, ‘b’, ‘c’] ‘a’ X crée une référence vers la liste
X

‘b’
1ère Solution: ‘c’
 Pour faire une copie de X, nous devons faire une copie plus explicite avec list ()
ou en utilisant [ : ].

Y=list(X)  créer une liste Y qui pointe sur une nouvelle liste.
Ou
Y=X[ : ]  utiliser le découpage pour sélectionner explicitement tous les
éléments de la liste.

>>>Y=list(X) ou >>> Y=X[ : ] Y [1]=‘z’

>>> Y[1]=‘z’; print(Y); print(X) X ‘a’ Y ‘a’
[‘a’, ‘z’, ‘c’] ‘b’ ‘b’ ’z’
[‘a’, ‘b’, ‘c’] ‘c’ ‘c’
 Listes
 Créer une liste avec une copie d’une autre liste
X=[‘a’, ‘b’, ‘c’] ‘a’ X crée une référence vers la liste
X

‘b’
2ème Solution: ‘c’
 Utiliser la commande deepcopy du module copy :

>>> import copy

>>>X=[‘a’, ‘b’, ‘c’] X ‘a’ Y ‘a’
>>> Y=copy.deepcopy(X) ‘b’ ‘b’ ’z’
>>>Y[1]=‘z’ ‘c’ ‘c’
>>> print (X); print(Y)
[‘a’, ‘b’, ‘c’] Y [1]=‘z’
[‘a’, ‘z’, ‘c’]
 Listes
 La fonction range
 La fonction range crée un itérateur.
 Au lieu de créer et garder en mémoire une liste d’entiers, cette fonction génère
les entiers au fur et à mesure des besoins:

range([début,] fin [, pas])

N.B: Les arguments entre crochets sont optionnels.

range(n): renvoi un itérateur de 0n-1

range(n,m): renvoi un itérateur de n, n+1, n+2, …, m-1
range(n,m,p): renvoi un itérateur de n, n+p, n+2p, …, m-1

>>>A=range(0,10)
>>>A=range(0,10)
>>>A=list(A)
>>>print(A)
Pour les afficher, >>>print(A)
range(0,10) on crée une Liste [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Listes
 La fonction range

>>>print(list(range(5)))
[0,1,2,3,4]
>>>print(list(range(0,30,3) ))
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
>>>print(list(range(0,-30,-3)))
[0, -3, -6, -9, -12, -15, -18, -21, -24, -27]
>>>print(list(range(3,7)))
[3, 4, 5, 6]
>>>print(list(range(30,0,-3)))

[30, 27, 24, 21, 18, 15, 12, 9, 6, 3]

Listes
 Matrice : Liste de Listes
Une matrice peut être représentée comme une liste imbriquée. Chaque ligne est
un élément d’une liste.

info2=[[“Liz”,1.73],[”Emna”,1.68], [”man”,1.71], [“dad”,1.89]]

info2 = “Liz”,1.73
”Emna”,1.68
info2 définie une matrice 4*2 ”man”,1.71
“dad”,1.89

>>>info2=[[“Liz”,1.73],[”Emna”,1.68], [”man”,1.71], [“dad”,1.89]]

>>>print(len(info2))  la commande len renvoie la longueur de la liste
= nombre de lignes de matrice
4
>>>print(len(info2[1]))  renvoie le nombre de colonnes de matrice
2
 Tuples
 Les tuples sont des listes qui ne peuvent pas être modifiée.

 Les objets dans un tuple sont rangés dans un certain ordre , séparés par des
virgules et encadrés par des parenthèses.

 Un tuple n’est pas forcément homogène: il peut contenir des objets de types
différents les uns des autres.
>>>tuple = (12, 10, 18, 7, 15, 3, "toto", 1.5)
>>>print(tuple[2])
18

NB. Si on essaye de modifier les éléments d’un tuple, on a un message d’erreur.

>>>tuple [1]=11
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError:'tuple'object does not support item assignment
>>>print(tuple)
(12,10, 18, 7, 15, 3, ‘toto’, 1.5)
 Tuples
 Toute fonction ou méthode qui s’applique à une liste sans la modifier peut
être utilisée pour un tuple.
>>>a = (12, 10, 18, 7, 15, 3)
>>>print(a)
(12,10, 18, 7, 15, 3)
>>>a.count(15)
1
>>>a.index(18)
2
>>>print(len(a))
6
>>>print (a+a)
(12, 10, 18, 7, 15, 3,12, 10, 18, 7, 15, 3)
>>>print (a*3)
(12, 10, 18, 7, 15, 3,12, 10, 18, 7, 15, 3, 12, 10, 18, 7, 15, 3 )
>>> print(a+(4,5))
(12, 10, 18, 7, 15, 3, 4,5)
 Dictionnaire (Tableau Associatif)
 Un dictionnaire est une collection modifiable de couples <clé :valeur> .
 Pareil à une liste sauf que l’accès à un élément se fait par un code au lieu d’un
indice
>>>D={ } # dictionnaire vide, comme L=[] pour une liste
>>> D[‘nom’]=‘Ali’
>>> D[‘prenom’]=‘Salem’

>>>D={'nom':‘Ali','prenom':‘Salem ‘}

>>>D ["nom"]
‘Ali’
>>> D [‘prenom’]
‘Salem’
>>>print(D)
{'nom':‘Ali','prenom':‘Salem‘}
Dictionnaire (Tableau Associatif)
>>>D1=dict(nom=‘Ali’, prenom=‘Salem’}
>>>print(D1)
{'nom':‘Ali','prenom':‘Salem‘}

>>>D1=dict( [ (‘nom’,Ali’), (‘prenom’,‘Salem’)])

>>>print(D1)
{'nom':‘Ali','prenom':‘Salem‘}

 On peut utiliser des tuples comme clé lors de l’utilisation de coordonnées:

>>>B={ }
>>> B[(3,2)]=12
>>> B[(4,5)]=13
>>>print(B)
{(3,2): 12,(4,5):13}
Dictionnaire (Tableau Associatif)
 Pour vérifier la présence d’une clé on utilise in :
>>>C={ }
>>> C["nom"] = " Ali "
>>> C["prenom"] = " Salem "
>>>verif="nom" in C
>>> print(verif)
True
>>>verif="age" in C
>>> print(verif)
False
 Supprimer une entrée en indiquant sa clé:
>>>D1={'nom':‘Ali','prenom':‘Salem ‘}
>>>del D1[‘nom’]
>>> print (D1)
{'prenom':‘Salem ‘}
Dictionnaire (Tableau Associatif)
 Récupérer les clés, on utilise la méthode keys

 Récupérer les valeurs, on utilise la méthode values

 Récupérer les valeurs et les clés en même temps, on utilise la méthode items
qui retourne un tuple.

>>>D1={'nom':‘Ali','prenom':‘Salem ‘}
>>>print( [cle for cle in D1. keys()] )
[‘nom’,’prenom’]
>>> print( [val for val in D1. values()] )
[‘Ali‘, ‘Salem’]
>>> print( [k for k in D1. items()] )
[('nom',’Ali'), ('prenom',‘Salem')]
Dictionnaire (Tableau Associatif)
 Créer une copie: (comme avec les listes , utiliser la méthode copy)

>>>D1={'nom':‘Ali','prenom':‘Salem ‘}
>>> e = D1.copy()
>>> print(D1)
{'nom':‘Ali','prenom':‘Salem‘}
>>> print(e)
{'nom':‘Ali','prenom':‘Salem‘}
>>>D1[‘nom’]=‘Sami’ //modifier le nom
>>>print(D1)
{'nom':‘Sami','prenom':‘Salem‘}
>>>print(e)
{'nom':‘Ali','prenom':‘Salem‘} //pas de modification dans la copie
 Chapitre IV:
Structure Conditionnelle
Structure Conditionnelle
 Dans un programme, les conditions permettent de faire des choix dépendants
des différentes données que l’on peut retrouver dans notre programme.

>>>
If expression is True then doSometing
Ou
If expression == True : doSomething

age=int(input(« Quel est votre age? »))

If age >= 18 :
print(« vous êtes majeur »)

*Attention, pour que les lignes soit considérées dans le « if », il est nécessaire
de faire un alinéa! (indentation)  délimiter chaque bloc d’instructions
Structure Conditionnelle
 Dans un Il est également possible de gérer plusieurs conditions:

>>> >>>
If condition_1: age1=int(input(« Quel est votre age? »))
instruction_1.1 age2=int(input(« Quel est l’ age de ton
instruction_1.2... frère? »))
elif condition_2:
instruction_2.1 If age1 > age2 :
instruction_2.2...... print(« vous êtes le plus vieux »)
else: elif age1<age2 :
instruction_n.1 print(« vous êtes le plus jeune »)
instruction_n.2 Else:
print(« vous avez le même age»)
Chapitre V:
Les boucles
 Les boucles
 Les boucles sont très importantes en programmation. Elles permettent de

répéter des instruction un nombre de fois défini à l’avance.

Les boucles : While
 Une boucle while répète les instruction tant que la condition d’entrée est
vérifiée (True).
 Les instructions présentes dans la boucle doivent être décalées d’un alinéa
de plus que l’initialisation de la boucle.
Attention, ce genre de boucle peut entrainer des boucles infinies!
Initialisation de la variable

Condition de sortie de la
boucle. La boucle va se
répéter tant que cette
condition est vérifiée

La variable i va s’incrémenter
à chaque boucle.

Cette instruction n’est pas dans la boucle. Le résultat affiché dans la console
sera la valeur de la variable i à la fin du programme (i = 10 000)
Les boucles : While
Exemple de boucle infinie:

Ici, les instructions se répéteront tant que

i sera supérieur à 1
La variable i est initialisée à la valeur 2 et
continue d’augmenter.

La variable i Tant que i>1

augmente On reste dans la boucle
Les boucles : For
La boucle for va parcourir une liste et renvoyer toutes les valeurs de la liste
dans une variable définie dans la boucle.

La variable i va prendre alternativement

toutes les valeurs de la liste.
Les boucles : For
On peut utiliser l’outil range avec la boucle for. Cela permet de parcourir une
liste d’entier définie

*La fonction range permet de déterminer

à l’avance combien de fois on veut
répéter les instructions (dans cet
exemple, les instructions seront répétées
10 fois)
Les boucles : For
On peut utiliser l’outil range avec la boucle for. Cela permet de parcourir une
liste d’entier définie

*La fonction range permet de déterminer

à l’avance combien de fois on veut
répéter les instructions (dans cet
exemple, les instructions seront répétées
10 fois)
Les boucles : For
Pour parcourir les indices d’une liste, il est possible de combiner range() et
len() comme ci-dessous :

0 Ali
L=[‘Ali’, ’est’, ’dans’, ’le’, ’jardin’] 1 Est
2 Dans
for i in range(len(L)): 3 Le
print(i, L[i]) 4 jardin

N.B: Il est toujours possible de remplacer une boucle for par une boucle while.

i=0
for i in range(4): while i < 4:
print("i a pour valeur", i) print("i a pour valeur", i)
i=i+1
L’instruction break
L’instruction break permet de « casser » l’exécution d’une boucle (while ou for).
Elle fait sortir de la boucle et passer à l’instruction suivante.

for i in range(10): debut iteration 0

print("debut iteration", i) bonjour
print("bonjour") fin iteration 0
if i == 2: debut iteration 1
break bonjour
print("fin iteration", i) fin iteration 1
debut iteration 2
print("apres la boucle") bonjour
apres la boucle
L’instruction continue
L’instruction continue permet de passer prématurément au tour de boucle
suivant. Elle fait continuer sur la prochaine itération de la boucle.

OK 2
for num in range(2,10): KO 3
If num% 2==0: OK 4
print("OK", num) KO 5
continue OK 6
print ("KO", num) KO 7
OK 8
KO 9
Chapitre VI:
Les Fonctions
 Les Fonctions
 Une fonction est un morceau de code que l’ont peut appeler à tout moment
dans une autre partie de son code.
 Lorsque l’on a un nombre important de fonctions, il est possible de les
regrouper dans des modules.

Définition d’une fonction - def

La syntaxe Python pour la définition d’une fonction est la suivante :

def nom_fonction(liste de paramètres):

bloc d'instructions

N.B:
-Le nom de la fonction ne doit pas être l’un des mots-clés réservés du langage,
et ne contient pas un caractère spécial ou accentué (le caractère souligné « _ »
est permis).
- Comme c’est le cas pour les noms de variables, on utilise par convention des
minuscules, notamment au début du nom (les noms commençant par une
majuscule seront réservés aux classes).
 Les Fonctions
Fonction sans paramètres

def compteur3():
Fonction sans paramètres est
i=0
bonjour souvent connue comme une
while i < 3:
0 procédure dans la terminologie de la
print(i)
1 programmation
i=i+1
2
print("bonjour")
compteur3()
* La fonction peut être appelée à différents endroit sans pour autant devoir répéter
les instructions:

def double_compteur3(): bonjour

compteur3() 0
compteur3() 1
2
0
print("bonjour") 1
double_compteur3() 2
 Les Fonctions
Fonction avec paramètres

* Une fonction peut également utiliser des arguments (données d’entrée) et

renvoyer des résultats:

def div_mod(a,b):
div=a//b
mod=a%b
return div,mod bonjour
20
print("bonjour")

val1,val2= div_mod(20,10)
print(val1,val2)

print(div_mod(a=20,b=10))
 Les Fonctions
Fonction avec paramètres: Valeurs par défaut pour les paramètres

* Il est possible de donner des valeurs aux arguments, ceux-ci prendront alors la
valeur indiquée si aucune valeur ne leurs sont appliqué.

def calcul(x1,y1,x2=3,y2=5):
a=(y2-y1)/(x2-x1)
b=y1-a*x1
return a,b 2.0 -1.0

x,y= calcul(20,10)
print(x,y)
 Les Fonctions
Variables locales, variables globales
 Les variables définies à l’intérieur du corps d’une fonction, ne sont accessibles qu’à
la fonction elle-même. => variables locales à la fonction.

 Les variables définies à l’extérieur d’une fonction sont des variables globales.
Leur contenu est « visible » de l’intérieur d’une fonction, mais la fonction ne
peut pas le modifier.

 Une variable locale peut avoir le même nom qu’une variable globale mais elle
reste néanmoins indépendante.
total=0
def sum(arg1, arg2):
total=arg1+arg2
print(« inside the function , total is: »,total) inside the function , total is: 30
return total outside the function , total is: 0

sum(10,20)
print(« outside the function , total is: »,total)
 Les Fonctions
Utilisation d’une variable globale - global
Il peut se faire par exemple que vous ayez à définir une fonction qui soit capable de
modifier une variable globale.
 Pour atteindre ce résultat, il vous suffira d’utiliser l’instruction global

def test():
global b
b=5 25
print(a, b) 25
a=2
b=7
test()
print(a, b)
 Les Fonctions
Passage var valeur et par référence
Tous les paramètres du langage python sont passés par référence

 si vous modifiez ce à quoi un paramètre fait référence dans une fonction, le

changement se reflète également dans la fonction appelante.

def change_me(mylist): def change_me(mylist):

mylist.append([1,2,3,4]) mylist=[1,2,3,4]
print(“values inside are:”, mylist) print(“values inside are:”, mylist)

mylist=[10,20,30] mylist=[10,20,30]
change_me(mylist) change_me(mylist)
print(“values outside are:”, mylist) print(“values outside are:”, mylist)

values inside are: [10, 20, 30, [1, 2, 3, 4]] values inside are: [1, 2, 3, 4]
values outside are: [10, 20, 30, [1, 2, 3, 4]] values outside are: [10, 20, 30]
 Chapitre VII:
Modules et importations
 Modules et importations
 Comment utiliser une même fonction dans plusieurs programmes différents ?

Comment avoir la définition d’une fonction dans un fichier différent de celui qui
contient le programme principal ?.

 Définir des fonctions dans un module et faire en sorte qu’un utilisateur

puisse appeler ces fonctions dans son programme.

Créer un fichier nommé

puissance.py qui va définir 2 fonctions def carre(valeur):
: carre() et cube(). resultat = valeur**2
Un tel fichier est appelé un module et return resultat
il va pouvoir être importé dans un def cube(valeur):
autre fichier, et en particulier dans le resultat = valeur**3
fichier qui contient le programme return resultat
principal.
Modules et importations
On importe une seule fonction dans le P.P

from puissance import carre N.B:

a=5 Le fichier puissance.py doit être dans le
u=carre(a) même répertoire que le programme
print("le carre vaut", u) principal).

On importe explicitement les deux On importe toutes les fonctions

fonctions
from puissance import carre, cube from puissance import *
a=5 a=5
u=carre(a) u=carre(a)
print("le carre vaut", u) print("le carre vaut", u)
v = cube(a) v = cube(a)
print("le cube vaut", v) print("le cube vaut", v)
Modules et importations
On importe une fonction d’un module et on lui donne un alias

from puissance import carre as ca

a=5
u=ca(a)
print("le carre vaut", u)

On importe le module

import puissance
a=5
u=puissance.carre(a)
print("le carre vaut", u)
v = puissance.cube(a)
print("le cube vaut", v)
 Packages
 Un dossier qui rassemble des modules.

 Les packages disponible sont: numpy, matplotlib, scikit-learn.

Exemple: on crée un dossier package1 dans lequel on place le fichier module1.py

suivant :

def fonction1(a):
return a**2

Ensuite , on peut utiliser la fonction fonction1() définie dans module1.py, en

important package1.module1 comme suit :

import package1.module1

u = package1.module1.fonction1(3)
print("u vaut", u)
NumPy (Numerical Python)

 La bibliothèque NumPy (http://www.numpy.org/) permet d’effectuer des

calculs numériques avec Python.

Elle introduit une gestion facilitée des tableaux de nombres.

Il faut au départ importer le package numpy avec l’instruction suivante:

import numpy as np
 NumPy
Les Variables Prédéfinies

Variables pi
>>>np.pi
NumPy définit par défaut la valeur de pi. 3.141592653589793

Les Tableaux numpy.array()

Création
>>> a = np.array([[1, 2, 3], [4, 5, 6]])

Affichage Accès aux éléments d’un tableau

>>> a >>>a[0,1]
array([[1, 2, 3], [4, 5, 6]]) 2
>>>a[1,2]
>>> type(a)
6
Numpy.ndarray # un objet de type
numpy.ndarray (n-dimentionnal array)
NumPy
La fonction numpy.arange()

>>> m = np.arange(3, 15, 2)

>>>m
array([ 3, 5, 7, 9, 11, 13])
>>>type(m)
numpy.ndarray

Noter la différence entre numpy.arange() et range() :

numpy.arange() retourne un objet de type numpy.ndarray.
range() retourne un objet de type range.

 numpy.arange() accepte des arguments qui ne sont pas entiers.

>>> np.arange(0, 11*np.pi, np.pi)

array([ 0. , 3.14159265, 6.28318531, 9.42477796, 12.56637061,
15.70796327, 18.84955592, 21.99114858, 25.13274123, 28.27433388,
31.41592654])
 NumPy
Créer des Tableaux directement
Numpy contient plusieurs fonctions pour cette tâche

>>> np.zeros(10, dtype=int) # Un tableau de longueur 10, rempli d’entiers valent 0

>>> np.ones((3, 5), dtype=float) # Un tableau de taille 3x5 rempli de nombres à
virgule flottante de valeur 1
>>>np.full((3, 5), 3.14) # Un tableau 3x5 rempli de 3,14
>>>np.arange(0, 20, 2) # Un tableau rempli d'une séquence linéaire
# commençant à 0 et qui se termine à 20, avec un pas de 2
>>>np.linspace(0, 1, 5) # Un tableau de 5 valeurs, espacées uniformément entre 0
et 1
>>>np.eye(3) # La matrice identité de taille 3x3
#eye(n) renvoie tableau 2D carré de taille n x n, avec des uns sur la diagonale et
des zéros partout ailleurs.
 NumPy
Les propriétés des Tableaux
Chaque tableau Numpy a des propriétés qui se révèlent souvent utiles.

>>>x1 = np.random.randint(10, size=6) # Tableau de dimension 1

array([3, 0, 8, 2, 4, 0])
>>>print("nombre de dimensions de x1: ", x1.ndim)
nombre de dimensions de x1: 1
>>>print("taille de x1: ", x1.size)
taille de x1: 6
>>>print("type de x1: ", x1.dtype)
type de x1: int32
 NumPy
Nombres Aléatoires
La fonction numpy.random.random() permet d’obtenir des nombres compris
entre 0 et 1 par tirage aléatoire.

>>> np.random.random()
0.5540884899329033
>>>np.random.random(3)
Passer des arguments pour
array([ 0.86431861, 0.88519197, 0.30663316]) obtenir des tableaux.
>>>np.random.random((2,3)) Les arguments précisent alors
la forme (shape) du tableau
array([[ 0.66265691, 0.39385577, 0.09319192], souhaité.
[ 0.43483474, 0.42859904, 0.79189574]])
 NumPy
Indexation et Slicing
Accéder à un ou plusieurs éléments contigus d'un tableau.
Accéder à un seul élément

>>>x1 = np.arange(3, 15, 2)

>>>print(x1)
array([ 3, 5, 7, 9, 11, 13])
>>>print(x1[0]) # Pour accéder au premier élément
>>>print(x1[-1]) # Pour accéder au dernier élément
>>>x1[1] = "1000" # On peut aussi modifier les valeurs
>>>print(x1)
array([ 3, 1000, 7, 9, 11, 13])
 NumPy
Indexation et Slicing
Accéder à un ou plusieurs éléments contigus d'un tableau.
Accéder à un seul élément

>>>x2 = np.random.randint(10, size=(3, 4)) # Tableau de dimension 2

array([[3, 0, 3, 5],
[1, 6, 7, 4],
[5, 3, 6, 5]])
>>>print(x2[0,1]) #donne un tableau 1D correspondant à la colonne d’indice 1 de
x2
>>> x2[0][1] = x2[0,1]
 NumPy
Indexation et Slicing
Accéder à un ou plusieurs éléments contigus d'un tableau.
Accéder à plusieurs éléments

>>>x1 = np.arange(3, 15, 2) array([ 3, 5, 7, 9, 11, 13])

>>>print(x1[:5]) # Les cinq premiers éléments
>>>print(x1[5:]) # Les éléments à partir de l'index 5
>>>print(x1[::2]) # Un élément sur deux
>>>x1[::-1] # Si le pas est négatif, le début et la fin du slice sont inversés.
 NumPy
Indexation et Slicing
Accéder à un ou plusieurs éléments contigus d'un tableau.
Accéder à plusieurs éléments
>>>x2 = np.random.randint(10, size=(3, 4))
array([[3, 0, 3, 5],
[1, 6, 7, 4],
[5, 3, 6, 5]])
>>> x2[0,:] # La première ligne
array([3, 0, 3, 5])
>>>x2[:,1:3] >>>x2[:,0]
array([[0, 3], array([3, 1, 5])
[6, 7],
[3, 6]])
 NumPy
Concaténation
On peut concaténer deux ou plusieurs tableaux

>>> x = np.array([1, 2, 3])

>>>y = np.array([3, 2, 1])
>>>np.concatenate([x, y])
array([1, 2, 3, 3, 2, 1])
>>> A = np.array(([1,2],[3,4]))
>>> B = np.array(([5,6],[7,8]))
>>> C = np.concatenate((A, B))
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
 NumPy
Concaténation
On peut aussi spécifier l'axe sur lequel fusionner les deux matrices:

>>> A = np.array(([1,2],[3,4]))
>>> B = np.array(([5,6],[7,8]))
>>> C = np.concatenate((A, B), axis=1)
array([[1, 2, 5, 6],
[3, 4, 7, 8]])
>>> C = np.concatenate((A, B), axis=0)
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
 NumPy
Opérations sur les tableaux Numpy
Produit terme à terme
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>>b = np.array([[2, 1, 3], [3, 2, 1]])
>>>a*b
array([[ 2, 2, 9],
[12, 10, 6]])
Produit Matriciel numpy.dot() Le produit d’une matrice de taille n x m par une
matrice m x p donne une matrice n x p

>>> a = np.array([[1, 2, 3], [4, 5, 6]])

>>>b = np.array([[4], [2], [1]])
>>>np.dot(a,b)
array([[11],
[32]])
 NumPy
Opérations sur les tableaux Numpy
Transposé
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>>a.T
array([[1, 4],
[2, 5],
[3, 6]])
Changement de la taille d’un tableau

>>> u = np.arange(1, 16)

array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
>>>np.shape(u)
(15,)
>>>u.shape = (3, 5)
array([[ 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
NumPy
Fonctions Mathématiques avec Numpy
numpy.sin(x)
numpy.cos(x) racine carrée: numpy.sqrt(x)
numpy.tan(x) Exponentielle: numpy.exp(x)
numpy.arcsin(x) valeur absolue: numpy.abs(x)
numpy.arccos(x) Signe: numpy.sign(x)
numpy.arctan(x)

>>> x = np.array([ 2 ,3, -4])

>>>np.sin(x)
array([ 0.90929743, 0.14112001, 0.7568025 ])
>>> np.abs(x)
array([2, 3, 4])
>>> np.sign(x)
array([ 1, 1, -1])
 Tracé de courbes
Pour tracer des courbes, Python n’est pas suffisant et nous avons besoin des
bibliothèques NumPy et matplotlib .

 il faut importer le package numpy et le module pyplot de matplotlib

>>> import numpy as np

>>>import matplotlib.pyplot as plt
>>>x = np.array([1, 3, 4, 6])
>>>y = np.array([2, 3, 5, 1])
>>> plt.plot(x, y)
>>>plt.show() # affiche la figure a l'ecran
 Tracé de courbes
Définition du domaine des axes - xlim() et ylim():

Il est possible fixer indépendamment les domaines des abscisses et des
ordonnées en utilisant les fonctions xlim() et ylim().
xlim(xmin, xmax)
ylim(ymin, ymax)

>>> import numpy as np

>>>import matplotlib.pyplot as plt
>>>x = np.linspace(0, 2*np.pi, 30)
>>> y = np.cos(x)
>>>plt.plot(x, y)
>>>plt.xlim(-1, 5)
>>> plt.title("Fonction cosinus")
>>>plt.show()
 Tracé de courbes

Ajout d’une légende - legend()

>>> import numpy as np

>>>import matplotlib.pyplot as plt
>>>x = np.linspace(0, 2*np.pi, 30)
>>> y = np.cos(x)
>>>plt.plot(x,y,label="cos(x)")
>>>plt.legend()
>>>plt.show()
 Tracé de courbes

Labels sur les axes - xlabel() et ylabel()

>>> import numpy as np

>>>import matplotlib.pyplot as plt
>>>x = np.linspace(0, 2*np.pi, 30)
>>> y = np.cos(x)
>>>plt.plot(x,y)
>>>plt.xlabel("abscisses")
>>>plt.ylabel("ordonnees")
>>>plt.show()
 Tracé de courbes
Affichage de plusieurs courbes

>>> import numpy as np

>>>import matplotlib.pyplot as plt
>>>x = np.linspace(0, 2*np.pi, 30)
>>> y 1= np.cos(x)
>>>y2 = np.sin(x)
>>>plt.plot(x, y1, label="cos(x)")
>>>plt.plot(x, y2, label="cos(x)")
>>>plt.legend()
>>>plt.show()
 Tracé de courbes
Formats de courbes
Il est possible de préciser la couleur, le style de ligne et de symbole
(« marker ») en ajoutant une chaîne de caractères de la façon suivante :

>>> import numpy as np

>>>import matplotlib.pyplot as plt
>>>x = np.linspace(0, 2*np.pi, 30)
>>> y 1= np.cos(x)
>>>y2 = np.sin(x)
>>>plt.plot(x,y1,"r--", label="cos(x)")
>>>plt.plot(x,y2,"b:o", label="sin(x)")
>>>plt.legend()
>>>plt.show()

NB. La documentation de Matplotlib (en anglais) : https://matplotlib.org/

 Tracé de courbes
Formats de courbes
Il est possible de préciser la couleur, le style de ligne et de symbole
(« marker ») en ajoutant une chaîne de caractères de la façon suivante :

>>> import numpy as np

>>>import matplotlib.pyplot as plt
>>>x = np.linspace(0, 2*np.pi, 30)
>>> y 1= np.cos(x)
>>>y2 = np.sin(x)
>>>plt.plot(x,y1,"r--", label="cos(x)")
>>>plt.plot(x,y2,"b:o", label="sin(x)")
>>>plt.legend()
>>>plt.show()

NB. La documentation de Matplotlib (en anglais) : https://matplotlib.org/