Syntaxe Python - Guide complet

La syntaxe Python est l'ensemble des règles qui définissent comment un programme Python doit être écrit pour que l'interpréteur puisse le comprendre et l'exécuter. Contrairement à des langages comme C ou Java, Python utilise l'indentation par espaces à la place des accolades pour délimiter les blocs de code, et il se lit presque comme de l'anglais courant — ce qui en fait l'une des principales raisons pour lesquelles Python est un premier langage populaire pour les débutants.

Ce chapitre couvre les éléments fondamentaux de la syntaxe Python : l'indentation, les instructions, les commentaires, les variables, les types de données, les opérateurs, le flux de contrôle, les boucles, les fonctions et quelques erreurs courantes à éviter.

Indentation

En Python, l'indentation n'est pas une préférence stylistique — elle fait partie de la grammaire du langage. L'interpréteur utilise l'indentation pour déterminer quelles instructions appartiennent au même bloc. La convention standard (et celle appliquée par la plupart des linters) est 4 espaces par niveau.

Mélanger des tabulations et des espaces dans le même fichier provoque une IndentationError. Utilisez l'un ou l'autre de manière cohérente — le guide de style Python (PEP 8) recommande les espaces.

Erreurs d'indentation courantes

# IndentationError: expected an indented block
if True:
print("oops")   # missing indentation

# IndentationError: unexpected indent
x = 1
    y = 2    # indented for no reason

Instructions et continuation de ligne

