Comment refactoriser un long code Python

1. Convertir la boucle for en une liste/dictionnaire/expression d'ensemble

Une situation que nous rencontrons souvent est de créer un ensemble de valeurs.

Par exemple, nous pouvons créer une liste de nombres cubes et la remplir de manière itérative. La méthode standard dans la plupart des langages est la suivante :

cubes = []
for i in range(20):
    cubes.append(i ** 3)

En Python, nous pouvons utiliser des expressions de liste pour générer les données requises. Ce code peut être compressé en une seule ligne pour éviter la définition de la liste et les opérations fastidieuses de remplissage.

cubes = [i ** 3 for i in range(20)]

Regardez, nous avons converti trois lignes de code en une seule ligne, ce qui est sans aucun doute un bon choix : vos yeux n'ont pas besoin de vérifier le code de haut en bas, à gauche et à droite.

Compresser le code sur une seule ligne rend la lecture plus difficile, mais cela ne s'applique pas aux expressions dérivées. Une fois que vous vous êtes familiarisé avec la syntaxe, tous les éléments dont vous avez besoin sont présentés très clairement, ce qui le rend plus facile à lire que la version en boucle for.

Un autre point est que l'affectation ressemble désormais davantage à une opération atomique : nous déclarons ce que sont les cubes, plutôt que de donner des instructions sur la façon de les construire. En faisant cela, le code est plus facile à lire car nous nous concentrons sur la signification des cubes variables plutôt que sur la façon dont ils sont construits.

Enfin, les expressions sont souvent plus rapides que la création d'une collection en boucle, ce qui est également un facteur important si les performances sont prises en compte.

2. Remplacer l'affectation par une affectation incrémentielle

L'affectation incrémentielle est une syntaxe Python simple et rapide.

Chaque fois qu'il y a un code comme celui-ci :

count = count + other_value

peut être remplacé par le code suivant :

count += other_value

Le code est court et clair - nous n'avons pas besoin de réfléchir deux fois à la variable de comptage. Plusieurs opérateurs sont également disponibles, notamment moins égal (-=), ET au niveau du bit égal (&=), diviser égal (/=) et multiplier égal (*=).

Vous devez être prudent car le type auquel vous attribuez doit avoir l'opérateur approprié défini. Par exemple, les tableaux numpy ne prennent pas en charge l'opération /=.

3. Variables en ligne utilisées une seule fois

Une situation que nous voyons souvent dans le code des gens consiste à attribuer le résultat à une variable temporaire, puis à le renvoyer immédiatement.

def state_attributes(self):
    """Return the state attributes."""
    state_attr = {
        ATTR_CODE_FORMAT: self.code_format,
        ATTR_CHANGED_BY: self.changed_by,
    }
    return state_attr

En fait, une meilleure façon est de renvoyer le résultat directement au lieu d'utiliser une variable temporaire pour stocker le résultat

def state_attributes(self):
    """Return the state attributes."""
    return {
        ATTR_CODE_FORMAT: self.code_format,
        ATTR_CHANGED_BY: self.changed_by,
    }

Cela peut raccourcir le code et supprimer les variables inutiles, réduisant ainsi la consommation mentale liée à la lecture du code.

Les variables temporaires peuvent être utiles lorsqu'elles sont utilisées comme paramètres ou conditions, et le nom reflète leur contenu. Dans l'exemple ci-dessus, seul l'attribut state est renvoyé et state_attr ne fournit aucune information supplémentaire. Il n'est donc pas nécessaire d'affecter le résultat à une variable temporaire.

4. Remplacez les instructions if par des expressions if

Une situation que vous rencontrez souvent est que vous souhaitez souvent définir une variable sur l'une des deux valeurs différentes.

if condition:
    x = 1
else:
    x = 2

Cela peut être écrit sur une seule ligne en utilisant la syntaxe d'expression conditionnelle de Python (la version python de l'opérateur ternaire) :

x = 1 if condition else 2

C'est certainement plus concis, mais c'est une refactorisation plus controversée (tout comme les expressions de liste). Certains programmeurs n'aiment pas cette expression car ils la trouvent plus difficile à comprendre que d'écrire la condition dans son intégralité dans une instruction if.

Cette amélioration peut améliorer l'efficacité si les expressions conditionnelles sont plus courtes et peuvent être combinées, ce qui est notre avis. Semblable à l'exemple d'expression de liste, lorsque nous lisons du code, nous n'avons généralement pas besoin de savoir comment x est attribué, nous le voyons simplement être attribué puis avancer.

5. Remplacez les expressions indésirables par des générateurs

Convertissez en phrases simples : vous pouvez utiliser des fonctions comme any, all et sum qui prennent des générateurs comme paramètres au lieu d'ensembles. Cela signifie qu'au lieu de faire :

hat_found = any([is_hat(item) for item in wardrobe])

vous pouvez changer le code en :

hat_found = any(is_hat(item) for item in wardrobe)

Cela supprimera une paire de parenthèses et rendra le code légèrement plus clair. Si la fonction any trouve un résultat, elle le renvoie immédiatement sans avoir à construire la liste entière. Cela peut conduire à des améliorations de performances.

Notez que nous passons en fait le générateur dans any(), à proprement parler le code devrait ressembler à ceci :

hat_found = any(is_hat(item) for item in wardrobe)

Mais Python vous permet d'omettre cette paire de parenthèses. Voici les fonctions de bibliothèque standard qui acceptent les générateurs :

'all', 'any', 'enumerate', 'frozenset', 'list', 'max', 'min', 'set', 'sum', 'tuple'

6. Simplifiez la condition dans une instruction return

La dernière technique de refactoring introduite est que la fonction doit renvoyer le résultat est True ou False. Une approche courante est la suivante :

def function():
    if isinstance(a, b) or issubclass(b, a):
        return True
    return False

Cependant, il est plus concis de renvoyer le résultat directement, comme indiqué ci-dessous :

def function():
    return isinstance(a, b) or issubclass(b, a)

Cela ne peut être fait que si l'expression est évaluée à une valeur booléenne. Par exemple, dans cet exemple

def any_hats():
    hats = [item for item in wardrobe if is_hat(item)]
    if hats or self.wearing_hat():
        return True
    return False

, vous pouvez utiliser bool() pour combiner hat et self.wearing_hat() dans une liste booléenne, éliminant ainsi la condition if et simplifiant le programme.

def any_hats():
    hats = [item for item in wardrobe if is_hat(item)]
    return bool(hats or self.wearing_hat())

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!