01 - Semma - INSEA (La Base Du Langage Python)

Programmation Avancée
- Python -
Chapitre 1 : La Base du langage Python
Cours 1ère année S2
1
Plan :
Les Bases du langage Python
Syntaxe du langage Python (if-boucles-Fonctions et Modules)
Programmation-Orientée-Objet
Interfaces Graphiques et Programmation évenementielle (Lib : tkinter)
Bases de données et Python
Principales librairies (Numpy, Matplotlib …)
K.ELHARI 2015-2016 2 S1 : Architecture des Ordinateurs

Chapitre 1. Les Bases du langage Python
Introduction
 Crée par : Guido Van Rossum en 1989
 Première version publiée : V 0.9 en Février 1991
 Versions existantes : 2. et 3.

https://learn.onemonth.com/fr/10-sites-web-
celebres-construits-avec-python/
Parmi les entreprises tech les plus prospères du moment,

beaucoup choisissent Python pour le back-end de leur
site web . Jetons un coup d’œil à 10 sites Web célèbres
construits avec Python.

Python has won the prestigious TIOBE Programming Language of the Year award for the second time in a row.
K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

Introduction
 Multiplateforme : Windows, Mac OS X, Linux, Android, iOS
 Gratuit
 Simple : Peu de connaissances en algorithmique
 Langage interprété : Un script Python n’a pas besoin d’être compilé
pour être exécuté, contrairement à des langages comme le C ou le C++
 Orienté objet
 Très utilisé en analyse de données et IA

Installation
 Installation d’une version de python 3.6 ou plus
 Installation d’un éditeur comme PyCharm, Anaconda et Visual Studio
 Installation des librairies an cas de besoin comme Numpy, Pandas,
Seaborn, Matplotlib, Tensorflow, PyTorch, Requests, BeautifulSoup …

Installation
Choix de la version de python

Installation
Choix de l’OS

Installation
Installation
de Python

Installation
Installation
de Python

Installation
Installation
de Python

Installation
Installation
de PyCharm

Installation
Installation
de PyCharm

Installation
Installation
de PyCharm

Installation
Installation
de PyCharm

Installation
Installation
de PyCharm

Installation
Installation
de PyCharm

Installation
Création d’un
nouveau projet

Installation
Création d’un
nouveau projet

Installation
Création d’un
nouveau projet

Les Variables

Les variables
54tr=36 # déclenche une erreur (SyntaxError: invalid syntax)

Identificateur
k,r=36 # déclenche une erreur
Variable
g!r=36 # déclenche une erreur
Type def=25 # déclenche une erreur
Règles générales :
1. Le nom des variables Python doit commencer par une lettre ou un trait de soulignement. Exemples: var, _var=3,6
2. Un chiffre ne peut pas être la première lettre d'un nom de variable.
3. À l'exception de la première lettre d'un nom de variable, les lettres restantes peuvent être caractères minuscules (az),
caractères majuscules (AZ), trait de soulignement (_) ou chiffre (0-9).
4. L'espace blanc ou caractères spéciaux comme (!,$,%,@,#,&,* …) ne doivent pas faire partie du nom de la variable
Python.
5. Les variables Python ne doivent pas être identiques au mot réservé comme (in and or if del for is raise assert elif from
lambda return break else global not try class except while continue exec import pass yield def finally ). Les mots ou mots clés
réservés sont définis avec une signification et une syntaxe prédéfinies dans la langue.
6. Les variables Python sont sensibles à la casse. Par exemple, var et Var sont considérés comme deux variables différentes.

Les variables
Il est toujours recommandé d'avoir un nom significatif pour une variable. Il rend le code facile à lire lorsque le
nom de la variable est descriptif. Même les noms de variables à plusieurs mots sont acceptables. Nous
pouvons créer des variables multi-mots en utilisant les méthodes ci-dessous:
Forme de chameau
Chaque mot ou abréviation au milieu de la phrase commence par une majuscule, sans espace ni ponctuation.
Exemples: employeeId, nameOfTheEmployee, ageOfTheEmployee
Forme de Pascal
C'est la même chose que le cas du chameau sauf que la première lettre est également en majuscule.
Exemples: EmployeeId, NameOfTheEmployee, AgeOfTheEmployee
Forme de serpent
Ici, nous utilisons un trait de soulignement (_) pour séparer les mots.
Exemples: id_employé, nom_du_employé, age_de_le_employé

Les variables
Simples (int, float, complex)

Structures de données
Composites (Tuples, Listes,
Dictionnaires et Sets)

Les variables
Définition : type immuable (ou immutable)
Une variable de type immuable ne peut être modifiée. Une opération sur une variable de ce type entraîne
nécessairement la création d’une autre variable du même type, même si cette dernière est temporaire.
Autrement dit, la simple instruction x+=3 qui consiste à ajouter à la variable x la valeur 3 crée une seconde variable dont la
valeur est celle de x augmentée de 3 puis à en recopier le contenu dans celui de la variable x. Les nombres sont des types
immuables tout comme les chaînes de caractères et les tuple qui sont des tableaux d’objets. Il n’est pas possible de modifier
une variable de ce type, il faut en recréer une autre du même type qui intègrera la modification.
• Lorsque nous attribuons la même valeur à deux variables différentes, - (x=3) --> id(x) : 1798602928
cela crée un seul objet et les deux variables font référence au même - (x=3) --> type(x) : <class 'int'>
objet. C'est pourquoi nous obtenons le même identifiant lors de - (x+=1) --> id(x) : 1798602960
l'impression de l'id () des deux variables. (Exemple : x,y=25,25  - (x+=1) --> type(x) : <class 'int'>
id(x)=id(y)) - (x+=0.5) --> id(x) : 2985067683960
• Lorsque nous attribuons une valeur différente aux variables, cela - (x+=0.5) --> type(x) : <class 'float'>
crée deux objets différents et nous obtenons donc deux sorties - (L=[0,1,2]) --> id(L) : 2985102564424
différentes. - (L=[0,1,2]) --> type(L) : <class 'list'>
- (L.append(3)) --> id(L) : 2985102564424
- (L.append(3)) --> type(L) : <class 'list'>

