Glossaire et mots clés

annotation de type

Information facultative sur le type d’une variable, d’une fonction ou d’un paramètre. Utilisée par des outils tels que mypy pour vérifier la cohérence du code.

argument

Valeur envoyée à une fonction, qui sera assignée à un paramètre. Les arguments peuvent être positionnels (une simple valeur dans la liste des arguments) ou nommés (préfixés du nom du paramètre : end='\n').

assertion

Prédicat évalué avec le mot-clé assert qui lève une exception s’il est faux.

assignation

Affectation d’une valeur à une variable.

variable = 42

attribut

Champ contenu dans un objet, données relatives à l’objet (obj.attr).

bibliothèque standard (stdlib)

Ensemble des modules, paquets et fonctions natives embarquées avec Python par défaut.

bloc

Élément de syntaxe qui réunit plusieurs lignes de code dans une même entité, introduit par une instruction particulière (boucle, condition, etc.) suivie d’un :.

booléen

Type de valeur à deux états, vrai (True) ou faux (False).

boucle

Bloc de code répété un certain nombre de fois (pour itérer avec une boucle for ou selon une condition booléenne avec un while).

while condition:
    ...

for item in iterable:
    ...

boucle infinie

Boucle dont la condition de fin n’est jamais atteinte, qui ne s’arrête jamais.

bytes

Valeur semblable aux chaînes de caractères pour représenter des séquences d’octets (des nombres entre 0 et 255). b'a\x01b\x02' est de type bytes.

callable

Objet que l’on peut appeler, tel qu’une fonction.

>>> min(3, 4)
3
>>> int('123')
123

chaîne de caractères (string)

Valeur représentant du texte, une séquence de caractères ('abcdef' par exemple).

chemin (path)

Adresse d’un fichier sur le système d’exploitation.

clé

Identifiant d’une valeur dans un dictionnaire. Seuls les types de données hashables peuvent être utilisés en tant que clés.

condition

Bloc de code exécuté selon la valeur d’une expression booléenne.

if condition:
    ...

conteneur

Objet contenant des éléments (des valeurs), auxquels on peut généralement accéder par itération ou via l’opérateur container[key].

débogueur

Outil permettant de déceler pas-à-pas les bugs dans le code d’un programme.

décorateur

Élément de syntaxe permettant de modifier le comportement d’une fonction, introduit par un @ suivi du nom du décorateur avant la définition de la fonction (@cache par exemple).

@cache
def addition(a, b):
    return a + b

dictionnaire

Table d’association, pour associer des valeurs à des clés.

{'a': 'foo', 2: 3}

docstring

Chaîne de caractères en en-tête d’une fonction pour documenter son comportement.

def addition(a, b):
    "Addition entre deux nombres"
    return a + b

EAFP

Easier to Ask Forgiveness than Permission (il est plus simple de demander pardon que demander la permission), mécanisme de traitement des erreurs qui préconise de laisser se produire les exceptions pour les attraper ensuite (demander pardon).
EAFP s’oppose à LBYL.

éditeur de texte

Logiciel permettant de modifier des fichiers texte (ou fichiers de code) sur le système d’exploitation.

encodage

Norme de codage des caractères dans une chaîne de caractères, associe chaque caractère (lettres, chiffres, symbole, accents, etc.) à un nombre.

ensemble (set)

Conteneur non-ordonné composé de valeurs uniques et hashables.

{'a', 'b', 'c'}

entrée standard

Flux de données en entrée du programme, le terminal par défaut, sollicité par la fonction input. Correspond à sys.stdin.

environnement virtuel

Répertoire cloisonné de paquets Python.

exception

Comportement permettant de remonter des erreurs dans le programme afin de les traiter.

expression

Ensemble d’opérations Python qui produisent une valeur.

>>> (1 + 2 * 3) / 5 + round(1/3, 2)
1.73

fichier

Document sur le système d’exploitation (adressé par un chemin), représenté en Python par un objet qui permet d’interagir avec lui (lire son contenu, écrire dans le fichier, etc.).

fonction

Opération recevant des arguments et renvoyant une nouvelle valeur en fonction de ceux-ci (fonctions mathématiques par exemple : round, abs).

