Nous aimons tous Python car il facilite la programmation et la compréhension. Mais si nous ne faisons pas attention, nous ignorerons les règles et écrirons un tas de code poubelle d'une manière non pythonique, gaspillant ainsi l'élégance que l'excellent langage de Python nous donne. Le style de codage Python est très élégant, clair et simple, l'implémentation de l'interpréteur Python import thisvous permet de voir la préparation de Tim Peters Python Zen:
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
Ici, j'ai trouvé la meilleure version chinoise actuellement:
La beauté vaut mieux que la laideur
Explicite vaut mieux qu'implicite
Le simple vaut mieux que le complexe
Compliqué vaut mieux que compliqué
Plat vaut mieux que niché
Clairsemé vaut mieux que bondé
La lisibilité est importante
Bien que le code soit plus important que la propreté,
Les cas particuliers que nous pensons ne sont souvent pas si particuliers que les règles ci-dessus doivent être enfreintes
N'ignorez pas les exceptions sans raison, sauf si vous vous taisez volontairement
Si vous rencontrez une logique ambiguë, ne faites pas de suppositions intelligentes.
Il doit fournir une, et de préférence une seule, une solution claire
Bien sûr, cela ne peut pas être fait du jour au lendemain, sauf si vous êtes néerlandais [1]
Bien sûr, il vaut mieux commencer immédiatement que de ne jamais le faire.
Cependant, il vaut mieux ne jamais le faire que de ne pas réfléchir attentivement et de le faire de manière imprudente.
Si votre implémentation est difficile à expliquer, cela ne doit pas être une bonne idée
Même si votre implémentation est assez simple, cela peut être un bon moyen
L'espace de noms Dafa est bon, si vous ne le faites pas, vous n'êtes pas un être humain!
[1]: L'auteur de cet article, Tim peters, a expliqué que le néerlandais se réfère ici à Guido van Rossum, l'auteur de Python.
Voici 8 façons d'écrire un meilleur code en Python:
1. Oubliez le style de langage de type C
Si vous avez besoin d'imprimer tous les éléments de la liste et leurs index, la première chose à laquelle vous pensez est:
for i in range(len(arr)):
print(i, arr[i])
Ensuite, vous écrivez toujours du code C. Pour vous en débarrasser, gardez à l'esprit l'énumération des mots clés Python. Il indexe tous les éléments de la liste / chaîne et prend en charge la définition du numéro de départ de l'index :
>>> for index, item in enumerate(['a','b','c']):
... print(index, item)
...
0 a
1 b
2 c
>>> for index, item in enumerate(['a','b','c'],1): #这里第二个参数可以设置起始编号
... print(index,item)
...
1 a
2 b
3 c
Maintenant, il est meilleur et plus pythonique. Qu'en est-il de la conversion de la liste en une chaîne? Si vous écrivez:
# The C way
string = ''
for i in arr:
string += i
C'est le style C. Si vous utilisez la jointure par mot-clé Python, elle est non seulement plus efficace, mais aussi plus élégante:
# The Python way
string = ''.join(arr)
Tout comme join, Python a de nombreux mots-clés magiques, alors ne travaillez pas pour le langage, mais utilisez ce langage pour travailler pour vous.
Deux, gardez à l'esprit PEP8
Je ne vous demande pas de suivre complètement PEP8, mais de suivre la plupart des règles. De plus, il existe de nombreux outils de formatage automatique qui suffisent pour rendre votre code plus beau. Notre père de Python a également dit: lisez le code plus fréquemment Bien supérieur à la fréquence d'écriture du code, il est tellement correct! Par conséquent, la lisibilité du code est très importante.
Êtes-vous curieux de connaître le code que vous avez écrit? Pourquoi écrivez-vous ceci, pourquoi cette phrase est-elle ici? Eh bien, PEP8 est la réponse à la plupart de ces questions. Bien que les commentaires de code soient un bon moyen, le style du code doit également être ajusté, comme les variables i, j, count, etc. Même si vous écrivez des commentaires lorsqu'ils apparaissent pour la première fois, il n'y a aucune garantie que vous vous en souviendrez plus tard, ce qui est un gaspillage de précieux temps.
Tout programmeur ordinaire peut écrire du code que l'ordinateur peut comprendre. Seuls les bons programmeurs peuvent écrire du code que les humains peuvent comprendre.
CamelCase est préféré comme classe, UPPER_WITH_UNDERSCORES comme constante et lower_with_underscores comme variable, méthode et nom de module. Même si vous l'utilisez, évitez d'utiliser la fonction lambda à nom unique.
Troisièmement, faites bon usage de la déduction
Les déductions couramment utilisées sont: la déduction de liste, la déduction d'ensemble, la déduction par dictionnaire. Permettez-moi de parler de la compréhension de la liste suivante.
La compréhension de liste est le format de syntaxe utilisé lorsque nous devons créer une nouvelle liste basée sur une liste existante. La compréhension de liste comprend les quatre parties suivantes:
1. Une séquence d'entrée (Input Sequence) 2. Une variable représentant un membre de la séquence d'entrée (Variable) 3. Une expression de prédicat optionnelle qui exprime la condition que cette variable satisfait (Optional Predicate) 4. Une séquence de sortie, Générer une séquence de sortie basée sur 2 et 3 (Expression de sortie)
Par exemple, si vous avez une liste avec des nombres et des caractères, vous devez maintenant calculer le carré des nombres et placer le résultat dans la nouvelle liste. Si vous n'utilisez pas la compréhension de liste, le code écrit est comme ceci:
# bad code
a_list = [1, ‘4’, 9, ‘a’, 0, 4]
squared_ints = []
for item in a_list:
if type(item) == types.IntType:
squared_ints.append(item**2)
Si vous utilisez la compréhension de liste, vous n'avez besoin que de deux lignes de code, ce qui est très élégant:
a_list = [1, ‘4’, 9, ‘a’, 0, 4]
squared_ints = [ e**2 for e in a_list if type(e) == types.IntType ]
Bien sûr, si vous aimez la carte et le filtre, vous pouvez toujours le faire, ce qui n'était pas recommandé à l'époque en raison d'une mauvaise lisibilité:
map(lambda e: e**2, filter(lambda e: type(e) == types.IntType, a_list))
Par exemple, l'utilisation des compréhensions d'ensemble:
Compte tenu de l'entrée
names = [ 'Bob', 'JOHN', 'alice', 'bob', 'ALICE', 'J', 'Bob' ]
espère obtenir:
{ 'Bob', 'John', 'Alice' }
Alors la compréhension d'ensemble est:
{ name[0].upper() + name[1:].lower() for name in names if len(name) > 1 }
Un autre exemple est la déduction du dictionnaire:
mcase = {'a':10, 'b': 34, 'A': 7, 'Z':3}
mcase_frequency = { k.lower() : mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys() }
# mcase_frequency == {'a': 17, 'z': 3, 'b': 34}
Cela peut être vu de ce qui précède. Le code de style déductif est élégant et lisible par l'homme.
4. Fermez-vous toujours le fichier explicitement?
Si vous fermez toujours explicitement le fichier lors de l'écriture du code, comme le programmeur dans l'image ci-dessus, vous travaillez pour un langage de programmation, si vous apprenez à utiliser le gestionnaire de contexte avec, alors vous êtes un programmeur Python, laissez le langage de programmation être Tu travailles:
with open('filename.txt', 'w') as filename:
filename.write('Hello')
Lorsque le programme quitte le bloc with, le fichier est automatiquement fermé. Le format de syntaxe de l'instruction with:
with VAR as EXPR:
BLOCK
Est équivalent à:
mgr = (EXPR)
exit = type(mgr).__exit__ # Not calling it yet
value = type(mgr).__enter__(mgr)
exc = True
try:
try:
VAR = value # Only if "as VAR" is present
BLOCK
except:
# The exceptional case is handled here
exc = False
if not exit(mgr, *sys.exc_info()):
raise
# The exception is swallowed if exit() returns true
finally:
# The normal and non-local-goto cases are handled here
if exc:
exit(mgr, None, None, None)
Il existe de nombreuses connexions réseau et bibliothèques de connexions à la base de données qui fournissent la fonction with. Même après vous être familiarisé avec le mécanisme de mise en œuvre de avec, vous pouvez implémenter vous-même la fonction with:
class File(object):
def __init__(self, file_name, method):
self.file_obj = open(file_name, method)
def __enter__(self):
return self.file_obj
def __exit__(self, type, value, traceback):
self.file_obj.close()
Tant que la méthode est définie __enter__, l' __exit__instruction with peut être utilisée:
with File('demo.txt', 'w') as opened_file:
opened_file.write('Hola!')
Cinq, utilisez des itérateurs et des générateurs
Iterator: iterator Generator: Generator
Les itérateurs et les générateurs sont des outils puissants en Python qui méritent d'être maîtrisés. Un itérateur est un concept plus général: tout objet est un itérateur tant que la classe à laquelle il appartient a une __next__méthode (ensuite en Python 2) et une __iter__méthode qui retourne self .
Chaque générateur est un itérateur, mais pas l'inverse. Le générateur est construit en appelant une fonction avec une ou plusieurs expressions de rendement, et la fonction est un objet qui satisfait la définition d'itérateur dans le paragraphe précédent.
Utilisez la différence:
De nombreux blogueurs techniques sur Internet disent que les générateurs sont des versions paresseuses d'itérateurs, qui économisent plus de mémoire que les itérateurs. C'est en fait faux. Ils économisent tous de la mémoire (je vais donner un exemple).
La vraie différence entre eux est: lorsque vous avez besoin d'une classe avec un comportement de maintenance d'état complexe, ou que vous souhaitez exposer des méthodes autres que __next__(et __iter__et __init__), vous avez besoin d'un itérateur personnalisé, pas d'un générateur.
Habituellement, un générateur (parfois, pour des exigences assez simples, une expression de générateur) est suffisant, et il est plus facile d'écrire du code.
Par exemple, pour calculer le carré direct d'un entier positif de a à b (b est beaucoup plus grand que a), le générateur serait:
def squares(start, stop):
for i in range(start, stop):
yield i * i
generator = squares(a, b)
ou:
generator = (i*i for i in range(a, b))
Si c'est un itérateur, c'est comme ça:
class Squares(object):
def __init__(self, start, stop):
self.start = start
self.stop = stop
def __iter__(self): return self
def __next__(self): # next in Python 2
if self.start >= self.stop:
raise StopIteration
current = self.start * self.start
self.start += 1
return current
iterator = Squares(a, b)
On constate que les itérateurs sont un peu gênants à écrire, et lorsqu'ils sont plus flexibles, par exemple, lorsque vous souhaitez fournir une méthode courante, vous pouvez l'ajouter directement à la classe Squares:
def current(self):
return self.start
On peut voir d'après ce qui précède que l'itérateur n'enregistre pas toutes les valeurs entre a et b, et que toutes ne consomment pas trop de mémoire. Cela peut également être testé par vous-même. Le code est le suivant:
>>> from collections.abc import Iterator
>>> from sys import getsizeof
>>> a = [i for i in range(1001)]
>>> print(type(a))
<class 'list'>
>>> print(getsizeof(a))
9016
>>>
>>> b = iter(a)
>>> print(type(b))
<class 'list_iterator'>
>>> print(isinstance(b,Iterator))
True
>>> print(getsizeof(b))
48
>>> c = (i for i in range(1001))
>>> print(getsizeof(b))
48
>>> type(c)
<class 'generator'>
>>> type(b)
<class 'list_iterator'>
On peut voir que b est un itérateur et c est un générateur, et ils occupent la même taille de mémoire.
Six, faites bon usage d'itertools
Le module itertools standardise un ensemble d'outils de base pour une utilisation rapide et efficace de la mémoire Ces outils sont utiles seuls ou en combinaison. Ensemble, ils forment une «algèbre itératrice», qui permet de créer des outils spéciaux concis et efficaces en pur Python. Par exemple, si vous voulez toutes les combinaisons de caractères dans une chaîne ou toutes les combinaisons de nombres dans une liste, il vous suffit d'écrire
from itertools import combinations
names = 'ABC'
for combination in combinations(names, 2):
print(combination)
''' Output -
('A', 'B')
('A', 'C')
('B', 'C')
'''
Il s'agit d'une bibliothèque standard qui vaut la peine d'être utilisée fréquemment. Pour des fonctions plus détaillées, veuillez consulter la documentation officielle: https://docs.python.org/zh-cn/3/library/itertools.html [1]
Sept, faites bon usage des collections
Il s'agit d'une autre collection de bibliothèques standard qui vaut la peine d'être utilisée. Elle fournit plusieurs conteneurs qui remplacent les types de données intégrés, tels que defaultdict, OrderedDict, namedtuple, Counter, deque, etc., qui sont très utiles et beaucoup plus sûrs et stables que leur propre implémentation. tel que:
# frequency of all characters in a string in sorted order
from collections import (OrderedDict, Counter)
string = 'abcbcaaba'
freq = Counter(string)
freq_sorted = OrderedDict(freq.most_common())
for key, val in freq_sorted.items():
print(key, val)
''' Output -
('a', 4)
('b', 3)
('c', 2)
'''
Pas grand chose à dire, voir le document officiel: https://docs.python.org/3/library/collections.html [2]
8. N'abusez pas des cours
N'abusez pas des cours. Les programmeurs qui insistent pour utiliser Java et C ++ utiliseront souvent des classes, mais lorsqu'ils utilisent Python, ils peuvent réutiliser du code à l'aide de fonctions et de modules. À moins que cela ne soit absolument nécessaire, il n'est pas nécessaire de créer une classe.
Cet article décrit 8 méthodes pour vous permettre d'écrire un meilleur code Python, j'espère que cela vous aidera.
Lecture recommandée:
10 conseils pour rendre votre code plus élégant
Référence
[1]
https://docs.python.org/zh-cn/3/library/itertools.html: https://docs.python.org/zh-cn/3/library/itertools.html
[2]https://docs.python.org/3/library/collections.html: https://docs.python.org/3/library/collections.html