Refactors communs en Python pour les débutants

La refactorisation contribue à rendre votre code plus propre et plus efficace. Voici cinq refactors courants pour les débutants en Python.

Je. Simplifier les expressions booléennes

Un modèle courant consiste à utiliser un bloc if-else juste pour renvoyer True ou False. Par exemple :

if condition:
    return True
else:
    return False

Refactorisez-le en :

return condition

La condition elle-même est déjà une expression booléenne, donc le bloc if-else n'est pas nécessaire. En renvoyant directement la condition, le code devient plus court et plus lisible. C'est un moyen simple mais efficace d'améliorer la clarté sans modifier la fonctionnalité.

II. Liste des compréhensions au lieu de for / if

Les débutants utilisent souvent des boucles for avec des instructions if pour créer des listes. Par exemple :

result = []
for item in items:
    if condition(item):
        result.append(item)

Refactorisez-le pour une compréhension de liste :

result = [item for item in items if condition(item)]

Les compréhensions de listes offrent une manière plus concise de construire des listes. Elles sont également généralement plus rapides que les boucles for équivalentes car elles sont optimisées en interne par Python. Cette approche est également plus facile à lire, en particulier pour les tâches simples de création de liste.

III. Évitez de répéter les calculs

Si vous appelez plusieurs fois la même fonction dans une boucle, stockez le résultat dans une variable. Par exemple :

for item in items:
    if len(item) > 5:
        result.append(item)
...

Refactorisez-le en :

for item in items:
    len = len(item)
    if len > 5:
        result.append(item)
...

Imaginez si cette condition est remplie dans plusieurs déclarations elif ou if imbriquées. Ici, len(item) est appelé deux fois pour chaque itération, ce qui peut être inefficace, en particulier pour les grandes listes. Stocker le résultat de len(item) dans une variable (len) élimine les calculs répétés, améliorant les performances et rendant le code plus propre. Ceci est un exemple basique.

IV. Remplacez les boucles par une carte et un filtre

Au lieu d'écrire des boucles explicites, utilisez les fonctions intégrées de Python comme map() et filter(), qui peuvent être plus efficaces et concises. Par exemple, pour doubler chaque élément d'une liste :

result = []
for item in items:
    result.append(item * 2)

Refactorisez-le en :

result = list(map(lambda x: x * 2, items))

Ou pour filtrer les éléments supérieurs à 5 :

result = []
for item in items:
    if item > 5:
        result.append(item)

Refactorisez-le en :

result = list(filter(lambda x: x > 5, items))

map() et filter() prennent des fonctions comme arguments, nous pouvons donc utiliser lambda pour définir de petites fonctions anonymes. La fonction lambda est une manière concise de définir des opérations simples. Par exemple, lambda x: x * 2 crée une fonction qui multiplie x par 2. L'avantage de map() et filter() est qu'ils sont souvent plus efficaces que l'utilisation d'une boucle for et sont généralement plus lisibles. On pourrait également utiliser des compréhensions de listes (voir ci-dessus).

V Combiner plusieurs instructions if

Lors de la vérification de plusieurs conditions, les combiner avec des opérateurs logiques (et, ou) peut simplifier votre code. Par exemple :

if a > 0:
    if b > 0:
        result = a + b

Refactorisez-le en :

if condition:
    return True
else:
    return False

Cela réduit les imbrications inutiles et rend le code plus facile à lire et à maintenir. La combinaison des conditions en une seule instruction if rend le flux logique plus clair et élimine la redondance.

Conclusion

La refactorisation consiste à rendre votre code plus court, plus clair et plus efficace sans changer ce qu'il fait. En simplifiant les expressions booléennes, en utilisant la compréhension de listes, en évitant les calculs répétés, en tirant parti des fonctions intégrées telles que map() et filter() et en fusionnant les conditions, vous pouvez rendre votre code SEC. L'utilisation de lambda vous permet de définir de petites fonctions sur une seule ligne, en gardant le code propre et rapide. Ces pratiques améliorent non seulement les performances, mais améliorent également la lisibilité, ce qui est crucial pour maintenir le code à long terme.

Lectures complémentaires :

https://www.w3schools.com/python/python_lambda.asp

https://www.w3schools.com/python/ref_func_filter.asp

https://www.w3schools.com/python/ref_func_map.asp

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!