Les variables (Type: None)
Type « rien » ou None (Type 1)
python propose un type None pour signifier qu’une variable ne contient rien.
La variable est de type None et est égale à None.
s = None - (n = None) --> n : None

print(s) # affiche None - (n = None) --> id(n) : 1798143280
- (n = None) --> type(n) : <class 'NoneType'>
Nombres réels et entiers (Type 2)
Il existe deux types de nombres en python, les nombres réels float et les
nombres entiers int.
x=3
y = 3.0 >>> x = 3 <class 'int'>
print("x =", x, type(x)) y = 3.0 <class 'float'>
print("y =", y, type(y))

Les variables (Types int, float et complex)
Exemples de structures de données simples et immutables
Parmi les structures de données simples on peut citer les types des nombres
entiers int, des nombres réels float et les types de nombres complexes complex.
Ces structures de données représentent des types immutables.
x = 3 # donne une variable de type int

y = 3.5 # donne une variable de type float
z = 3 + 5j # donne une variable de type complex
print("x:", type(x), " y:", type(y), " z:", type(z))

# affiche x: <class 'int'> y: <class 'float'> z: <class 'complex'>

Les variables (Types int, float et complex)
Fonctions de conversion
Les fonctions int et float permettent de convertir un nombre quelconque ou une

chaîne de caractères respectivement en un entier (arrondi) et en un nombre réel.
x = int(3.5)
y = float(3)
>>> x: <class 'int'> y: <class
z = int("3")
print("x:", type(x), " y:", type(y), " z:",
'float'> z: <class 'int'>
type(z))
Attention: Si on veut convertir une chaîne de caractères en entier mais cette

chaîne représente un réel. Il faut d’abord la convertir en réel puis en entier
i = int ("3.5") # provoque une erreur
i = int (float ("3.5")) # fonctionne

Les variables (Opérations possibles)
opérateur signification exemple

+- addition, soustraction x=y+z
+= -= addition ou soustraction puis affectation x += 3
* / multiplication, division x=y*z
// division entière, le résultat est de type réel si x = y // 3
l’un des nombres est réel
% reste d’une division entière (modulo) x=y%3
*= /= multiplication ou division puis affectation x *= 3
** puissance (entière ou non, racine carrée = ** x = y ** 3
0.5)
<< >> décalage à gauche, à droite (8=1000 << 116 ) (8 >> 14 )
| opérateur logique ou bit à bit (8=1000 | 2=001010=1010)
& opérateur logique et bit à bit (10=1010 & 2=00102=0010)
Les variables (Booléen)
Booléen (Type 3)
Les booléens sont le résultat d’opérations logiques et ont deux valeurs
possibles : True ou False.

and or et, ou logique x = True or False
(résultat = True)
not négation logique x = not x
Exemple :
x=4<5
print(x) # affiche True
print(not x) # affiche False

Les variables (Booléen)
Booléen
La liste des opérateurs de comparaisons
<> inférieur, supérieur x=5 <5
<= >= inférieur ou égal, supérieur ou égal x = 5 <= 5
== != égal, différent x = 5 == 5
Il existe deux autres mots-clés qui retournent un résultat de type booléen :

is test d’identification "3" is str
in test d’appartenance 3 in [3, 4, 5]

Les variables (Chaines de caractères)
Chaîne de caractères (Type 4)

Le terme « chaîne de caractères » ou string en anglais signifie une suite finie de
caractères, autrement dit, du texte.
t = "string = texte " # initialisation avec guillemets

t = 'string = texte‘ # initialisation avec apostrophes
t = "morceau 1" \
"morceau 2" # second morceau ajouté au premier par l'ajout du
symbole \, il ne doit rien y avoir après le symbole \, pas d'espace ni de
commentaire
t = """première ligne
seconde ligne""" # chaîne de caractères qui s'étend sur deux lignes

Manipulation d’une chaîne de caractères

Une chaîne de caractères est semblable à un tableau et certains opérateurs
qui s’appliquent aux tableaux s’appliquent également aux chaînes de
caractères.
La fonction str() permet de convertir un nombre, un tableau, un objet en

chaîne de caractères afin de pouvoir l’afficher. La fonction len() retourne la
longueur de la chaîne de caractères.
x = 5.567
s = str(x)
print(type(s), s) # <type 'str'> 5.567
print(len(s)) # affiche 5


+ concaténation de chaînes de caractères t = "abc" + "def"
+= concaténation puis affectation t += "abc"
in, not in une chaîne en contient-elle une autre ? "ed" in "med"
* répétition d’une chaîne de caractères t = "abc" * 4
[n] obtention du enième caractère, le premier t = "abc"
caractère a pour indice 0 print(t[0]) # donne a
[i:j] obtention des caractères compris entre les t = "abc"
indices i et j-1 inclus, le premier caractère a print(t[0:2]) # donne ab
pour indice 0