>>> round(3.5)
4
>>> abs(-2)
2

fonction native (builtin)

Fonction disponible directement dans l’interpréteur, sans import.

fonction récursive

Fonction qui se rappelle elle-même pour mettre en place un mécanisme de répétition.

def my_len(s):
    if s:
        return 1 + len(s[1:])
    return 0

formatage

Action d’obtenir une représentation d’une valeur dans un format voulu.

f-string

Chaîne de formatage, élément de syntaxe permettant de composer facilement des chaines de caractères.

>>> f"1 + 3 = {1+3}"
'1 + 3 = 4'

gestionnaire de contexte

Bloc permettant de gérer des ressources (telles que des fichiers).

with open('file.txt') as finput:
    ...

hashable

Valeur qui peut être utilisée en tant que clé de dictionnaire ou contenue dans un ensemble. Le hash est un « code-barre » généré à partir de la valeur, qui permet de la retrouver : le hash d’un objet ne doit pas changer et deux valeurs égales doivent avoir le même hash.

Les types immutables natifs de Python sont hashables tandis que les mutables ne le sont pas.

IDLE

Interactive DeveLopment Environment, l’environnement de développement fourni avec Python.

import

Instruction qui permet de charger le code d’un module Python.

import math

instruction

Élément de syntaxe de Python au sens large, souvent équivalent à une ligne de code.

intension

Manière de créer des listes / ensembles / dictionnaires par itération.

>>> [i**2 for i in range(5)]
[0, 1, 4, 9, 16]
>>> {i**2 for i in range(5)}
{0, 1, 4, 9, 16}
>>> {i**2: i for i in range(5)}
{0: 0, 1: 1, 4: 2, 9: 3, 16: 4}

interpréteur interactif / REPL

Mode de l’interpréteur de Python qui permet d’entrer les instructions et de les exécuter directement, en affichant les valeurs des expressions.
REPL pour Read-Eval-Print-Loop, soit boucle qui lit, évalue et affiche.

introspection

Caractéristique d’un programme qui est capable de s’inspecter lui-même (parcourir les attributs de ses objets, explorer les méthodes, etc.).

itérable

Valeur sur laquelle on peut itérer à l’aide d’une boucle for, appliquer un traitement sur chacun des éléments.

for item in [3, 2, 5, 8]:
    ...

itérateur

Curseur le long d’un itérable, utilisé par les boucles for pour les parcourir.

itération / itérer

Action de parcourir les éléments d’un itérable avec un itérateur.

LBYL

Look Before You Leap (réfléchis avant d’agir), mécanisme de traitement des erreurs qui préconise d’empêcher les erreurs en vérifiant les conditions de réussite au préalable.
LBYL s’oppose à EAFP.

liste

Séquence mutable d’élements de types variables.

[1, 2, 3, 4]
['a', 42, 1.5, [0]]

littéral

Élément de syntaxe de base qui possède une valeur, comme les chaînes de caractères, les listes ou les dictionnaires.

méthode

Fonction intégrée à un objet, opération spécifique à un type.

>>> [1, 2, 3].pop()
3

module

Fichier de code Python, que l’on peut charger à l’aide d’un import.

mot-clé

Élément de syntaxe formé de lettres correspondant à une instruction ou un opérateur du langage. Les mots-clés ne peuvent pas être utilisés comme noms de variables.

mutable / immutable

Une valeur mutable est une valeur modifiable, que l’on peut altérer (les listes par exemple) contrairement à une valeur immutable (comme les tuples).

>>> values = [1, 2, 3]
>>> values[0] = 4
>>> values
[4, 2, 3]
>>> values = (1, 2, 3)
>>> values[0] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

nombre complexe

Représentation d’un nombre complexe en Python, formé de deux flottants (partie réelle et partie imaginaire suffixée d’un j) comme 3.2+5j.

nombre entier

Représentation d’un nombre entier relatif (positif ou négatif) en Python. Suite de chiffres potentiellement précédée d’un + ou d’un -, comme 101 ou -42.

nombre flottant

Représentation d’un nombre réel en Python, formé d’une partie entière et d’une partie décimale, comme 10.0, 8.3 ou 5e2.

objet / valeur

