A todos nos gusta Python porque facilita la programación y la comprensión. Pero si no tenemos cuidado, ignoraremos las reglas y escribiremos un montón de código basura de una manera no Pythonic, desperdiciando así la elegancia que nos da el excelente lenguaje de Python. El estilo de codificación de Python es muy elegante, claro y simple, la implementación del intérprete de Python import thisse puede ver en la preparación 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!
Aquí encontré la mejor versión china actualmente:
La belleza es mejor que lo feo
Explícito es mejor que implícito
Lo simple es mejor que lo complejo
Complicado es mejor que complicado
Plano es mejor que anidado
Escaso es mejor que abarrotado
La legibilidad es importante
Aunque el código es más importante que la limpieza,
Los casos especiales que creemos a menudo no son tan especiales que las reglas anteriores deben romperse.
No ignore las excepciones sin motivo alguno a menos que guarde silencio a propósito
Si encuentra una lógica ambigua, no haga una suposición inteligente.
Debe proporcionar una, y preferiblemente solo una, una solución transparente.
Por supuesto, esto no se puede hacer de la noche a la mañana, a menos que sea holandés [1]
Por supuesto, es mejor empezar de inmediato que no hacerlo nunca.
Sin embargo, nunca hacerlo es mejor que no pensar con cuidado y hacerlo de manera imprudente.
Si su implementación es difícil de explicar, no debe ser una buena idea
Incluso si su implementación es lo suficientemente simple, podría ser una buena manera
El espacio de nombres Dafa es bueno, si no lo haces, ¡no eres un ser humano!
[1]: El autor de este artículo, Tim peters, explicó que el holandés aquí se refiere a Guido van Rossum, el autor de Python.
Aquí hay 8 formas de escribir mejor código en Python:
1. Olvídate del estilo de lenguaje similar a C
Si necesita imprimir todos los elementos de la lista y sus índices, lo primero que piensa es:
for i in range(len(arr)):
print(i, arr[i])
Entonces todavía estás escribiendo código C. Para deshacerse de esto, tenga en cuenta la palabra clave Python enumerate. Indexa todos los elementos de la lista / cadena y admite la configuración del número inicial del índice :
>>> 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
Ahora se ve mejor y más Pythonic. ¿Qué hay de convertir la lista en una cadena? Si tú escribes:
# The C way
string = ''
for i in arr:
string += i
Es estilo C. Si usa la combinación de palabras clave de Python, no solo es más eficiente, sino también más elegante:
# The Python way
string = ''.join(arr)
Al igual que unirse, Python tiene muchas palabras clave mágicas, así que no funcione para el idioma, use ese idioma para que funcione para usted.
Dos, tenga en cuenta PEP8
No te estoy pidiendo que sigas PEP8 por completo, sino que sigas la mayoría de las reglas. Además, hay muchas herramientas de formateo automático que son suficientes para hacer que tu código sea más hermoso. Nuestro padre de Python también dijo: lee el código con más frecuencia Mucho más alto que la frecuencia de escritura de código, ¡es tan correcto! Por tanto, la legibilidad del código es muy importante.
¿Tiene curiosidad por el código que ha escrito? ¿Por qué escribe esto, por qué está esta oración aquí? Bueno, PEP8 es la respuesta a la mayoría de estas preguntas. Aunque los comentarios de código son una buena forma, el estilo del código también necesita ser ajustado, como las variables i, j, count, etc. Incluso si escribe comentarios cuando aparecen por primera vez, no hay garantía de que los recordará más tarde, lo cual es una pérdida de preciosos hora.
Cualquier programador común puede escribir código que la computadora pueda comprender. Solo los buenos programadores pueden escribir código que los humanos puedan entender.
Se prefiere CamelCase como clase, UPPER_WITH_UNDERSCORES como constante e lower_with_underscores como variable, método y nombre de módulo. Incluso si lo usa, evite usar la función lambda de un solo nombre.
Tres, haz un buen uso de la deducción
Las deducciones comúnmente utilizadas son: deducción por lista, deducción por conjunto y deducción por diccionario. Permítanme hablar sobre la siguiente lista de comprensión.
La comprensión de listas es el formato de sintaxis que se utiliza cuando necesitamos crear una nueva lista basada en una lista existente. La comprensión de listas consta de las siguientes cuatro partes:
1. Una secuencia de entrada (Secuencia de entrada) 2. Una variable que representa un miembro de la secuencia de entrada (Variable) 3. Una expresión de predicado opcional que expresa la condición que satisface la variable (Predicado opcional) 4. Una secuencia de salida, Genere una secuencia de salida basada en 2 y 3 (Expresión de salida)
Por ejemplo, si tiene una lista con números y caracteres, necesita calcular el cuadrado de los números y poner el resultado en una nueva lista. Si no necesita una comprensión de la lista, el código escrito es así:
# 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 usa la lista de comprensión, solo necesita dos líneas de código, lo cual es muy elegante:
a_list = [1, ‘4’, 9, ‘a’, 0, 4]
squared_ints = [ e**2 for e in a_list if type(e) == types.IntType ]
Por supuesto, si le gusta el mapa y el filtro, aún puede hacer esto, lo cual no se recomendó en ese momento debido a la mala legibilidad:
map(lambda e: e**2, filter(lambda e: type(e) == types.IntType, a_list))
Por ejemplo, el uso de comprensiones de conjuntos:
Entrada dada
names = [ 'Bob', 'JOHN', 'alice', 'bob', 'ALICE', 'J', 'Bob' ]
espero conseguir:
{ 'Bob', 'John', 'Alice' }
Entonces la comprensión del conjunto es:
{ name[0].upper() + name[1:].lower() for name in names if len(name) > 1 }
Otro ejemplo es la deducción del diccionario:
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}
Se puede ver desde arriba. El código de estilo deductivo es elegante y legible por humanos.
4. ¿Sigues cerrando el archivo explícitamente?
Si todavía está cerrando explícitamente el archivo mientras escribe el código, como el programador en la imagen de arriba, está trabajando para un lenguaje de programación, si aprende a usar el administrador de contexto, entonces es un programador de Python, deje que el lenguaje de programación sea Tu trabajas:
with open('filename.txt', 'w') as filename:
filename.write('Hello')
Cuando el programa sale del bloque with, el archivo se cierra automáticamente. El formato de sintaxis de la declaración with:
with VAR as EXPR:
BLOCK
Es equivalente a:
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)
Hay muchas conexiones de red y bibliotecas de conexiones de bases de datos que proporcionan la función. Incluso después de estar familiarizado con el mecanismo de implementación de with, puede implementar la función with usted mismo:
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()
Siempre que se defina el método __enter__, __exit__se puede utilizar la instrucción with:
with File('demo.txt', 'w') as opened_file:
opened_file.write('Hola!')
Cinco, usa iteradores y generadores
Iterador: iterador Generador: generador
Tanto los iteradores como los generadores son herramientas poderosas en Python que merecen ser dominadas. Un iterador es un concepto más general: cualquier objeto es un iterador siempre que la clase a la que pertenece tenga un __next__método (siguiente en Python 2) y un __iter__método que devuelva self .
Cada generador es un iterador, pero no al revés. El generador se construye llamando a una función con una o más expresiones de rendimiento, y la función es un objeto que satisface la definición de iterador en el párrafo anterior.
Diferencia de uso:
Muchos blogueros técnicos en Internet dicen que los generadores son versiones perezosas de los iteradores, que ahorran más memoria que los iteradores. En realidad es incorrecto. Todos ahorran memoria (daré un ejemplo).
La diferencia real entre ellos es: cuando necesita una clase con algún comportamiento de mantenimiento de estado complejo, o desea exponer métodos distintos de __next__(y __iter__y __init__), necesita un iterador personalizado, no un generador.
Por lo general, un generador (a veces, para requisitos bastante simples, una expresión de generador) es suficiente y es más fácil escribir código.
Por ejemplo, para calcular el cuadrado directo de un entero positivo de a a b (b es mucho mayor que a), el generador sería:
def squares(start, stop):
for i in range(start, stop):
yield i * i
generator = squares(a, b)
o:
generator = (i*i for i in range(a, b))
Si es un iterador, es así:
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)
Se puede ver que los iteradores son un poco difíciles de escribir y cuando son más flexibles, por ejemplo, cuando desea proporcionar un método actual, puede agregarlo directamente a la clase Squares:
def current(self):
return self.start
De lo anterior se puede ver que el iterador no guarda todos los valores entre ayb, y todos ellos no consumen demasiada memoria. También puede probar esto usted mismo. El código es el siguiente:
>>> 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'>
Se puede ver que b es iterador yc es generador, y ocupan el mismo tamaño de memoria.
Seis, haz un buen uso de las herramientas de iteración
El módulo itertools estandariza un conjunto de herramientas básicas para un uso rápido y eficiente de la memoria Estas herramientas son útiles por sí mismas o en combinación. Juntos forman un "álgebra de iteradores", que hace posible crear herramientas especiales concisas y eficientes en Python puro. Por ejemplo, si desea todas las combinaciones de caracteres en una cadena o todas las combinaciones de números en una lista, solo necesita escribir
from itertools import combinations
names = 'ABC'
for combination in combinations(names, 2):
print(combination)
''' Output -
('A', 'B')
('A', 'C')
('B', 'C')
'''
Esta es una biblioteca estándar que vale la pena usar con frecuencia. Para funciones más detalladas, consulte la documentación oficial: https://docs.python.org/zh-cn/3/library/itertools.html [1]
Siete, haz un buen uso de las colecciones
Esta es otra colección de bibliotecas estándar que vale la pena usar. Proporciona múltiples contenedores que reemplazan los tipos de datos integrados, como defaultdict, OrderedDict, namedtuple, Counter, deque, etc., que son muy útiles y mucho más seguros y estables que su propia implementación. como:
# 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)
'''
No hay mucho que decir, consulte el documento oficial: https://docs.python.org/3/library/collections.html [2]
8. No abuses de las clases
No abuses de las clases. Los programadores que insisten en usar Java y C ++ a menudo usan clases, pero cuando usan Python, pueden reutilizar el código con la ayuda de funciones y módulos. A menos que sea absolutamente necesario, no es necesario crear una clase.
Este artículo describe 8 métodos para que escribas mejor código Python, espero que te ayude.
Lectura recomendada:
10 consejos para hacer tu código más elegante
6 códigos de Python que vale la pena jugar
Referencia
[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