Les notes de cours

Introduction à Python
Stéphane De Mita
Mathieu Siol
Novembre 2012
Introduction à Python – Page 1

1. Généralités
Langage interprété : pas besoin de compiler, mais l'interpréteur (python) est nécessaire pour exécuter
du code. Fréquemment décrit comme le langage le plus convivial et facile à apprendre, tout en
permettant l'élaboration de programmes / bibliothèques complexes.
Comme pour tous les langages interprétés, python peut être utilisé en mode interactif (on entre les
commandes une à une dans une console) ou via des scripts (toutes les commandes sont sauvegardées
dans un fichier qui est exécuté d'un coup). Python permet cependant de développer des programmes
complexes. On favorisera donc les scripts.
Dans les exemples de code présentés ci-dessous, le code est précédé de trois chevrons (>>>) indiquant
du code rentré à la console (et ... pour du code indenté). Les symboles apparaissent quand on lance
Python en mode interactif (commande python sous un interpréteur de commande, ou console Python
sous Windows). Sauf pour des tâches très ponctuelles et des tests, ils est souvent préférable d'écrire le
code dans un fichier que l'on exécutera en le passant comme argument à la commande python
(contrairement à R et perl où il faut passer le script dans l'entrée standard de l'interpréteur).
2. Lexique
classe : type d'objet (non l'objet lui-même) renfermant à la fois des données et des fonctions permettant
de les traiter (méthodes).
constructeur : fonction qui initialise un objet d'une classe donnée. En Python, il sera toujours appelé
en utilisant le nom de la classe suivi de parenthèses (avec éventuellement des arguments), comme si la
classe était une fonction.
fonction : fragment de code prenant une liste d'arguments et pouvant être appelé depuis d'autres
endroits du code.
instance : objet créé selon le modèle d'une classe.
itérable (en Python) : objet qui supporte l'itération.
méthode : fonction attachée à un objet.
module (en Python) : fichier de code Python (il peut s'agir d'un programme, d'un script, d'une
bibliothèque, etc).
objet (en Python) : toute variable stockée en mémoire. Les variables classiques (entiers, chaînes de
caractères, etc) en sont, mais aussi les instances de classes (voir ci-dessous) et même les fonctions et les
classes elles-mêmes.
programme : instructions exécutables remplissant une tâche donnée en s'adaptant aux conditions,
options passées par l'utilisateur, etc.
Introduction à Python – Page 2

script : liste d'instructions à exécuter de manière linéaire (la distinction entre programme et script est
arbitraire et la limite entre les deux est vague).
séquence : itérable qui contient des éléments indexés (parmi les types pré-définitis : list et tuple et
chaînes de caractères).
3. Syntaxe de base
3.1. Opérateurs
Python fournit les opérateurs mathématiques standards : +, -, *, /, ainsi que +=, -=, *= et /= (i +=
1 équivaut à i = i + 1). ** est le symbole de puissance et % le modulo (reste de division). Dans
Python 2.x, la division est entière (diviser un entier par un entier donne un entier, tronqué au besoin) et
il faut souvent convertir l'un des deux entiers en float. Le point est utilisé comme séparateur pour
accéder à un membre ou une méthode d'un objet, ainsi qu'à un objet d'un module et à un module d'un
package. Les crochets [ ] sont utilisés pour accéder à un élément d'une séquence (mais aussi pour
définir une liste littéralement ). Les accolades {} sont utilisées pour définir un dictionnaire
littéralement. Les parenthèses ( ) permettent de regrouper des expressions (comme dans les opérations
mathématiques). Les commentaires commencent par # et continuent jusqu'à la fin de la ligne. Les
chaînes de caractères littérales sont spécifiques avec une paire de simple ou double guillemets. Le
guillemet final doit être le même que le guillemet initial, mais sinon les deux peuvent être utilisés
indifféremment. Cela permet d'utiliser l'autre type de guillemet dans la chaîne de caractère sans avoir à
utiliser de caractère d'échappement. Les chaînes de caractères indiquées par des triples guillemets
peuvent occuper plusieurs lignes.
3.1. Variables
Python est un langage typé (c'est-à-dire que tous les objets relèvent d'un type pré-défini) mais le typage
est dynamique (contrairement à C ou Perl). C'est-à-dire que Python décide lui-même quel est le type de
l'objet au moment où il est déclaré. Dans cet exemple :
>>> a = 1
Il n'y a pas besoin de déclarer que a est un entier (type int), Python le comprendra tout seul. On peut
réutiliser les noms de variables comme ci-dessous :
>>> a = 1
>>> a = 5
>>> a = "bidon"
À chaque fois, l'objet précédent est éliminé (voir ci-dessous) et un nouvel objet est créé.
3.2. Types
Introduction à Python – Page 3

