Lesson 7/9 7 min

Files and modules

Read and write files, import modules and discover pip, os, json and datetime.

FR EN

Lire un fichier

Python peut lire et écrire des fichiers sur votre ordinateur. La fonction open() ouvre un fichier :

# Lire tout le contenu d'un fichier
with open("mon_fichier.txt", "r") as f:
    contenu = f.read()
    print(contenu)

# Lire ligne par ligne
with open("mon_fichier.txt", "r") as f:
    for ligne in f:
        print(ligne.strip())  # strip() enlève le \n

Le mot-clé with ferme automatiquement le fichier à la fin du bloc. C'est la manière recommandée en Python.

with ouvre le fichier, vous travaillez dedans, puis Python le referme automatiquement à la fin du bloc. fermé ouvert lecture / écriture fermé auto. with open() fin du bloc
with ouvre le fichier, vous travaillez dedans, puis Python le referme tout seul à la fin du bloc indenté.

Modes d'ouverture : "r" = lecture, "w" = écriture (écrase), "a" = ajout, "r+" = lecture + écriture.

Écrire dans un fichier

# Écrire (écrase le contenu existant)
with open("resultats.txt", "w") as f:
    f.write("Score : 95/100\n")
    f.write("Statut : Réussi\n")

# Ajouter à la fin (sans écraser)
with open("log.txt", "a") as f:
    f.write("2026-05-27 : Connexion réussie\n")

Résultat dans resultats.txt :

Score : 95/100
Statut : Réussi

import : les modules

Un module est un fichier Python contenant des fonctions réutilisables. Python en fournit des centaines :

# Importer un module entier
import math
print(math.sqrt(16))   # 4.0
print(math.pi)         # 3.141592653589793

# Importer une fonction spécifique
from random import randint
print(randint(1, 10))  # nombre aléatoire entre 1 et 10

# Renommer un import (alias)
import datetime as dt
maintenant = dt.datetime.now()
print(maintenant)  # 2026-05-27 14:30:00.123456

pip install : les packages externes

La bibliothèque standard de Python est riche, mais pour des besoins spécifiques, on installe des packages externes avec pip :

# Dans le terminal (pas dans Python)
pip install requests        # requêtes HTTP
pip install beautifulsoup4  # web scraping
pip install pandas          # data science
pip install flask           # framework web

Une fois installé, on l'importe normalement :

import requests
response = requests.get("https://api.example.com/data")
print(response.status_code)  # 200

Bonne pratique : utilisez un environnement virtuel (python -m venv mon_env) pour isoler les packages de chaque projet.

Modules utiles : os, json, datetime

# os : manipuler le système de fichiers
import os
print(os.getcwd())        # dossier courant
print(os.listdir("."))    # lister les fichiers
os.makedirs("data", exist_ok=True)  # créer un dossier

# json : lire/écrire du JSON
import json

# Écrire du JSON
data = {"nom": "Alice", "scores": [95, 87, 92]}
with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

# Lire du JSON
with open("data.json", "r") as f:
    data = json.load(f)
    print(data["nom"])  # Alice

# datetime : dates et heures
from datetime import datetime, timedelta
maintenant = datetime.now()
demain = maintenant + timedelta(days=1)
print(maintenant.strftime("%d/%m/%Y %H:%M"))  # 27/05/2026 14:30

Créer son propre module

N'importe quel fichier .py est un module. Créez outils.py :

# outils.py
def formater_prix(montant, devise="€"):
    return f"{montant:.2f} {devise}"

def calculer_tva(prix_ht, taux=20):
    return prix_ht * (1 + taux / 100)

Puis importez-le dans un autre fichier :

# main.py
from outils import formater_prix, calculer_tva

prix_ttc = calculer_tva(100)
print(formater_prix(prix_ttc))  # 120.00 €

if __name__ == "__main__"

Python remplit automatiquement une variable spéciale, __name__, pour chaque fichier. Sa valeur dépend de la façon dont le fichier est utilisé :

  • Si vous lancez le fichier directement (python mon_fichier.py), alors __name__ vaut "__main__".
  • Si le fichier est importé par un autre (import mon_fichier), alors __name__ vaut le nom du module (ici "mon_fichier").

Du coup, le bloc if __name__ == "__main__": permet d'avoir du code qui ne s'exécute que si on lance le fichier directement, et pas quand on l'importe :

def saluer(nom):
    return f"Bonjour {nom} !"

print(f"__name__ vaut : {__name__}")

if __name__ == "__main__":
    # Ce code ne tourne QUE si on lance ce fichier directement
    print(saluer("Alice"))
    print("Le fichier a été lancé directement.")

Ici, comme on exécute le fichier directement, __name__ vaut "__main__" et le bloc s'exécute. Si un autre fichier faisait import ce_fichier, la fonction saluer serait disponible, mais le bloc du if ne se déclencherait pas.

Bonne pratique : placez le point d'entrée de votre programme (le code qui démarre tout) dans un bloc if __name__ == "__main__":. Votre fichier reste alors réutilisable comme module, sans tout déclencher à l'import.

Reading a file

Python can read and write files on your computer. The open() function opens a file:

# Read the entire content of a file
with open("my_file.txt", "r") as f:
    content = f.read()
    print(content)

# Read line by line
with open("my_file.txt", "r") as f:
    for line in f:
        print(line.strip())  # strip() removes \n

The with keyword automatically closes the file at the end of the block. This is the recommended way in Python.

with opens the file, you work inside, then Python closes it automatically at the end of the block. closed open read / write auto-closed with open() end of block
with opens the file, you work inside, then Python closes it automatically at the end of the indented block.

Opening modes: "r" = read, "w" = write (overwrites), "a" = append, "r+" = read + write.

Writing to a file

