Bases de Python, variables et types

Cours · Python (école d'ingénieur), chapitre 1 · école d'ingénieur, informatique · le début du chapitre, la suite sur Adloun

1.1 Introduction et Motivation

Python est un langage de programmation moderne, interprété et multi-paradigmes. Sa syntaxe claire, épurée et proche du langage naturel en fait le choix privilégié pour l'enseignement de l'informatique, le calcul scientifique, l'intelligence artificielle et l'analyse de données. L'objectif de ce premier chapitre est de poser les bases de l'écosystème Python, de distinguer le mode interactif du mode script, et de comprendre précisément comment Python gère les variables en mémoire. Nous aborderons également les types primitifs de base et le découpage de séquences (slicing) à travers des exemples théoriques et des exercices d'application corrigés.

1.2 Écosystème et Environnement de Travail

Python est un langage interprété. Contrairement aux langages compilés (comme le C ou le C++), où le code source est traduit en code machine avant l'exécution, Python utilise un programme appelé interpréteur qui traduit et exécute les instructions ligne par ligne.

1.2.1 Mode Interactif vs Mode Script

On distingue deux manières principales d'interagir avec l'interpréteur :

Le mode interactif (REPL) : L'utilisateur saisit une commande après l'invite de commande (>>> ou In [1]:), l'interpréteur l'évalue immédiatement, affiche le résultat s'il y en a un, et attend l'instruction suivante. C'est l'outil idéal pour tester des expressions simples ou inspecter des structures de données.
Le mode script : Les instructions sont rédigées dans un fichier texte portant l'extension .py. L'interpréteur lit et exécute l'intégralité du fichier d'une seule traite. Dans ce mode, l'évaluation d'une expression (par exemple écrire simplement 2 + 3 sur une ligne) ne produit aucun affichage à l'écran. Il est nécessaire d'utiliser explicitement des fonctions d'affichage comme print().

1.2.2 Retour de Valeur vs Effet de Bord

Un point d'achoppement classique pour les débutants est la distinction fondamentale entre le retour de valeur d'une fonction et son effet sur l'environnement (effet de bord).

Définition 1.1Retour vs Effet de bord

Le retour de valeur est le résultat mathématique ou logique produit par l'évaluation d'une expression ou d'une fonction. Ce résultat est transmis au programme appelant et peut être stocké dans une variable.
L'effet de bord (ou effet sur l'environnement) est toute modification de l'état du système extérieur à la fonction, comme l'affichage de texte sur la console (stdout), l'écriture dans un fichier ou la modification d'un périphérique.

Exemple 1.2Analyse de print

La fonction print() affiche la représentation textuelle de ses arguments à l'écran (effet sur l'environnement). Cependant, elle ne renvoie rien d'utile au programme : son retour de valeur est l'objet spécial None.


>>> res = print("Bonjour")
Bonjour
>>> print(res)
None

1.2.3 Personnalisation de l'Affichage

La fonction intégrée print accepte plusieurs arguments nommés facultatifs permettant de contrôler finement son comportement :

sep (chaîne de caractères, par défaut un espace ' ') : définit le séparateur entre les différents arguments.
end (chaîne de caractères, par défaut un retour à la ligne ' n') : définit le caractère ajouté à la fin de l'affichage.
file : permet de rediriger le flux de sortie vers un fichier ouvert en écriture.

Exemple 1.3Redirection de print

Le code suivant n'affiche rien à l'écran, mais crée un fichier essai.txt contenant la chaîne Hello world ! :


print('Hello world !', file=open('essai.txt', 'w'))

1.3 Variables et Référencement en Mémoire

Contrairement à des langages comme le C où une variable correspond à une boîte mémoire de taille fixe stockant directement une valeur, Python utilise un système de références d'objets (ou liaison de noms).

1.3.1 Mécanisme de Liaison (Binding)

En Python, tout est objet. Une affectation comme largeur = 12.45 réalise les étapes suivantes :

Création d'un objet de type float en mémoire à une adresse spécifique, contenant la valeur 12.45.
Liaison du nom de variable largeur à cette adresse mémoire dans le tableau de référencement local.

Le schéma suivant illustre la structure mémoire après l'exécution du script d'affectation :


largeur = 12.45
longueur = 42.18
aire = longueur * largeur

iRemarqueGarbage Collector

Lorsqu'un objet en mémoire n'est plus référencé par aucune variable (par exemple si largeur est réaffectée à une autre valeur), son compteur de références tombe à zéro. Le garbage collector (ramasse-miettes) de Python libère alors automatiquement cet espace mémoire.

1.3.2 Égalité de Valeur vs Égalité Physique

La distinction entre les variables comme références d'objets mène à deux notions d'égalité :

