Post Top Ad

Your Ad Spot

martes, 18 de agosto de 2020

Mejores prácticas de Python

¿Qué es la "mejor práctica" de cualquier lenguaje de programación?

La programación es un arte tanto como ciencia y lógica. Por lo tanto, aunque el estilo o la técnica de programación pueden variar de un desarrollador a otro, existen algunas reglas básicas que generalmente se siguen en toda la industria. Estas reglas se establecen con el fin de hacer que la experiencia de programación sea más uniforme entre las diferentes variedades de desarrolladores. Por supuesto, la lógica desarrollada por un desarrollador para lograr una determinada tarea puede no coincidir con la lógica desarrollada por otro para la misma tarea. Pero, el "formato" de escritura de código debería ser similar, al igual que el formato general de escritura de un correo electrónico comercial es fijo.
La “mejor práctica” de cualquier lenguaje de programación se refiere a la forma recomendada de escribir un programa, de manera que sea uniforme en todo el mundo y cualquier desarrollador que no sea el autor original puede comprender y modificar fácilmente el programa.

¿Por qué es necesario seguir las "mejores prácticas"?

En la industria, más de una persona está involucrada en el desarrollo de un determinado proyecto para una determinada empresa. En tal caso, es de suma importancia que cada miembro del equipo actual o cualquier empleado futuro que trabaje en el mismo proyecto sea capaz de comprender el flujo del programa y lo que ha hecho el desarrollador anterior.
Dado que el desarrollo es un proceso dinámico, incluso si se completa un proyecto, por el momento, es posible que se asigne a algún otro desarrollador para realizar actualizaciones o agregar funciones al mismo proyecto en una fecha posterior. Luego, esa persona tiene que leer y comprender el código escrito por el autor anterior para poder modificarlo. Por lo tanto, para que a los desarrolladores les resulte más fácil y eficiente leer y comprender el programa escrito por otros desarrolladores, es necesario seguir un cierto conjunto de “Mejores prácticas” recomendadas.

Mejores prácticas para Python

mejores prácticas para Python

Hay muchas mejores prácticas que se siguen en toda la industria. Cubrirlos todos está más allá del alcance de este artículo. Sin embargo, a continuación se enumeran algunas de las prácticas más comunes a las que debe adherirse cualquier desarrollador principiante.

 1. Seguir una convención de nomenclatura adecuada

Cuando un desarrollador ve un fragmento de código, debería poder comprender instantáneamente qué nombre se refiere a qué tipo de datos. Por tanto, una convención de nomenclatura adecuada es importante para permitir que el programador determine fácilmente cuál es el propósito de una instancia / variable definida por el usuario en particular.

Reglas para una convención de nomenclatura adecuadaReglas para una convención de nomenclatura adecuada

  • General: los nombres no deben ser genéricos y deben tener un significado relevante. Deben ser breves pero descriptivos. Ejemplo:
    • Nombres incorrectos : my_variable, x, list_for_storing_word_counts
    • Buenos nombres: row_dict, product_id, word_counts
  • Variable de instancia: en Python, las variables se nombran en minúsculas con un guión bajo (_) que separa cada palabra; Similar a los ejemplos mostrados arriba. Si la variable no es pública, el nombre de la variable debe comenzar con un guión bajo, por ejemplo: _private_variable .
  • Constantes: las constantes no se usan comúnmente, sin embargo, se supone que deben nombrarse en mayúsculas y separadas por un guión bajo. Ejemplo: PRODUCT_ID
  • Función: similar a las variables, los nombres de las funciones también deben estar en minúsculas separados por un guión bajo.
  • Métodos: en Python, los métodos son funciones que pertenecen a una clase. Su esquema de nomenclatura es el mismo que el de las funciones normales, con la excepción de los métodos privados, que comienzan con un guión bajo, similar a las variables de instancia.
  • Clases: dado que Python es un lenguaje de programación orientado a objetos, las clases se utilizan con mucha frecuencia. Se nombran en mayúsculas con carcasa de camello. Ejemplo: NeuralNetworkClass
  • Paquetes: estos son módulos que se importan a un programa para agregar funcionalidad. Deben nombrarse en minúsculas con un guión bajo que los separe. Preferiblemente son de una sola palabra.

2. Guía de estilo PEP 8