Résultat d’une expression, qui peut être stocké dans une variable. Toute valeur Python est un objet, et peut posséder des attributs et méthodes.

opérateur

Élément de syntaxe (mot-clé ou caractères spéciaux) représentant une opération en Python, comme + pour l’addition.

paquet (package)

Niveau d’indirection au-dessus du module : un module qui contient des modules.
S’utilise aussi pour parler des bibliothèques tierces, installables via pip (gestionnaire de paquets).

paramètre

Variable d’une fonction dont la valeur sera automatiquement assignée selon un argument. Un paramètre peut choisir d’accepter les arguments positionnels ou nommés, et posséder une valeur par défaut.

def func(param1, param2=None):
    pass

PEP

Python Enhancement Proposal, soit Proposition d’amélioration pour Python, c’est par là que passent les demandes de fonctionnalités au langage, avant d’être acceptées ou non.

prédicat

Expression booléenne, utilisée dans une condition.

pythonique

Qualificatif de ce qui est idiomatique en Python, qui correspond à la philosophie du langage. Voir cet article à propos du code pythonique.

représentation

Chaîne de caractères obtenue à partir d’une valeur, qui permet d’en décrire le contenu.

retour

Valeur renvoyée par une fonction. Donne sa valeur à l'expression d’appel de la fonction.

>>> x = abs(-1)
>>> x
1

séquence

Conteneur dont les clés sont des nombres entiers de 0 à N-1 (avec N la taille du conteneur).

scope

Espace de noms, là où sont déclarées les variables.

slicing

Découpage d’une séquence selon un intervalle.

>>> 'abcdefghi'[1:-1:2]
'bdfh'
>>> [1, 2, 3, 4][1:]
[2, 3, 4]

sortie d’erreur

Flux de données en sortie du programme dédié aux erreurs, le terminal par défaut. Correspond à sys.stderr.

sortie standard

Flux de données en sortie du programme où sont affichés les messages (par appel à print par exemple), le terminal par défaut. Correspond à sys.stdout.

test

Fonction composée d'assertions pour vérifier le bon comportement d’un code.

tuple

Séquence immutable d’éléments de types variables.

(1, 2, 3, 4)
('a', 42, 1.5, [0])

tuple nommé

tuple dont les éléments peuvent aussi être accédés via des atributs.

from collections import namedtuple
Point = namedtuple('Point', ('x', 'y'))
p = Point(3, 5)
print(p.x, p.y)

type

Toute valeur en Python possède un type, qui décrit les opérations et méthodes qui lui sont applicables.

variable

Étiquette posée sur une valeur par assignation. Plusieurs variables peuvent correspondre à la même valeur.

variable = 42

zen

Zen of Python, ou PEP 20, sorte de poème qui décrit la philosophie du langage : https://www.python.org/dev/peps/pep-0020/ (traduction).

Voici le tableau de l’ensemble des mots-clés de Python :

À cela on pourrait aussi ajouter les mots-clés match et case, qui sont bien des mots-clés mais pas des noms réservés (vous pouvez nommer une variable match ou case sans souci).

• False : Valeur False du type booléen.
• None : Valeur None, qui représente l’absence de valeur.
• True : Valeur True du type booléen.
• and : Opération booléenne ET (conjonction).
  >>> True and False
  False
  

• as : Permet une assignation si couplé à un autre mot-clé. (import, with, except).

  import math as m
  

  with open('file') as f:
      ...
  

  try:
      ...
  except ValueError as e:
      ...
  

• assert : Assertion, échoue si l’expression donnée est fausse (les assertions ne sont pas exécutées si Python est lancé en mode optimisé -O).

  assert 5 == 4 + 1
  

• async : Introduit une fonction asynchrone (async def)¹³.
• await : Attend un résultat asynchrone (depuis une fonction asynchrone)¹³.
• break : Permet de sortir immédiatement d’une boucle. En cas de boucles imbriquées, le mot-clé affecte la boucle intérieure uniquement.
  while condition:
      ...
      break
  

• case : Introduit un motif de filtrage dans un bloc match²³.
• class : Définit une classe en programmation orientée objet⁴.
• continue : Permet de passer à l’itération suivante de la boucle. En cas de boucles imbriquées, le mot-clé affecte la boucle intérieure uniquement.
  while condition:
      ...
      continue
  

