L’écriture de code est difficile et les programmeurs Python sont souvent confrontés à une courbe d’apprentissage abrupte. L’un des problèmes les plus courants qui peuvent vous empêcher d’écrire du code lisible est les mauvaises pratiques d’organisation de votre code. Dans cet article, nous discuterons de quelques moyens de vous aider à éviter ces erreurs et à vous améliorer dans l’écriture de code Python.
La meilleure chose à faire pour écrire un meilleur code Python est de rendre votre code lisible. Écrire un code compréhensible est essentiel pour diverses raisons.
- Cela vous permet de comprendre plus facilement votre code, ce qui le rend simple à utiliser pour les autres
- Si des modifications doivent être apportées à la même section de code à l’avenir, cela simplifie les choses pour les autres développeurs et même pour vous (par exemple, si une partie d’une classe doit être modifiée)
10 trucs et astuces pour écrire le meilleur code Python
1. Utiliser Context Manager pour automatiser la fermeture des ressources
Lorsqu’un contexte est fermé dans Python, les gestionnaires de contexte peuvent automatiquement fermer des ressources telles que des fichiers, des connexions réseau et des bases de données. Ce faisant, les fuites de ressources peuvent être évitées et l’utilisation de la mémoire peut être augmentée.
L’ instruction ‘ with ‘ , qui définit un contexte pour gérer la ressource, simplifie l’utilisation d’un gestionnaire de contexte. Même si une exception est déclenchée, le gestionnaire de contexte ferme toujours la ressource lorsque la fonction du contexte a fini de s’exécuter. Cela peut rendre votre code plus efficace et moins sujet aux erreurs en garantissant que la ressource est toujours fermée correctement.
Voici un exemple simple de la façon de lire un fichier et de s’assurer qu’il est correctement fermé à l’aide d’un gestionnaire de contexte :
- Python3
with open('example.txt', 'r') as f: contents =f.read() print(contents) |
Dans cet exemple, nous allons ouvrir le fichier “example.txt” en mode lecture à l’aide de la fonction open, puis l’affecter à la variable “f”. L’instruction ‘with’ est ensuite utilisée pour fournir le contexte ‘ ‘f’ . Nous utilisons f.read() pour lire le contenu du fichier et l’imprimer à l’intérieur du bloc ‘with’ .
Python invoque automatiquement la méthode __exit__ du gestionnaire de contexte , qui dans ce cas est la méthode close() de l’objet fichier f, lorsqu’un bloc est quitté. En procédant ainsi, même si une exception survient pendant la lecture du fichier, le fichier sera fermé de manière appropriée.
2. Écrire des instructions conditionnelles plus propres
Bien qu’elles puissent être difficiles à écrire correctement, les instructions conditionnelles sont une excellente approche pour rendre votre code plus lisible. Les instructions if/elif/else sont fréquemment utilisées en Python, mais elles sont souvent surutilisées et difficiles à lire. Vous pouvez occasionnellement découvrir que vous créez plus de code que nécessaire lorsque vous utilisez des expressions if/else . Les opérateurs ternaires de Python vous permettent de créer des instructions conditionnelles plus courtes et plus simples à lire.
- Python3
age =25 ifage >=18: can_vote ="Yes"else: can_vote ="No" print(f"Can vote: {can_vote}") |
Sortir
Peut voter : Oui
Cependant, nous pouvons simplifier ce bloc de code :
- Python3
age =25can_vote ="Yes"ifage >=18else"No"print(f"Can vote: {can_vote}") |
Sortir
Peut voter : Oui
Dans cette version du bloc de code, nous utilisons un opérateur ternaire pour définir la valeur de can_vote en fonction de la valeur de age . Si l’ âge est supérieur ou égal à 18 ans , can_vote est défini sur “Oui” ; sinon, il est réglé sur “Non”. Ce code est plus concis et plus facile à lire que l’exemple précédent.
3. Simplifier les définitions de fonctions avec des décorateurs
Sans changer le code source de la fonction, les décorateurs vous permettent d’ajouter des fonctionnalités à une fonction existante. En d’autres termes, un décorateur est une fonction qui accepte une autre fonction comme argument et renvoie une nouvelle fonction avec la capacité ajoutée.
Voici un exemple de définition d’un décorateur en Python :
- Python3
defmy_decorator(func): defwrapper(): print("Errors before Editing.") func() print("Accuracy after Editing.") returnwrapper @my_decoratordefmy_function(): print("Hello, world!") my_function() |
Sortir
Erreurs avant l'édition. Bonjour le monde! Précision après montage.
Ainsi, en utilisant un décorateur, vous pouvez ajouter des fonctionnalités communes qui sont utilisées dans plusieurs fonctions sans répéter le même code dans chaque fonction, ce qui simplifie la création de ces fonctions.
4. Garder une trace des éléments avec la fonction d’énumération
Les éléments d’une liste peuvent être difficiles à retenir. Cela peut être fait en utilisant la fonction Énumérer , qui vous permet de parcourir les éléments d’une liste tout en gardant une trace de son index.
Disons que nous avons la liste de fruits suivante :
- Python3
fruits =['apple', 'banana', 'orange', 'grape'] forindex, fruit inenumerate(fruits): print(index, fruit) |
Sortir
0 pomme 1 banane 2 oranges 3 raisin
5. Utilisez des variables pour éviter la duplication de code
Pour éviter la duplication de code, vous pouvez utiliser des variables pour stocker des valeurs. Au lieu d’avoir deux fonctions qui font exactement la même chose et qui ont un code identique, vous pouvez créer une variable dans la première fonction et l’utiliser dans une seconde fonction en y accédant par son nom.
6. Boucler sur plusieurs listes avec la fonction Zip
La fonction zip est utile pour combiner deux listes en une seule et est facile à utiliser. Si vous avez deux listes d’éléments (par exemple, des villes en France), vous pouvez créer une troisième liste en combinant les deux premières :
Voici un exemple d’utilisation de la fonction zip pour combiner deux listes :
- Python3
list1 =[1, 2, 3]list2 =['a', 'b', 'c']combined_list =list(zip(list1, list2))print(combined_list) |
Sortir
[(1, 'a'), (2, 'b'), (3, 'c')]
7. Utilisez des noms de variables significatifs
Donnez du contexte à vos noms de variables. Évitez d’utiliser des acronymes ou des abréviations. Par exemple, “la première valeur” et “la deuxième valeur”, respectivement, sont des noms plus descriptifs pour les variables que “x” ou “x2” .
Évitez d’utiliser le même nom de variable dans des variables distinctes dans différentes fonctions ou modules ; par exemple, ce n’est probablement pas une bonne idée de créer une seconde fonction avec le nom « seconde valeur » si la première fonction renvoie deux valeurs. Il y a fort à parier que quelqu’un oubliera bientôt que cette seconde valeur existe !
8. Masquer les entrées utilisateur sensibles avec GetPass
Il est crucial de prendre des précautions de sécurité lors de l’écriture de programmes qui demandent aux utilisateurs de saisir des données sensibles, y compris des mots de passe. Le module Python getpass peut être utilisé comme une méthode pour y parvenir. Le module getpass offre une méthode pour masquer l’entrée de l’utilisateur lorsqu’il entre son mot de passe ou d’autres données sensibles. Ceci est important car cela empêche les autres de voir la frappe de l’utilisateur.
Importez simplement le module de fonction getpass pour commencer à l’utiliser. Cela demandera à l’utilisateur une entrée mais ne l’affichera pas à l’écran.
Par exemple:
- Python3
importgetpass password =getpass.getpass("Enter your password: ")print("Your password is:", password) |
Le paramètre prompt facultatif de la fonction getpass () peut afficher un message à l’utilisateur avant qu’il n’entre sa saisie. L’entrée de l’utilisateur ne sera pas visible à l’écran pendant qu’il l’écrit.
Il est important de noter que le module getpass n’offre aucune protection de sécurité supplémentaire comme le hachage ou le cryptage. Il ne masque que les entrées de l’utilisateur lors de la saisie. Utilisez des mesures de sécurité supplémentaires pour protéger les informations sensibles si vous devez les conserver ou les transférer.
9. Utilisation de la fonction d’aide pour en savoir plus sur un module
Une liste de toutes les fonctions d’un module Python peut être obtenue à l’aide de la fonction d’aide. Par exemple, si vous voulez en savoir plus sur la fonction range :
- Python3
help(range) |
Sortir
...valeur. | | __len__(soi, /) | Retour len(soi). | | __lt__(soi, valeur, /) | Retourne soi<valeur. | | __ne__(self, value, /) | Renvoie self!=valeur. | | __réduire__(...) | Aide pour le cornichon. | | __repr__(soi, /) | Retour repr(soi). | | __renversé__(...) | Renvoie un itérateur inverse. | | compter(...) | rangeobject.count(value) -> integer -- renvoie le nombre d'occurrences de value | | indice(...) | rangeobject.index(value) -> integer -- renvoie l'index de la valeur. | Augmente ValueError si la valeur n'est pas présente. | | ---------------------------------------------------------------------- | Méthodes statiques définies ici : | | __new__(*args, **kwargs) de builtins.type | Crée et renvoie un nouvel objet. Voir l'aide (type) pour une signature précise. | | ---------------------------------------------------------------------- | Descripteurs de données définis ici : | | commencer | | marcher | | arrêt
Les paramètres de la fonction de plage, la valeur de retour et d’autres détails pertinents seront affichés. En donnant le nom du module en argument, la fonction d’aide peut également être utilisée pour obtenir des détails concernant un module ou un package particulier :
- Python3
importmathhelp(math) |
Sortir
...s en radians.
reste(x, y, /)
Différence entre x et le multiple entier le plus proche de y.
Renvoie x - n*y où n*y est le multiple entier le plus proche de y.
Dans le cas où x est exactement à mi-chemin entre deux multiples de
y, la valeur paire la plus proche de n est utilisée. Le résultat est toujours exact.
péché(x, /)
Renvoie le sinus de x (mesuré en radians).
naissance(x, /)
Renvoie le sinus hyperbolique de x.
carré(x, /)
Renvoie la racine carrée de x.
bronzer(x, /)
Renvoie la tangente de x (mesurée en radians).
tanh(x, /)
Renvoie la tangente hyperbolique de x.
tronc(x, /)
Tronque le x réel à l'intégrale la plus proche vers 0.
Utilise la méthode magique __trunc__.
DONNÉES
e = 2,718281828459045
inf = inf
dans = dans
pi = 3,141592653589793
obtenir = 6.283185307179586
DÉPOSER
/usr/local/lib/python3.7/lib-dynload/math.cpython-37m-x86_64-linux-gnu.so
Cela affichera des détails sur le module mathématique, y compris ses fonctions et constantes disponibles.
10. Ne vous répétez pas (DRY)
DRY est un principe de programmation pour « Ne vous répétez pas ». C’est une façon d’écrire du code qui évite les répétitions et garde votre code propre, lisible et facile à comprendre.
Par exemple : si vous avez une fonction qui prend deux paramètres, au lieu d’écrire deux fois la même fonction avec des noms différents (par exemple, my_func() et my_func2()), il serait préférable d’écrire une fonction dont le nom est les deux (par exemple, my_func) — alors vous pouvez appeler cette version de n’importe où dans votre code sans avoir à spécifier quelle version vous voulez à chaque fois !
L’écriture de code réutilisable est importante car elle réduit le nombre de lignes de code et facilite la compréhension de ce que fait chaque élément, même si vous ne comprenez pas encore l’image complète. Certains programmeurs appellent ces “petits modules”, mais c’est plus communément appelé ” modules “.