30 astuces Python pour un meilleur code, avec exemples

La demande en compétences de programmation Python a fortement augmenté ces dernières années. Pour vous aider à développer vos compétences en Python, nous avons rassemblé 30 astuces Python pour améliorer votre code. Essayez d’en apprendre une par jour pendant 30 jours et consultez notre article sur les bonnes pratiques Python pour garantir un code de référence. 

Si vos compétences en Python ont besoin d’un rafraîchissement, vous pouvez aussi les renforcer avec notre parcours de compétences Python.

Astuces sur les séquences et structures de données

#1 Slicing

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Le slicing (découpage) est une fonctionnalité de Python qui repose sur l’indexation et permet d’accéder à un sous-ensemble d’une séquence. Un index n’est que la position d’un élément dans une séquence. Si le type de séquence est mutable, vous pouvez utiliser le slicing pour extraire et modifier des données. 

Remarque : On peut aussi utiliser le slicing sur une séquence immuable, mais tenter de modifier la tranche lèvera un TypeError. 

La syntaxe des tranches est : sequence[start:stop:step]. Si aucune valeur n’est indiquée pour les paramètres start, stop et step, les valeurs par défaut s’appliquent : 

• "start" vaut 0 par défaut 
• "stop" vaut la longueur de la séquence
• "step" vaut 1 s’il n’est pas spécifié. 

Avec sequence[start:stop], les éléments retournés vont de l’index de départ jusqu’à stop - 1 (l’index stop n’est pas inclus). 

On peut aussi passer des indices négatifs, utiles notamment pour inverser la séquence. Par exemple, dans une liste de 4 éléments, l’index 0 correspond aussi à -4, et le dernier index correspond à -1. Dans l’exemple ci-dessus, cette propriété est utilisée dans le paramètre step : la chaîne est donc affichée à l’envers, de la fin jusqu’à l’index 0.   

#2 Échange en place / affectation simultanée

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Si vous avez d’abord pensé que la valeur de b serait 7 au lieu de 12, vous êtes tombé dans le piège de l’échange en place. 

En Python, on peut dépaqueter des itérables vers des variables en une seule affectation grâce au dépaquetage automatique. Par exemple : 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

On peut aussi regrouper plusieurs valeurs dans une seule variable avec * – cette astuce s’appelle le « packing ». Exemple :  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

En combinant packing et unpacking automatiques, on obtient l’affectation simultanée, qui permet d’assigner une série de valeurs à une série de variables.

#3 Listes vs tuples 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

La plupart des programmeurs Python connaissent les listes. On ne peut pas en dire autant des tuples. Les deux sont itérables, acceptent l’indexation et peuvent stocker des types hétérogènes. Mais il existe des cas où un tuple est préférable à une liste. 

D’abord, les listes sont mutables, donc modifiables à volonté : 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Les tuples, eux, sont immuables : tenter de les modifier lève un TypeError. 

De ce fait, les tuples sont plus économes en mémoire, car Python peut allouer exactement le bloc nécessaire. À l’inverse, une liste réserve de la mémoire supplémentaire au cas où elle s’agrandirait – c’est l’allocation dynamique. 

En bref : si vous ne souhaitez pas que les données changent, privilégiez un tuple pour des raisons de mémoire. Les tuples sont aussi plus rapides que les listes. 

Pour en savoir plus, consultez ce tutoriel sur les structures de données en Python. 

#4 Générateurs

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

Les compréhensions de liste sont la manière pythonique de créer une liste à partir d’un autre itérable – bien plus rapide qu’une boucle for. Mais si vous remplacez par inadvertance [] par (), vous obtenez… un générateur.

En Python, des parenthèses contenant une logique de compréhension créent un générateur. Les générateurs sont un type particulier d’itérable. Contrairement aux listes, ils ne stockent pas leurs éléments : ils conservent des instructions pour générer chaque élément en séquence ainsi que l’état courant de l’itération.

Chaque élément n’est produit que sur demande, via l’évaluation paresseuse. L’avantage principal est une consommation mémoire bien moindre, puisque la séquence complète n’est pas construite d’un bloc. 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python est un langage orienté objet : tout est objet. Assigner un objet à un identifiant crée donc une référence vers cet objet. 

Quand on assigne un identifiant à un autre, on obtient deux identifiants qui référencent le même objet : c’est l’aliasing. Une modification via un alias affecte l’autre. Parfois voulu, souvent surprenant. 

