Cours de Python - Découvrir les bases de la programmation avec Python

version 1.4.0, dernière mise à jour le 27 septembre 2023.

   

Table des matières (TdM)

  1. I. Introduction
    1. Instructions de base
      1. Lancer et quitter Python en ligne de commande
      2. Afficher un texte
      3. Exercice : Affichage de texte
    2. Opérateurs
    3. Variables
      1. Variables ; opérateur d'affectation
      2. Types
      3. Conversions de types
      4. Exercice : Manipulation de variables
    4. De la ligne de commande aux échanges
      1. Entrées/sorties
      2. Utilisation de fichiers
      3. Exercice : Entrées/sorties
    5. Conventions
  1. II. Listes et tableaux
    1. Introduction
    2. Manipuler une liste
      1. Créer une liste
      2. Ajouter des valeurs
      3. Afficher une valeur
      4. Exercice : Création et affichage d'une liste
      5. Supprimer des valeurs
      6. Inverser les valeurs
    3. Extraire une sous-liste
    4. Obtenir des informations
    5. Copier une liste
      1. Exercice : Manipulation de liste
  1. III. Tests logiques
    1. Introduction
    2. Test simple si… alors…
      1. Test conditionnel if
    3. Test si… alors… sinon
      1. Exercice : Tester (1)
      2. Exercice : Tester (2)
  1. IV. Boucles
    1. Introduction
    2. Boucles for
      1. Introduction
      2. Boucle de parcours: for
      3. Exercice : Boucle for (simple)
      4. Exercice : Boucle for (intermédiaire)
      5. Exercice : Boucles imbriquées
      6. Exercice : Boucle for (difficile)
    3. Boucle while
      1. Syntaxe
      2. Risque de boucle inifnie
      3. Exercice : Boucle while
      4. Exercice : Boucles for et while
  1. V. Fonctions
    1. Qu'est-ce qu'une fonction ?
    2. Définition d'une fonction
      1. Définition de base
      2. Utilisation de valeurs par défaut
      3. Exercice : Définition d'une fonction avec paramètre
      4. Exercice : Définition d'une fonction avec valeur par défaut
    3. Portée d'une variable

Retour au menu

Contenu du cours

I. Introduction

1. Instructions de base

a. Lancer et quitter Python en ligne de commande

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 !).

b. Afficher un texte

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).

Exercice 1. Affichage de texte

Énoncé
Correction

>Retour à la TdM

2. Opérateurs

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).

>Retour à la TdM

3. Variables

a. Variables ; opérateur d'affectation

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.

b. Types

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 :

c. Conversions de types

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.

Exercice 1. Manipulation de variables

Énoncé
Correction

>Retour à la TdM

4. De la ligne de commande aux échanges

a. Entrées/sorties

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.

b. Utilisation de fichiers

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)

Exercice 1. Entrées/sorties

Énoncé
Correction

>Retour à la TdM

5. Conventions

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.

>Retour à la TdM

II. Listes et tableaux

1. Introduction

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"]…

>Retour à la TdM

2. Manipuler une liste

a. Créer une liste

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.

b. Ajouter des valeurs

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].

c. Afficher une valeur

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…

Exercice 1. Création et affichage d'une liste

Énoncé
Correction
d. Supprimer des valeurs

On peut supprimer un élément de liste de deux manières :

e. Inverser les valeurs

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].

>Retour à la TdM

3. Extraire une sous-liste

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] :

>Retour à la TdM

4. Obtenir des informations

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]) :

>Retour à la TdM

5. Copier une liste

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.

Exercice 1. Manipulation de liste

Énoncé
Correction

>Retour à la TdM

III. Tests logiques

1. Introduction

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.

>Retour à la TdM

2. Test simple si… alors…

a. Test conditionnel if

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")

>Retour à la TdM

3. Test si… alors… sinon

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")

Exercice 1. Tester (1)

Énoncé
Correction

Exercice 2. Tester (2)

Énoncé
Correction

>Retour à la TdM

IV. Boucles

1. Introduction

>Retour à la TdM

2. Boucles for

a. Introduction

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.

b. Boucle de parcours: for

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)

Exercice 1. Boucle for (simple)

Énoncé
Correction

Exercice 2. Boucle for (intermédiaire)

Énoncé
Correction

Exercice 3. Boucles imbriquées

Énoncé
Correction (Boucle simple)
Correction (Boucles imbriquées)

Exercice 4. Boucle for (difficile)

Énoncé
Correction

>Retour à la TdM

3. Boucle while

a. Syntaxe

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 :

  1. on initialise d'abord la variable i à la valeur 0

  2. on teste si i est strictement inférieur à 3.

  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

  4. on recommence la boucle, et on teste si i est strictement inférieur à 3.

  5. 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

  6. on recommence la boucle, et on teste si i est strictement inférieur à 3.

  7. 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

  8. on recommence la boucle, et on teste si i est strictement inférieur à 3.

  9. ce n'est plus le cas, donc on sort de la boucle et on affiche « Fin de la boucle ».

b. Risque de boucle inifnie

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.

Exercice 1. Boucle while

Énoncé
Correction

Exercice 2. Boucles for et while

Énoncé
Correction

>Retour à la TdM

V. Fonctions

1. Qu'est-ce qu'une fonction ?

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.

>Retour à la TdM

2. Définition d'une fonction

a. Définition de base

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.

b. Utilisation de valeurs par défaut

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).

Exercice 1. Définition d'une fonction avec paramètre

Énoncé
Correction

Exercice 2. Définition d'une fonction avec valeur par défaut

Énoncé
Correction

>Retour à la TdM

3. Portée d'une variable

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".

>Retour à la TdM

Historique de ce document

Conditions d'utilisation et licence

Creative Commons License
Cette création est mise à disposition par Gilles Chagnon sous un contrat Creative Commons.

Retour au menu