%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %%
> [!nav]
> ↩ [[Design et Création Numérique/Design/Esthétique du code/Esthétique du code|Accueil · Esthétique du code]]
%% nav-fin %%
# 📘 Techniques pour rendre son code esthétique
Ce cours présente des techniques concrètes pour rendre un code Python plus lisible, plus simple et plus concis. Ces techniques suivent des conventions partagées par la communauté Python : un code qui les respecte se relit plus vite, par soi-même et par les autres.
## ✅ 1. Soigner la présentation (PEP 8)
- Utiliser **4 espaces** pour l'indentation.
- Limiter les lignes à **79 caractères**.
- Nommer les variables et les fonctions en `snake_case`.
- Nommer les classes en `CapWords`, par exemple `CompteBancaire`.
- Laisser une ligne vide entre deux fonctions.
- Éviter les importations inutiles.
- Mettre des espaces autour des opérateurs : `a + b`, pas `a+b`.
- Sauter une ligne entre les blocs logiques.
- Écrire des commentaires utiles et brefs.
## 🧠 2. Nommer clairement
Des noms explicites rendent souvent les commentaires superflus :
```python
# Mauvais
x = 7
# Meilleur
nombre_utilisateurs_actifs = 7
```
## 🧩 3. Réduire la complexité
- Découper les fonctions longues ou imbriquées.
- Éviter les `if` / `else` emboîtés en préférant des retours directs :
```sq-avant-apres
titre: Retour direct
--- avant
def est_pair(n):
if n % 2 == 0:
return True
else:
return False
print(est_pair(4))
--- après
def est_pair(n):
return n % 2 == 0
print(est_pair(4))
--- sortie
True
```
## 🐍 4. Utiliser les idiomes Python
### ✅ Affectation multiple
```python
x, y = 3, 4
```
### 🔄 Échange de deux variables
```python
a, b = b, a
```
### 📇 enumerate et zip
```python
for i, val in enumerate(liste):
print(i, val)
for a, b in zip(liste1, liste2):
print(a, b)
```
**À manipuler :** prédisez la sortie de chaque `print`.
```sq-affiche
a, b = 3, 4
a, b = b, a
print(a, b)
liste = ['a', 'b', 'c']
print(list(enumerate(liste))[1])
print(list(zip([1, 2], ['x', 'y'])))
---
saisie: lignes
réponse: 4 3\n(1, 'b')\n[(1, 'x'), (2, 'y')]
explication: L'échange se fait en une ligne. enumerate associe à chaque élément son indice, en partant de 0. zip associe les éléments de même rang de deux listes.
```
## 🔁 5. Utiliser les compréhensions
Les compréhensions rendent le code plus compact :
```python
# Carrés des nombres pairs
[x**2 for x in range(10) if x % 2 == 0]
```
```python
# Remplacer les négatifs par 0
[x if x >= 0 else 0 for x in valeurs]
```
```python
# Produit cartésien
[(x, y) for x in [1, 2] for y in ['a', 'b']]
```
**À manipuler :** prédisez la sortie de chaque `print`.
```sq-affiche
valeurs = [3, -1, 0, -7, 5]
print([x**2 for x in range(10) if x % 2 == 0])
print([x if x >= 0 else 0 for x in valeurs])
print([(x, y) for x in [1, 2] for y in ['a', 'b']])
---
saisie: lignes
réponse: [0, 4, 16, 36, 64]\n[3, 0, 0, 0, 5]\n[(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
explication: La condition placée à la fin filtre les éléments. L'expression conditionnelle placée au début transforme chaque élément. Deux for imbriqués parcourent toutes les paires.
```
## 🔂 6. Éviter les répétitions (DRY, Don't Repeat Yourself)
Un bloc copié-collé plus de deux fois mérite une fonction. Le code avant répète trois fois le même test. Le code après le place dans une fonction.
```sq-avant-apres
titre: Une fonction à la place de trois copies
--- avant
roles = ["admin", "eleve", "eleve"]
if roles[0] == "admin":
print("Admin")
else:
print("Standard")
if roles[1] == "admin":
print("Admin")
else:
print("Standard")
if roles[2] == "admin":
print("Admin")
else:
print("Standard")
--- après
def statut(role):
return "Admin" if role == "admin" else "Standard"
roles = ["admin", "eleve", "eleve"]
for role in roles:
print(statut(role))
--- sortie
Admin
Standard
Standard
```
Une correction se fait alors à un seul endroit.
## 🧮 7. Utiliser des fonctions anonymes avec `lambda`
```python
eleves = [("Alice", 14), ("Bob", 12)]
tri = sorted(eleves, key=lambda x: x[1])
```
## 🧪 8. Utiliser `all()`, `any()`, `map()`
```python
# Vérifier si tous les éléments sont valides
notes = [12, 15, 18]
if all(note >= 10 for note in notes):
print("Tous les étudiants ont validé")
# Vérifier si au moins un élément est valide
if any(x > 15 for x in notes):
print("Au moins une note dépasse 15")
# Appliquer une fonction à chaque élément
nombres = ['1', '8', '27']
entiers = list(map(int, nombres))
```
**À manipuler :** prédisez la sortie de chaque `print`.
```sq-affiche
notes = [12, 15, 18]
eleves = [("Alice", 14), ("Bob", 12)]
print(all(note >= 10 for note in notes))
print(any(x > 15 for x in notes))
print(list(map(int, ['1', '8', '27'])))
print(sorted(eleves, key=lambda x: x[1]))
---
saisie: lignes
réponse: True\nTrue\n[1, 8, 27]\n[('Bob', 12), ('Alice', 14)]
explication: all vaut True si toutes les notes valent au moins 10. any vaut True dès qu'une note dépasse 15 : 18. map applique int à chaque chaîne. La clé lambda trie les élèves par note croissante.
```
%% nav-debut : généré par gen_navigation.py, ne pas modifier à la main %%
> [!nav]
> ↩ [[Design et Création Numérique/Design/Esthétique du code/Esthétique du code|Accueil · Esthétique du code]]
%% nav-fin %%
---
🗓️ Historique
Dernière mise à jour : `21 juillet 2025`
Rédigé par : [[Julien DUQUENNOY]]