Los desarrolladores de Python Community descubrieron que, incluso al seguir algunas de las “Mejores prácticas de programación” en general, el tipo de código Python que muchos desarrolladores escribieron variaba enormemente. Esto creó inconvenientes para la comunidad y para cualquiera que intentara leer y / o modificar el código existente.
Por lo tanto, la comunidad ideó un conjunto de pautas, que diseñarían un flujo de diseño particular al que los desarrolladores pueden adherirse para mantener el código lo más uniforme posible. Este conjunto de pautas, diseñado específicamente para Python, se ha mencionado en PEP 8 de la documentación oficial de Python.
Es una lista extensa de reglas y pros y contras, la mayoría de las cuales están fuera del alcance de este artículo. Aquí, hemos enumerado algunas de las convenciones de estilo PEP 8 comúnmente utilizadas .

Reglas PEP 8

  • Sangría:  Tradicionalmente, la sangría se usaba para mejorar la legibilidad del código. Pero Python es un lenguaje donde la sangría se usa para diferenciar entre varios bloques de código y, por lo tanto, la sangría es más una necesidad que un lujo. El problema surge cuando diferentes desarrolladores utilizan un número diferente de espacios o pestañas para una sangría. Por lo tanto, PEP 8 define específicamente que una sangría es igual a cuatro espacios y no recomienda el uso de tabulaciones en absoluto. Además, una combinación de pestañas y espacios en cualquier secuencia de comandos de Python arroja un error de sintaxis.
    Además, PEP 8 también menciona cómo escribir código para funciones largas de varias líneas. Algunos ejemplos se muestran a continuación:
Hacer:
# Alineado con el delimitador de apertura.
foo = nombre_función_larga (var_one, var_two,
                        var_three, var_four)

# Agregue 4 espacios (un nivel adicional de sangría) para distinguir los argumentos del resto.
def  nombre_función_larga (
       var_one, var_two, var_three,
       var_four):
   imprimir (var_one)

# Las sangrías colgantes deben agregar un nivel.
foo = nombre_función_larga (
   var_one, var_two,
   var_three, var_four)
No:
# Se prohíben los argumentos en la primera línea cuando no se utiliza la alineación vertical.
foo = nombre_función_larga (var_one, var_two,
   var_three, var_four)

# Se requiere más sangría, ya que la sangría no es distinguible.
def  nombre_función_larga (
   var_one, var_two, var_three,
   var_four): 
   imprimir (var_one)
  • Longitud máxima de línea:  PEP 8 limita la longitud máxima de línea a un número fijo de caracteres. Esto se hace para aumentar la legibilidad del código y evitar que el programa salga de la página, lo que causa molestias al lector.
    Para el código de programa normal, se recomienda no superar los 79 caracteres por línea.
    Para cadenas de documentos y comentarios, se recomienda mantener el recuento de caracteres dentro de 72 por línea.
    Para las líneas que superan el límite dado, se pueden escribir en más de una línea. Como se muestra en los ejemplos de "Sangría" anteriores.
  • Importar:  PEP 8 menciona el método de importar módulos. Aunque se puede importar más de un módulo en una sola línea usando una coma (,) en medio. Sin embargo, no se recomienda. PEP 8 sugiere importar un módulo por línea, como se muestra en el siguiente ejemplo.
Hacer:
importar numpy
 importar pandas
 importar matplotlib
No:
importar numpy, pandas, matplotlib

La documentación original de PEP 8

Las pocas pautas mencionadas anteriormente apenas comienzan a arañar la superficie de todas las listas de pautas de PEP 8 . Nuevamente, debe recordarse que seguir las pautas de PEP 8 no es obligatorio, pero es necesario.

3. Escribir código modular y no repetitivo

Analicemos las prácticas de codificación modular y no repetitiva. El código modular significa escribir código en un formato breve y comprensible. Esto mejora la legibilidad del código y reduce la repetición de código. Ambos se pueden lograr con bastante facilidad mediante el uso frecuente y adecuado de Clases y Funciones.
Ya hemos visto el uso de clases en las prácticas de programación orientada a objetos. A continuación se muestra un ejemplo del uso de funciones.
Ejemplo
# Ejemplo de código de Python Función de Python
 def  find_odd_nums (num_list) :
 return [num for num in num_list if num% 2 ! = 0 ]