# Write (overwrites existing content)
with open("results.txt", "w") as f:
    f.write("Score: 95/100\n")
    f.write("Status: Passed\n")

# Append to the end (without overwriting)
with open("log.txt", "a") as f:
    f.write("2026-05-27: Login successful\n")

Result in results.txt:

Score: 95/100
Status: Passed

import — modules

A module is a Python file containing reusable functions. Python provides hundreds of them:

# Import an entire module
import math
print(math.sqrt(16))   # 4.0
print(math.pi)         # 3.141592653589793

# Import a specific function
from random import randint
print(randint(1, 10))  # random number between 1 and 10

# Rename an import (alias)
import datetime as dt
now = dt.datetime.now()
print(now)  # 2026-05-27 14:30:00.123456

pip install — external packages

Python's standard library is rich, but for specific needs, install external packages with pip:

# In the terminal (not in Python)
pip install requests        # HTTP requests
pip install beautifulsoup4  # web scraping
pip install pandas          # data science
pip install flask           # web framework

Once installed, import it normally:

import requests
response = requests.get("https://api.example.com/data")
print(response.status_code)  # 200

Best practice: use a virtual environment (python -m venv my_env) to isolate each project's packages.

Useful modules: os, json, datetime

# os — manipulate the file system
import os
print(os.getcwd())        # current directory
print(os.listdir("."))    # list files
os.makedirs("data", exist_ok=True)  # create a folder

# json — read/write JSON
import json

# Write JSON
data = {"name": "Alice", "scores": [95, 87, 92]}
with open("data.json", "w") as f:
    json.dump(data, f, indent=2)

# Read JSON
with open("data.json", "r") as f:
    data = json.load(f)
    print(data["name"])  # Alice

# datetime — dates and times
from datetime import datetime, timedelta
now = datetime.now()
tomorrow = now + timedelta(days=1)
print(now.strftime("%d/%m/%Y %H:%M"))  # 27/05/2026 14:30

Creating your own module

Any .py file is a module. Create utils.py:

# utils.py
def format_price(amount, currency="EUR"):
    return f"{amount:.2f} {currency}"

def calculate_vat(price_excl, rate=20):
    return price_excl * (1 + rate / 100)

Then import it in another file:

# main.py
from utils import format_price, calculate_vat

price_incl = calculate_vat(100)
print(format_price(price_incl))  # 120.00 EUR

if __name__ == "__main__"

Python automatically fills a special variable, __name__, for every file. Its value depends on how the file is used:

  • If you run the file directly (python my_file.py), then __name__ equals "__main__".
  • If the file is imported by another one (import my_file), then __name__ equals the module name (here "my_file").

So the if __name__ == "__main__": block lets you have code that runs only when you run the file directly, and not when you import it:

def greet(name):
    return f"Hello {name}!"

print(f"__name__ is: {__name__}")

if __name__ == "__main__":
    # This code runs ONLY if you run this file directly
    print(greet("Alice"))
    print("The file was run directly.")

Here, since we run the file directly, __name__ equals "__main__" and the block runs. If another file did import this_file, the greet function would be available, but the if block would not fire.

Best practice: put your program's entry point (the code that starts everything) inside an if __name__ == "__main__": block. Your file then stays reusable as a module, without triggering everything on import.

Avec l'IA

Copiez ce prompt dans Claude ou ChatGPT :

Écris un script Python qui lit un fichier CSV de contacts, le convertit en JSON, et crée un résumé avec le nombre de contacts par ville. Utilise les modules csv, json et collections.
Ré-explique sans regarder

Sans relire la leçon : à quoi sert le bloc if __name__ == "__main__":, et que vaut __name__ selon qu'on lance le fichier ou qu'on l'importe ?

Une bonne explication dit : Python remplit __name__ pour chaque fichier. Quand on lance le fichier directement (python fichier.py), __name__ vaut "__main__" ; quand le fichier est importé, __name__ vaut le nom du module. Le bloc if __name__ == "__main__": ne s'exécute donc qu'au lancement direct, jamais à l'import : on y met le point d'entrée du programme pour garder le fichier réutilisable comme module.
Accepter ou rejeter le code de l'IA

Tu demandes à l'IA de lire un fichier de config JSON. Elle te propose ce code. Ton rôle de relecteur : l'accepter tel quel ou le rejeter, et dire pourquoi.

import json

def lire_config():
    try:
        with open("config.json", "r") as f:
            return json.load(f)
    except:
        return {}
À rejeter. Le with open() est correct, mais le except: nu est le piège : il avale TOUT, y compris une faute de frappe dans le code, un KeyboardInterrupt (Ctrl+C) ou une erreur de permission. Si config.json existe mais contient du JSON cassé, tu récupères un {} silencieux et tu débugges à l'aveugle pendant une heure. Attrape seulement ce que tu sais gérer : except (FileNotFoundError, json.JSONDecodeError):, et laisse remonter le reste.
Rappel libre

Sans remonter dans la leçon : que fait le mot-clé with quand on ouvre un fichier, et quelle est la différence entre les modes "w" et "a" ?

with ouvre le fichier et le referme automatiquement à la fin du bloc indenté, même si une erreur survient : pas besoin d'appeler f.close() à la main. Côté modes : "w" (write) écrase tout le contenu existant du fichier, alors que "a" (append) ajoute à la fin sans rien effacer.
Pourquoi utiliser with open() plutôt que open() seul ?
Quelle commande installe un package externe en Python ?
Quelle fonction transforme un dictionnaire Python en texte JSON ?
Next step

You read local files and install packages with pip. The logical next step: fetch data from elsewhere, on the web. We use requests to query REST APIs and BeautifulSoup to scrape pages.

Lesson 8: Error handling →
Besoin d'un développeur pour votre projet ?

Réponse sous 24h · Sans engagement