Chaque instruction Python occupe normalement une ligne et ne se termine pas par un point-virgule (bien qu'un point-virgule soit techniquement valide). Lorsqu'une instruction est trop longue, vous pouvez la répartir sur plusieurs lignes de deux façons.

Continuation implicite à l'intérieur de crochets — toute parenthèse (, crochet [ ou accolade { ouverte vous permet de continuer sur la ligne suivante :

total = (
    100
    + 200
    + 300
)
print(total)   # 600

Continuation explicite avec une barre oblique inverse (\) :

result = 1 + 2 + 3 \
         + 4 + 5
print(result)  # 15

Vous pouvez également placer plusieurs instructions sur une même ligne avec un point-virgule, mais cette pratique est déconseillée :

x = 1; y = 2; print(x + y)   # works, but avoid this style

Commentaires

Les commentaires expliquent l'intention et sont ignorés par l'interpréteur. Python en propose deux types.

Commentaires sur une seule ligne

Commencez un commentaire par #. Tout ce qui suit # sur cette ligne est ignoré :

# Calculate the area of a circle
radius = 5
area = 3.14159 * radius ** 2   # ** is the exponentiation operator
print(area)

Commentaires multi-lignes (docstrings)

Python ne dispose pas de syntaxe dédiée aux commentaires en bloc. La convention consiste à utiliser des chaînes entre guillemets triples. Lorsqu'elles sont placées au début d'une fonction, d'une classe ou d'un module, elles deviennent des docstrings — accessibles à l'exécution via help() :

def greet(name):
    """Return a greeting for the given name.

    Args:
        name (str): The person's name.
    """
    return f"Hello, {name}!"

print(greet("Alice"))   # Hello, Alice!

Variables et affectation

Une variable est créée dès qu'on lui affecte une valeur. Python est dynamiquement typé, vous n'avez donc pas à déclarer un type :

x = 10          # integer
pi = 3.14       # float
name = "Alice"  # string
active = True   # boolean

Vous pouvez affecter plusieurs variables sur une seule ligne :

a, b, c = 1, 2, 3
print(a, b, c)   # 1 2 3

Ou affecter la même valeur à plusieurs variables en même temps :

x = y = z = 0
print(x, y, z)   # 0 0 0

Les noms de variables sont sensibles à la casse (age, Age et AGE sont trois variables différentes). Pour en savoir plus sur les règles de nommage et les conventions, consultez le chapitre Variables Python.

Types de données

Chaque valeur en Python possède un type. Les types intégrés les plus courants sont :

Vérifiez le type de n'importe quelle valeur avec type() :

print(type(42))        # <class 'int'>
print(type(3.14))      # <class 'float'>
print(type("hello"))   # <class 'str'>
print(type(True))      # <class 'bool'>
print(type(None))      # <class 'NoneType'>

Pour une étude approfondie des types, consultez le chapitre Types de données Python.

Opérateurs

Python prend en charge plusieurs catégories d'opérateurs.

Opérateurs arithmétiques

a, b = 10, 3
print(a + b)    # 13  — addition
print(a - b)    # 7   — subtraction
print(a * b)    # 30  — multiplication
print(a / b)    # 3.3333...  — true division (always returns float)
print(a // b)   # 3   — floor division
print(a % b)    # 1   — modulo (remainder)
print(a ** b)   # 1000 — exponentiation

Opérateurs de comparaison

Les opérateurs de comparaison renvoient True ou False :

print(5 == 5)    # True
print(5 != 3)    # True
print(5 > 3)     # True
print(5 < 3)     # False
print(5 >= 5)    # True
print(5 <= 4)    # False

Opérateurs logiques

print(True and False)   # False
print(True or False)    # True
print(not True)         # False

Pour une référence complète incluant les opérateurs d'affectation, bit à bit et d'identité, consultez le chapitre Opérateurs Python.

Chaînes de caractères

Les chaînes de caractères sont des séquences de caractères Unicode. Elles peuvent être délimitées par des guillemets simples, des guillemets doubles ou des guillemets triples :

s1 = "Hello, World!"
s2 = 'Hello, World!'
s3 = """This string
spans multiple lines."""

f-strings (littéraux de chaîne formatés)

Introduits dans Python 3.6, les f-strings sont la méthode recommandée pour intégrer des expressions dans des chaînes :

name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")
# My name is Alice and I am 30 years old.

Opérations courantes sur les chaînes

s = "python"
print(s.upper())        # PYTHON
print(s.capitalize())   # Python
print(len(s))           # 6
print(s[0])             # p  (indexing)
print(s[1:4])           # yth (slicing)
print(s + " rocks")     # python rocks (concatenation)

Listes

Une liste est une collection ordonnée et modifiable. Les éléments peuvent être de types différents :

fruits = ["apple", "banana", "cherry"]
print(fruits[0])         # apple
print(fruits[-1])        # cherry (negative index = from end)
fruits.append("date")
print(fruits)            # ['apple', 'banana', 'cherry', 'date']
print(len(fruits))       # 4

Flux de contrôle

L'instruction if / elif / else

Utilisez if, elif (sinon si) et else pour exécuter des branches selon des conditions :

score = 75

if score >= 90:
    grade = "A"
elif score >= 75:
    grade = "B"
elif score >= 60:
    grade = "C"
else:
    grade = "F"

print(f"Grade: {grade}")   # Grade: B

Un point important à noter : contrairement à de nombreux langages, Python ne possède pas de syntaxe switch/case avant Python 3.10. Pour plusieurs conditions portant sur la même variable, utilisez des chaînes de elif ou une recherche par dictionnaire. Python 3.10+ a introduit l'instruction match comme alternative de correspondance structurelle de motifs.

Pour une référence complète, consultez le chapitre Python If Else.

La boucle for

La boucle for itère sur tout itérable — une liste, une chaîne, un intervalle ou une autre séquence :

Utilisez range() pour itérer un nombre précis de fois :

for i in range(5):
    print(i)   # 0, 1, 2, 3, 4

Utilisez enumerate() lorsque vous avez besoin à la fois de l'index et de la valeur :

colors = ["red", "green", "blue"]
for index, color in enumerate(colors):
    print(index, color)
# 0 red
# 1 green
# 2 blue

La boucle while

La boucle while se répète tant que sa condition est True :

Veillez toujours à ce que la condition finisse par devenir False, sinon vous obtiendrez une boucle infinie.

break, continue et else sur les boucles

• break — quitte la boucle immédiatement
• continue — ignore le reste de l'itération en cours et passe à la suivante
• else sur une boucle — s'exécute une fois la boucle terminée normalement (c'est-à-dire sans avoir rencontré break)

for n in range(10):
    if n == 3:
        continue   # skip 3
    if n == 6:
        break      # stop at 6
    print(n)
# 0 1 2 4 5

Fonctions

Les fonctions vous permettent de regrouper une logique réutilisable sous un nom. Définissez une fonction avec def :

def add(a, b):
    """Return the sum of a and b."""
    return a + b

result = add(3, 4)
print(result)   # 7

Valeurs par défaut des paramètres

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")             # Hello, Alice!
greet("Bob", "Hi")         # Hi, Bob!

Retourner plusieurs valeurs

Les fonctions Python peuvent retourner plusieurs valeurs sous forme de tuple :

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([3, 1, 4, 1, 5, 9])
print(low, high)   # 1 9

Pour plus de détails, consultez le chapitre Fonctions Python.

Mots-clés

Python réserve certains mots pour le langage lui-même. Vous ne pouvez pas les utiliser comme noms de variables :

False    await    else     import   pass
None     break    except   in       raise
True     class    finally  is       return
and      continue for      lambda   try
as       def      from     nonlocal while
assert   del      global   not      with
async    elif     if       or       yield

Si vous utilisez accidentellement un mot-clé comme nom de variable, Python lève une SyntaxError :

# SyntaxError: invalid syntax
for = 10

Modules et importations

Le code Python est organisé en modules (fichiers .py). Vous importez le contenu d'un module avec import :

import math
print(math.sqrt(16))   # 4.0
print(math.pi)         # 3.141592653589793

Importez des noms spécifiques avec from ... import :

from math import sqrt, pi
print(sqrt(25))   # 5.0

Utilisez un alias pour raccourcir les noms de modules longs :

import datetime as dt
today = dt.date.today()
print(today)   # e.g. 2026-06-19

Pratique