números_aleatorios = [ 2, 3, 5, 8, 34, 62, 6, 3, 4, 23, 13, 34, 0, 39 ]
imprimir (find_odd_nums (random_numbers))
Salida:
[3, 5, 3, 23, 13, 39]
En el ejemplo anterior, podemos ver que la función se define una vez y se llama más adelante en el código. En este caso particular, se usa solo una vez y, por lo tanto, no es tan efectivo. Pero, a menudo, es necesario realizar una operación en particular varias veces en el mismo programa. En esos momentos, se recomienda definir una función al respecto y luego llamarla tantas veces como sea necesario.
Esto tiene muchas ventajas. Se enumeran a continuación:
  • Legibilidad de código más fácil
  • Modularidad de código
  • Código no repetitivo
  • Uso eficiente de variables
  • Reducción del tiempo de codificación y depuración
El uso de funciones en el código no es obligatorio, pero se recomienda encarecidamente. Es una de las “buenas” prácticas de programación más fundamentales.

 4. Uso de la programación orientada a objetos

POOs Sistema de programación orientado a objetos)

Comencemos con lo que es la programación orientada a objetos, o más popularmente conocida como OOP. Es una forma de programación que involucra "objetos" y los datos asociados a ellos. Tiene un enfoque diferente en comparación con la programación convencional orientada a procedimientos en la parte en que el enfoque principal se basa en "objetos" en lugar de "acciones". Esto puede sonar bastante insignificante, pero proporciona muchas ventajas en términos de metodología de programación, gestión de datos, ocultación de datos, modularidad de código, etc.
La Programación Orientada a Objetos se implementa con el uso de Clases y sus métodos . Tratemos de entender esto brevemente. Una clase puede tener varios "objetos" o "instancias". Los métodos son funciones de clase a las que puede acceder un "Objeto" o "Instancia" de esa clase.

Ejemplo de una clase con métodos y creación de objetos:

# Ejemplo de código de la clase Python
# Crear una clase
clase  Empleado: 
def  __init__ (persona, nombre, edad, designación):
self.name = nombre
self.age = edad
self.designation = designación
print ( "¡Empleado creado!" )
 def  modificar_detalles (persona, nombre, edad, designación):
self.name = nombre
self.age = edad
self.designation = designación
print ( "¡Detalles del empleado modificados!" )
 def  show_employee (self) :
print ( "Nombre:" , self.name)
print ( "Edad:" , self.age)
print ( "Designación:" , autodesignación)
# Crea dos instancias de una clase
empleado_1 = Empleado ( 'John Doe' , 35, 'Científico de datos' )
empleado_2 = Empleado ( 'Natasha' , 29, 'DevOps' )
# Mostrar los detalles de los empleados
employee_1.show_employee ()
employee_2.show_employee ()
# Modificar los detalles del empleado 1.
employee_1.modify_details (' John Doe ', 31 , ' Científico de datos ')
# Los detalles del empleado 2 permanecen sin cambios, pero el empleado 1 se ha modificado
employee_1.show_employee ()
employee_2.show_employee ()
Salida:
¡Empleado creado!
¡Empleado creado!
Nombre: John Doe
Edad: 35
Designación: científico de datos
Nombre: Natasha
Edad: 29
Designación: DevOps
¡Detalles del empleado modificados!
Nombre: John Doe
Edad: 31
Designación: científico de datos
Nombre: Natasha
Edad: 29 
Designación: DevOps

¿Cómo afecta OOP al proceso de desarrollo?

Respondamos la pregunta explicando el fragmento de código anterior.
Como se muestra, se crea una clase que contiene algunos métodos (funciones) dentro de ella. Tenga en cuenta que definimos la clase solo una vez, pero estamos creando dos instancias (objetos) diferentes de ella, llamadas "employee_1" y "employee_2" . Estos dos empleados se inicializan con sus detalles relevantes, pero cada uno es completamente independiente el uno del otro. Incluso cuando se modifican los detalles de employee_1 , employee_2 no se ve afectado.
Esto fue solo un adelanto de las ventajas de usar clases. Para implementar el código anterior sin OOP significaría tener un conjunto separado de variables para almacenar los detalles de cada empleado. Esto hace que sea muy difícil trabajar con una gran cantidad de variables a medida que aumenta el número de empleados.
Ahora que sabemos cuál puede ser la consecuencia de no usar OOP, enumeremos las ventajas de usar OOP:
  • Modularidad de código
  • Reutilización de código
  • Polimorfismo
  • Encapsulación de datos
  • Herencia