• def : Définit une fonction.
  def func(a, b):
      ...
  

• del : Supprime une variable ou un élément d’un conteneur.

  del var
  

  del container[key]
  

• elif : Condition sinon-si dans un bloc conditionnel.
  if condition:
      ...
  elif other_condition:
      ...
  

• else : Condition sinon dans un bloc conditionnel, ou deuxième clause d’une expression conditionnelle.
  if condition:
      ...
  else:
      ...
  

  true_val if condition else false_val
  

  Peut aussi se placer après un bloc for/while (réagir en cas de sortie de boucle prématurée) ou try (réagir si tout s’est bien passé).
• except : Attrape une exception après un bloc try.
  try:
      ...
  except ValueError:
      ...
  

• finally : Exécute des instructions dans tous les cas après un bloc try.
  try:
      ...
  finally:
      ...
  

• for : Introduit une boucle d’itération. Peut aussi introduire une intension (liste, ensemble, etc.).
  for item in iterable:
      ...
  

  [... for item in iterable]
  

• from : Réalise un import dans l’espace de nom courant, conjointement avec import (from ... import).

  from collections import Counter
  

• global : Déclare une variable comme étant globale.

  global var
  

• if : Introduit un bloc conditionnel avec une condition si. Peut aussi introduire une expression conditionnelle ou une condition de filtrage dans une intension.
  if condition:
      ...
  

  true_val if condition else false_val
  

  [... for item in iterable if condition]
  

• import : Réalise un import, utilisé seul (import simple) ou conjointement avec from (from ... import).

  import math
  

  from collections import Counter
  

• in : Opérateur d’appartenance, teste si une valeur est présente dans un conteneur.

  value in container
  

• not in : Opérateur de non-appartenance, teste si une valeur est absente d’un conteneur.

  value not in container
  

• is : Opérateur d’identité.

  value is None
  

• is not : Opérateur de non-identité.

  value is not None
  

• lambda : Introduit une fonction lambda.

  lambda x: x**2
  

• match : Introduit un bloc de filtrage par motif²³.
• nonlocal : Déclare une variable comme non-locale⁵.
• not : Opération booléenne NON (négation).
  >>> not True
  False
  

• or : Opération booléenne OU (disjontion).
  >>> True or False
  True
  

• pass : Ne fait rien, ne renvoie rien (utile quand un bloc indenté est attendu).
  if True:
      pass
  

• raise : Lève une exception.

  raise ValueError()
  

• return : Renvoie une valeur depuis une fonction (la fonction se termine au premier return).
  def f(a, b):
      return ...
  

• try : Introduit un bloc de traitement d’exception.
  try:
      ...
  except:
      ...
  

• while : Introduit une boucle sur une condition.
  while condition:
      ...
  

• with : Introduit un gestionnaire de contexte (pour ouvrir un fichier par exemple).
  with open('file') as f:
      ...
  

• yield : Produit une valeur depuis un générateur³.

Opérateurs simples (expressions)

En plus des mots-clés précédents, on trouve aussi les opérateurs suivants. Ces opérateurs sont constitués de caractères spéciaux et ne sont donc pas des noms.

• +: Addition / concaténation, ou opérateur unaire positif.
  >>> 3 + 5
  8
  >>> 'abc' + 'def'
  'abcdef'
  >>> +42
  42
  

• -: Soustraction / différence ou opérateur unaire négatif.
  >>> 3 - 5
  -2
  >>> -42
  -42
  

  >>> {1, 2, 3} - {2, 3, 4}
  {1}
  

• *: Multiplication, concaténation multiplicative, ou opérateur splat.
  >>> 3 * 5
  15
  >>> 'cou' * 2
  'coucou'
  >>> [3] * 4
  [3, 3, 3, 3]
  

  func(*[1, 2, 3])
  

• /: Division ou séparateur de chemins.
  >>> 3 / 5
  0.6
  

  >>> Path('a') / Path('b')
  PosixPath('a/b')
  

• //: Division entière (euclidienne).
  >>> 10 // 3
  3
  

