ITC 2023-2024

S YNTHÈSE DE LA SYNTAXE EN P YTHON

1 Types de base
1.1 Nombres
Il existe deux types représentant les nombres en Python : int pour les entiers, et float pour re-
présenter les nombres flottants (attention, les flottants arrondissent les nombres réels à 17 chiffres
significatifs. Ainsi, on ne peut pas représenter avec exactitude tous les réels. D’autre part, cette limi-
tation peut entraîner une instabilité numérique de certains algorithmes en propageant et cumulant
des erreurs d’approximation.

• Un entier s’écrit simplement par sa valeur : par exemple 4

• Un flottant s’écrit avec un "." : 4.5 est un flottant. Si on veut considérer un entier comme un
flottant, il faut écrire 4. (4 suivi de .)

• int(nombre flottant) renvoie la partie entière inférieure du flottant, de type int

• float(nombre entier) renvoie le flottant de même valeur que l’entier

• Une opération entre deux entiers sera de type int, une opération entre deux flottants sera de
type float, et une opération entre un entier et un flottant sera de type float.

Ci-dessous, la liste des opérations sur les nombres en Python :

1.2 Chaînes de caractères

• Une chaîne de caractère est définie par ’chaîne’ ou "chaîne" ;

• Le caractère d’échappement \permet, dans une chaîne de caractère, de passer à la ligne en écri-
vant "\n", et de faire une tabulation s’il est suivi du caractère "\t" ;

• L’utilisation de triples guillemets permet d’écrire des commentaires sur plusieurs lignes, par
exemple : """Ceci est un commentaire""".

1
 Ci-dessous, la liste des opérations sur les chaînes de caractères :

La syntaxe est similaire à celle des listes (voir plus loin), toutefois une chaîne de caractères est un
type immuable : on ne peut pas la modifier.

Enfin, on peut passer d’une chaîne de caractère représentant un nombre à un nombre et inverse-
ment :

• int("45") renvoie l’entier 45 ;

• float("3.12") renvoie le flottant 3.12 ;

• str(42) renvoie la chaîne de caractère "42".

1.3 Booléens
Le type booléen (boolean) peut prendre deux valeurs : True et False. Ils correspondent aux vrai et
faux logiques. On peut effectuer les opérations suivantes entre des booléens :

• not b renvoie la négation du booléen b ;

• b 1 and b 2 renvoie le booléen correspondant à la conjonction ("et" logique) des booléens b 1 et

• b 1 or b 2 renvoie le booléen correspondant à la disjonction ("ou" logique) des booléens b 1 et b 2 ;

Pour ces deux derniers cas, Python fait ce qu’on appelle une évaluation paresseuse : dans le cas
d’une conjonction, l’évaluation s’arrête au premier booléen rencontré évalué à False, et au premier
booléen évalué à True dans le cas de multiples disjonctions. Il faut ainsi notamment être vigilant et
utiliser quand nécessaire des parenthèses lors d’une suite de disjonctions et conjonctions.

1.4 Les tuples (n-uplets)

• On accède au i ème élément d’un tuple avec la syntaxe tuple[i] ;

• On peut définir un tuple sans les parenthèses : l’instruction t = 1,2,3 définit le tuple (1, 2, 3) ;

• On peut concaténer deux tuples avec l’opération + ;

• Un tuple est un type de donnée immuable, i.e. qu’on ne peut pas modifier.

2
2 Listes
2.1 Définition
Une liste est un ensemble ordonné d’éléments (chaque élément a un indice) pouvant être de types
différents. Une liste est définie entre crochets et ses éléments sont séparés par des virgules. On peut
créer une liste de différentes manières :

• Directement : L = [1, 2, 3] ;

• Par conversion d’un objet itérable : L = list(range(10)), L = list("une chaîne de caractères") ;

• Par concaténation de deux listes : L = L 1 + L 2 ;

• Par copie d’une liste : L ′ = L.cop y(). Attention, ceci fait une copie superficielle de la liste. Dans
le cas d’une liste dont des éléments sont des conteneurs (comme des listes de listes), il faut
effectuer une copie profonde, à l’aide de la méthode d eepcop y(), utilisable en important le
module cop y ;

• Par concaténation multiple : L = [0]∗5 donne la liste [0, 0, 0, 0, 0] (attention à l’utilisation de cette
syntaxe dans le cas de listes imbriquées, les éléments multipliés sont des copies superficielles) ;

• Par compréhension : [ fonction(x) for x in iterable], par exemple [i**2 for i in range(5)] donne
[0, 1, 4, 9, 16] ;

• Par compréhension et filtrage : [ fonction(x) for x in iterable if conditions], par exemple [3*i for i
in range(10)] if i**2 < 25 donne [0, 3, 6, 9, 12].

2.2 Manipulation des listes

Ces opérations sont faites en temps constant.

Ci-dessous, un mémo des méthodes permettant de manipuler des listes :

3
4
3 Dictionnaires
Un dictionnaire est une structure de données qui permet de stocker des couples (clef,valeur). On
accède à une valeur par sa clef, tout comme, dans un dictionnaire au sens de la vie courante, on accède
à une définition par le mot correspondant. C’est donc un type de conteneur, comme un tableau ou
une liste, mais dans lequel les éléments ne sont pas indicés (c’est-à-dire identifiés par des entiers)
mais sont identifiés par des clefs, qui peuvent être de différents types.

• Les clefs sont de type i nt (entier), f l oat (nombre flottant, i.e. la représentation en machine des
nombres réels, sur laquelle nous reviendrons plus tard en cours), et st r i ng (chaîne de carac-
tères), ou encore des tuples. Une clef ne peut pas être, par exemple une liste : les clefs doivent
être immuables (c’est-à-dire des objets qu’on ne peut pas modifier) ;

• Les valeurs peuvent être des types ci-dessus mais peuvent aussi être des objets plus complexes,
comme des listes ;

• On ajoute, supprime et accède à un élément d’un dictionnaire par sa clef avec un coût constant.

Ci-dessous, un mémo de la syntaxe permettant de manipuler des dictionnaires :