count( sub[, s Retourne le nombre d’occurences de la chaîne de caractères sub, les s="les lettres et chiffres"
tart[, end]]) paramètres par défaut start et end permettent de réduire la recherche entre print(s.count('res')) # affiche 2
les caractères d’indice start et end exclu. Par défaut, start est nul tandis print(s.count('res',10)) # affiche 1
que end correspond à la fin de la chaîne de caractères. print(s.count('res',10,23)) #  1
find( sub[, sta Recherche une chaîne de caractères sub, les paramètres par print(s.find('res')) # affiche 8
rt[, end]]) défaut start et end ont la même signification que ceux de la fonction count. print(s.find('res',8,10)) # affiche -1
Cette fonction retourne -1 si la recherche n’a pas abouti.
isalpha() Retourne True si tous les caractères sont des lettres, False sinon. print(s.isalpha()) # affiche False
isdigit() Retourne True si tous les caractères sont des chiffres, False sinon. print(s.isdigit()) # affiche False
replace( old, Retourne une copie de la chaîne de caractères en remplaçant toutes les print(s.replace('e','_',2)) # affiche
new[, count]) occurrences de la chaîne old par new. Si le paramètre optionnel count est l_s l_ttres et chiffres
renseigné, alors seules les count premières occurrences seront remplacées.
split( [sep [,m Découpe la chaîne de caractères en se servant de la chaîne sep comme print(s.split('e',2)) # affiche une
axsplit]]) délimiteur. Si le paramètre maxsplit est renseigné, au plus maxsplit coupures liste de trois éléments ['l', 's l',
seront effectuées. 'ttres et chiffres']

upper() Remplace les minuscules par des majuscules.

lower() Remplace les majuscules par des minuscules.
join ( li ) li est une liste, cette fonction agglutine tous les éléments d’une liste
séparés par sep dans l’expression sep.join ( ["un", "deux"]).
startswith(prefix[, start Teste si la chaîne commence par prefix.
[, end]])
endswith(suffix[, start[, Teste si la chaîne se termine par suffix.
end]])
Exemples :
st = "langage python"
print(st.startswith('gage',3,20)) # affiche True
print(st.endswith('py',3,20)) # affiche False
print(st.index("p")) # affiche 8
print(st.count("python")) # affiche 1
print(st.count("python", 9)) # affiche 0
Formatage d’une chaîne de caractères (1/3)
Syntaxe %
".... %c1 .... %c2 " % (v1,v2)
Avec ci indique le format dans lequel la variable vi devra être transcrite
Exemple de Code Désignation

d entier relatif
e nombre réel au format exponentiel
f nombre réel au format décimal
g nombre réel, format décimal ou exponentiel si
la puissance est trop grande ou trop petite
s chaîne de caractères

x = 5.5
y=7
s = "caractères"
res = "un nombre réel %f et un entier %d, une chaîne de %s, \n" \
"un réel d'abord converti en chaîne de caractères %s" % (
x, y, s, str(x + 4))
print(res)
res = "un nombre réel " + str(x) + " et un entier " + str(d) + \
", une chaîne de " + s + \
",\n un réel d'abord converti en chaîne de caractères " + str(x + 4)
print(res)
un nombre réel 5.500000 ou 5.5 et un entier 7, une chaîne de caractères,

un réel d'abord converti en chaîne de caractères 9.5
>>>
un nombre réel 5.5 et un entier 7, une chaîne de caractères,
un réel d'abord converti en chaîne de caractères 9.5


"%n.df" % x
n est le nombre de chiffres total et d est le nombre de décimales, f désigne

un format réel indiqué par la présence du symbole %.
Exemple:
x = 0.123456789
print(x) # affiche 0.123456789
print("%1.2f" % x) # affiche 0.12
print("%06.2f" % x) # affiche 000.12
print("%09.2f" % x) # affiche 000000.12


Méthode format
La méthode format propose plus d’options pour formater le texte et son
usage est de plus en plus fréquent. La méthode interprète les accolades {}
comme des codes qu’elle remplace avec les valeurs passée en argument. Le
type n’importe plus. Quelques exemples :
print('{0}, {1}, {2}'.format('a', 'b', 'c')) # le format le plus simple

print('{}, {}, {}'.format('a', 'b', 'c')) # sans numéro
print('{2}, {1}, {0}'.format('a', 'b', 'c')) # ordre changé
print('{0}{1}{0}'.format('abra', 'cad')) # répétition
a, b, c
a, b, c
>>>
c, b, a
abracadabra