Les types sont les différentes formes de données pouvant être gérées par Python. En Python, tous les
types sont des classes (y compris les types fondamentaux) et ils sont extensibles à l'infini par la
définition de nouvelles classes.
Les types fondamentaux sont int (nombres entiers), float (nombres réels) et bool (qui n'a que deux
instances, True et False). En général, il n'est pas utile de savoir qu'il s'agit de classes, si ce n'est qu'on
peut utiliser leur constructeur :
>>> a = float(5)
>>> print a
5.0
À noter qu'ici float n'est pas une fonction de conversion, mais un appel au constructeur de la classe
float (ce qui dans les faits ne constitue pas une différence fondamentale, il est vrai).
La variable pré-définie None a un type particulier (NoneType) qui ne peut pas être instanciée. None est
extrêmement pratique dans tous les cas où aucune valeur n'est appropriée ou pour spécifier des valeurs
par défaut (plutôt que de mettre des valeurs arbitraires comme 0 ou 999). None n'a rien à voir avec la
chaîne de caractère "None".
D'autres types prédéfinis très importants sont list, tuple et str.
list contient des éléments qui peuvent être de tous types (y compris dans la même instance). On peut
tout stocker dans les listes, y compris d'autres listes (par exemple pour faire des matrices). Par contre,
aucun type de matrice n'est disponible dans la bibliothèque standard (on trouvera ça dans le module
externe numpy). Les listes permettent l'indexation avec l'opérateur [ ]. À noter que le premier élément
est 0. L'opérateur [ ] permet de lire, modifier ou éliminer des éléments ou des ranges d'éléments. Les
indices négatifs sont comptés à partir de la fin. Il existe en plus de nombreuses méthodes comme
append, remove, find, sort permettant d'analyser ou modifier l'instance. On peut créer des listes à l'aide
du constructeur (qui permet de convertir depuis d'autres types compatibles, y compris tuple et str), des
fonctions créants des listes (comme range) ou encore avec la syntaxe suivante :
>>> a = [1, 2, 3, 4]
Mais attention, l'élément est recopié par référence (voir ci-dessous). On ne peut donc pas, par exemple,
créér une liste de 10 listes indépendantes de cette manière.
Les tuple sont des list immutables. Il est logique d'utiliser un tuple pour un objet qui n'est pas appelé à
être modifié. On peut s'en servir quand on veut explicitement interdire la modification de l'objet (ça
peut être important dans une bibliothèque pour prévenir des erreurs). On verra également plus tard des
cas où les types immutables sont requis. Les tuple sont créés ainsi :
>>> a = 1, 2, 3, 4
On verra souvent l'utilisation de parenthèses (mais les parenthèses ne sont pas limitées à la définition
de tuples) :
>>> a = (1, 2, 3, 4)
Introduction à Python – Page 4

Il s'agit d'ailleurs de la représentation "officielle" des tuples sous python.
Dans le cas d'un tuple d'un élément, il faut ajouter une virgule (même si des parenthèses sont utilisées)
pour éviter que la valeur ne soit comprise comme un entier :
>>> a = (1)
>>> print a
1
>>> a = 1,
>>> print a
(1,)
Les chaînes de caractères (type str) sont immutables. Les caractères eux-mêmes sont des str (de
longueur 1). Python offre beaucoup de possibilités pour manipuler les chaînes de caractères (à explorer
dans la documentation de la classe str). Le constructeur de str a souvent un comportement qui dépend
de l'objet qui lui est passé. À noter que ce comportement est défini par du code attaché à l'objet passé (il
s'agit d'une méthode cachée __str__ qui est disponible pour beaucoup de types et qui renvoie une
chaîne de caractère représentant l'objet en question). On peut ainsi créer une chaîne de caractère à partir
de listes, par exemple. Et réciproquement, d'ailleurs.
Note : on peut créer une liste d'élément identiques en utilisant cette syntaxe :
>>> a = [0] * 10
>>> print a
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
On peut aussi faire la même chose pour les tuple et str :
>>> (1,) * 10
(1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
>>> 's' * 10
'sssssssss'
Un type moins central mais très utile est set. Comme son nom l'indique, les instances de set contiennent
des éléments qui ne peuvent pas être dupliqués. Quand on ajoute un élément à un set, il n'est
effectivement ajouté que s'il n'est pas présent auparavant. Les opérations associées aux ensembles sont
supportées. On peut créer un set en lui passant un type itérable (voir les itérations ci-dessous), auquel
cas il prendra tous les éléments uniques de l'objet passé. Il n'y a pas d'ordre dans un set et on ne peut
pas accéder aux valeurs par indice. Une limite importante est que les objets de types mutables ne
peuvent pas être passés à un set (en effet, ils peuvent être modifiés après être passés, compromettant
l'intégrité du set). Ainsi, on peut utiliser des str et des tuple mais pas des list. Il y a ainsi un ( frozenset
identique à set mais immutable qui peut être utilisé dans des set (et des dict, voir ci-dessous).
Le dernier type important de Python est dict, qui est un tableau associatif. C'est-à-dire qu'il contient des
données sous la forme de couples clé-valeur. En réalité, les dict sont des sets de clés avec une valeur
associée à chaque clé. N'importe quel type peut être utilisé pour les valeurs, mais seuls les types
immutables peuvent être utilisés comme clés (de la même manière que pour les set). On accède au
valeur en utilisant l'opérateur [ ] (avec la clé comme argument).
Introduction à Python – Page 5