Programmation et langages (partie 1) : Programmation en Python¶

I. Introduction.¶
Programmer, c'est créer des programmes (suite d'instructions données à l'ordinateur) ! Un ordinateur sans programme ne sait rien faire. Il existe différents langages qui permettent de programmer un ordinateur et le seul directement utilisable directement par le processeur est le langage machine (suite de 1 et de 0). Aujourd'hui personne ne programme en langage machine c'est bien trop compliqué.
Python est un langage de programmation "facile" à apprendre (en tout cas en comparaison d'autres langages), avec des lignes de commande claires et concises. Il fonctionne sur tous les systèmes d’exploitation (Windows, Mac et Linux), il est gratuit et sous licence libre. Python est utilisé dans de nombreux domaines, particulièrement dans la data science (analyse de données/statistiques), pour l'intelligence artificielle, dans le développement Web ou encore en robotique. Des sites très connus ont été développés en Python comme par exemple, Dropbox, Youtube, Spotify, Reddit ou encore Pinterest. Depuis plusieurs années il fait parti des 2-3 langages les plus utilisés dans le monde.
Python a été développé à la fin des années 80 par Guido van Rossum.

Ce n’est pas du tout à cause du serpent que Python s’appelle comme ça, mais parce que son créateur hollandais (Guido van Rossum) était un fan des Monty Python (une série anglaise des années 70). Guido van Rossum s'est inspiré du langage ABC pour élaborer son propre langage, Python, qui a vu le jour en 1991. Il a reçu en 2002 le prix du logiciel libre pour Python.
La dernière version en ligne est la version 3.13 (2025). Celle installée au lycée est un peu plus ancienne mais ça n'a pas d'importance.
Les informaticiens utilisent des "instructions" (mots souvent en anglais) qui seront ensuites "traduites" en langage machine par un programme spécialisé qui assure cette traduction. Ce système de traduction est soit un interpréteur soit un compilateur. Python utilise un interpréteur pour être "traduit", on dit que c'est un langage interprété. L'interpréteur convertit le programme "à la volée", ligne par ligne en langage machine compréhensible directement par le processeur. Un compilateur prend tout le programme et le convertit en code machine (en assembleur) stocké dans un fichier, c'est ce qui est utilisé si on programme en C, par exemple.
Il existe 2 grandes familles de langages de programmation :
Les langages de bas niveau qui sont très complexes à utiliser, car très éloignés du langage naturel. On dit que ce sont des langages "proches de la machine", en contrepartie ils permettent de faire des programmes très rapides à l'exécution. L'assembleur est le langage de bas niveau (on fera une introduction à ce langage dans l'année). Certains "morceaux" de programmes sont écrits en assembleur encore aujourd'hui.
Les langages de haut niveau qui eux sont plus "faciles" à utiliser, car plus proches du langage naturel comme par exemple Python, C++, Javascript, Java... ce qui facilite l'écriture des programmes.
En NSI, notre langage de prédilection sera Python.
En classe, nous utiliserons l'IDE (environnement de développement intégré) Pyzo qui permet d'écrire et exécuter des programmes Python (du moment qu'un interpréteur Python est installé). On peut utiliser d'autres logiciels pour coder en Python, comme par exemple Visual Studio Code qui est très polyvalent, gratuit, disponible pour tous les OS et qui permet de faire autre chose que programmer en Python (contrairement à Pyzo) ou encore l'IDE Pycharm qui est une référence mais qui est plus délicat à utiliser.
Chez-soi, il est vivement conseillé de télécharger Python https://www.python.org/, PUIS installer Pyzo.
Un ordinateur est "une machine automatique de traitement de l'information, obéissant à des programmes formés par des suites d'opérations arithmétiques et logiques" (définition du petit Larousse).
Qui dit "traitement de l'information", dit donc données à manipuler. Un programme passe son temps à traiter des données. Pour pouvoir traiter ces données, l'ordinateur doit les placer dans sa mémoire vive, la RAM (Random Access Memory). Pour simplifier, nous dirons que la RAM se compose de "cases" dans lesquelles l'ordinateur range les données (une donnée par case) qu'il doit utiliser et chaque case a une adresse, ce qui permet au processeur de savoir où sont rangées les données. Ces notions seront développées et approfondies au cours de l'année.
Une variable est un symbole qui permet d'associer un nom à une valeur. C'est un "conteneur" (une sorte de boite), utilisé par un programme pour stocker de l'information, conteneur lui-même stocké dans la RAM. On dit qu'elle est "variable", car c'est une valeur qui peut changer pendant le déroulement du programme.
Une variable est constituée de 2 parties :
Une valeur, c'est la donnée qu'elle stocke (par exemple un nombre, une chaine de caractères, etc.).
Un nom qui permet de la reconnaître et ainsi nous n'aurons besoin de connaître l'adresse mémoire pour travailler avec cette variable. Ce nom peut être formé d'un seul caractère (comme "x" en maths) mais aussi une suite de caractères alphanumériques.

Le nom d'une variable doit commencer par une lettre et ne doit contenir que des caractères alphanumériques courants. Les caractères spéciaux ne sont pas autorisés, tout comme les espaces et il vaut mieux éviter les caractères accentués.
Pour respecter les règles d'écriture en Python, les noms de variables doivent être en minuscules.
On utilise le caractère "_" (underscore) pour séparer les mots, par exemple : age_moyen
En pseudo-code, on note : var <- 5, ce qui signifie que 5 est stocké dans la variable var. On dit qu'on affecte la valeur 5 à la variable var.
En Python, c'est l'opérateur = qui est utilisé pour l'affectation d'une valeur à une variable.
Par exemple, si on tape (et qu'on valide) dans la console :
nombre1 = 10
On définit alors la variable nommée "nombre1" à qui on affecte la valeur 10 (nombre entier).
Si maintenant on tape nombre1 directement dans la console de Pyzo (et qu'on valide), le shell va renvoyer la valeur de cette variable, c'est à dire 10.
Une variable peut "référencer" un nombre entier, comme dans l'exemple précédent mais elle peut aussi référencer un nombre décimal et bien d'autres types de valeurs que nous allons voir peu à peu.
En programmation, les données qu’on manipule avec un langage sont classées par “type”. Un “type” de données définit la nature des valeurs que peut prendre une donnée et les manipulations qu’on va pouvoir faire sur ces données : on va pouvoir effectuer les mêmes opérations sur chaque donnée d’un même type et des opérations différentes sur différents types de données.
Les nombres entiers sont appelés "integer" en anglais et abrégés en "int" dans Python. C'est l'un des trois types numériques natifs en Python. Par soucis de simplification, nous allons associer les nombres décimaux (à virgule) à ce qu'on appelle des nombres "flottants" ("float" en anglais). Nous verons la différence plus tard entre ces nombres et les nombres décimaux vus en mathématiques depuis des années. Le type de ces nombres en le type float en Python, c'est le 2ème type numérique.
Il existe un 3ème type numérique qui est le type "complex" pour les nombres complexes (vus en terminale par les élèves qui choisissent maths expertes) mais nous ne l'utiliserons pas en NSI.
Remarque : Il est possible de connaitre le type d'une variable à l'aide de la fonction type(nom_variable).
x = 2.3
type(x)
float
y = 12
type(y)
int
Attention, la virgule est remplacée par le ".". Si on utilise une virgule, le shell ne renvoit pas une erreur mais interprète cette notation comme étant d'un autre type qu'un nombre flottant (ça aussi nous allons le voir plus tard dans l'année).
Remarque : Contrairement à de nombreux langages, on n'a pas besoin de déclarer la variable et son type avant de l'utiliser en Python. On dit que Python est un langage typé dynamiquement, c'est à dire que les variables ne sont pas typées à l'avance, leur type est défini en fonction de la valeur qu'elles contiennent et peut changer au fur et à mesure de l'exécution du programme.
2. Opérations sur les types numériques.¶
a. Calculs "de base".¶
Python est capable d'effectuer des opérations mathématiques "de base". On peut étendre ses capacités avec des modules dont nous verrons plus tard l'utilisation.

Les signes utilisés pour les différentes opérations en Python sont : +, - , * (multiplication), / (division), // (quotient d'une division euclidienne), % (modulo c'est à dire reste d'une division euclidienne) et ** pour exposant.
Remarques :
Attention
a / bretourne un nombre de type float même si a et b sont des entiers et que a est un multiple de b alors que // retourne toujours un nombre entier (type int) si a et b sont entiers.Python respecte les priorités opératoires et les parenthèses peuvent être utilisées pour faire des regroupements
Exemples :
2**3
8
1 + 3.5*4 #le résultat est de type float
15.0
22 % 5
2
22 // 5 #le résultat est de type int
4
20 / 5 #le résultat est de type float
4.0
12.5 - (7 + 3)
2.5
Remarques :
Attention, en programmation une notation du type "a = a + 1" n'a pas du tout le même sens qu'en mathématiques. Le signe = permet d'affecter une valeur donc, dans ce cas, cette notation signifie que la valeur de a + 1 est affectée à la variable a. Autrement dit, qu'on ajoute 1 à la valeur de la variable a. On dit que la variable a été incrémenté de 1.
Notation : En Python, l'écriture
a = a + 10est équivalent àa += 10ou encorea = 3 * aest équivalent àa *= 3.
b. Calculs plus complexes.¶
Il est aussi possible d'effectuer des calculs mathématiques plus complexes utilisant, par exemple, des racines carrées ou des fonctions trigonométriques mais ce n'est pas faisable nativement dans Python, pour cela il faut utiliser des modules qui permettent d'étendre les possiblités du langage (c'est un fichier écrit généralement en Python qui regroupe des fonctions et qui, une fois importé, permet d’accéder à ces fonctions et ainsi étendre les possibilités du langage).
Pour utiliser des fonctions mathématiques plus avancées, il est nécessaire d'utiliser le module math. Comme pour n'importe quel module, il existe différentes méthodes pour l'importer. Dans tous les cas, il faut ajouter une ligne au début du programme.
Voici les différentes façon de faire :
import math #méthode recommandée : on importe le module mais pas les fonctions
a = math.sqrt(5) #il faut préciser le nom du module pour calculer la racine carrée de 5
from math import sqrt #on importe juste la fonction dont on a besoin, ici racine carrée
a = sqrt(5) #pour calculer la racine carrée de 5
import math as mt #on renomme un module (pour que ce soit + rapide à utiliser ensuite)
a = mt.sqrt(5) #il faut préciser le "nouveau" nom du module pour calculer la racine carrée de 5
Enfin la dernière méthode : il faut éviter de l'utiliser car elle risque d'engendrer des conflits et donc des bugs.
from math import * #on importe toutes les fonctions du module (pratique mais à éviter)
a = sqrt(5) #pour calculer la racine carrée de 5
Attention, Python ne calcule que des valeurs approchées et ne peut pas effectuer des calculs avec des valeurs exactes comme le fait la calculatrice. De plus, certaines valeurs décimales données par Python sont parfois des valeurs approchées alors que ce devrait être des valeurs exactes (nous verrons la raison dans un prochain chapitre).
Exemple :
0.1 + 0.2
0.30000000000000004
Remarque : Nous aurons l'occasion de croiser différents modules dans l'année, pour l'instant nous n'aurons besoin que du module math et du module random qui permet de manipuler et générer des nombres pseudo-aléatoires.
3. Les chaînes de caractères : le type str.¶
a. Généralités.¶
Les variables peuvent aussi référencer des suites de caractères, qu'on appelle "chaînes de caractères".
Le type de ces variables est le type "string" (chaîne en anglais), abrégé par str en Python.
Elles peuvent être écrites entre guillemets simples ('...') ou entre guillemets doubles ("...") sans distinction pour attribuer une valeur de type str à une variable. Les caractères spéciaux sont "protégés" avec des barres obliques inverses ( \ : backslash).
Exemple :
nom = 'Touille'
prenom = "Sacha"
loisir1 = "l'informatique" #si on veut utiliser un caractère ' dans ce cas, mettre le str entre ""
loisir2 = 'l\'informatique' #ou bien utiliser le caractère \ pour "échapper" le guillemet '
Attention : Il ne faut pas oublier les " " ou les ' ' pour définir des chaînes de caractères sinon Python ne comprend pas que c'est une chaîne de caractères. Si on tape ch = bonjour Python veut attribuer la valeur de variable bonjour à la variable ch. Soit bonjour a déjà été défini comme une variable et Python ne renverra pas d'erreur (mais ce sera un bug) soit bonjour n'a pas déjà été défini et, dans ce cas, Python va renvoyer une erreur.
Remarque :
La fonction print() affiche les chaînes en retirant les guillemets et en affichant les caractères spéciaux qui étaient protégés par une barre oblique inverse :
loisir2 = 'l\'informatique'
print(loisir2)
l'informatique
b. Quelques opérations sur les chaînes à connaître.¶
Le signe + qui a été vu pour ajouter des nombres sert aussi à "coller" des chaînes de caractères. On dit qu'on concatène les deux chaînes de caractères.
Exemple :
ch1 = 'bonjour'
ch2 = 'le monde'
ch3 = ch1 + ch2
ch3
'bonjourle monde'
Remarque : Il n'est pas possible de concaténer un nombre et une chaîne de caractères. Python le dit lui-même, il suffit de lire le message qu'il indique si on essaye. Il faut d'ailleurs prendre l'habitude de chercher à comprendre les messages d'erreurs renvoyés par Python, il donne souvent une explication (en anglais) qui permet de comprendre et retrouver ses erreurs.
ch1 = 'toto'
nb = 2
ch1 = ch1 + nb
ch1
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-15-02abf07151a5> in <module> 1 ch1 = 'toto' 2 nb = 2 ----> 3 ch1 = ch1 + nb 4 ch1 TypeError: can only concatenate str (not "int") to str
On peut aussi utiliser le signe * entre un nombre entier (int) et un str pour répéter une chaîne de caractères. Par contre les signes - et / ne sont pas utilisés sur les chaînes de caractères.
Exemple :
ch1 = 'Bonjour'
ch1 = ch1 * 3
ch1
'BonjourBonjourBonjour'
On peut aussi noter ch1 = 3 * ch1 ou ch1 *= 3pour obtenir le même résultat.
On peut "transformer" un nombre (int ou float) en chaîne de caractères avec la fonction str() et inversement (quand cela est possible) avec les fonctions int() ou float().
Exemple :
a = str(5)
type(a)
str
b = "12"
print(type(b))
b = int(b)
print(type(b))
<class 'str'> <class 'int'>
c = float("2.35")
type(c)
float
On peut connaître la longueur d'une chaîne de caractères en utilisant la fonction len().
Exemple :
ch = 'Coucou'
len(ch)
Remarque : Le caractère \ peut également être utilisé pour donner un sens particulier à caractère ; par exemple, \n symbolise un retour à la ligne, et \t symbolise une tabulation.
print("Hello\nWorld !")
Hello World !
c. Indices d'une chaîne de caractères.¶
On peut accéder à chaque caractère d'une chaîne de caractères par son indice qui est un nombre entier qui va de 0 (pour le premier caractère) à n-1 (pour le dernier). On peut accéder au caractère d'indice i en tapant : ch[i].

Attention :
On peut accéder à un caractère d'une chaîne de caractères mais pas le modifier.
le 1er caractère d'une chaîne de caractères a pour indice 0 et non pas 1.
Il ne faut pas confondre l'indice du caractère et sa position dans la chaîne (il y a un décalage de 1 puisqu'on commence à 0).
Exemples :
ch1 = 'Sacha'
ch2 = 'Touille'
ch1[2]
'c'
ch2[3]
'i'
len(ch1)
5
NOTION PLUS AVANCÉE : On peut aussi accéder à une suite de caractères d'une chaîne de caractères avec la notation ch[i:j] qui sera formée des caractères de la chaîne ch de l'indice i (inclus) à l'indice j (exclu). Attention j est exclu. On dit alors qu'on récupère une tranche (ou slice en anglais) de la chaîne de caractères.
Exemple :
ch1[1:4]
'ach'
Remarque : On peut aussi taper ch[:j] au lieu de ch[0:j] et de même ch[i:] au lieu de ch[i:n-1].
ch1[:3]
'Sac'
ch1[2:]
'cha'
On peut aussi repérer un caractère d'une chaîne de caractères par un indice négatif. Dans ce cas, le dernier caractère d'une chaîne de caractères notée ch a pour indice -1, l'avant dernier a pour indice -2, ... et le 1er a pour indice -len(ch).

Exemple :
ch = 'abcdef'
ch[-1]
'f'
Remarque : Cette notation est surtout pratique pour récupérer le dernier caractère d'une chaîne de caractères avec l'indice -1.
4. Les booléens.¶
Les variables de type booléen (bool en Python) sont des variables qui ne peuvent prendre que deux valeurs : True et False (attention à bien respecter les majuscules).
Pour stocker un booléen dans une variable, il ne faut pas utiliser de guillemets sinon Python va les interpréter comme des chaînes de caractères. Les valeurs booléennes sont très utilisées en programmation et comme nous allons le voir dans les prochains paragraphes, elles sont notamment très utiles pour valider ou invalider un test.
Exemple :
a = True
type(a)
bool
b = 5 < 10
print(b)
type(b)
True
bool
c = 5 > 10
print(c)
type(c)
False
bool
Remarque : Le mot "booléen" vient de George Boole (1815-1864) qui était un mathématicien et philosophe britannique. Il est le créateur de la logique moderne que l’on appelle aujourd’hui algèbre de Boole.
Nous verrons dans la suite du chapitre d'autres types plus complexes que les 3 types évoqués dans cette partie. Pour ceux qui voudraient en savoir plus sur les types natifs en Python, vous pouvez regarder : types natifs Python mais attention certaines notions abordées dépassent largement le cadre de ce début d'année et même parfois le cadre du programme de NSI.
IV. Les expressions et les booléens.¶
Si on nous dit que "4 est égal à 5" alors on répond que "c'est faux". Si maintenant on nous dit que "7 est égal à 7", alors on répond que "c'est vrai".
En Python, ces deux "affirmations" ("4 est égal à 5" et "7 est égal à 7") s'écrivent 4 == 5 et 7 == 7 (avec un double signe égal).
Ce type d'égalité, comme 4 == 5 est appelé une expression et une expression est soit vraie (True), soit fausse (False) (des booléens).
Exemples :
1 == 1
True
2 == 3
False
1 + 1 == 2
True
Jusqu'à là tout va bien, ça reste logique. MAIS...
0.1 + 0.2 == 0.3
False
Là ça se gâte... Cette égalité est bien sûr vraie en mathématiques mais on a déjà vu que Python a un peu de mal avec les nombres décimaux flottants et du coup il peut parfois y avoir des bugs !
Il ne faut donc pas faire des tests d'égalités sur des flottants !
On peut aussi utiliser les opérateurs mathématiques de comparaison avec Python, on peut donc tester si deux nombres (entiers) sont égaux avec == mais aussi supérieurs, inférieurs, etc. avec <, >, <=, >= et même différents avec !=.
Exemples :
2 < 3
True
2 <= 2
True
2 != 3 #différent
True
x = 2 == 3 #plus étrange... on affecte à x la valeur 2==3 donc False
print(x)
False
b = 2 < 3 #on affecte à b la valeur 2<3 donc True
print(b)
True
ATTENTION : On a vu que 0.1 + 0.2 == 0.3 retourne False. Si vous devez tout de même impérativement faire un test sur des flottants, dans ce cas, la bonne pratique est de vérifier si un flottant est compris dans un intervalle avec une certaine précision. Par exemple :
abs(0.1 + 0.2 - 0.3) <= 0.000000001 #abs = valeur absolue
True
On peut alors considérer que 0.1 + 0.2 est tellement proche de 0.3 (puisque la différence est très proche de 0) que la somme 0.1 + 0.2 est égale à 0.3 (horreur en mathématiques, acceptable en physique...).
if condition: #le ":" est obligatoire
bloc_instructions1 #l'indentation de 4 espaces aussi obligatoire
else:
bloc_instructions2
Si (if ) "condition" est vérifiée (donc True) alors "bloc_instructions1" est exécuté et " bloc_instructions2" est alors ignoré, sinon (else), la "condition" est "False" et c'est la "bloc_instructions2" qui est exécuté et "bloc_instructions1" qui est ignoré.
"bloc_instructions1" et de "bloc_instructions2" forment des blocs d'instructions définis par l'indentation qui est obligatoire (il peut y avoir plusieurs indentations si le if est à l'intérieur d'un autre bloc d'instructions).
Remarque : Pour indenter du code, on peut utiliser la touche <Tab> (tabulation) qui fait automatiquement les 4 espaces.
Exemple : On rappelle qu'un nombre entier pair est un nombre divisible par 2.
# teste la parité d'un nombre entier n
n = 128
if n % 2 == 0: #on teste si le reste de la division par 2 est 0
print("Vrai")
else:
print("Faux")
Vrai
Remarque : Il existe aussi le mot clé elif qui est la contraction de "else if" (sinon si).
Exemple :
# affiche un texte en fonction d'une note obtenue
n = 13
if n >= 15:
print('Super') # affiché si la note est supérieure ou égale à 15
elif 10 <= n < 15:
print('Ça va') # affiché si la note est entre 10 et 15
else:
print('Oups...') # affiché dans tous les autres cas
Ça va
Remarque : if et elif sont suivis d'une expression qui a la valeur True ou False et la ligne se termine par le signe ":" mais par contre else est immédiatement suivie du signe ":".
2. Des opérateurs logiques.¶
Nous allons commencer par parler de 2 opérateurs logiques : le "ou" (or en Python) et le "et" (and en Python).
(expression1 or expression2) est vraie si au moins l'une des 2 expressions est vraie.
(expression1 and expression2) est vraie si les 2 expressions sont vraies.
Exemples :
ch = 'oui'
if ch == 'yes' or ch == 'oui': #si ch est 'oui' ou 'yes' la condition sera vérifiée
print(':-)')
else:
print(':-(')
:-)
a = 2
b = 4
if a == 2 or b == 5: #il faut que a soit égal à 2 ou que b soit égal à 5 pour que ce soit vrai
print('ok')
else:
print('pas ok')
ok
a = 2
b = 4
if a == 2 and b == 5: #il faut que a soit égal à 2 ET en mm temps que b soit égal à 5 pour que ce soit vrai
print('ok')
else:
print('pas ok')
pas ok
On peut aussi nier une expression avec not. not retourne l'opposé d'une expression c'est à dire que si A est vrai alors not A est faux et réciproquement.
Exemple :
a = 5
if not(a == 3): #on teste si a==3 est faux donc si a est différent de 3, on peut aussi utiliser != dans ce cas
print('bravo')
else:
print('...')
bravo
b = True
not(b)
False
VI. Les fonctions.¶
1. Définition et généralités.¶
Une fonction est un bloc de code qui a un nom et qui est formé par un ensemble d’instructions créées pour effectuer une tâche précise qui pourra être répétée autant de fois que l'on veut dans le programme (on dit qu'on appelle une fonction) sans avoir à la réécrire à chaque fois.
Elles permettent de décomposer un programme complexe en une série de sous-programmes plus simples et rendent ainsi le code plus lisible.
Le programme principal désigne le code qui est exécuté lorsqu'on lance le script Python, c'est-à-dire toute la suite d'instructions en dehors des fonctions. En général, dans un script Python, on écrit d'abord les fonctions puis le programme principal.
En mathématiques, une fonction est un procédé qui permet d'associer à un nombre, un unique autre nombre appelé image. En quelque sorte on "rentre" un nombre x dans la fonction et elle "renvoie" un nombre f(x) qui est appelé l'image de x. Comme souvent en informatique, la notion mathématique n'est pas loin et une fonction en informatique est aussi basée sur cette idée :

Le langage utilisé n'est pas le même qu'en mathématiques. La variable "rentrée" dans la fonction est appelée paramètre ou argument (il peut y avoir plusieurs valeurs et donc plusieurs paramètres).
Pour définir une fonction en Python, on utilise cette syntaxe :
def ma_fonction(valeur1, valeur2, ...): #le caractère : est obligatoire tout comme les parenthèses
instruction1 #bloc d'instructions et indentation de 4 pixels obligatoire
instruction2
...
return valeur #valeur renvoyée par la fonction
Le mot def est un mot clé du langage Python. Il permet de définir le nom de la fonction, ici la fonction se nomme ma_fonction. Il est possible qu'une fonction n'ait pas besoin de paramètres pour fonctionner mais les parenthèses sont tout de même obligatoires (il n'y a rien dedans dans ce cas).
Tout ce qui n'est pas indenté ne fait pas parti de la fonction : soit on continue le programme soit on commence une autre fonction.
Il est recommandé de sauter 2 lignes entre 2 fonctions pour que le code soit plus lisible.

Par exemple, pour faire le parallèle avec une fonction mathématique, on va définir une fonction qui calcule l'image d'un nombre x par la fonction (mathématique cette fois) qui à tout réel x associe le nombre 3x – 4 :
# une fonction très mathématiques
def f(x): #x est le paramètre
y = 3*x - 4 #on calcule l'image de x et on stocke le résultat dans la variable y
return y #la fonction renvoie la valeur de y
# En reprenant le test de paritè
def est_pair(n): #n est le paramètre
if n % 2 == 0: #on teste si le reste de la division par 2 est 0
return True #renvoie True si n est pair
else:
return False #renvoie False sinon
Pour "utiliser" une fonction, on appelle cette fonction en utilisant la même notation qu'en mathématiques : nom_fonction(valeur).
Par exemple :
est_pair(3)
False
est_pair(124)
True
Pour renvoyer un résultat, le corps de la fonction doit contenir l'instruction return. Il peut y avoir plusieurs instructions return dans une même fonction mais chacune interrompt l'exécution de la fonction en renvoyant un résultat dans le programme principal, il faut donc faire attention à la façon de les utiliser.
Une fonction qui ne renvoie pas de valeur (pas de return) est appelée une procédure, mais Python ne fait pas la différence entre les deux (contrairement à certains langages), nous utiliserons, du coup, toujours le mot fonction (et le mot clé def).
⚠ NOTION TRÈS IMPORTANTE ⚠¶
Il ne faut pas confondre afficher et renvoyer une valeur. 😓
La fonction print() que nous avons déjà croisée affiche quelque chose à l’écran mais ne renvoie rien, on ne peut donc pas récupérer une valeur dans une variable en utilisant cette fonction.
Par exemple :
def ma_fonction_affiche(x):
print(x + 1)
def ma_fonction_renvoie(x):
return x + 1
a = ma_fonction_affiche(5) #on appelle ma_fonction_affiche et on affecte son résultat à la variable a
b = ma_fonction_renvoie(5) #on appelle ma_fonction_renvoie et on affecte son résultat à la variable b
print("a =", a)
print("b =", b)
6 a = None b = 6
ma_fonction_affiche affiche 6 (c'est le 1er 6 qui apparaît) mais elle ne retourne aucune valeur et donc la variable a ne reçoit aucune valeur et vaut alors None (c'est à dire rien). Par contre ma_fonction_renvoie n'affiche rien (il n'y a pas de 6 affiché) mais elle renvoie une valeur qui est alors stockée dans la variable b.
Contrairement à la variable a, la variable b ne vaut pas None, mais 6.
La majorité des fonctions n’affichent rien, mais renvoient une valeur qui pourra donc être affectée à une variable pour être ensuite utilisée dans le programme. Cette différence qui n'est pas simple à comprendre mais elle est fondamentale pour bien utiliser des fonctions.
En reprenant l'exemple de la fonction f :
f(5)
11
L'interpréteur a renvoyé la valeur 11.
a = f(5)
La valeur de f(5) est affectée à la variable a, rien n'est affiché. On peut vérifier :
a
11
Remarques :
Depuis le début de ce cours, on a déjà croisé des fonctions natives de Python sans avoir expliqué ce que c'était : les fonctions print() ou encore type(), ou str()...
Juste après avoir défini une fonction, on doit normalement placer une "docstring" (chaîne de documentation, en français). C'est une chaîne de caractères qui permet de documenter la fonction. Si on précise une docstring dans une fonction, la fonction help(fonction) permettra au shell d'afficher la chaîne correspondant à la docstring. On utilise toujours des guillemets triples """ autour des docstrings, nous verons plus tard ce qu'il faut placer dans ces docstrings.
Exemple :
def fonction_inutile():
"""fonction qui ne sert à rien
ne prend aucun paramètre
ne renvoie rien"""
return #elle ne renvoie rien...
help(fonction_inutile)
Help on function fonction_inutile in module __main__:
fonction_inutile()
fonction qui ne sert à rien
ne prend aucun paramètre
ne renvoie rien
NOTION AVANCÉE
Remarque : Il est possible de passer un ou plusieurs argument(s) de manière facultative et de leur attribuer une valeur par défaut avec la syntaxe : def fct(arg=val):. Par exemple :
def fct(x=0, y=0, z=0):
return x + y + z
print(fct())
#on ne passe pas de paramètres lors l'appel de la fonction
#la fonction va prendre les arguments par défaut donc 0, 0 et 0.
print(fct(1, 2, 3))
#on passe des paramètres lors de l'appel de la fonction
print(fct(1, 2))
#on passe 2 paramètres lors de l'appel de la fonction
#le dernier reste à 0
print(fct(z=8, x=1))
#on passe 2 paramètres en précisant lesquels lors de l'appel de la fonction
#le dernier (y non précisé) reste à 0
0 6 3 9
2. Deux fonctions particulières.¶
a. La fonction print()
Nous avons déjà rencontré la fonction print() qui affiche une chaîne de caractères dès le début du cours. En fait cette fonction affiche l'argument qu'on lui passe en paramètre (entre parenthèses) et un retour à ligne. Ce retour à ligne supplémentaire est ajouté par défaut. Si toutefois, on ne veut pas afficher ce retour à la ligne, on peut utiliser l'argument end : print('Coucou', end = '') annulera le retour à la ligne.
La fonction print() peut également afficher le contenu d'une variable quel que soit son type voire de plusieurs variables en les séparant par des virgules :
ch1 = 'Bonjour'
x = 2
print(ch1, 'Sacha, j\'ai', x, 'nouveaux jeux vidéo')
Bonjour Sacha, j'ai 2 nouveaux jeux vidéo
On remarque que par défaut le shell ajoute automatiquement des espaces (ce n'est pas le cas sur MacOs) et on peut là-aussi changer ce comportement en utilisant l'argument sep (séparateur) utilisé pour indiquer avec quel caractère séparer ce qui est affiché (on peut séparer avec ce qu'on veut, pas forcément des espaces) :
print(ch1, 'Sacha, j\'ai', x, 'nouveaux jeux vidéo', sep = '')
BonjourSacha, j'ai2nouveaux jeux vidéo
print(ch1,'Sacha, j\'ai', x, 'nouveaux jeux vidéo', sep = ' ')
Bonjour Sacha, j'ai 2 nouveaux jeux vidéo
print(ch1, 'Sacha, j\'ai', x, 'nouveaux jeux vidéo', sep = '..')
Bonjour..Sacha, j'ai..2..nouveaux jeux vidéo
Il y a d'autres façons d'écrire du texte (formatage de texte) avec Python en utilisant la fonction print() mais nous ne l'aborderons pas dans ce chapitre.
b. La fonction input()
Un programme nécessite parfois l'intervention de l'utilisateur (entrée d'un paramètre au clavier, clic de souris, 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 input(). Cette fonction provoque une interruption dans le programme en cours d'exécution. L'utilisateur est invité à entrer des caractères au clavier et à terminer avec la touche <Entrée>. Lorsque cette touche est enfoncée, l'exécution du programme se poursuit, et la fonction renvoie en retour une valeur correspondant à ce que l'utilisateur a saisi. Cette valeur peut alors être affectée à une variable.
La fonction input() renvoie une chaîne de caractères donc même si l'utilisateur veut saisir un nombre, Python comprendra que c'est une chaîne de caractères (mais on peut ensuite le "transformer" avec int() ou float() en nombre).
Exemple :
nom = input('Quel est ton nom ? ') #le paramètre 'Quel est ton nom ? ' est un texte affiché à l'écran
# la variable nom va contenir la chaîne de caractères renvoyée par la fonction input
print('Bonjour', nom, 'content de te voir')
Remarque : Sauf cas particulier (petit interface en mode texte), nous n'utiliserons pas cette fonction qui est source d'incompréhensions en particulier dans le cadre d'utilisation de fonctions.
3. Espace et portée des variables.¶
Dans un programme, on distingue différents espaces :
un espace global (le programme principal) dans lequel des variables dites globales sont définies, ce sont des variables dont la portée s'étend à tout le programme, c'est à dire qu'elle est visible dans le programme principal ainsi que dans toutes les fonctions.
un espace local pour chaque fonction distinct des autres espaces dans lequel des variables dites locales sont définies.
Lorsqu'une variable est déclarée dans le programme principal, elle est visible dans celui-ci ainsi que dans toutes les fonctions. On a vu qu'on parlait de variable globale.
Il est très important lorsque l'on manipule des fonctions de connaître la portée des variables (scope en anglais), c'est-à-dire savoir là où elles sont visibles. Les variables créées au sein d'une fonction ne sont pas visibles à l'extérieur de celle-ci, elles sont locales à la fonction. L'espace local d'une fonction contient les paramètres qui lui sont passés et les variables définies dans le corps de la fonction. Ces variables locales n'existent qu'à l'intérieur de la fonction et seulement pendant son utilisation.
Contrairement aux variables locales qui ne sont utilisables que dans la fonction dans laquelle elles sont déclarées, les variables globales peuvent être utilisées par n'importe quelle fonction du programme mais, attention, une variable globale (non mutable, nombres, booléens, chaînes de caractères) ne sera pas modifiée par la fonction.
Exemples :
def ma_fonction(x):
y = x + 1 #y est une variable locale (définie uniquement dans la fonction)
return y
a = 5 #a est une variable globale (définie dans le programme principal)
print(y) #déclenche une erreur car b n'est pas définie dans le programme principal
12
def f(x):
b = a + 1 #b est une variable locale qui utilise a qui est une variable globale
print('b =', b) #on affiche la valeur de b, on constate que Python a bien fait 2+1
return x**2
a = 2 #a est une variable globale
print('l\'image de 4 est :', f(4)) #l'appel f(4) affiche la valeur de b puis retourne le carré de 4
b = 3 l'image de 4 est : 16
La variable a n'est pas déclarée dans la fonction mais Python "reconnaît" qu'une variable a est déclarée dans le programme principal, il va alors utiliser cette valeur pour obtenir la valeur à stocker dans b. Pour autant b est une variable locale qui n'existe que dans la fonction et qu'on ne peut donc utiliser ni dans le programme principal ni dans une autre fonction (voir l'exemple ci-dessous).
def f(x):
a = 2 #a est une variable locale bien qu'il soit déclaré comme variable globale en dehors de f
b = a + 1 #b est une variable locale
print('b =',b) #on affiche la valeur de b, on constate que Python a bien fait 2+1
return x + b
a = 5 #a est une variable globale
print(f(4))
b = 3 7
On constate que b a bien été calculé à partir de la valeur a = 2 (variable locale) et non a = 5 (variable globale).
Pour éviter les confusions, il est donc vivement recommandé de ne pas utiliser les mêmes noms pour les variables locales et les variables globales.
Même si c'est à éviter, il existe tout de même une façon de modifier quand même une variable globale à l'intérieur d'une fonction. Pour cela, il suffit de déclarer dans la fonction la variable à modifier comme étant une variable globale en utilisant le mot-clé : global suivi du nom de la variable. Par convention, on le place juste après la définition de la fonction (en-dessous de la docstring, s'il y en a une), cela permet de retrouver rapidement les variables globales sans parcourir tout le code.
Exemple :
def f(): #fonction qui affiche uniquement
global a #on déclare a comme étant une variable globale => elle peut être modifiée dans la fonction
a += 1 #on modifie la valeur de a
print('Dans la fonction a =', a) #on affiche a dans la fonction
a = 12
print('1. a =', a) #on affiche la valeur de a avant d'exécuter la fonction
f() #on appelle la fonction f
print('2. a =', a) #on affiche de nouveau la valeur de a, cette fois dans le programme principal
1. a = 12 Dans la fonction a = 13 2. a = 13
On constate que, cette fois, la variable globale a est bien modifiée lors de l'appel de la fonction.
Remarque : Cette distinction entre variables locales et variables globales se retrouve dans d'autres langages. D'une manière générale il est très fortement déconseillé d'utiliser des variables globales (tout comme le mot-clé global) moins on en utilise et mieux c'est (nous verrons pourquoi peu à peu dans l'année et comment en éviter l'année prochaine). Malgré tout, ce n'est pas une règle absolue et nous serons parfois obligés cette année de l'utiliser.
VII. Boucle conditionnelle : la boucle while.¶
La notion de boucle est fondamentale en informatique : une boucle permet d'exécuter plusieurs fois à la suite des instructions qui ne sont présentes qu'une seule fois dans le code.
Par exemple si on veut écrire un programme qui génère la table de multiplication par 7, de 1 × 7 à 10 × 7 :
La première solution serait de répéter 10 fois le calcul et de l'afficher (avec son résultat) à l'aide de la fonction print(). Cela va fonctionner mais il faudra répéter 10 fois de suite (presque) la même ligne de code sans pouvoir utiliser de copier/coller puisque les nombres vont changer à chaque ligne, ça se fait mais c'est bien long ! C'est là que la notion de boucle qui va nous éviter ce travail est intéressante.

Une boucle conditionnelle permet de répéter un bloc d'instructions tant qu'une condition est vraie. On utilise pour cela l'instruction while en Python ("tant que" en anglais).
La structure est la suivante :
while condition:
bloc_instructions
Une nouvelle fois la structure est identique à celles déjà vues (fonctions et instructions conditionnelles). La condition qui suit while est une expression dont la valeur est True ou False. Tant que l'expression est vraie (True), le bloc d'instruction qui suit sera exécuté.
Attention : La valeur de l'expression doit être modifiée dans le bloc d'instruction, sinon la condition restera toujours vraie et le programme bouclera à l'infini (on parle d'ailleurs de boucle infinie dans ce cas).
Exemples :
a = 5
while a > 0: #tant que a>0 est vrai, on exécute le bloc ci-dessous
print(a, end = ' ') #affiche la valeur de a
a -= 1 #on retire 1 à chaque passage, dès que 'a>0' devient faux, la boucle sera arrétée
print('la nouvelle valeur de a est :',a)
5 4 3 2 1 la nouvelle valeur de a est : 0
On constate que a est passé à 0 donc a>0 est faux et la boucle a bien été stoppée (par contre, attention la valeur de a est 0 et non 1).
a = 5
while a > 0:
print('coucou') #à ne pas lancer, le programme part dans une boucle infinie !
a reste toujours égal à 5 donc a>0 sera toujours vrai et donc le programme part dans une boucle infinie.
VIII. Boucle non conditionnelle : la boucle for.¶
Tout comme une boucle conditionnelle, une boucle non conditionnelle permet de répéter un bloc d'instructions à la suite. Mais contrairement à la boucle conditionnelle, le nombre de répétitions doit être précisé et donc connu dès le départ de la boucle. Pour cela on utilise les mots clés for (pour) et in (dans).
La syntaxe est :
for i in range(n): #range() est une fonction qui permet d'indiquer les valeurs que i va prendre
bloc_instructions
La fonction range() renvoie la séquence des entiers successifs de 0 inclus à n exclu, i va alors prendre les valeurs de 0 à n-1 et donc i prend successivement n valeurs., en mathématiques, on noterait : $i\in [\![0;n[\![$
Exemple :
for i in range(3):
print(i)
0 1 2
On constate que i prend les valeurs de 0 à 2 (et non de 1 à 3)
Remarque : Une boucle non conditionnelle peut toujours être remplacée par une boucle conditionnelle, par exemple, on peut remplacer la boucle précédente par :
i = 0
while i < 3:
print(i)
i += 1
0 1 2
Remarques : La fonction range() offre différentes possibilités :
On peut obtenir la séquence de tous les entiers successifs compris entre 2 entiers m et n (avec m ≤ n) avec range(m,n).
range(m, n)est équivalent à la notation mathématique ⟦m ; n⟦.On peut aussi préciser le pas, p, avec
range(m, n, p). Le pas peut être un nombre entier négatif, ce qui permet d'obtenir, dans ce cas, une séquence décroissante de nombres entiers :
for i in range(7, 3, -1):
print(i)
7 6 5 4
La boucle for en Python propose d'autres possibilités. On peut remplacer la fonction range() par une chaîne de caractères ou une liste ou encore un dictionnaire (on verra ces notions dans les chapitres suivants).
La boucle for "itère" alors les caractères de la chaîne un à un et la variable de boucle prend successivement la valeur de ces différents caractères. Une variable que l'on peut parcourir avec une boucle for est dite "itérable".
Exemple :
ch = "bonjour"
for i in ch: #i prend successivement les valeurs des caractères de ch
print(i)
b o n j o u r
L'instruction break permet d'interrompre une boucle (mais ce n'est pas recommandé de l'utiliser, d'ailleurs nous ne l'utiliserons presque jamais) :
for i in range(12):
if i == 3:
break #la boucle va être arrétée si i est égal à 3
else:
print(i)
0 1 2