Pour l’éviter avec des objets mutables, abstenez-vous d’aliaser ou créez un clone de l’objet original plutôt qu’une référence. 

La manière la plus simple de cloner est d’utiliser le slicing : 

b = a[:] 

Cela crée une nouvelle référence vers un nouvel objet liste pour b. 

D’autres solutions existent, comme appeler list(a) à l’affectation ou utiliser la méthode copy(). 

#6 L’opérateur « not »

a = []
print(not a)

"""
True
"""

Le moyen le plus simple de vérifier si une structure de données est vide est d’utiliser l’opérateur not. Le not intégré de Python est un opérateur logique qui renvoie True si l’expression n’est pas vraie, sinon False – il inverse la valeur de vérité des expressions booléennes et des objets.  

On le voit aussi souvent dans une instruction if : 

if not a:
    # do something... 

Quand a est True, l’opérateur not renvoie False, et inversement. 

Pas toujours intuitif au début : testez par vous-même.

Astuces sur les chaînes et l’affichage

#7 F-strings

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Il arrive qu’on doive formater une chaîne ; Python 3.6 a introduit une fonctionnalité très pratique appelée f-strings pour simplifier cela. Pour l’apprécier, rappelons comment on formatait les chaînes auparavant. 

Avant, on écrivait : 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

La nouvelle méthode est plus rapide, plus lisible, plus concise, et limite les erreurs.

Autre usage des f-strings : afficher le nom d’un identifiant avec sa valeur, introduit en Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Pour en savoir plus, consultez ce tutoriel sur le formatage avec f-strings en Python. 

#8 Le paramètre « end » de print()

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Il est courant d’appeler print sans préciser ses paramètres optionnels. Beaucoup de pythonistes ignorent donc qu’on peut piloter l’affichage.

Un paramètre utile est end. Il définit ce qui doit être ajouté à la fin d’un appel à print. 

Par défaut, end vaut "\n" (nouvelle ligne). Dans l’exemple ci-dessus, nous l’avons remplacé par un espace, de sorte que tous les éléments de la liste soient affichés sur une même ligne.

#9 Ajouter à un tuple

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Nous savons déjà que les tuples sont immuables – voir l’astuce #3 listes vs tuples. Tenter de modifier un tuple lève un TypeError. Mais si l’on considère un tuple comme une suite de noms liés à des objets dont le lien ne peut pas changer, on voit les choses autrement.

Les deux premiers éléments de notre tuple sont des entiers – immuables. Le dernier est une liste, objet mutable en Python.

Si l’on voit cette liste comme un autre nom dans une séquence liée à un objet dont le lien est fixe, on comprend que l’objet lui-même (la liste) peut être modifié depuis le tuple.

Le recommander en pratique ? Probablement pas, mais c’est bon à savoir.

#10 Fusionner des dictionnaires

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

Depuis Python 3.9, on peut fusionner des dictionnaires avec | (opérateur OU bit à bit). Pas grand-chose à ajouter, si ce n’est que c’est bien plus lisible ! 

Astuces de style de code et de syntaxe

#11 Opérateur ternaire / expression conditionnelle 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

Dans le code ci-dessus, on voit ce qu’on appelle un opérateur ternaire (ou expression conditionnelle). On l’utilise pour évaluer une valeur selon qu’une condition est True ou False.

On aurait pu écrire :

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Les deux versions produisent le même résultat, mais l’expression ternaire permet un code plus court et plus clair. C’est la façon la plus « pythonique » d’écrire ce cas simple. 

#12 Supprimer les doublons d’une liste

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

Le moyen le plus simple de supprimer les doublons d’une liste est de la convertir en ensemble (puis, si besoin, de revenir en liste).

Par leur mutabilité, ensembles et listes semblent proches. On peut ajouter et retirer des éléments dans les deux, mais ils restent très différents.

Les listes sont ordonnées, indexées à partir de zéro et mutables. Les ensembles sont non ordonnés et non indexés. Les éléments d’un ensemble doivent être de type immuable, même si l’ensemble lui-même est mutable – tenter d’accéder par index ou de modifier un élément lèvera une erreur.

Autre différence clé : un ensemble ne contient pas de doublons. C’est ce qui nous permet d’éliminer les répétitions.