L'égalité de valeur (opérateur ==) : Vérifie si deux objets contiennent la même valeur logique.
L'égalité physique / d'identité (opérateur is) : Vérifie si deux variables pointent vers le même objet physique en mémoire (c'est-à-dire si elles ont la même adresse mémoire, obtenue par la fonction intégrée id()).

Exemple 1.4Comparaison de variables

Soit le script suivant :


a = 257
b = 257
c = a

Ici, a == b vaut True (mêmes valeurs), mais a is b vaut False (deux objets distincts créés en mémoire). En revanche, a is c renvoie True car c a été liée directement à la même adresse que a.

1.4 Types Primitifs et Représentation

En Python, les types sont dynamiquement associés aux objets, et non aux noms de variables. On utilise la fonction type() pour inspecter le type d'un objet.

1.4.1 Représentation Numérique

Python possède trois types numériques fondamentaux :

int : Représente les entiers relatifs. En Python 3, les entiers ont une précision arbitraire (limitée uniquement par la mémoire vive disponible). Il n'y a donc pas de dépassement d'entier (overflow).
float : Représente les nombres décimaux à virgule flottante. Ils sont codés sur 64 bits selon la norme IEEE 754 (double précision). Du fait de cette représentation binaire finie, certains nombres réels (notamment ceux dont la partie fractionnaire n'a pas de représentation dyadique finie, comme $0.1$ ) ne sont représentés que de façon approchée.
complex : Représente les nombres complexes. Ils s'écrivent sous la forme a + bj où j est l'unité imaginaire ( $j^{2} = - 1$ ). Les attributs .real et .imag permettent d'extraire respectivement les parties réelle et imaginaire sous forme de flottants.

1.4.2 Opérateurs Mathématiques

Les opérateurs de calcul de base sont présentés dans le tableau ci-dessous :

Opérateur	Opération	Exemple
`x + y`	Somme	`5 + 3.0` $\to$ `8.0`
`x - y`	Différence	`10 - 2` $\to$ `8`
`x y`	Produit	`4 5` $\to$ `20`
`x / y`	Quotient de la division réelle	`23 / 3` $\to$ `7.666...`
`x // y`	Quotient de la division euclidienne	`23 // 3` $\to$ `7`
`x % y`	Reste de la division euclidienne (modulo)	`23 % 3` $\to$ `2`
`x y`	Puissance ( $x^{y}$ )	`2 3` $\to$ `8`
`abs(x)`	Valeur absolue / Module d'un complexe	`abs(-5)` $\to$ `5`

Figure : Principales opérations arithmétiques.

iRemarqueType du résultat

L'utilisation de la division réelle / produit toujours un type float, même si le résultat est entier (ex. 4 / 2 renvoie 2.0). Lors d'opérations mixtes entre int et float, la conversion en float est automatique.

1.4.3 Booléens et Logique

Le type booléen (bool) ne contient que deux valeurs : True (vrai) et False (faux). Les opérateurs logiques sont les mots-clés not, and et or. Les opérateurs de comparaison comparant les valeurs numériques sont <, >, <=, >=, == et !=.

1.5 Chaînes de Caractères et Slicing

Le type str représente des séquences immuables de caractères Unicode.

1.5.1 Définition et Opérations

Les chaînes de caractères peuvent être délimitées par des apostrophes simples ' ou des guillemets doubles ".

La concaténation (opérateur +) : permet de coller deux chaînes.
La duplication (opérateur *) : permet de répéter une chaîne.

1.5.2 Indexation

On accède à un caractère individuel par son index entre crochets. Python utilise un adressage à base 0. Il est également possible d'utiliser des index négatifs pour compter à partir de la fin du conteneur (l'index -1 désignant le dernier caractère).

Caractère	L	o	u	i	s	-	L	e	-	G	r	a	n	d
Index positif	0	1	2	3	4	5	6	7	8	9	10	11	12	13
Index négatif	-14	-13	-12	-11	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1

1.5.3 Slicing (Découpage en Tranches)

Le slicing permet d'extraire une sous-séquence d'une chaîne (ou de n'importe quelle liste). La syntaxe générale est :

$sequence[debut:fin:pas]$

où debut est inclus, et fin est exclu.

Si debut est omis, il vaut par défaut 0.
Si fin est omis, le découpage va jusqu'au bout de la séquence.
Le pas définit l'écart entre chaque caractère extrait. Un pas négatif (par exemple -1) permet de parcourir la chaîne à l'envers.

Exemple 1.5Exemples de slicing

Soit ch = "Louis-Le-Grand" :

ch[3:8] renvoie "is-Le" (indices 3 à 7 inclus).
ch[6:] renvoie "Le-Grand".
ch[::-1] renvoie "dnarG-eL-siuoL" (inversion complète de la chaîne).

1.6 Exercices résolus

Exercice 1 : Analyse de l'interpréteur (Retour vs Effet)

Déterminer l'affichage produit sur la console par l'exécution successive des instructions suivantes sous IPython :


In [1]: 1 + 2
In [2]: print(1 + 2)
In [3]: print(print(1 + 2))
In [4]: print(1) + 2

La suite du cours est sur Adloun

Le chapitre en entier, formules et figures comprises, avec le tuteur, les fiches, les QCM et les exercices.

Lire la suite du cours

En accès libre, sans inscription.

Exercices corrigés de ce chapitre

Lire la suite du cours →