Académique Documents
Professionnel Documents
Culture Documents
Larhlimi
Introduction à Python
Présentation des outils de programmation
Dans cette introduction à Python pour la programmation élémentaire, nous pouvons travailler
en ligne sur la plateforme Google Colab, ou installer et utiliser un environnement de
développement intégré, pour le calcul scientifique et pour la visualisation.
Vous pouvez installer sur votre ordinateur le logiciel gratuit Anaconda qui offre une
installation aisée de l’ensemble de l’environnement de développement nécessaire à ce cours:
https://www.anaconda.com/download/
Voici un autre :
Note
Pour exécuter ce code pas à pas, utiliser le lien
http://pythontutor.com/visualize.html#mode=edit.
La prochaine ligne à exécuter est indiquée par une flèche rouge. Une flèche verte signale la
ligne qui vient d’être exécutée.
valeur : 0
valeur : 1
valeur : 2
Fin
Dans Spyder, on dispose d’une zone de fenêtre pour l’interpréteur de commandes IPython.
Son invite de commande est différente de celle de l’interpréteur Python standard (qui est >>>).
Elle se présente de la façon suivante :
In [1]:
In [1]: 3 * 4
Out[1]: 12
In [2]: 5 + 2
Out[2]: 7
Les parties qui débutent par In et Out correspondent aux entrées et sorties respectivement.
Premiers calculs
Testez les calculs suivants :
>>> 4 + 5
>>> 3 - 7 # les espaces sont optionnels
>>> 5 + 2 * 3 # la priorité des opérations mathématiques est-elle respectée
?
>>> (6 + 3) * 2
>>> 5**2
L’opérateur /
Avertissement
L’opérateur / ne donne pas les mêmes résultats suivant les versions de Python. En Python 2,
il réalise par défaut une division euclidienne, aussi appelée division entière (c’est-à-dire
une division dont le résultat est un entier). En Python 3, il réalise une division décimale
standard comme sur une calculatrice. En Python 2.7, on peut obtenir le même comportement
qu’en Python 3 grâce à l’instruction from __future__ import division.
Exemple
>>> 7 / 2
3.5
>>> 7 // 2
3
3 A. Larhlimi
L’opérateur %
L’opérateur % (appelé opérateur modulo) fournit le reste de la division entière d’un nombre
par un autre.
Exemple
>>> 7 % 2
1
>>> 6 % 2
0
Affectation
>>> a = 2
>>> a
2
>>> b = a + 3
>>> b
5
>>> print("bonjour")
bonjour
>>> a = 5
>>> print(a)
5
Il est possible de réaliser plusieurs affichages à la suite. Pour cela, on sépare les éléments
par des virgules.
>>> a = 5
>>> print("a vaut", a)
a vaut 5
Avertissement
En Python 2, on ne mettait pas de parenthèses.
Python 2 : print "a vaut", a
Python 3 : print("a vaut", a)
Pour ne pas aller à la ligne et continuer sur la même ligne lors du prochain print :
Python 2 : print "a vaut", a,
4 A. Larhlimi
Voir aussi
https://python.developpez.com/cours/apprendre-python3/?page=page_4#L4
La fonction range()
Si vous avez besoin de créer sur une suite d’entiers, vous pouvez utiliser la fonction range().
Elle génère une suite arithmétique.
>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Le nombre de fin qui lui est passé n’est jamais dans la liste générée. Par exemple, range(10)
génère 10 valeurs, exactement les indices des éléments d’une séquence de longueur 10. Il
est possible de faire commencer l’intervalle à un autre nombre, ou de spécifier un incrément
différent (même négatif) :
De manière générale, on a :
Le pas peut être positif ou négatif. La valeur de la borne de fin (maximale ou minimale) n’est
jamais atteinte.
Exercice 1
Pour accéder à un élément d’une liste, on indique entre crochets [] l’indice de l’élément.
Avertissement
En Python, l’indice du premier élément d’une liste est 0 (ceci est à distinguer d’autres
langages).
La fonction len()
La fonction len() renvoie le nombre d’éléments. Par exemple :
>>> a = list(range(7,10))
>>> a
[7, 8, 9]
>>> len(a)
3
Par défaut, la fonction input() renvoie une chaîne de caractères. Il faut donc utiliser la
fonction int() qui permet d’obtenir un entier.
for i in range(n):
bloc d'instructions
if x > 0:
print(x, "est positif")
else:
print(x, "est négatif ou nul")
Les mots-clés
Les mots réservés par le langage Python (if, for, etc.) ne peuvent pas être utilisés comme
identificateurs.
Voir aussi
Liste des mots-clés : https://python.developpez.com/cours/apprendre-
python3/?page=page_4#L4-C
Les commentaires
Les commentaires usuels:
Instruction if
Syntaxe
if condition:
Instruction A
condition est une expression booléenne, c’est-à-dire une expression qui prend pour
valeur True (Vrai) ou False (Faux).
L”instruction A n’est exécutée que si la condition est vérifiée (c’est-à-dire si elle prend pour
valeur True).
x = 15
if x > 10:
print(x, "est plus grand que 10")
print("Fin")
8 A. Larhlimi
x = 3
if x > 10:
print x, "est plus grand que 10"
print "Fin"
Fin
x = 5
if x > 0:
print(x, "est plus grand que 0")
print("il est strictement positif")
print("Fin")
x = -2
if x > 0:
print(x, "est plus grand que 0")
print("il est strictement positif")
print("Fin")
Fin
Instruction if … else
Syntaxe
if condition:
Instruction A
9 A. Larhlimi
else:
Instruction B
x = 5
if x > 0:
print(x, "est positif")
else:
print(x, "est négatif ou nul")
print("Fin")
x = -2
if x > 0:
print(x, "est positif")
else:
print(x, "est négatif ou nul")
print("Fin")
Opérateur Signification
x == y x est égal à y
x != y x est différent de y
Opérateur Signification
>>> 3 < 4
True
>>> 3 > 4
False
Exercice 2:
Opérateur logique or
>>> 2 < 3 or 3 < 4
True
>>> 2 < 3 or 3 > 4
True
11 A. Larhlimi
Boucles
Les boucles s’utilisent pour répéter plusieurs fois l’exécution d’une partie du programme.
Boucle for
Exemple d’utilisation :
i a pour valeur 0
i a pour valeur 1
i a pour valeur 2
i a pour valeur 3
L’instruction for est une instruction composée, c’est-à-dire une instruction dont l’en-tête se
termine par deux-points :, suivie d’un bloc indenté qui constitue le corps de la boucle.
On dit que l’on réalise une itération de la boucle à chaque fois que le corps de la boucle est
exécuté.
Dans l’en-tête de la boucle, on précise après le mot-clé for le nom d’une variable (i dans
l’exemple ci-dessus) qui prendra successivement toutes les valeurs qui sont données après le
mot-clé in. On dit souvent que cette variable (ici i) est un compteur car elle sert à numéroter
les itérations de la boucle.
Il est possible d’obtenir le même résultat sans donner la liste des valeurs, mais en utilisant la
fontion range().
for i in range(4):
print("i a pour valeur", i)
Pour parcourir les indices d’une liste, il est possible de combiner range() et len() comme ci-
dessous :
Dans l’exemple suivant, nous allons illustrer que la variable indiquée après for parcourt
toutes les valeurs de la liste donnée après in :
Boucle while
Syntaxe :
while condition:
Instruction A
13 A. Larhlimi
Exemple de programme :
x = 1
while x < 10:
print("x a pour valeur", x)
x = x * 2
print("Fin")
x a pour valeur 1
x a pour valeur 2
x a pour valeur 4
x a pour valeur 8
Fin
Exercice 3 :
p = 1
n =10
i=1
while i <= n:
p = p*i
i=i+1
print("P =", p)
Le mot-clé while signifie tant que en anglais. Le corps de la boucle (c’est-à-dire le bloc
d’instructions indentées) sera répété tant que la condition est vraie.
Dans l’exemple ci-dessus, x sera multiplié par 2 tant que sa valeur reste inférieure à 10.
Remarque : Si la condition est fausse au départ, le corps de la boucle n’est jamais exécuté.
Si la condition reste toujours vraie, alors le corps de la boucle est répété indéfiniment.
14 A. Larhlimi
Note
Il est toujours possible de remplacer une boucle for par une boucle while.
i = 0
while i < 4:
print("i a pour valeur", i)
i = i + 1
Voir aussi
https://python.developpez.com/cours/apprendre-python3/?page=page_6#L6-B
Exemple
for i in range(10):
print("debut iteration", i)
print("bonjour")
if i == 2:
break
print("fin iteration", i)
print("apres la boucle")
debut iteration 0
15 A. Larhlimi
bonjour
fin iteration 0
debut iteration 1
bonjour
fin iteration 1
debut iteration 2
bonjour
apres la boucle
Note
Dans le cas de boucles imbriquées, l’instruction break ne fait sortir que de la boucle la plus
interne.
while True:
n = int(input("donnez un entier > 0 : "))
print("vous avez fourni", n)
if n > 0:
break
print("reponse correcte")
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.
Exemple
for i in range(4):
print("debut iteration", i)
print("bonjour")
if i < 2:
continue
print("fin iteration", i)
print("apres la boucle")
debut iteration 0
bonjour
debut iteration 1
bonjour
debut iteration 2
bonjour
fin iteration 2
16 A. Larhlimi
debut iteration 3
bonjour
fin iteration 3
apres la boucle
Contrairement aux instructions présentes après la boucle, qui s’exécutent dans tous les cas
(avec ou sans interruption par un break), le bloc d’instructions défini dans la clause else ne
s’exécutera pas lors de l’interruption par un break. Après l’interruption, on passera
directement aux instructions après la boucle.
Autrement dit, le bloc de la clause else est exécuté lorsque la boucle se termine par
épuisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas
quand la boucle est interrompue par un break. Ceci est illustré dans la boucle suivante, qui
recherche des nombres premiers :
La fonction type()
Pour connaître le type d’une donnée ou le type de la valeur d’une variable, il suffit d’utiliser la
fonction type().
Exemples :
>>> type(15)
int
>>> a = 15
>>> type(a)
int
>>> a = "toto"
>>> type(a)
str
>>> type(128)
int
Exemples :
>>> a = 14.5
>>> type(a)
float
>>> a = 11.
>>> type(a)
float
>>> a
11.0
18 A. Larhlimi
>>> a = 3.25e7
>>> type(a)
float
>>> a
3.25e+7
>>> a = 'Bonjour'
>>> type(a)
str
>>> b = "Bonsoir"
>>> type(b)
str
>>> a = True
>>> type(a)
bool
>>> b = not(a)
>>> b
False
Remarque : la fonction not est un opérateur logique qui renvoie l’opposé de la valeur
booléenne transmise. Pour True, on obtient False. Réciproquement, il renvoie False quand
on lui transmet True.
Exemple :
Python possède par défaut un type pour manipuler les nombres complexes. La partie
imaginaire est indiquée grâce à la lettre « j » ou « J ». La lettre mathématique utilisée
habituellement, le « i », n’est pas utilisée en Python car la variable i est souvent utilisé dans les
boucles.
Exemples :
>>> a = 2 + 3j
>>> type(a)
complex
>>> a
(2+3j)
>>> b = 1 + j
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
b = 1 + j
NameError: name 'j' is not defined
>>> b = 1 + 1j
>>> a * b
(-1+5j)
>>> 1j**2
(-1+0j)
Exercice 4 :
N=10
L=[]
For i in range(x) :
L.append(i*i)
Print(L)
Donner le résultat de l’
affichage
Que réalise ce programme
Fonctions en Python
Nous avons déjà rencontré diverses fonctions prédéfinies : print(), input(), range(), len().
Lorsqu’une tâche doit être réalisée plusieurs fois par un programme avec seulement des
paramètres différents, on peut l’isoler au sein d’une fonction. Cette approche est également
intéressante si la personne qui définit la fonction est différente de celle qui l’utilise. Par
exemple, nous avons déjà utilisé la fonction print() qui avait été définie par quelqu’un
d’autre.
Voir aussi
https://python.developpez.com/cours/apprendre-python3/?page=page_9
Vous pouvez choisir n’importe quel nom pour la fonction que vous créez, à l’exception des
mots-clés réservés du langage, et à la condition de n’utiliser aucun 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).
Corps de la fonction
Comme les instructions if, for et while, l’instruction def est une instruction composée. La
ligne contenant cette instruction se termine obligatoirement par un deux-points :, qui
introduisent un bloc d’instructions qui est précisé grâce à l’indentation. Ce bloc d’instructions
constitue le corps de la fonction.
def compteur3():
i = 0
while i < 3:
print(i)
i = i + 1
print("bonjour")
compteur3()
compteur3()
bonjour
0
1
2
0
1
2
En entrant ces quelques lignes, nous avons défini une fonction très simple qui compte jusqu’à
2. Notez bien les parenthèses, les deux-points, et l’indentation du bloc d’instructions qui suit
la ligne d’en-tête (c’est ce bloc d’instructions qui constitue le corps de la fonction proprement
dite).
Il est également possible de sauvegarder ce programme en tant que script au sein d’IDLE.
Après avoir exécuté ce script, pour utiliser à nouveau la fonction que nous venons de définir,
il suffit de l’appeler par son nom au niveau du shell. Ainsi :
>>> compteur3()
provoque l’affichage de :
0
1
2
Nous pouvons maintenant réutiliser cette fonction à plusieurs reprises, autant de fois que
nous le souhaitons.
1. def compteur3():
i = 0
while i < 3:
print(i)
i = i + 1
def double_compteur3():
compteur3()
compteur3()
print("bonjour")
double_compteur3()
Exécuter
22 A. Larhlimi
Une première fonction peut donc appeler une deuxième fonction, qui elle-même en appelle
une troisième, etc.
Créer une nouvelle fonction offre l’opportunité de donner un nom à tout un ensemble
d’instructions. De cette manière, on peut simplifier le corps principal d’un programme, en
dissimulant un algorithme secondaire complexe sous une commande unique, à laquelle on
peut donner un nom explicite.
Une fonction est donc en quelque sorte une nouvelle instruction personnalisée, qu’il est
possible d’ajouter librement à notre langage de programmation.
def compteur(stop):
i = 0
while i < stop:
print(i)
i = i + 1
compteur(4)
compteur(2)
Exécuter
Affichage après exécution :
0
1
2
3
0
1
Pour tester cette nouvelle fonction, il nous suffit de l’appeler avec un argument.
Exemple
def compteur(stop):
i = 0
while i < stop:
print(i)
i = i + 1
a = 5
compteur(a)
23 A. Larhlimi
Exécuter
Affichage après exécution :
0
1
2
3
4
Avertissement
Dans l’exemple ci-dessus, l’argument que nous passons à la fonction compteur() est le
contenu de la variable a. A l’intérieur de la fonction, cet argument est affecté au
paramètre stop, qui est une tout autre variable.
Notez donc bien dès à présent que :
Le nom d’une variable que nous passons comme argument n’a rien à voir avec le
nom du paramètre correspondant dans la fonction.
Ces noms peuvent être identiques si vous le voulez, mais vous devez bien
comprendre qu’ils ne désignent pas la même chose (en dépit du fait qu’ils puissent
contenir une valeur identique).
La fonction suivante utilise trois paramètres : start qui contient la valeur de départ, stop la
borne supérieure exclue comme dans l’exemple précédent et step le pas du compteur.
compteur_complet(1, 7, 2)
Exécuter
Affichage après exécution :
1
3
5
Note
24 A. Larhlimi
Pour définir une fonction avec plusieurs paramètres, il suffit d’inclure ceux-ci entre
les parenthèses qui suivent le nom de la fonction, en les séparant à l’aide de virgules.
Lors de l’appel de la fonction, les arguments utilisés doivent être fournis dans le
même ordre que celui des paramètres correspondants (en les séparant eux aussi à
l’aide de virgules). Le premier argument sera affecté au premier paramètre, le second
argument sera affecté au second paramètre, et ainsi de suite.
A chaque fois que nous définissons des variables à l’intérieur du corps d’une fonction, ces
variables ne sont accessibles qu’à la fonction elle-même. On dit que ces variables sont
des variables locales à la fonction. Une variable locale peut avoir le même nom qu’une
variable de l’espace de noms global mais elle reste néanmoins indépendante.
Les contenus des variables locales sont stockés dans l’espace de noms local qui est
inaccessible depuis l’extérieur de 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.
Exemple
def test():
b = 5
print(a, b)
a = 2
b = 7
test()
print(a, b)
Exécuter
Affichage après exécution :
2 5
2 7
Explications en vidéo
Cette instruction permet d’indiquer - à l’intérieur de la définition d’une fonction - quelles sont
les variables à traiter globalement.
def test():
global b
b = 5
print(a, b)
a = 2
b = 7
test()
print(a, b)
Exécuter
Affichage après exécution :
2 5
2 5
La présentation de cette page est inspirée par le livre de Gérard Swinnen « Apprendre à
programmer avec Python 3 » disponible sous licence CC BY-NC-SA 2.0.
def cube(w):
return w**3
>>> cube(3)
27
>>> a = cube(4)
>>> a
64
Exemples :
Lorsque l’on appelle cette fonction en ne lui fournissant que le premier argument, le second
reçoit tout de même une valeur par défaut. Si l’on fournit les deux arguments, la valeur par
défaut pour le deuxième est tout simplement ignorée.
Python autorise cependant une souplesse beaucoup plus grande. Si les paramètres
annoncés dans la définition de la fonction ont reçu chacun une valeur par défaut, sous la
forme déjà décrite ci-dessus, on peut faire appel à la fonction en fournissant les arguments
correspondants dans n’importe quel ordre, à la condition de désigner nommément les
paramètres correspondants.
Exemple :
V=43πR3V=43πR3
Exemple :
27 A. Larhlimi
import numpy as np
def cube(n):
return n**3
def volume_sphere(r):
return 4 / 3 * np.pi * cube(r)
Notez bien que les deux parties du programme ont été disposées dans un certain ordre :
Pour vous en convaincre, intervertissez cet ordre (en plaçant par exemple le corps principal
du programme au début), et prenez note du type de message d’erreur qui est affiché
lorsque vous essayez d’exécuter le script ainsi modifié.
En fait, le corps principal d’un programme Python constitue lui-même une entité un peu
particulière, qui est toujours reconnue dans le fonctionnement interne de l’interpréteur sous
le nom réservé __main__ (le mot « main » signifie « principal », en anglais. Il est encadré par
des caractères « souligné » en double, pour éviter toute confusion avec d’autres symboles).
L’exécution d’un script commence toujours avec la première instruction de cette entité
__main__, où qu’elle puisse se trouver dans le listing. Les instructions qui suivent sont alors
exécutées l’une après l’autre, dans l’ordre, jusqu’au premier appel de fonction. Un appel de
fonction est comme un détour dans le flux de l’exécution : au lieu de passer à l’instruction
suivante, l’interpréteur exécute la fonction appelée, puis revient au programme appelant
pour continuer le travail interrompu. Pour que ce mécanisme puisse fonctionner, il faut que
l’interpréteur ait pu lire la définition de la fonction avant l’entité __main__, et celle-ci sera
donc placée en général à la fin du script.
Dans notre exemple, l’entité __main__ appelle une première fonction qui elle-même en
appelle une deuxième. Cette situation est très fréquente en programmation. Si vous voulez
comprendre correctement ce qui se passe dans un programme, vous devez donc apprendre
à lire un script, non pas de la première à la dernière ligne, mais plutôt en suivant un
cheminement analogue à ce qui se passe lors de l’exécution de ce script. Cela signifie
concrètement que vous devrez souvent analyser un script en commençant par ses dernières
lignes !
28 A. Larhlimi
Pour définir une nouvelle liste en Python, on va devoir utiliser une paire de
crochets [ ]. Nous allons placer les différents éléments de notre liste dans ces
crochets en les séparant par des virgules. On peut par exemple créer une liste
de 5 éléments et la placer dans une variable liste comme ceci :
De plus, vous devez savoir que tous les éléments d’une liste n’ont pas à être du
même type, on va très bien pouvoir créer des listes composées de nombres,
chaines et booléens par exemple :
30 A. Larhlimi
Note : Si vous avez déjà étudié un langage de script par le passé, les liste doivent
vous faire penser à ce qu’on appelle communément dans ces autres langages
des tableaux. En effet, les listes Python sont très proches des tableaux
(numérotés) qu’on peut retrouver dans de nombreux autres langages.
Pour récupérer une valeur en particulier dans une liste, on va devoir préciser le
nom de la liste suivi de l’indice de cette valeur entre crochets. Notez que les
indices négatifs sont acceptés; dans ce cas on partira de la fin de la liste (l’indice
-1 correspond au dernier élément, -2 à l’avant dernier et etc.).
On va également pouvoir récupérer une tranche de valeurs dans une liste, c’est-
à-dire un ensemble de valeurs qui se suivent. Pour cela, on utilisera le
symbole : entre les crochets avec 0, 1 ou 2 indices autour.
Si on utilise : sans indice, alors une copie superficielle de la liste sera renvoyée.
Si on mentionne un indice avant : mais pas d’indice après, alors une copie
superficielle partielle de la liste de départ sera renvoyée, en commençant à
copier à partir de l’indice donné. Si au contraire on mentionne un indice
après : mais pas d’indice avant, une copie superficielle partielle de la liste de
départ sera renvoyée qui commence au début de la liste et jusqu’à l’indice
31 A. Larhlimi
Vous devez également savoir que ce qu’on a vu jusqu’ici sur les listes s’applique
également aux chaines de caractères. Les chaînes de caractères peuvent en effet
également être indexées, ce qui signifie qu’on peut accéder aux caractères par
leur position). Cela est logique après tout : les chaines de caractères sont des
“séquences” de caractères tandis que les listes sont des “séquences” de valeurs.
Comme pour les listes, le premier caractère d’une chaîne possède l’indice 0, le
deuxième l’indice 1 et etc; On va également pouvoir utiliser des indices négatifs
et récupérer des tranches avec :.
Notez qu’il n’existe pas de type distinct pour les caractères en Python : un
caractère est simplement une chaîne de longueur 1.
En effet, vous devez bien comprendre qu’une fois qu’on définit une valeur
“chaine de caractères” par exemple, celle-ci ne peut plus être modifiée par la
suite. Les seules opération qu’on va pouvoir faire vont être de créer une nouvelle
chaine en concaténant deux chaines d’origine (qui une nouvelle fois ne seront
pas modifiées) ou de remplacer une chaine par une autre valeur en affectant une
nouvelle valeur dans une variable (ce qui a pour effet d’écraser la chaine de
départ).