Conditions d'utilisation et licence
Cette création est mise à disposition par Gilles Chagnon sous un contrat Creative Commons.
version 1.4.0, dernière mise à jour le 27 septembre 2023.
Python permet de produire des applications, mais est aussi disponible en ligne de commande pour tester le fonctionnement d'un script. Il suffit de le lancer en tapant python à une invite de commande (ou python3 pour spécifier que l'on souhaite utiliser la version 3 du langage si plusieurs versions sont installées sur le système). Pour quitter, il suffit de taper quit() ou exit() (ne pas oublier les parenthèses !).
Il peut être utile d'afficher le résultat d'un calcul, une chaîne de caractères, etc. La fonction print() permet de le faire. On écrira ainsi print("Bonjour"). Écrire print('Bonjour','tout le monde') insère automatiquement un espace et produit "Bonjour tout le monde" à l'écran. Il est tout à fait possible de procéder à des calculs et les afficher : print("Résultat :", 2+3).
Les opérateurs classiques des opérations mathématiques sont +, -, * et /.
D'autres opérateurs arithmétiques sont moins courants, comme // qui renvoie le quotient de la division euclidienne (par exemple 9/8 renvoie 1), et ** qui permet d'élever à une puissance donnée (par exemple, 2**3 renvoie 8).
Une variable, en programmation, est une sorte de case nommée dans laquelle pourra être stockée une valeur. Cette valeur peut ensuite être utilisée dans des calculs, simplement en rappelant le nom de la variable. Par exemple, si on veut créer une variable appelée maVariable, contenant comme valeur la « chaîne de caractères » "Hello", on écrira maVariable="Hello" : le caractère = est ce que l'on appelle l'opérateur d'affectation et permet d'affecter la valeur "Hello" à la variable maVariable. Tous les noms de variables ne sont pas possibles, et il existe des noms réservés (comme while, exec, if…)
On peut alors écrire print(maVariable), et cela affichera à l'écran le texte "Hello". Notez qu'il ne faut pas ajouter de guillemets autour du nom de la variable : si on avait écrit print("maVariable"), cela aurait en effet affiché le texte "maVariable".
On peut utiliser une variable pour stocker le résultat d'un calcul. On peut par exemple écrire a=2+3, et print(a) affichera ensuite 5.
Cet opérateur d'affectation n'est pas une égalité au sens mathématique ! Ainsi, on peut légitimement écrire a=a+2 : cela signifie qu'à l'issue de cette instruction, la nouvelle valeur de a est égale à l'ancienne à laquelle on a ajouté 2. Si a vaut initialement 3, à la fin a vaudra 3+2=5.
On peut d'ailleurs, dans ce cas, utiliser une syntaxe plus compacte, et à la place de a=a+2 écrire a+=2. Il est de même possible d'écrire a-=2, a*=2 ou a/=2, qui remplacent respectivement a=a-2, a=a*2 et a=a/2.
Une variable possède un type. C'est ce qui caractérise le type de valeurs qu'une variable peut prendre. On parlera par exemple d'une variable de type texte, d'une variable de type booléen, etc. Le type d'une variable est donné par la fonction type. Par exemple, a=3 puis print(type(a)) renvoie <class 'int'>, ce qui signifie que la variable est de type integer (nombre entier). Les types de variables sont :
int pour integer, les nombres entiers comme 42, -1, 0…
float pour floating point, les nombres à « virgule flottante » comme 1.0, -3.1, 5.2…
complex pour complex, les nombres complexes. En Python, le nombre dont le carré est égal à -1 est noté j. Ainsi, 1+2j est de type complexe.
bool pour boolean, les variables booléennes : elles ne peuvent prendre que les valeurs true (vrai) ou false (faux).
str pour string, les chaînes de caractères.
On peut transformer une chaîne de caractères en nombre à virgule flottante avec la fonction float : ainsi, type(float("42.2")) renverra <class 'float'> ; ou bien en entier avec la fonction int. L'pếration inverse (transformation d'un nombre en chaîne de caractères) est possible avec la fonction str.
Une saisie au clavier se fait à l'aide de la fonction input. Par exemple, x=input("Entrez une chaîne de caractères : ") permet d'affecter une chaîne de caractères saisie par l'utilisateur à la variable x à l'invite "Entrez une chaîne de caractères : ".
Attention, cette fonction retourne toujours une chaîne de caractères : si on écrit x=input("Saisissez un nombre : "), que l'utilisateur saisit 42 et qu'on fasse ensuite print(x+3), Python affichera un message d'erreur, car on ne peut pas additionner une chaîne de caractères ("42") et un nombre (3). Il faut alors procéder à une conversion de type.
Le code peut être écrit dans un fichier, portant traditionnellement l'extension py. Dans ce cas, le script est lancé par la commande python nomFichier.py. On peut par exemple écrire dans ce fichier
a=3
b=5
x=input("Saisissez une chaîne de caractères : ")
print(x, a+b)
On peut écrire plusieurs instructions sur une seule ligne en les séparant par le caractère ;. Par exemple, on peut écrire a=3;b=5;x=input("Saisissez une chaîne : ");print(x, a+b).
Un commentaire commence par le caractère #. Tout ce qui suit jusqu'au retour à la ligne n'est pas interprété par Python. Ainsi, pour écrire un commentaire de plusieurs lignes, il est nécessaire de faire débuter chaque ligne par #.
L'indentation (c'est-à-dire le fait de mettre des lignes de code en retrait par des tabulations ou des espaces) demande une attention toute particulière en Python car à la différence de la plupart des langages de programmation, les blocs d'instructions ne sont pas délimités par des accolades, mais sont définis par l'indentation. Si on revient à la ligne sans indenter dans un bloc d'instructions, ce dernier est considéré comme terminé. Nous y reviendrons plus loin.
Dans la plupart des langages de programmation, on utilise des tableaux. Ce sont des rassemblements ordonnés de variables. On peut avoir par exemple un tableau de nombres, un tableau de chaînes de caractères… Si tab désigne un tel tableau, on peut accéder à son n-ième élément avec des crochets mais attention, la numérotation des tableaux commence dans la très grande majorité des langages par 0 ! Ainsi, tab[0] désigne le premier élément du tableau, tab[1] le deuxième, etc.
Un tableau peut se déclarer ainsi : tab=[1, 42, -96.3].
Les listes en Python vont au-delà de cette simple notion de tableau. Si on peut concevoir une liste sous la forme simple et habituelle ["pain","beurre", "confiture"], en fait une liste peut incorporer des éléments de types différents, comme [1,2,"trois"]…
La manière la plus simple de créer une liste consiste à l'affecter à une variable, comme nous l'avons vu précédemment : a=[1,4,6] par exemple.
Mais Python offre plus de possibilités. Si l'on souhaite initialiser une liste à une suite arithmétique de nombres, on peut utiliser la fonction range (nous reviendrons plus loin sur cette notion de fonction). Par exemple, b=list(range(1,43,7)) va créer une liste comportant tous les nombres compris entre 1 et 42 inclus, par pas de 7, soit [1, 8, 15, 22, 29, 36] (remarquez l'absence de 43). Si le dernier argument est omis, le pas vaut 1 par défaut, et c=list(range(1,43)) renvoie une liste comportant tous les nombres entiers compris entre 1 et 42 inclus. Enfin, d=list(range(43)) renvoie une liste comportant tous les nombres entiers compris entre 0 et 42 inclus.
On peut ajouter à une liste déjà créée soit un dernier item unique, à l'aide d'append(), soit une autre liste avec extend(). Par exemple, a=[1,2];a.append(3) donne comme résultat [1,2,3]. Et a=[1,2];a.extend([3,4]) donne comme résultat [1,2,3,4]. Attention, a=[1,2];a.append([3,4]) donne comme résultat [1,2,[3,4]]. On peut d'ailleurs aussi utiliser l'opérateur + : b=a+[3,4] qui donne le même résultat ([1,2,3,4]).
On peut aussi « multiplier » une liste. Par exemple, a=[1,2]*3 donne au final pour a la valeur [1,2,1,2,1,2].
Supposons définie la liste a=[2,3,4,5,6]. Classiquement, a[0] nous permet d'obtenir le premier élément de la liste, ici 2. Mais Python permet facilement d'afficher tout ou partie de cette liste. Ainsi…
a[-1] renvoie le dernier élément de la liste
Plus généralement, a[-n], où n est un entier naturel, renvoie le n-ième élément à partir de la fin de la liste
On peut supprimer un élément de liste de deux manières :
par son index avec l'instruction del. Par exemple, si a vaut [1,2,3,4], alors del(a[1]);print(a) renvoie [1,3,4]
par sa valeur avec la méthode remove. Cela retire la première occurrence de la valeur dans la liste. Par exemple, si a vaut [1,2,3,4,3], alors a.remove(3);print(a) renvoie [1,2,4,3]
pour vider complètement la liste, on écrit a[:]=[]
On peut aussi inverser l'ordre des éléments d'une liste avec la méthode reverse() : si a vaut [1,2,3,4], a.reverse();print(a) renvoie [4,3,2,1].
Nous avons vu précédemment comment afficher un seul élément d'une liste. Mais on peut extraire une sous-liste, à l'aide de filtres. Si a est la liste [2,3,4,5,6,7,8,9,10] :
a[:2] renvoie les deux premiers éléments de la liste, ici [2,3]
a[2:] renvoie les derniers éléments de la liste à partir du deuxième exclu, ici [4,5,6,7,8,9,10]
Plus généralement, a[debut:fin:pas] affiche de debut exclu à fin exclu par pas de pas. Par exemple:
a[2:5:1], qui équivaut à a[2:5], renvoie [4,5,6]
a[2:8:2] renvoie [4,6,8]
a[:3:2], qui équivaut à a[0:3:2], renvoie [2,4]
a[::3] renvoie tous les éléments de la liste a par pas de 3 : [2,5,8]
Plusieurs fonctions et méthodes permettent d'obtenir des informations sur une liste. Supposons par exemple que a=list(range(2,6)) (autrement dit, a vaut [2,3,4,5]) :
la longueur de la liste est donnée par la fonction len. Ici, len(a) renvoie 4.
l'index de la première ocurrence d'une valeur est donné par la méthode index. Par exemple, a.index(4) renvoie 2.
le nombre d'occurrences d'un élément donné peut être obtenu par la méthode count : si b=[1,1,1,3,1,4,1,1,3,6,1,2,3,1,4], alors b.count(1) renvoie 8.
pour déterminer si un élément est présent dans une liste, on utilise le mot clef in. Par exemple, ici 3 in a renvoie true mais 7 in a renvoie false.
Nous avons vu précédemment que si on écrit a=[1,2,3,4] puis b=a;b[1]=6 alors on la valeur renvoyée par a est [1,6,3,4] : ainsi, alors qu'on pense ne modifier que b, on modifie aussi a. Afin de pouvoir copier une liste, il faut en fait affecter ses valeurs dans une nouvelle liste. Ainsi, si on écrit b=a[:]; b[1]=6, la valeur de a n'est pas changé au contraire de celle de b.
Les tests logiques servent à donner des instructions conditionnelles à l'ordinateur: ces instructions ne seront exécutées que si une condition est réalisée, ou bien au contraire si elle ne l'est pas.
La syntaxe d'un test est simple, mais il faut prendre garde à l'indentation :
if test:
#Instruction 1
#Instruction 2
#Instruction 3
#Fin du test…
Par exemple…
saisie = float(input("Saisissez un nombre"))
if (saisie<5):
print("Le nombre est strictement inférieur à 5")
Ce genre de test permet de gérer des cas du type « si test est vrai, alors on fait telle chose, sinon on fait telle autre ».
On code un tel test avec if… else, les instructions if et else devant être alignées :
if test:
#Instruction 1
#Instruction 2
#Instruction 3
else:
#Instruction si test échoué 1
#Instruction si test échoué 2
#Fin du test…
Par exemple…
saisie = float(input("Saisissez un nombre"))
if (saisie<5):
print("Le nombre est strictement inférieur à 5")
else :
print("Le nombre est supérieur ou égal à 5")
Une « boucle » est un ensemble d'instructions destinées à être répétées. Il existe en programmation deux grands types de boucles : les boucles permettant de par exemple passer en revue les éléments d'une liste (ou d'un tableau…), et les boucles destinées à être répétées tant qu'une certaine condition n'est pas remplie.
Supposons que l'on doive écrire cinq fois le mot ≤ bi ». On peut faire ainsi :
print("Bi")
print("Bi")
print("Bi")
print("Bi")
print("Bi")
Mais ce n'est pas très efficace. On va utiliser une boucle, que l'on exécutera 5 fois et pour cela, Python a besoin d'un compteur de boucle (pour que l'on sache à n'importe quel moment où on en est). On utilise traditionnellement le nom de variable i pour un tel compteur, mais n'importe quel autre nom de variable ferait l'affaire. On va écrire que i doit parcourir tous les nombres entre 0 et 4 : autrement dit, i va prendre toutes la valeurs de la liste range(5) :
for i in range(5): print("Bi")
On peut aussi demander à ce que plusieurs instructions soient exécutées :
for i in range(5): print("Bi");print("Ba")
Cependant, quand le nombre d'instructions à exécuter à chaque itération augmente trop, le code devient illisible. On va donc définir un bloc d'instructions, et en Python un tel bloc se définit à l'aide d'une indentation :
for i in range(5):
print("Bi")
print("Ba")
Le code précédent produit comme résultat Bi Ba Bi Ba Bi Ba Bi Ba Bi Ba. Mais si on avait écrit…
for i in range(5):
print("Bi")
print("Ba")
… alors on aurait obtenu Bi Bi Bi Bi Bi Ba.
On peut aussi avoir accès au compteur de boucle :
for i in range(3):
print(i)
Si on veut parcourir les éléments d'une liste dont on ne connaît pas la longueur a priori, on peut recourir à la fonction len :
a = ["pain", "beurre", "confiture", "miel"]
for i in range(len(a)):
print(a[i])
Mais on peut aussi indexer directement la liste :
a = ["pain", "beurre", "confiture", "miel"]
for i in a:
print(i)
La boucle while sert à spécifier qu'une instruction soit être réalisée tant qu'un certain test est vérifié. Par exemple…
i=0
while i<3 :
print(i)
i = i+1
print("Fin de la boucle")
Dans le code précédent :
on initialise d'abord la variable i à la valeur 0
on teste si i est strictement inférieur à 3.
c'est bien le cas, donc on affiche la valeur de i, soit 0, puis on augmente de 1 la valeur de i. i vaut maintenant 1
on recommence la boucle, et on teste si i est strictement inférieur à 3.
c'est bien encore le cas, donc on affiche la valeur de i (1), puis on augmente encore de 1 la valeur de i. i vaut maintenant 2
on recommence la boucle, et on teste si i est strictement inférieur à 3.
c'est bien encore le cas, donc on affiche la valeur de i (2), puis on augmente encore de 1 la valeur de i. i vaut maintenant 3
on recommence la boucle, et on teste si i est strictement inférieur à 3.
ce n'est plus le cas, donc on sort de la boucle et on affiche « Fin de la boucle ».
Un tel genre de boucle peut très bien devenir infini. Si on modifie ainsi l'exemple précédent :
i=0
while i<3 :
print(i)
i = i-1
print("Fin de la boucle")
… la valeur de i ne pouvant que diminuer, i restera toujours strictement inférieur à 3, et donc la boucle devient inifnie : on n'en sort jamais.
Parfois, il est nécessaire de répéter de mêmes portions de code. Par exemple, on peut souhaiter afficher un résultat donné sous une certaine forme, ou bien faire un calcul répétitif. Dans ce cas, au lieu de réécrire plusieurs fois cette même portion de code, on définit ce que l’on appelle des fonctions. Ces fonctions peuvent accepter des paramètres, ou arguments, pour leur permettre de réaliser l’action désirée.
Une fonction est un ensemble d'instructions que l'on peut appeler séparément. La forme générale de sa déclaration est…
def nomFonction (paramètres) :
#Bloc d'instructions
Là encore, il faut prendre garde à l'indentation pour la définition du bloc. Par exemple…
def affiche () :
print("Bonjour!")
Quand on écrit ensuite dans le code affiche(), la chaîne de caractère "Bonjour!" est affichée.
Une fonction peut aussi prendre un paramètre. On le précise alors dans les parenthèses lors de la définition de la fonction.
def multiplieParDeux (x) :
return x*2
Cette fonction prend un paramètre, que l'on désigne par le nom x. Elle calcule ensuite la multiplication de x par 2, et ≤ renvoie » le résultat. Si on fait print(multiplieParDeux(4.2)), par exemple, on affichera 8.4. Le nom du paramètre x est tout à fait subjectif. Ainsi le code suivant définit exactement la même fonction :
def multiplieParDeux (ceciEstUnNombre) :
return ceciEstUnNombre*2
Une fonction peut aussi prendre plusieurs paramètres. Par exemple…
def additionne (x,y) :
return x+y
On peut alors appeler additionne(5,3.2), et le code affichera 8.2.
On peut très facilement indiquer des valeurs par défaut pour le jeu de paramètres d'une fonction. Il suffit de les spécifier dans la définition de la fonction :
def additionne (x=1,y=2) :
return x+y
Si on appelle par exemple additionne(3), alors le second paramètre est supposé présent et égal à sa valeur par défaut. Le résultat renvoyé au final dans ce cas est donc 5.
Cette syntaxe permet de plus d'appeler les paramètres par leurs étiquettes. Par exemple, avec la même définition de fonction, additionne(y=3) renvoie 4 car x est supposé présent et valoir sa valeur par défaut, 1. Il est alors possible de changer l'ordre d'apparition des paramètres, par exemple additionne(y=3,x=4).
Par défaut en Python, les variables sont locales. Si on définit une variable dans le corps principal du programme, nommée maVariable, et qu'on utilise une variable nommée également maVariable dans une fonction, cette variable sera locale. Autrement dit, sa portée ne dépassera pas celle de la fonction et même si on redéfinit sa valeur à l'intérieur de la fonction, la valeur de la variable globale ne sera pas modifiée. Si l'on souhaite modifier la variable globale à l'intérieur de la fonction, il faut déclarer cette variable explicitement, sous la forme global maVariable. Par exemple :
variable1 = "Bonjour"
variable2="Au revoir"
print(variable1, variable2)
def change() :
variable1="Hello"
global variable2
variable2="Bye"
change()
print(variable1, variable2)
Ce code affiche successivement "Bonjour Au revoir", puis "Hello Bye", enfin "Bonjour Bye".
Cette création est mise à disposition par Gilles Chagnon sous un contrat Creative Commons.