Méthode format
La méthode accepte aussi les paramètres nommées et des expressions:
print('Coordinates: {latitude}, {longitude}'.format(

latitude='37.24N', longitude='-115.81W')) >>>
coord = (3, 5) Coordinates: 37.24N, -115.81W
print('X: {0[0]}; Y: {0[1]}'.format(coord))
X: 3; Y: 5
print('{:.2%}'.format(19.0 / 22.0))
>>>
print("int: {0:d}; hex: {0:x}; oct: {0:o}; bin:
{0:b}".format(42)) 86.36%
print("int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: int: 42; hex: 2a; oct: 52; bin: 101010
{0:#b}".format(42)) int: 42; hex: 0x2a; oct: 0o52; bin:
print('{:,}'.format(1234567890)) 0b101010
1,234,567,890

Exercice 1:
Définir une chaine de caractères : ch="il a 50 ans, 11 mois et 25 jours", puis effectuez les
actions suivantes :
– calculez la longueur de la chaine ch;
– vérifiez si la chaine ch contient le chiffre 30;
– calculez le nombre d’apparition de la lettre i dans la chaine ch;
– affichez l’indice de la lettre m dans la chaine ch;
– divisez la chaine ch en une liste l en prenant la chaine d’espace " " comme délimiteur;
– Reconstruisez la chaine ch en concaténant les éléments de la liste l;
– affichez les caractères du 10eme au 16eme élément de la chaine ch;
– affichez le 14ème caractère de la chaine ch ;
– vérifiez si la chaine ch est numérique ou non;
– vérifiez si la chaine ch se termine par "ours" .
Les variables (Tuples)
Tuple
Les tuples sont un tableau d’objets qui peuvent être de tout type. Ils ne sont
pas modifiables (les tuple sont immuables ou immutable)
Un tuple apparaît comme une liste d’objets compris entre parenthèses et

séparés par des virgules. Leur création reprend le même format :
x = (4,5) # création d'un tuple composé de 2 entiers

x = ("un",1,"deux",2) # création d'un tuple composé de 2 chaînes de
caractères et de 2 entiers, l'ordre d'écriture est important
x = (3,) # création d'un tuple d'un élément, sans la virgule,
# le résultat est un entier

x in s vrai si x est un des éléments de s

x not in s réciproque de la ligne précédente
s+t concaténation de s et t
s*n concatène n copies de s les unes à la suite des autres
s[i] retourne le ième élément de s
s[i:j] retourne un tuple contenant une copie des éléments
de s d’indices i à j exclu
s[i:j:k] retourne un tuple contenant une copie des éléments de s dont les
indices sont compris entre i et j exclu, ces indices sont espacés de k :
len(s) nombre d’éléments de s
min(s) plus petit élément de s, résultat difficile à prévoir lorsque les types
des éléments sont différents
max(s) plus grand élément de s
sum(s) retourne la somme de tous les éléments

Tuple
Les tuples ne sont pas modifiables (ou mutables), cela signifie qu’il est
impossible de modifier un de leurs éléments. Par conséquent, la ligne
d’affectation suivante n’est pas correcte :
x = ("un",[1,2,3],"deux",2)
x [0] = 3 # déclenche une erreur d'exécution
x[1][1]=5
print(x) # affiche ('un', [1, 5, 3], 'deux', 2)
a,b=2,3
c=(a,b)
print(c) # affiche (2, 3)
c=(b,a)
print(c) # affiche (3, 2)

Les variables (Types mutables)
Types modifiables ou mutables

Définition :
Une variable de type modifiable peut être modifiée, elle conserve le même
type et le même identificateur. C’est uniquement son contenu qui évolue.
Liste
Dictionnaire
Ensemble ou set

Les variables (Listes)
Liste
Définition :
Les listes sont des collections d’objets qui peuvent être de tout type. Elles sont
modifiables. Une liste apparaît comme une succession d’objets compris entre
crochets et séparés par des virgules.
x = [4,5] # création d'une liste composée de deux entiers

x = ["un",1,"deux",2] # création d'une liste composée de
# deux chaînes de caractères
# et de deux entiers, l'ordre d'écriture est important
x = [3,] # création d'une liste d'un élément, sans la virgule,
# le résultat reste une liste
x=[] # crée une liste vide
x = list () # crée une liste vide
y = x [0] # accède au premier élément
y = x [-1] # accède au dernier élément

x in l vrai si x est un des éléments de l

Opérations x not in l réciproque de la ligne précédente
sur les listes l+t concaténation de l et t
l*n concatène n copies de l les unes à la suite des autres
l[i] retourne l’élément i$^text{ème}$ élément de l, à la différence des tuples,
l’instruction l [i] = "a" est valide, elle remplace l’élément i par "a". Un indice
négatif correspond à la position len(l)+i.
l[i:j] retourne une liste contenant les éléments de l d’indices i à j exclu. Il est possible
de remplacer cette sous-liste par une autre en utilisant
l’affectation l[i:j] = l2 où l2 est une autre liste (ou un tuple) de dimension
différente ou égale.
l[i:j:k] retourne une liste contenant les éléments de l dont les indices sont compris
entre i et j exclu, ces indices sont espacés de k : Ici encore, il est possible d’écrire
l’affectation suivante : l[i:j:k] = l2 mais l2 doit être une liste (ou un tuple) de
même dimension que l[i:j:k].
len(l) nombre d’éléments de l

min(l) plus petit élément de l, résultat difficile à prévoir lorsque les types des
éléments sont différents
Opérations max(l) plus grand élément de l
sur les listes sum(l) retourne la somme de tous les éléments
del l [i:j] supprime les éléments d’indices entre i et j exclu. Cette instruction est
équivalente à l [i:j] = [].
list (x) convertit x en une liste quand cela est possible
l.count (x) Retourne le nombre d’occurrences de l’élément x. Cette notation suit la
syntaxe des classes développée au chapitre Classes. count est une méthode
de la classe list.
l.index (x) Retourne l’indice de la première occurrence de l’élément x dans la liste l. Si
celle-ci n’existe pas, une exception est déclenchée (voir le
paragraphe Exceptions)
l.append (x) Ajoute l’élément x à la fin de la liste l. Si x est une liste, cette fonction ajoute la
liste x en tant qu’élément, au final, la liste l ne contiendra qu’un élément de
plus.
l.extend (k) Ajoute tous les éléments de la liste k à la liste l. La liste l aura autant
d’éléments supplémentaires qu’il y en a dans la liste k.
l.insert(i,x) Insère l’élément x à la position i dans la liste l.

Opérations l.remove(x) Supprime la première occurrence de l’élément x dans la
sur les listes liste l. S’il n’y a aucune occurrence de x, cette méthode
déclenche une exception.
l.pop(i) Retourne l’élément l[i] et le supprime de la liste. Le
paramètre i est facultatif, s’il n’est pas précisé, c’est le dernier
élément qui est retourné puis supprimé de la liste.
l.reverse() Retourne la liste, le premier et dernier élément échange leurs

places, le second et l’avant dernier, et ainsi de suite.
l.sort (key=None, re Cette fonction trie la liste par ordre croissant. Le
verse=False) paramètre key est facultatif, il permet de préciser la fonction
qui précise la clé de comparaison qui doit être utilisée lors du
tri. Si reverse est True, alors le tri est décroissant.

x = [9, 0, 3, 5, 4, 7, 8] # définition d'une liste [9, 0, 3, 5, 4, 7, 8]

Opérations print(x) # affiche cette liste >>> [0, 3, 4, 5, 7, 8, 9]
sur les listes x.sort() # trie la liste par ordre croissant
print(x) # affiche la liste triée
x = [9,0,3,5,0]
print(x.index(1)) # cherche la position de >>> ValueError: list.index(x): x not in list
l'élément 1
x = [9, 0, 3, 5, 0]
try:
print(x.index(1)) >>> 1 n'est pas présent dans la liste x
except ValueError:
print("1 n'est pas présent dans la liste x")
else:
print("trouvé")

Opérations sur les listes

- l : [0, 4, 6, 8] - l.count(5) : 3
- t : [5, 9, 0, 1, 5, 5] - l.index(5) : 1
- 3 in l : False - 50 n'est pas présent dans la liste [8, 5, 9, 0, 1, 5, 5]
- 4 in l : True - l.append([5,6,7]) : [8, 5, 9, 0, 1, 5, 5, [5, 6, 7]]
- 4 not in l : False - l.extend([15,16,17]) : [8, 5, 9, 0, 1, 5, 5, [5, 6, 7], 15,
- l+t : [0, 4, 6, 8, 5, 9, 0, 1, 5, 5] 16, 17]
- l*3 : [0, 4, 6, 8, 0, 4, 6, 8, 0, 4, 6, 8] - l.insert(0,1) : [1, 8, 5, 9, 0, 1, 5, 5, [5, 6, 7], 15, 16, 17]
- l : [0, 4, 6, 8, 5, 9, 0, 1, 5, 5] - l.remove(1) : [8, 5, 9, 0, 1, 5, 5, [5, 6, 7], 15, 16, 17]
- l[2] : 6 - l.pop(7) : [5, 6, 7]
- l[4:9] : [5, 9, 0, 1, 5] - l : [8, 5, 9, 0, 1, 5, 5, 15, 16, 17]
- l[4:9:2] : [5, 0, 5] - l.pop() : 17
- len(l) : 10 - l : [8, 5, 9, 0, 1, 5, 5, 15, 16]
- min(l) : 0 - l.reverse() : [16, 15, 5, 5, 1, 0, 9, 5, 8]
- max(l) : 9 - l.sort() : [0, 1, 5, 5, 5, 8, 9, 15, 16]
- sum(l) : 43 - l.sort(reverse=True) : [16, 15, 9, 8, 5, 5, 5, 1, 0]
- del l[0:3] : [8, 5, 9, 0, 1, 5, 5]

Liste
Fonction range
Les listes sont souvent utilisées dans des boucles ou notamment par l’intermédiaire
de la fonction range. Cette fonction retourne un itérateur sur des entiers:
range ([debut,] fin [,pas])
print(range(0, 10, 2)) range(0, 10, 2)

print(list(range(0, 10, 2))) >>> [0, 2, 4, 6, 8]
s=0
for n in range (1,20,2) : # ce programme est équivalent à
s += n # s = sum(range(1,20,2))

Boucles et listes
Il est possible aussi de ne pas se servir des indices comme intermédiaires
pour accéder aux éléments d’une liste quand il s’agit d’effectuer un même
traitement pour tous les éléments de la liste
x = ["un", 1, "deux", 2] la liste inclut : un

for el in x: >>> la liste inclut : 1
print("la liste inclut : ", el) la liste inclut : deux
la liste inclut : 2
y = list()
for i in range(0, 5):
y.append(i + 1) >>> [1, 2, 3, 4, 5]
print(y)

Boucles et listes
Le langage python offre la possibilité de résumer cette écriture en une seule ligne.
y = [i + 1 for i in range(0, 5)]

print(y) # affiche [1, 2, 3, 4, 5]
Cette définition de liste peut également inclure des tests ou des boucles
imbriquées.
y = [i for i in range(0, 5) if i % 2 == 0] # sélection les éléments pairs

print(y) # affiche [0,2,4]

Copie
Le signe égal = peut être utilisé pour construire une copie d’une liste.
Cependant, la nouvelle liste sera liée à la liste existante. Cela signifie que la
nouvelle liste sera également modifiée si vous mettez à jour la liste originale.
La nouvelle liste se réfère à un élément similaire à l’ancienne liste.
La meilleure solution pour copier une liste qui sera indépendante de la liste
d’origine est la fonction copie().
l = [4, 5, 6]
l2 = l
print(l) # affiche [4,5,6]
print(l2) # affiche [4,5,6]
l2[1] = "modif"
print(l) # affiche [4, 'modif', 6]
print(l2) # affiche [4, 'modif', 6]

Copie
Pour copier une liste, on peut utiliser la fonction copy du module copy
Exemple 1: Exemple 2:
import copy import copy

l = [4, 5, 6] l = [1, 2, 3]
l2 = copy.copy(l) l2 = copy.copy(l)
print(l) # affiche [4,5,6] l3 = l
print(l2) # affiche [4,5,6]
l2[1] = "modif" print(l == l2) # affiche True
print(l) # affiche [4,5,6] print(l is l2) # affiche False
print(l2) # affiche [4, 'modif', 6] print(l is l3) # affiche True

Fonction ``copy`` et ``deepcopy``

Le comportement de la fonction copy peut surprendre dans le cas où une liste contient
d’autres listes. Pour être sûr que chaque élément d’une liste a été correctement
recopiée, il faut utiliser la fonction deepcopy.
import copy
l = [[1, 2, 3], [4, 5, 6]]
l2 = copy.copy(l)
l3 = copy.deepcopy(l)
l[0][0] = 1111
print(l) # affiche [[1111, 2, 3], [4, 5, 6]]
print(l2) # affiche [[1111, 2, 3], [4, 5, 6]]
print(l3) # affiche [[1, 2, 3], [4, 5, 6]]
print(l is l2) # affiche False
print(l is l3) # affiche False
print(l[0] is l2[0]) # affiche True
print(l[0] is l3[0]) # affiche False

Exercice 2:
Définir la liste : liste =[15, 10, 5, 20, 35], puis effectuez les actions suivantes :
– triez de manière décroissante et affichez la liste ;
– ajoutez l’élément 60 à la liste et affichez la liste ;
– renversez et affichez la liste ;
– affichez l’indice de l’élément 35;
– enlevez l’élément 20 et affichez la liste ;
– affichez la sous-liste du 2eme au 4eme élément ;
– affichez la sous-liste du début au 3eme élément ;
– affichez la sous-liste du 3eme élément à la fin de la liste ;
– calculer le nombre d’apparition du l’élément 5 ;
– dupliquez la liste 2 fois.

Les variables (Dictionnaires)
Dictionnaire
Les dictionnaires sont des listes de couples. Chaque couple contient une clé
et une valeur. Chaque valeur est connue par sa clé. La valeur peut-être de
tout type, la clé doit être de type immuable, ce ne peut donc être ni une liste,
ni un dictionnaire. Chaque clé comme chaque valeur peut avoir un type
différent des autres clés ou valeurs.
Un dictionnaire apparaît comme une succession de couples d’objets comprise

entre accolades et séparés par des virgules. La clé et sa valeur sont séparées
par le symbole : .
x = { "cle1":"valeur1", "cle2":"valeur2" }
y={} # crée un dictionnaire vide
z = dict() # crée aussi un dictionnaire vide
print(x["cle1"]) #affiche valeur1
La plupart des fonctions disponibles pour les listes sont interdites pour les - dict = {'nom': 'ali', 'age': 20, 'fonction':
dictionnaires comme la concaténation ou l’opération de multiplication. Les 'étudiant'}
seuls repères des éléments d’un dictionnaire sont leurs clés. - dict['nom'] : ali
- dict1.get('age') : 20
- dict1.get('ville') : None
x in d vrai si x est une des clés de d - dict1["ville"]="rabat"
x not in d réciproque de la ligne précédente - dict1["pays"]="maroc"
- dict : {'nom': 'ali', 'age': 20, 'fonction':
d[i] retourne l’élément associé à la clé i 'étudiant', 'ville': 'rabat', 'pays': 'maroc'}
len(d) nombre d’éléments de d - type(dict) : <class 'dict'>
- len(dict1) : 5
min(d) plus petite clé
- min(dict1) : age
max(d) plus grande clé - max(dict1) : ville
- 'nom' in dict1 : True
del d [i] supprime l’élément associé à la clé i
- 'ali' in dict1 : False
list (d) retourne une liste contenant toutes les clés du dictionnaire d - 'ali' in dict1.values() : True
for cle,valeur in dict2.items():
dict (x) convertit x en un dictionnaire si cela est possible, d est alors print("- la clé -%s- contient la valeur -%s-
égal à dict ( d.items () ) "%(cle,valeur)) # affiche les clés et leurs valeurs
d.copy () Retourne une copie de d

d.items () Retourne un itérateur sur tous les couples (clé, valeur) inclus dans le
dictionnaire.
d.keys () Retourne un itérateur sur toutes les clés du dictionnaire d
d.values () Retourne un itérateur sur toutes les valeurs du dictionnaire d
d.get (k[,x]) Retourne d[k]. Mais si la clé k est manquante, alors la

valeur None est retournée à moins que le paramètre optionnel x soit
renseigné, auquel cas, ce sera cette valeur qui sera retourné.
d.clear () Supprime tous les éléments du dictionnaire.
d.update(d2) Le dictionnaire d reçoit le contenu de d2.
d.setdefault(k[,x]) Définit d[k] si la clé k existe, sinon, affecte x à d[k]
d.pop() Retourne un élément et le supprime du dictionnaire.

Dictionnaire
Les variables (Dictionnaires) Exemples:
d = {"un": 1, "zéro": 0, "deux": 2, "trois": 3, "quatre": 4, "cinq": 5,
"six": 6, "sept": 1, "huit": 8, "neuf": 9, "dix": 10}
key = list(d.keys())
key.sort()
for k in key:
print(k, d[k]) # permet d’afficher tous les éléments d’un dictionnaire
selon un ordre croissant des clés.
d = {"un": 1, "zero": 0, "deux": 2, "trois": 3, "quatre": 4, "cinq": 5,

"six": 6, "sept": 1, "huit": 8, "neuf": 9, "dix": 10}
dinv = {} # création d'un dictionnaire vide, on parcourant

for key, value in d.items(): # les éléments du dictionnaire comme si
# c'était une liste de 2-uple (clé,valeur)
dinv[value] = key # on retourne le dictionnaire
print(dinv) # affiche {0: 'zero', 1: 'un', 2: 'deux‘, # 3: 'trois', 4: 'quatre',
5: 'cinq', 6: 'six‘, # 8: 'huit', 9: 'neuf', 10: 'dix'}
Dictionnaire
Fonctions ``copy`` et ``deepcopy``

d = {4: 4, 5: 5, 6: 6}
d2 = d
print(d) # affiche {4: 4, 5: 5, 6: 6}
print(d2) # affiche {4: 4, 5: 5, 6: 6}
d2[5] = "modif"
print(d) # affiche {4: 4, 5: 'modif', 6: 6}
print(d2) # affiche {4: 4, 5: 'modif', 6: 6}
d = {4: 4, 5: 5, 6: 6}
d2 = d.copy()
print(d) # affiche {4: 4, 5: 5, 6: 6}
print(d2) # affiche {4: 4, 5: 5, 6: 6}
d2[5] = "modif"
print(d) # affiche {4: 4, 5: 5, 6: 6}
print(d2) # affiche {4: 4, 5: 'modif', 6: 6}
Il en est de même pour la remarque concernant la fonction deepcopy. Cette

fonction recopie les listes et les dictionnaires.
Les variables (Set)
Ensemble ou set
Les ensemble ou sets forment un autre type de données composites Python.
Un ensemble est une collection d’éléments non ordonnée, sans index et qui ne
peut pas posséder l’élément dupliqué.
Une des utilisation les plus courantes des ensembles est de les utiliser pour
supprimer des valeurs doublons à partir d’un autre type de données.
Pour créer un ensemble, nous allons utiliser une paire d’accolades { } et placer
les différents éléments de notre ensemble entre ces accolades en les séparant
avec une virgule.
NB: Notez que pour créer un ensemble vide il faudra utiliser la fonction set()
car la syntaxe { } va créer un dictionnaire vide et non pas un ensemble vide.

Les variables (Set)
Ensemble ou set
Exemples:
e1=set() # Initialise Ensemble vide

e1={1,2,1,3,1,4} # Affiche l‘ensemble {1, 2, 3, 4}
e2={"Yassine", 2, "Karim", 3, "Yassine", 3}
print(e2) # Affiche l‘ensemble {2, 3, 'Yassine', 'Karim'}
print(set((1, 2, 3)) & set((2, 3, 5)))

# construit l'intersection qui est set([2, 3])

Les variables (Set)
set1 = set() # Nouvel ensemble vide #1stitem = set1[0] # Erreur d'index introuvable
set1.add("cat") # Ajout d'un membre isempty = len(set1) == 0 # Test si l'ensemble est vide
print(set1) # Affiche {'cat'} set1 = set(["cat", "dog"]) # Initialisation de l'ensemble depuis une
set1.update(["dog", "mouse"]) # Ajout de plusieurs liste de membre
membres print(set1) # Affiche {'dog', 'cat'}
print(set1) # Affiche {'dog', 'cat', 'mouse'} set2 = set(["dog", "mouse"])
if "cat" in set1: # Recherche d'un membre print(set2) # Affiche {'dog', 'mouse'}
set1.remove("cat") # Retrait d'un membre set3 = set1 & set2 # Intersection
print(set1) # Affiche {'dog', 'mouse'} print(set3) # Affiche {'dog'}
#set1.remove("elephant") - Erreur de retrait d'un set4 = set1 | set2 # Union
membre introuvable print(set4) # Affiche {'dog', 'cat', 'mouse'}
set1.discard("elephant") # Aucune erreur de retrait set5 = set1 - set3 # Différence
d'un membre introuvable print(set5) # Affiche {'cat'}
print(set1) # Affiche {'dog', 'mouse'} set7 = set1.copy() # Copie d'un ensemble
print(set7) # Affiche {'dog', 'cat'}
set7.remove("cat")
for item in set1: # Itération pour chaque élément print(set7) # Affiche {'dog'}
print(item) # Affiche dog puis mouse set8 = set1.copy()
print("Item count:", len(set1)) # Compte des éléments - print(set8) # Affiche {'dog', 'cat'}
affiche 2 set8.clear() # Effacement d'un ensemble

Les variables
En résumé :
• Les listes sont des collections d’éléments ordonnés et altérables qui

peuvent contenir plusieurs fois la même valeur ;
• Les tuples sont des collections d’éléments ordonnés et immuables
qui peuvent contenir plusieurs fois la même valeur ;
• Les dictionnaires sont des collection d’éléments non ordonnés mais
indexés avec des clefs de notre choix et altérables qui n’acceptent
pas de contenir plusieurs fois le même élément ;
• Les ensembles sont des collections d’éléments non ordonnées, non
indexés et non modifiables qui n’acceptent pas de contenir
plusieurs fois le même élément.

-Indentation
-Quelques Fonctions utiles

Fonctions utiles
L’indentation
L’indentation est synonyme de décalage. Pour toute boucle, test, fonction, et plus tard, toute
définition de classe, le fait d’indenter ou décaler les lignes permet de définir une
dépendance d’un bloc de lignes par rapport à un autre.
Contrairement à d’autres langages comme le C ou JAVA, python n’utilise pas de délimiteurs

pour regrouper les lignes. L’indentation, souvent présentée comme un moyen de rendre les
programmes plus lisibles, est ici intégrée à la syntaxe du langage. Il n’y a pas non plus de
délimiteurs entre deux instructions autre qu’un passage à la ligne. Le caractère \ placé à la
fin d’une ligne permet de continuer l’écriture d’une instruction à la ligne suivante.
x = ["un", 1, "deux", 2] a="je suis "\

for el in x: "en vacances"
print("la liste inclut : ", el) x=\
y = list() 3
for i in range(0, 5): print(a) # affiche « je suis en vacances»
y.append(i + 1) print(x) # affiche 3
print(y)

Fonctions utiles
Fonction print, str et eval

 La fonction print permet d’afficher une ou plusieurs variables préalablement définies,
séparées par des virgules.
 La fonction str permet de convertir toute variable en chaîne de caractères.
 la fonction eval permet d’évaluer une chaîne de caractères ou plutôt de l’interpréter

comme si c’était une instruction en python.
32 + 9 = 41
32 - 9 = 23
x = 32
32 * 9 = 288
y=9 32 / 9 = 3.5555555555555554
32 % 9 = 5
op = "+ - * / % // & | and or << >>".split() 32 // 9 = 3
>>> 32 & 9 = 0
for o in op: 32 | 9 = 41
s = str(x) + " " + o + " " + str(y) 32 and 9 = 9
32 or 9 = 32
print(s, " = ", eval(s)) 32 << 9 = 16384
32 >> 9 = 0

Fonctions utiles
Fonction input
La plupart des scripts élaborés nécessitent à un moment ou l'autre une
intervention de l'utilisateur (entrée d'un paramètre, clic de souris sur un bouton,
etc.). Dans un script simple en mode texte (comme ceux que nous avons créés
jusqu'à présent), la méthode la plus simple consiste à employer la fonction
intégrée input(). Cette fonction provoque une interruption dans le programme
courant. L'utilisateur est invité à entrer des caractères au clavier et à terminer
avec la touche <Enter>.
prenom = input('Entrez votre prénom (entre guillemets) : ')

print ('Bonjour,', prenom)
print("Donnez une valeur entiere :")

nbr = int(input(" nombre entier = "))

01 - Semma - INSEA (La Base Du Langage Python)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

01 - Semma - INSEA (La Base Du Langage Python)

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Avancée

Chapitre 1 : La Base du langage Python

Cours 1ère année S2

Les Bases du langage Python

Syntaxe du langage Python (if-boucles-Fonctions et Modules)

Interfaces Graphiques et Programmation évenementielle (Lib : tkinter)

Bases de données et Python

Principales librairies (Numpy, Matplotlib …)

K.ELHARI 2015-2016 2 S1 : Architecture des Ordinateurs

 Crée par : Guido Van Rossum en 1989

 Première version publiée : V 0.9 en Février 1991

K.ELHARI 2015-2016 3 S1 : Architecture des Ordinateurs

Parmi les entreprises tech les plus prospères du moment,

K.ELHARI 2015-2016 4 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

 Multiplateforme : Windows, Mac OS X, Linux, Android, iOS

 Simple : Peu de connaissances en algorithmique

 Langage interprété : Un script Python n’a pas besoin d’être compilé

pour être exécuté, contrairement à des langages comme le C ou le C++

 Très utilisé en analyse de données et IA

K.ELHARI 2015-2016 6 S1 : Architecture des Ordinateurs

 Installation d’une version de python 3.6 ou plus

 Installation d’un éditeur comme PyCharm, Anaconda et Visual Studio

 Installation des librairies an cas de besoin comme Numpy, Pandas,

Seaborn, Matplotlib, Tensorflow, PyTorch, Requests, BeautifulSoup …

K.ELHARI 2015-2016 7 S1 : Architecture des Ordinateurs

Choix de la version de python

K.ELHARI 2015-2016 8 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 9 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 13 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 22 S1 : Architecture des Ordinateurs

54tr=36 # déclenche une erreur (SyntaxError: invalid syntax)

K.ELHARI 2015-2016 23 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 S1 : Architecture des Ordinateurs

Simples (int, float, complex)

K.ELHARI 2015-2016 25 S1 : Architecture des Ordinateurs

K.ELHARI 2015-2016 26 S1 : Architecture des Ordinateurs

s = None - (n = None) --> n : None

K.ELHARI 2015-2016 27 S1 : Architecture des Ordinateurs

Exemples de structures de données simples et immutables

x = 3 # donne une variable de type int

print("x:", type(x), " y:", type(y), " z:", type(z))

K.ELHARI 2015-2016 28 S1 : Architecture des Ordinateurs

Les fonctions int et float permettent de convertir un nombre quelconque ou une

Attention: Si on veut convertir une chaîne de caractères en entier mais cette

K.ELHARI 2015-2016 29 S1 : Architecture des Ordinateurs

opérateur signification exemple

opérateur signification exemple

K.ELHARI 2015-2016 31 S1 : Architecture des Ordinateurs

Il existe deux autres mots-clés qui retournent un résultat de type booléen :

in test d’appartenance 3 in [3, 4, 5]

K.ELHARI 2015-2016 32 S1 : Architecture des Ordinateurs