• %: Modulo (reste de division) ou formatage de chaîne.
  >>> 10 % 3
  1
  

  >>> 'salut %s' % 'toto'
  'salut toto'
  

• **: Exponentiation (puissance) ou double-splat
  >>> 5 ** 3
  125
  

  func(**{'arg': 42})
  

• x(...): Appel de fonction (ou callable), instanciation de type.
  >>> round(3.5)
  4
  >>> list()
  []
  

• x.attr: Accès à un attribut.
  >>> Path('a/b').name
  'b'
  

• x[...]: Accès à un élément. Permet aussi le slicing.
  >>> squares[3]
  9
  >>> squares[4:8]
  [16, 25, 36, 49]
  

• &: Conjonction (ET) bit-à-bit ou intersection d’ensembles.
  >>> bin(0b101 & 0b110)
  '0b100'
  

  >>> {1, 2, 3} & {2, 3, 4}
  {2, 3}
  

• |: Disjonction (OU) bit-à-bit ou union d’ensembles.
  >>> bin(0b101 | 0b110)
  '0b111'
  

  >>> {1, 2, 3} | {2, 3, 4}
  {1, 2, 3, 4}
  

• ^: XOR bit-à-bit ou différence symétrique d’ensembles.
  >>> bin(0b101 ^ 0b110)
  '0b11'
  

  >>> {1, 2, 3} ^ {2, 3, 4}
  {1, 4}
  

• ~: Négation (NON) bit-à-bit, opérateur unaire.
  >>> bin(~0b101)
  '-0b110'
  

• ==: Test d’égalité.
  >>> 5 == 4 + 1
  True
  

• !=: Test de différence.
  >>> 5 != 4 + 1
  False
  

• <: Test d’infériorité stricte.
  >>> 3 < 5
  True
  

• >: Test de supériorité stricte.
  >>> 3 > 5
  False
  

• <=: Test d’infériorité.
  >>> 3 <= 5
  True
  >>> 3 <= 3
  True
  

• >=: Test de supériorité.
  >>> 3 >= 5
  False
  >>> 3 >= 3
  True
  

• :=: Expression d’assignation².
  >>> if x:= 5:
  ...     print(x+1)
  ...
  6
  

• <<: Décalage de bits à gauche.
  >>> bin(0b101 << 2)
  '0b10100'
  

• >>: Décalage de bits à droite.
  >>> bin(0b10101 >> 2)
  '0b101'
  

• @: Multiplication matricielle¹³.
• ,: La virgule est un peu à part, c’est un séparateur (arguments, listes, etc.) mais aussi l’opérateur qui permet de créer des tuples.
  >>> 1,
  (1,)
  >>> 3, 4, 5
  (3, 4, 5)
  

Opérateurs d’assignation

Les opérations d’assignation suivent toutes le même principe, var = expression.

>>> x = 42
>>> x
42

L’opérateur utilisé applique simplement l’opération cible (+ pour += etc.) entre la variable initiale et l’expression.

>>> x += 2  # x = x + 2
>>> x
44
>>> x //= 3  # x = x // 3
>>> x
14

>>> values = [1, 2]
>>> copy = values
>>> values += [3]
>>> copy
[1, 2, 3]

Les opérations d’assignation permettent aussi d’assigner les éléments des conteneurs.

values[0] = 42
dic[key] = value

Ordre d’évaluation des expressions

Les expressions en Python sont toujours évaluées de la gauche vers la droite, à l’exception près des assignations où la partie droite sera évaluée avant la partie gauche.

Ainsi, dans les exemples fictifs suivants, expr1 sera toujours évaluée avant expr2, elle-même avant expr3, etc. jusque expr5.

expr1, expr2, expr3, expr4
(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2

Tableau des priorités

Aussi, dans une même expression, les opérations seront exécutées par ordre de priorité. Dans le tableau suivant, les opérations de rang inférieur seront exécutées prioritairement à celles de rang supérieur (** est évalué avant /).

Les exemples de cette section sont tirés de la page de documentation Référence sur les expressions, sur laquelle vous trouverez plus d’informations au sujet des expressions et des priorités des opérateurs.

Certains éléments font partie de la syntaxe Python sans être inclus dans les tableaux précédents, les voilà détaillés ici.