#13 Tiret bas seul 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Le tiret bas (_) est un identifiant valide en Python, on peut donc l’utiliser pour référencer un objet. Mais il a aussi un autre rôle : stocker le résultat de la dernière évaluation.

La documentation précise que « l’interpréteur interactif met le résultat de la dernière évaluation à disposition dans la variable _ (elle est stockée dans le module builtins, aux côtés de fonctions comme print) ».

Comme nous n’avions rien assigné à _ avant de l’appeler sur la première ligne, nous avons obtenu une erreur. Après avoir calculé 1 + 2, l’interpréteur a stocké le résultat dans l’identifiant _. 

#14 Underscore pour ignorer des valeurs

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

Comme vu à l’astuce #13, l’interpréteur interactif utilise _ pour le dernier résultat, mais ce n’est pas son seul cas d’usage.

On l’utilise aussi pour représenter des objets dont on n’a pas besoin et qu’on n’utilisera pas plus tard. C’est important, car utiliser un identifiant classique au lieu de _ lèvera une erreur F841 lors du linting : variable locale assignée mais non utilisée, ce qui est une mauvaise pratique.

#15 Underscore final

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Poursuivons sur l’usage de l’underscore (_). Une autre utilité est d’éviter les conflits avec les mots-clés Python. 

PEP 8 recommande d’ajouter un underscore final pour éviter les conflits avec les mots-clés. Il est « généralement préférable d’ajouter un underscore final plutôt que d’abréger ou déformer l’orthographe. Ainsi list_ vaut mieux que lst. »

#16 Underscore initial

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Vous verrez souvent des développeurs Python chevronnés préfixer un identifiant ou une méthode par un underscore – et pour une bonne raison.

Le préfixe underscore signale que la variable ou la méthode est destinée à un usage interne. C’est un avertissement aux autres développeurs, défini par PEP 8 mais non imposé par Python : un indicateur faible.

Contrairement à Java, Python ne distingue pas fortement privé/public. Autrement dit, cela n’a de sens que par convention communautaire. Leur présence n’affecte pas le comportement du programme.

#17 Underscore visuel

Dernière astuce sur les underscores. Nous avons couvert trois cas d’usage ; pour en savoir plus, consultez notre tutoriel sur le rôle de l’underscore (_) en Python. 

number = 1_500_000
print(number)

"""
15000000
"""

On peut aussi utiliser l’underscore comme séparateur visuel pour regrouper les chiffres dans les littéraux entiers, flottants et complexes – introduit en Python 3.6. 

L’idée est d’améliorer la lisibilité des grands nombres ou de ceux qu’il faut séparer en parties – voir PEP 515.

Astuces de style de code et de syntaxe

#18 __name__ == « __main__ » 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Vous avez très probablement vu cette syntaxe. Python utilise un nom spécial "__main__" et l’affecte à l’identifiant __name__ si le fichier Python exécuté est le programme principal.

Si l’on importe ce module dans un autre fichier et qu’on exécute ce dernier, l’expression devient fausse. En effet, lors d’un import, __name__ prend le nom du module (le fichier Python). 

#19 La méthode « setdefault » 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Vous pouvez vouloir fixer une valeur par défaut pour divers clés dans un dictionnaire, par exemple pour compter les mots d’un corpus. La manière classique : 

1. Vérifier si la clé existe
2. Si oui, incrémenter de 1
3. Sinon, l’ajouter et la mettre à 1

En code :

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Plus concis : utiliser la méthode setdefault() sur votre dictionnaire.

Le premier argument est la clé à vérifier. Le second est la valeur à attribuer si la clé n’existe pas encore – si elle existe, la méthode renvoie sa valeur sans la modifier.

Astuces de structuration de programme

#20 Correspondances regex

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Les expressions régulières permettent de définir un motif de texte à rechercher. Tout le monde sait utiliser CTRL+F, mais si vous ne connaissez pas exactement la chaîne à trouver, comment faire ? Réponse : cherchez des motifs.  

Par exemple, les numéros britanniques suivent un motif similaire : un zéro au début suivi de dix chiffres, ou +44 à la place du zéro puis dix chiffres – le second format est l’international. 

Les regex font gagner un temps précieux. Coder des règles pour ces cas pourrait prendre plus de 10 lignes, contre une seule avec une expression régulière. 

Comprendre les regex est utile même sans coder : la plupart des éditeurs et traitements de texte modernes permettent la recherche/remplacement avec regex.

