Les bases de python
1. Introduction :
Python est un langage de programmation développé depuis 1989 par le développeur néerlandais
Guido Van Rossum et de nombreux collaborateurs.
Le nom Python revient à une série de comédie des années 70 de la BBC nommée “Monty
Python’s Flying Circus”
Python est un langage de programmation polyvalent et modulaire, utilisé dans de très nombreux
domaines, scientifiques ou non. C’est pourquoi il existe de nombreuses versions de python.
2. Données et variables
2.1. Variables
Pour pouvoir accéder aux données, le programme (quel que soit le langage dans lequel il est
écrit) fait abondamment usage d’un grand nombre de variables de différents types. Pour
l’ordinateur, une variable est une référence désignant un emplacement précis dans la mémoire
vive. A cet emplacement est stockée une valeur bien déterminée.
Les langages de programmation font usage de différents types de variables (le type entier, le
type réel, le type chaîne de caractères, le type liste, etc.).
Sous Python, les noms de variables doivent obéir à quelques règles simples :
• Un nom de variable est une séquence de lettres (a → z, A → Z) et de chiffres (0 → 9), qui
doit toujours commencer par une lettre.
• Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les espaces,
les caractères spéciaux tels que $, #, @, etc. sont interdits, à l’exception du caractère _
(souligne).
• La casse est significative (les caractères majuscules et minuscules sont distingués).
Attention : Ali, ali, ALI sont donc des variables différentes.
En plus de ces règles, il ne faut pas utiliser comme nom de variables les 33 " mots réservés" ci-
dessous (ils sont utilisés par le langage lui-même) :
and as assert break class continue def
del elif else except False finally for
from global if import is in lambda
None nonlocal not or pass raise return
True try while with yield
2.2. Types et opérateurs
2.2.1. Les nombres
Dans les langages de programmation, à tout objet est associé l'ensemble des valeurs qu'il peut
prendre ainsi que les opérations qui peuvent lui être appliquées. Ces caractéristiques sont
appelées le type de l'objet. Par exemple, un objet peut être un entier, un nombre flottant, une
liste. . .
1
✓ Le type entier : int
Le type int n’est limité en taille que par la mémoire de la machine
Exemple : 2024 -12 0 25
✓ Le type réel : float
Un float est noté avec un point décimal (jamais avec une virgule) ou en notation exponentielle
avec un « e » symbolisant le « 10 puissance » suivi des chiffres de l’exposant.
Exemple : 2.71 -.2 -0.2 -1.6e-19 -1.6e-19
✓ Opérateurs sur les nombres
x+y somme de deux entiers, réels ou complexes
x*y produit de deux entiers, réels ou complexes
x–y différence de deux entiers, réels ou complexes
x/y division de réels (retourne un objet de type float même si le résultat
théorique est un entier ; peut être appliqué à des entiers, qui sont alors
convertis en flottants
x // y division entière (quotient de la division euclidienne) ; s’applique à des
entiers ou des réels. Appliqué à des entiers, retourne un 'int', sinon un 'float'
x%y modulo (reste de la division euclidienne) s’applique à des entiers ou réels
divmod(x,y) renvoie le couple (x // y, x % y) permet de faire les deux calculs en utilisant
une seule fois l’algorithme de la division euclidienne
x ** y x puissance y
abs(x) valeur absolue
int(x) partie entière de l’écriture décimale
2.2.2. Le type booléen (bool) et les tests
Les deux éléments de la classe des booléens sont True et False (avec les majuscules).
✓ Opérations sur les booléens:
x and y et
x or y ou
x^y ou exclusif
not x négation de x
Toute opération valable sur des entiers l’est aussi sur les booléens : le calcul se fait en prenant
la valeur 0 pour False, et la valeur 1 pour True.
La plupart du temps, les booléens sont obtenus au moyen de tests :
✓ Tests
x == y égalité (la double égalité permet de distinguer # syntaxiquement de l’affectation)
x<y infériorité stricte
x>y supériorité stricte
x <= y infériorité large
x >= y supériorité large
x != y diffèrent (non égalité)
x in y appartenance (pour les listes, dictionnaires, chaines de caractères)
2
3. Instructions élémentaires
3.1. Affectation
Le terme "affecter une valeur" à une variable désigne l’opération par laquelle on établit un
lien entre le nom de la variable et sa valeur (son contenu).
En Python, l’opération d’affectation est représentée par le signe égale (=) :
Exemple :
>>> n = 7 # définir la variable n et lui donner la valeur 7
>>> msg = "Bonjour !" # affecter la valeur "Bonjour !" à la variable msg
>>> pi = 3.14159 # assigner la valeur 3.14159 à la variable pi
Les exemples ci-dessus illustrent des instructions d’affectation Python tout à fait classiques.
Après qu’on les a exécutées, il existe dans la mémoire de l’ordinateur, à des endroits
différents :
• trois noms de variables, à savoir n, msg et pi ;
• trois séquences d’octets, ou sont encodées le nombre entier 7, la chaine de caractères
Bonjour ! et le nombre réel 3,14159.
Une simple affectation sous Python a pour effet de réaliser plusieurs opérations dans la mémoire
de l’ordinateur :
• créer et mémoriser un nom de variable ;
• lui attribuer un type bien déterminé;
• créer et mémoriser une valeur particulière ;
• établir un lien entre le nom de la variable et l’emplacement mémoire de la valeur
correspondante.
3.2. Afficher la valeur d’une variable
La fonction print permet d'afficher la valeur d'une ou plusieurs variables.
La fonction print est dédiée à l'affichage uniquement. Le nombre de ses paramètres est
variable, c'est-à-dire que vous pouvez lui demander d'afficher une ou plusieurs variables.
Syntaxe :
print(value, ..., sep= …, end= …)
value : Toutes les combinaisons possibles de : chaines, variables et expression
sep : Séparateur (par défaut : espace)
end : Chaine ajoutée à la fin du message imprimé (par défaut : retour à la ligne)
3
3.3. La fonction de saisie : input
En cours d’exécution, il est possible de demander à l’utilisateur de saisir une valeur au clavier
grâce à input.
Syntaxe :
nom_var = input( value )
nom_var : Nom de la variable à laquelle une valeur va être affecter
value : message à afficher input() accepte un paramètre facultatif : le message à afficher à
l'utilisateur.
Cette instruction interrompt le programme et attend que l'utilisateur saisisse ce qu'il veut
puis appuie sur « entrée ».
À cet instant, la fonction renvoie ce que l'utilisateur a saisi. Il faut donc affecter cette
valeur dans une variable.
Exemple :
Son exécution se déroule de la façon suivante
:
1- Le programme affiche sur l’écran le texte " Saisissez une année : "
2- Le programme est alors suspendu
3- l’utilisateur saisit une valeur au clavier
4- L’utilisateur appuie sur la touche <Entree>
5- Le programme reprend son exécution et affecte la valeur saisie dans la variable annee
N.B. la fonction input retourne toujours une chaine de caractères. Pour saisir un entier ou bien
un réel, il faut convertir le type de input.
4
4. Les structures conditionnelles
4.1. Structuration et indentation
La programmation structurée nécessite la définition de blocs d’instructions au sein des
structures de contrôles (for, while, if, . . .). Certains langages utilisent des délimiteurs pour
encadrer ces blocs d’instructions, mais le langage Python se distingue en utilisant l’indentation,
qui favorise la lisibilité du code.
Le début d’un bloc d’instructions est défini par un double-point (:), la première ligne pouvant
être considérée comme un en-tête. Le corps du bloc est alors indenté d’un nombre d’espaces
fixes (quatre par défaut), et le retour à l’indentation de l’en-tête marque la fin du bloc.
en_tête :
bloc ...........................
................................
d'instructions .................
Il est possible d’imbriquer des blocs d’instructions les uns dans les autres :
en_tête 1:
................................
................................
en_tête 2:
bloc .......................
............................
d'instructions .............
................................
................................
4.2. Structure de choix
4.2.1 Structure de choix alternatif
Les instructions de choix se définissent à l’aide de l’instruction if et prennent la forme suivante :
if condition :
bloc..............
d'instructions 1..
else:
bloc..............
d'instructions 2..
(Notez bien l’indentation qui permet de délimiter chacun des deux blocs d’instructions.)
Le fonctionnement de cette instruction est le suivant : si la condition de la première ligne
s’évalue en True, le premier bloc d’instructions est exécuté, si elle s’évalue en False c’est le
second bloc qui est exécuté.
L’instruction else est optionnelle si aucune instruction ne doit être réalisée dans le cas d’un test
négatif.
Exemple :
5
4.2.2. Instructions conditionnelles multiples
En informatique il est fréquent qu’on ait à imbriquer plusieurs tests, en python, il existe un mot
clé elif (qui est la contraction de else if) et qui fonctionne suivant le schéma qui suit :
if condition1:
bloc..............
d'instructions 1..
elif condition2:
bloc..............
d'instructions 2..
else:
bloc..............
d'instructions 3..
– Si la condition1 s’évalue en True, le bloc d’instructions 1 est réalisé ;
– Si la condition1 s’évalue en False et la condition2 en True, le bloc d’instructions 2 est réalisé;
– dans les autres cas, le bloc d’instructions 3 est réalisé.
Évidemment, plusieurs elif à la suite peuvent être utilisés pour multiplier les cas possibles, mais
n’oubliez pas que les tests sont effectués séquentiellement, c’est à dire les uns après les autres
jusqu’à trouver un test positif (ou arriver au cas final else).
Exemple :
4.3. Instructions itératives
Réaliser une itération, ou encore une boucle, c’est répéter un certain nombre de fois des
instructions semblables.
En python, il existe deux instructions pour réaliser une boucle, suivant qu’on peut calculer à
l’avance le nombre d’itérations à réaliser (on parle alors de boucles énumérées) ou que le
nombre d’itérations dépend de la réalisation ou non d’une certaine condition (on parle dans ce
cas de boucles conditionnelles).
4.3.1. La fonction range
La fonction range peut prendre entre 1 et 3 arguments entiers :
– range(b) énumère les entiers 0, 1, 2, …, b - 1 ;
– range(a, b) énumère les entiers a, a + 1, a + 2, …, b - 1 ;
– range(a, b, c) énumère les entiers a, a+c, a+2c, …, a+nc où n est le plus grand entier vérifiant
a+nc < b.
Exemple :
range(5) désigne les entiers 0,1,2,3,4 (la borne prend par défaut 0)
range(1, 10) désigne les entiers 1, 2, 3, 4, 5, 6, 7, 8, 9
range(1, 11, 2) désigne les entiers 1, 3, 5, 7, 9
range(10, 0, -1) désigne les entiers 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
6
4.3.2. Boucle for
On définit une boucle énumérée à l’aide de la fonction for, en suivant la structure suivante :
for compteur in range(...):
bloc ...........................
................................
d'instructions .................
Immédiatement après le mot-clé for doit figurer le nom d’une variable (compteur), qui va
prendre les différentes valeurs de l’énumération produite par l’instruction range. Pour chacune
de ces valeurs, le bloc d’instructions qui suit sera exécuté.
Exemple :
Il est bien entendu possible d’imbriquer des boucles à l’intérieur d’autres boucles ; attention
seulement à respecter les règles d’indentation pour délimiter chacun des blocs d’instructions.
Exemple :
4.3.3. Boucles conditionnelles
Une boucle conditionnelle exécute une suite d’instructions tant qu’une certaine condition est
réalisée ; elle peut donc tout aussi bien ne jamais réaliser cette suite d’instructions (lorsque la
condition n’est pas réalisée au départ) que de les réaliser un nombre infini de fois (lorsque la
condition reste éternellement vérifiée). La syntaxe d’une boucle conditionnelle est la suivante :
while condition :
bloc ...........................
d'instructions .................
La condition doit être une expression à valeurs booléennes
Exemple :
7
4.3.4. Forcer la sortie d’une boucle
La fonction break permet d’interrompre le déroulement des instructions du bloc interne à la
boucle pour passer à la suite.
Exemple :
La fonction continue permet d’interrompre l’itération coutante et de passer à l’itération
suivante :
Exemple :
4.3.5. La gestion des exceptions
L’exécution de certaines instructions peut fournir des erreurs. Il existe différents types d’erreur
en Python, par exemple : ZeroDivisionError, ValueError, NameError, TypeError, etc.
Dans certaines conditions, on veut pouvoir continuer l’exécution du programme tout de même,
éventuellement en adaptant légèrement l’algorithme au cas problématique détecté. On dispose
pour cela de la structure try, qui dans sa version la plus simple, s’écrit :
try :
instructions1
except:
instructions2
Exemple :
8
5. les séquences
5.1. Les listes
5.1.1. Notation d’une liste
[1,2,3,4] énumération des objets entre []
[[1,2],[1],1] liste dont les deux premiers termes sont des listes
[] liste vide
L’accès à un élément d’une liste est direct. L’indexation des éléments commence à 0 :
Accès aux éléments d’une liste par Accès aux éléments d’une liste par
indexation positive indexation négative:
>>> L = [1,2,3] >>> L[-1]
>>> L[0] 3
1 >>> L[-3]
>>> L[2] 1
3 >>> L[-4]
>>> L[3] Traceback (most recent call last):
Traceback (most recent call last): File "<stdin>", line 1, in <module>
File "<stdin>", line 1, in <module> IndexError: list index out of range
IndexError: list index out of range
5.1.2. Operations et méthodes applicables à une liste:
len(L) longueur (nombre d’éléments) de L
L1 + L2 concaténation des listes
n*L pour n entier: concaténation répétée de L avec elle-même.
[Link](a) ajout de l’objet a en fin de liste
[Link](i,a) insertion de l’objet a en position i
[Link](a) retrait de la première occurrence de a
[Link](i) retrait et renvoi de l’élément d’indice i par défaut, si i non précise: dernier
élément
[Link](a) position de la première occurrence de a
ValueError si a n’est pas dans la liste
[Link](a) nombre d’occurrences de a dans la liste
a in L teste l’appartenance de a à L
[Link]() copie simple de L
[Link]() retourne la liste à l’envers
9
5.1.3. Technique de slicing:
L[i:j] Extraction de la tranche [L[i], ... , L[j-1]]
L[i:j:p] De même de p en p à partir de L[i], tant que i+k*p < j
À noter que :
• Si le premier indice est omis, il est pris égal à 0 par défaut.
• Si le deuxième indice est omis, il est pris égal à la longueur de la liste par défaut (on extrait la
tranche finale)
• Si le troisième indice est omis, il est pris égal à 1 par défaut (cas de la première instruction ci-
dessus)
• Un pas négatif permet d’inverser l’ordre des termes
• Le slicing est possible aussi avec des indexations négatives.
5.1.4. Tri d’une liste
[Link]() tri simple
[Link](reverse=True) tri inverse
sorted(L) renvoie une liste triée ayant les même éléments que la liste L
5.1.5. Parcours d’une liste:
L’instruction for est l’instruction idéale pour parcourir une liste :
Il est très pratique de combiner les fonctions range() et len() pour obtenir automatiquement
tous les indices d’une séquence (liste ou chaine) :
10
5.2. Les chaînes de caractères : str
5.2.1. Notation d’une chaine de caractères:
'abcd' énumération des caractères successifs entre ' '
"abcd" énumération des caractères successifs entre " "
"""abcd""" énumération des caractères successifs entre """ """ (raw string)
Les slicings peuvent se faire également sur les chaînes de caractères, de la même manière que
pour les listes.
5.2.2. Operations et méthodes sur les chaines de caractères :
len(c) longueur (nombre de caractères)
c+d concaténation des chaines
n*c concaténation répétée n fois
d in c teste si d est sous-chaine de c
[Link](d) nombre d’occurrences ne se recouvrant pas de la chaine d
[Link](d) indice de la première occurrence de d
renvoie -1 si pas d’occurrence
[Link](d,e) remplace toutes les sous-chaines d par e
[Link]() convertit la chaîne de caractères ch en minuscules
[Link]() convertit la chaîne de caractères ch en mjuscules
5.2.3. Parcours d’une chaine de caractères :
Parcours d’une chaîne de caractères
L’instruction for est l’instruction idéale pour parcourir une chaîne de caractères :
11
5.3. Les dictionnaires
5.3.1. Notation d’un dictionnaire
{1:'janvier', 2:'février',3:'mars'} dictionnaire
dict() ou {} dictionnaire vide
5.3.2. Operations et méthodes applicables à une liste:
len(D) nombre d’éléments de D
a in D, a not in D test l’appartenance de a à D
[Link]() renvoie la séquence des clés utilisées dans D
[Link]() renvoie la séquence des valeurs memorisées dans D
D. items() renvoie un tuples des paires (liste) (clé,valeur)
[Link]() copie simple de D
D[cle]=val Remplace ou ajoute une valeur
[Link]({c1 :v1, Mise à jour ou ajout de plusieurs valeurs en même temps
c2 : v2})
D[cle] accès à un élément
del D[cle] enlève l’élément ayant la clé cle
[Link](cle) Supprime une clé et renvoie sa valeur.
[Link]() efface le dictionnaire D
5.3.3. Parcours d’un dictionnaire :
12
6. Import de modules
De nombreuses fonctions sont définies dans des modules spécialisées ; cela permet de ne pas
encombrer la mémoire de la définition de plein de fonctions dont on ne se servira pas : on peut
se contenter de charger (importer) les modules contenant les fonctions utilisées (ou même
sélectionner les fonctions qu’on importe dans chaque module). De cette manière, on peut définir
un très grand nombre de fonctions, sans pour autant alourdir l’ensemble.
6.1. Import simple du module
Syntaxe : import module
Cette instruction permet de faire savoir à l’ordinateur qu’on utilise le module module. On peut
alors utiliser les fonctions de ce module en les faisant précéder du préfixe module (nom du
module) : [Link]()
Exemple :
L’utilisation de préfixes permet d’utiliser des fonctions ayant éventuellement même nom et se
situant dans des modules différents. Certains noms de module sont longs, ou seront utilisés très
souvent. On peut, au moment de l’import du module, créer un alias, qui permettra d’appeler les
fonctions de ce module en donnant comme préfixe l’alias au lieu du nom complet :
Syntaxe : import module as al
[Link]()
Exemple :
13
6.2. Import d’une fonction d’un module
Syntaxe : from module import fonction
Cette instruction permet d’importer la définition de la fonction qui peut alors être utilisée sans
préfixe: fonction(). Les autres fonctions du module ne peuvent pas être utilisées, même avec le
préfixe.
Attention, si une fonction du même nom existe auparavant (de base dans Python, ou importée
précédemment), elle sera écrasée.
6.3. Import de toutes les fonctions d’un module
Syntaxe : from module import *
Cette instruction permet d’importer la définition de toutes les fonctions du module les autres
fonctions du module peuvent être utilisées de même.
Attention aussi aux écrasements possibles. Par ailleurs, l’import est plus long à effectuer, et
plus d’une gestion plus lourde, si le module est gros.
Nous passons en revue les modules qui nous seront les plus utiles. Il existe une foule d’autres
modules (se renseigner sur internet en cas de besoin), dans des domaines très spécifiques.
14
7. Les Fonctions en Python
7.1. Syntaxe
La définition d’une fonction se compose :
✓ du mot clé def suivi de l’identificateur de la fonction, de parenthèses entourant les
paramètres de la fonction séparés par des virgules, et du caractère « deux points » qui
termine toujours une instruction composée,
✓ d’une chaîne de documentation (ou docstring) indentée comme le corps de la fonction,
✓ du bloc d’instructions indenté par rapport à la ligne de définition, et qui constitue le
corps de la fonction.
La syntaxe Python pour la définition d’une fonction est la suivante :
def nom_de_la_fontion( liste des paramètres ):
instructions
return resultat
➢ Pas de déclaration de type des paramètres ni de la valeur de retour
Exemple 1 :
Exemple 2 :
15
7.2. L’instruction return
➢ L’instruction return resultat interrompe l’exécution de la fonction et renvoie la valeur de
resultat;
➢ resultat peut être de n’importe quel type;
➢ On récupère la valeur renvoyée normalement, par une affectation :
y = maFonction(z)
➢ On peut aussi l’utiliser dans une expression où elle est évaluée :
y = maFonction(z) + 3
print(maFonction(z))
➢ Par défaut, s’il n’y a pas de return ou si on met return simplement sans argument après,
la fonction renvoie None et se comportera comme une procédure;
Exemple :
➢ Le premier return n’a pas d’argument, il renvoie None et arrête la fonction.
➢ Le second return renvoie le résultat du calcul;
7.3. Renvoyer plusieurs valeurs
Une fonction peut renvoyer plusieurs valeurs:
16
7.4. Les formes lambda
Une fonction lambda est une manière d’écrire des fonctions à la volée, sans avoir besoin de
passer par une instruction def
Pour définir une fonction sous forme lambda, on utilise la syntaxe :
lambda param1,param2, ... : une_instruction_unique
➢ Par exemple, dans l’instruction suivante on définit une fonction qui fait la somme de
deux variable x et y et on l’applique au couple (1,3).
7.5. Paramètres par défaut
On peut spécifier des valeurs par défaut dans une fonction
Si les champs considérés ne sont pas donnés lors de l’appel à la fonction, ils prennent la valeur
par défaut :
Remarque :
➢ Attention, tous les paramètres par défaut doivent se trouver à la fin de la liste de
paramètres;
17