Module 1 — La syntaxe Python qui sert vraiment

Python est un grand langage, mais la science des données n'en utilise qu'un sous-ensemble étonnamment compact. Ce module couvre exactement ce sous-ensemble — celui que vous lirez et écrirez tous les jours — et laisse délibérément de côté les recoins que vous pouvez apprendre plus tard, ou jamais.

Variables et types : le typage dynamique, avec ses conséquences

Python associe les types aux valeurs, pas aux variables. Une même variable peut recevoir successivement un entier puis une chaîne — le langage ne proteste pas.

montant = 1250          # int
montant = 1250.75       # float — aucune erreur
nom_client = "Aïcha"    # str
actif = True            # bool

Cette souplesse fait la vitesse d'écriture de Python, et elle a un prix : les erreurs de type se révèlent à l'exécution, au moment où la ligne fautive s'exécute. En science des données, la manifestation classique est la colonne numérique lue comme texte : "1250" + 10 lève une erreur, mais seulement quand on y arrive.

Les quatre types de base à connaître : int, float, str, bool — et None, la valeur « absence de valeur », omniprésente dans les données réelles. Deux fonctions de survie : type(x) dit le type d'une valeur, int("42"), float("3.14"), str(42) convertissent explicitement.

Le piège des flottants

0.1 + 0.2 == 0.3 vaut False en Python — comme dans presque tous les langages, car les flottants sont des approximations binaires. Pour comparer des flottants, testez un écart : abs(a - b) < 1e-9. Pour l'argent, envisagez les entiers de centimes. Ce détail cause de vrais bugs dans de vrais pipelines.

Les f-strings : la seule façon moderne de formater

Toutes les sorties, tous les messages de journalisation, toutes les étiquettes de graphiques passent par les f-strings :

precision = 0.9273
n = 15420
print(f"Précision : {precision:.2%} sur {n:,} exemples")
# Précision : 92.73% sur 15,420 exemples

Les spécificateurs qui servent sans cesse : :.2f (deux décimales), :.2% (pourcentage), :, (séparateur de milliers), :>10 (alignement). Si vous croisez "..." % x ou "...".format(x) dans du vieux code, c'est la même chose en moins lisible.

Conditions : l'indentation est la syntaxe

Python délimite les blocs par l'indentation, pas par des accolades. Quatre espaces par niveau, c'est la convention universelle.

if score >= 0.9:
    verdict = "excellent"
elif score >= 0.7:
    verdict = "acceptable"
else:
    verdict = "à retravailler"

Deux idiomes à connaître parce qu'ils sont partout :

# Expression conditionnelle (ternaire)
statut = "majeur" if age >= 18 else "mineur"

# Vérité implicite : liste vide, chaîne vide, 0 et None sont "faux"
if lignes_invalides:
    print(f"{len(lignes_invalides)} lignes à corriger")

La comparaison à None s'écrit toujours is None / is not None, jamais == None.

Boucles : for sur n'importe quoi d'itérable

La boucle for de Python parcourt directement les éléments — pas les indices :

for fichier in fichiers_csv:
    traiter(fichier)

# Besoin de l'indice ? enumerate
for i, colonne in enumerate(colonnes):
    print(f"{i}: {colonne}")

# Parcourir deux séquences ensemble ? zip
for vrai, predit in zip(y_test, y_pred):
    if vrai != predit:
        erreurs += 1

range(n) génère les entiers de 0 à n−1 quand un compteur est vraiment nécessaire. break sort de la boucle, continue passe à l'itération suivante.

Retenez surtout ceci, qui prépare le module NumPy : en science des données, la boucle for sur des données volumineuses est presque toujours le mauvais outil. Elle sert pour parcourir des fichiers, des colonnes, des hyperparamètres — pas pour calculer sur des millions de lignes. Le calcul, lui, se vectorise.

Le découpage (slicing) : la notation qui revient partout

La syntaxe [début:fin:pas] s'applique aux chaînes, aux listes — et se retrouvera à l'identique dans NumPy et pandas, d'où son importance :

texte = "prediction_2026.csv"
texte[0:10]      # 'prediction'  — fin exclue
texte[-4:]       # '.csv'        — indices négatifs : depuis la fin
texte[:10]       # début implicite
valeurs[::2]     # un élément sur deux
valeurs[::-1]    # séquence inversée

La règle à mémoriser : l'indice de fin est exclu, et [a:b] contient exactement b - a éléments. Cette convention, déroutante au premier jour, rend les découpages composables : s[:k] + s[k:] == s.

Lire les erreurs : la compétence sous-cotée

Une traceback Python se lit de bas en haut : la dernière ligne donne le type d'erreur et le message ; les lignes au-dessus remontent la pile d'appels jusqu'à la ligne fautive.

Erreur	Cause typique en données
TypeError	Opération entre types incompatibles — souvent une colonne texte crue numérique
ValueError	Le type va, la valeur non : int("abc")
KeyError	Clé absente d'un dictionnaire — ou colonne absente d'un DataFrame
IndexError	Indice hors bornes
FileNotFoundError	Chemin faux — vérifier le répertoire de travail courant

Le réflexe de débogage minimal : afficher le type et la valeur (print(type(x), repr(x))) juste avant la ligne qui casse. Cela résout une proportion embarrassante des problèmes.

Ce qu'il faut retenir

• Types dynamiques : la souplesse se paie en erreurs à l'exécution — connaître int, float, str, bool, None et les conversions explicites.
• f-strings pour tout formatage ; :.2f, :.2% et :, couvrent l'essentiel des besoins.
• Indentation = syntaxe ; is None pour tester l'absence ; vérité implicite des conteneurs vides.
• for avec enumerate et zip pour l'orchestration — jamais pour du calcul volumineux, qui se vectorise (module 4).
• Le slicing [début:fin:pas], fin exclue, est la notation commune à Python, NumPy et pandas.

Au module suivant : les structures de données — listes, dictionnaires, tuples, ensembles — et les compréhensions qui les transforment en une ligne.