#21 Le pipe en regex

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Les expressions régulières disposent d’un caractère spécial, le pipe (|), pour faire correspondre l’une parmi plusieurs expressions, où que ce soit dans le motif. Très pratique lorsqu’on a plusieurs variantes proches.

Par exemple, « Superman », « Superwoman » et « Superhuman » partagent le même préfixe. On peut donc factoriser la partie commune et ne faire varier que la fin. Un vrai gain de temps.

Attention : si toutes les correspondances possibles apparaissent dans le même texte, la première occurrence sera renvoyée – par exemple, « An example text containing Superwoman, Superman, Superhuman » renverra Superwoman.

#22 Le paramètre « sep » de print()

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Beaucoup de programmeurs Python ne connaissent pas toutes les possibilités de print(). Si « Hello World » a été votre premier programme, vous avez découvert print() très tôt. On l’utilise pour afficher des messages formatés, mais il sait faire bien plus. 

Dans l’exemple ci-dessus, nous montrons différentes manières d’afficher le message. Le paramètre optionnel sep définit le séparateur entre les objets passés à print(). 

Par défaut, c’est un espace. Nous l’avons changé une fois en chaîne vide "", et une autre fois en point ".".

#23 Fonctions lambda 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Les fonctions lambda vous font passer à un niveau plus intermédiaire/avancé – apprenez l’Intermediate Python avec ce cours. Elles paraissent complexes au premier abord, mais elles sont assez simples.

Dans notre exemple, nous n’avons utilisé qu’un argument, mais on peut en utiliser plusieurs :

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

En substance, le mot-clé lambda permet de créer de petites fonctions anonymes, limitées, en une seule ligne. Elles se comportent comme une fonction définie avec def, mais sans nom.

#24 La méthode « swapcase »

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

La méthode swapcase() appliquée à une chaîne inverse la casse de chaque lettre en une seule ligne. Peu de cas d’usage, mais bon à connaître.

#25 La méthode « isalnum »

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Supposons que votre programme exige un mot de passe composé de lettres et de chiffres. On peut le vérifier en une ligne avec isalnum() sur la chaîne.

La méthode teste si tous les caractères sont alphabétiques (A–Za–z) ou numériques (0–9). Un espace ou un symbole (!#%$&? etc.) renverra False.

#26 Gestion des exceptions

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Un programme Python s’arrête lorsqu’il rencontre une erreur.

Parfois, on ne veut pas de ce comportement, par exemple avec un utilisateur final. Une interruption brutale serait problématique.

Plusieurs approches existent. La plupart des pythonistes préfèrent « demander pardon plutôt que permission » : ils laissent l’erreur se produire puis la gèrent via un bloc de traitement adapté. L’idée est qu’il est inutile d’anticiper tous les cas exceptionnels possibles.

Mais cela n’a de sens que si un mécanisme de rattrapage existe après coup.

#27 Identifier les différences entre listes

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Voici trois méthodes pour comparer la différence entre deux listes en Python. 

Remarque : à moins de savoir que list_1 est un sous-ensemble de list_2, la solution 1 n’est pas équivalente aux deux autres.

#28 Args et kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

On utilise *args et **kwargs comme paramètres quand on ne connaît pas le nombre d’arguments attendus. 

*args permet de passer un nombre variable d’arguments positionnels (sans nom). **kwargs permet de passer un nombre arbitraire d’arguments nommés.

En réalité, les mots args et kwargs n’ont rien de magique : la magie vient des astérisques (*). On aurait pu choisir d’autres noms, mais args et kwargs sont la convention adoptée par la communauté. 

#29 L’ellipsis

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

L’ellipsis est un objet Python accessible via trois points (...) ou via l’objet Ellipsis.

Son usage le plus connu est l’accès et le slicing de tableaux multidimensionnels avec NumPy, par exemple :

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

On peut aussi l’utiliser comme espace réservé dans une fonction non encore implémentée. 

Autrement dit, vous pouvez utiliser Ellipsis, ... ou pass : tout est valide.

#30 Compréhensions de liste

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Dernière astuce : les compréhensions de liste, une façon élégante de créer une liste à partir d’une autre séquence. Elles permettent une logique et un filtrage sophistiqués, comme ci-dessus.

On pourrait atteindre le même objectif autrement, par exemple avec une lambda :

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Mais beaucoup de pythonistes jugeront cette solution moins lisible que la compréhension de liste.