Huit conseils de refactoring pour rendre le code Python plus pythonique

1. Combinez les instructions if imbriquées

Nous commençons simplement. N'emboîtez pas les instructions if comme celle-ci, combinez-les simplement en une seule.

if a:
if b:
pass

# -> refactor
if a and b:
pas

2. Utilisez any au lieu de loop

Ici, nous voulons vérifier s'il y a au moins un élément positif dans la liste. Une solution plus longue consiste à parcourir tous les nombres, à vérifier le nombre actuel, puis à interrompre lorsque la condition est vraie. Mais pour cette tâche, il existe une méthode spécialisée en Python, la fonction any​. any renvoie True si un élément de l'itérable est vrai. C'est beaucoup plus court et plus pythonique qu'une boucle manuelle.

numbers = [-1, -2, -4, 0, 3, -7]
has_positives = False
for n in numbers:
if n > 0:
has_positives = True
break

# -> refactor
has_positives = any(n > 0 for n in numbers)

3. Extraire les instructions des boucles for/while

Souvent, vous verrez une variable définie dans la boucle, mais elle ne change jamais. Ce sont des opérations inutiles, alors retirez-le de la boucle et vous n'aurez plus qu'à le créer une seule fois.

for building in buildings:
city = 'London'
addresses.append(building.street_address, city)

# -> refactor
city = 'London'
for building in buildings:
addresses.append(building.street_address, city)

4. Débarrassez-vous des variables en ligne qui ne sont utilisées qu'une seule fois et reviennent immédiatement

Plusieurs fois, vous verrez du code qui définit une variable dans la dernière fonction et une ligne plus tard, elle revient immédiatement. Si vous savez ce que fait la fonction, renvoyez simplement le résultat directement. C'est plus concis et évite les variables inutiles. Cependant, parfois, si ce que fait la fonction n'est pas clair, vous pouvez donner à la dernière variable un nom significatif et l'utiliser comme code auto-documenté.

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

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

5. Remplacez les instructions if par des expressions if

Au lieu de définir la valeur d'une variable avec une instruction if else, vous pouvez la définir sur une seule ligne avec une expression if comme celle-ci. Cependant, cette technique de reconstruction est quelque peu discutable. Certaines personnes préfèrent encore la première option, et c'est très bien.

if condition:
x = 1
else:
x = 2

# -> refactor
x = 1 if condition else 2

6. Ajouter une déclaration d'avertissement

En regardant ce code, il est difficile de comprendre rapidement ce qui se passe. Il existe plusieurs instructions if-else et plusieurs indentations. Une fois que vous regardez attentivement, vous remarquerez peut-être que la première instruction if couvre presque tout le code de la fonction, c'est juste qu'à la fin nous avons la clause else correspondante, et nous renvoyons simplement False.

Nous pouvons déplacer cette clause else au début. C'est ce qu'on appelle également une mise en garde. Donc si la condition n’est pas vraie, nous n’exécuterons pas le reste du code de la fonction. Cela supprime une clause else et il y a désormais un niveau d'indentation en moins dans l'ensemble du code. Cela semble plus clair et plus facile à comprendre.

def should_i_wear_this_hat(self, hat):
if isinstance(hat, Hat):
current_fashion = get_fashion()
weather_outside = self.look_out_of_window()
is_stylish = self.evaluate_style(hat, current_fashion)
if weather_outside.is_raining:
print("Damn.")
return True
else:
print("Great.")
return is_stylish
else:
return False

# -> refactor
def should_i_wear_this_hat(self, hat):
if not isinstance(hat, Hat):
return False

current_fashion = get_fashion()
weather_outside = self.look_out_of_window()
is_stylish = self.evaluate_style(hat, current_fashion)
if weather_outside.is_raining:
print("Damn.")
return True
else:
print("Great.")
return is_stylish

7. Rapprocher l'allocation de l'utilisation

Il s'agit d'un code amélioré par rapport à l'exemple précédent, mais il faut encore un certain temps pour comprendre ce qui se passe ici. Nous voulons donc vérifier si nous devons porter un chapeau. La logique est la suivante : s’il pleut, on dit toujours Vrai, s’il ne pleut pas, et si le chapeau est stylé, on dit Vrai. Un moyen simple d’améliorer considérablement la lisibilité de cette logique consiste à rapprocher l’allocation de son utilisation. Nous devons comprendre les conditions météorologiques avant d'utiliser l'instruction if. Désormais, les variables de mode et de style ne sont nécessaires que dans la clause else, alors déplacez-les vers le bas. Ce qui se passe devrait être plus clair maintenant.

Au point 4 ci-dessus, nous pouvons raccourcir davantage le code et renvoyer immédiatement les résultats du style d'évaluation. Dans ce cas, is_stylish​ est un meilleur nom car il vous indique que si le chapeau est élégant, vous dites Vrai​, sinon vous dites Faux. Alors gardez simplement les variables supplémentaires ici.

def should_i_wear_this_hat(self, hat):
if not isinstance(hat, Hat):
return False

current_fashion = get_fashion()
weather_outside = self.look_out_of_window()
is_stylish = self.evaluate_style(hat, current_fashion)
if weather_outside.is_raining:
print("Damn.")
return True
else:
print("Great.")
return is_stylish

# -> refactor
def should_i_wear_this_hat(self, hat):
if not isinstance(hat, Hat):
return False

weather_outside = self.look_out_of_window()
if weather_outside.is_raining:
print("Damn.")
return True
else:
print("Great.")
current_fashion = get_fashion()
return self.evaluate_style(hat, current_fashion)
# is_stylish = self.evaluate_style(hat, current_fashion)
# return is_stylish

8. Simplifier la vérification des séquences

C'est une autre chose que je vois souvent. Lorsque vous devez vérifier s'il y a un élément dans une collection, par exemple dans une liste, vous n'avez pas besoin d'écrire if len(your_list) > 0​. Vous pouvez simplement dire if your_list. Il s’agit de l’approche recommandée par Pep 8, également connue sous le nom de test de vérité. Ceci est possible car en Python, les séquences et ensembles vides sont évalués à False. Cela peut donc être appliqué aux chaînes, tuples, listes, dictionnaires et ensembles.

if len(list_of_hats) > 0:
hat_to_wear = choose_hat(list_of_hats)

# -> refactor
if list_of_hats:
hat_to_wear = choose_hat(list_of_hats)

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!