Por lo tanto, es muy recomendable usar conceptos de programación orientada a objetos en Python cuando se trabaja en proyectos más grandes.

 5. Comentarios y documentación adecuados

Los comentarios son partes del código que no ejecuta el intérprete. Estas son declaraciones que se ignoran durante la ejecución del programa. La declaración de comentarios es diferente para cada lenguaje de programación. En Python, una línea que comienza con Hash (#) se considera un comentario. El objetivo principal de los comentarios es transmitir información al lector de una forma más sencilla en comparación con el propio programa. Los comentarios son de diferentes tipos:
  • Comentario de una sola línea
  • Comentario de varias líneas
  • DocStrings

Ejemplo de un comentario de una sola línea:

# Definir una lista de marcas
marcas = [ 'Apple', 'Google', 'Netflix', 'Amazon', 'Ford' ]

Ejemplo de un comentario de varias líneas:

# Bienvenido a la programación de Python
# Este es un lenguaje orientado a objetos de tipo dinámico
# Definamos algunas marcas
marcas = [ 'Apple', 'Google', 'Netflix', 'Amazon', 'Ford' ]

Ejemplo de un DocString:

def  find_odd_nums (num_list) :
"" "
Esta función se utiliza para buscar y enumerar los números impares de una lista determinada.
Toma una lista de números como argumento
Devuelve una lista de números impares
"" " 
devuelve [num para num en num_list si num% 2 ! = 0 ]
Como podemos ver en los fragmentos de código anteriores, los comentarios de una sola línea se utilizan para explicar segmentos cortos de un programa, mientras que un comentario de varias líneas es más descriptivo sobre un segmento más grande de código. Finalmente, los DocStrings se utilizan en las definiciones de clases y funciones. Explica la funcionalidad general de la clase / función y explica los parámetros y las declaraciones de retorno.

La necesidad de documentación:

La documentación puede parecer innecesaria, pero juega un papel clave en la programación. Un programa bien documentado es más fácil de leer y comprender en comparación con uno indocumentado.
Leer el programa línea por línea con el fin de comprender / modificar el programa es tedioso. En la industria, la duración de los programas suele llegar a miles de líneas. En tal caso, si en una fecha posterior cualquier desarrollador (incluso el propio autor) intenta depurar / modificar el código, entender el programa se convierte en un desafío, ya que a menudo es difícil comprender la funcionalidad prevista de cada parte del código. . Aquí surge la necesidad de una documentación adecuada. Un programa bien documentado es fácil de leer y comprender y, por lo tanto, más fácil de depurar en comparación con uno indocumentado.
Documentación de código eficiente:
La documentación no significa escribir lo que hace cada línea. Por ejemplo:
# Imprimir sobre Python
print ( 'Python es un lenguaje orientado a objetos' )
En cambio, se supone que la Documentación da una idea de una imagen más amplia de POR QUÉ se escribe una determinada pieza de código. Por ejemplo:
# crea una matriz numérica de ceros igual que df_log para inicializar la salida
output_predict = np.zeros ((df_log.shape [ 0 ] + future_day, df_log.shape [ 1 ]))
En cualquier tarea de desarrollo, todas las empresas siguen métodos de documentación exhaustivos. Se recomiendan buenas prácticas de documentación para cualquier lenguaje de programación y no se limitan a Python. Aunque la documentación no es obligatoria, es necesaria.

 6. Uso de entornos virtuales

Ambientes virtuales

Python es un lenguaje que tiene múltiples versiones (Python 3 y Python 2) y depende en gran medida de numerosas bibliotecas. La mayoría de los programas utilizan más de una biblioteca a la vez, y cada biblioteca tiene requisitos de versión específicos e interdependencia con otras. Además, una determinada tarea puede requerir el uso de una biblioteca que puede no ser compatible con otras bibliotecas preexistentes. Además, el desarrollador puede requerir que se instale más de una versión de Python en la misma máquina en un momento dado. Por ejemplo, Tensorflow, una biblioteca de aprendizaje profundo no es compatible con Python 3.7 (en el momento de escribir este artículo). Soporta hasta Python 3.6. Sin embargo, al mismo tiempo, es posible que el desarrollador desee utilizar las funciones más nuevas de Python 3.7 para otros proyectos.
No es prácticamente factible instalar y desinstalar el intérprete y todas las bibliotecas asociadas repetidamente cada vez que se requiere una versión diferente. Por lo tanto, se introdujeron los entornos virtuales. Estos son entornos autónomos que son completamente independientes del intérprete del sistema. Un entorno virtual puede ejecutar Python 2.7 y otro entorno virtual puede ejecutar Python 3.6 con Tensorflow en la misma máquina al mismo tiempo, mientras que ambos son completamente independientes entre sí. Esta es la razón principal por la que se utilizan entornos virtuales.

Cómo configurar un entorno virtual Paso para configurar un entorno virtual

Hay dos métodos para configurar un entorno virtual. Una es mediante el paquete " virtualenv " que se puede instalar mediante pip . El otro método es usar " venv " que viene con Anaconda . Dado que Anaconda no es nuestro enfoque principal aquí, nos ceñiremos al método predeterminado.
El siguiente tutorial se basa en la suposición de que el usuario ha instalado Python correctamente y tiene acceso a pip (se instala automáticamente con Python). De lo contrario, consulte esta guía sobre cómo hacerlo.
  • Abra su consola y escriba: pip install virtualenv
  • Cree un directorio donde desee crear su entorno virtual: mkdir nombre-carpeta
  • Navegue a esa carpeta: cd folder-name
  • Crear un entorno virtual: virtualenv env-name
  • Para utilizar este entorno virtual, navegue dentro de los Scripts  del entorno virtual: cd env-name / Scripts
  • Activar el entorno virtual: activar
Ahora el entorno virtual está configurado y se puede utilizar como su propio intérprete independiente. Ningún cambio realizado aquí afectará al intérprete del sistema.

¿Qué es "requirements.txt"?

Dado que Python depende en gran medida de bibliotecas y paquetes externos, la mayoría de las veces, los programas que crea un desarrollador requieren un cierto conjunto de bibliotecas con sus versiones específicas mencionadas. Un programa puede depender de numerosas bibliotecas. Por lo tanto, si cualquier otro desarrollador desea ejecutar el mismo programa en su máquina local, tendrá que instalar las bibliotecas manualmente, lo cual es muy tedioso.
Por lo tanto, "requirements.txt" es un archivo de texto que contiene la lista de todas las bibliotecas necesarias para ejecutar el programa en particular con éxito. A continuación se muestra un archivo de muestra.
Que son los requisitos
La principal ventaja es que el desarrollador solo puede usar el comando: pip install requirements.txt y esto instalará todas las dependencias requeridas automáticamente. Esto hace que el proceso sea más ágil.

¿Cómo se relaciona "requirements.txt" con las mejores prácticas y el entorno virtual?

Es muy recomendable agregar un archivo "requirements.txt" para cualquier proyecto complejo, ya que tiene dos funciones principales:
  • Cualquier otro desarrollador puede simplemente abrir el archivo y tener una idea de qué bibliotecas se han utilizado en el proyecto.
  • Como se mencionó anteriormente, al desarrollador le resulta bastante fácil instalar dependencias
Por lo tanto, se considera una "mejor práctica" en el desarrollo de Python.
Generar "requirements.txt" manualmente no es una necesidad. Se puede generar fácilmente usando el comando: pip freeze> requirements.txt, que crea una lista de bibliotecas dependientes como se muestra en la captura de pantalla en una sección anterior.
Sin embargo, este comando genera la lista de todas las bibliotecas instaladas actualmente en el entorno desde el que se ejecuta pip y, por lo tanto, las enumerará todas en el archivo requirements.txt. Esto es innecesario ya que es posible que el proyecto no requiera todas las bibliotecas. Aquí es donde los entornos virtuales se convierten en una necesidad, donde cada entorno virtual se configura específicamente para cada proyecto y, por lo tanto, contiene un número limitado de bibliotecas necesarias para ese proyecto. La creación del archivo requirements.txt a partir de ese entorno activo genera una lista específica de bibliotecas necesarias, dejando fuera las que no se utilizan para el proyecto.
Conclusión
Por lo tanto, hasta ahora hemos discutido algunas de las "mejores prácticas" más comunes en Python que se recomiendan en la industria del desarrollo. Esta lista, aunque no incluye todas las “mejores prácticas”, enumera las más importantes y, por lo tanto, es un buen lugar para comenzar. A medida que el desarrollador adquiere más experiencia en programación, automáticamente aceptará la mayoría de las "mejores prácticas".

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

outbrain

Páginas