Chapter 10: Python Best Practices
10.1 PEP 8 - Guía de estilo para el código Python
A medida que nos acercamos al final de este libro, es importante señalar que las mejores prácticas para los programadores de Python son fundamentales para el éxito de cualquier proyecto. Si bien existen muchas prácticas recomendadas que los programadores pueden seguir, las que se presentan aquí son esenciales para mantener un código eficiente, legible y mantenible. En este capítulo, profundizaremos en PEP 8, la guía de estilo oficial para el código Python, y exploraremos cómo se puede utilizar para mejorar su código.
Además, discutiremos otros temas críticos como la organización, la documentación y las pruebas del código. Es esencial comprender estos conceptos en su totalidad, ya que serán cruciales para garantizar que sus proyectos Python sean un éxito.
PEP 8 es la Propuesta de Mejora de Python que proporciona un conjunto de pautas y convenciones para escribir código Python. El propósito principal de PEP 8 es hacer que el código sea más legible y mantenible al proporcionar un estilo consistente. Aunque PEP 8 no es un requisito estricto, se recomienda encarecidamente seguir estas pautas para garantizar que su código sea fácilmente entendido por otros, e incluso por usted mismo, en el futuro.
Algunos de los aspectos clave de PEP 8 incluyen:
10.1.1: Sangría:
Al escribir código, es importante mantener un formato consistente. Esto se puede lograr utilizando 4 espacios por nivel de sangría, en lugar de mezclar espacios y tabulaciones. Al hacerlo, el código se vuelve más legible y fácil de entender para otras personas que puedan necesitar trabajar con el código en el futuro. Además, un formato consistente puede ayudar a prevenir errores y facilitar la depuración. Por lo tanto, se recomienda encarecidamente utilizar 4 espacios por nivel de sangría para todo el código que escriba.
Ejemplo:
# Good
def my_function(arg1, arg2):
result = arg1 + arg2
return result
# Bad
def my_function(arg1, arg2):
result = arg1 + arg2
return result10.1.2: Longitud máxima de línea:
Una forma de mejorar la legibilidad del código es limitar la cantidad de caracteres por línea. Esto se puede lograr estableciendo una longitud máxima de línea de 79 caracteres. Al hacer esto, el código se vuelve más fácil de leer, especialmente cuando se trabaja con varios archivos uno al lado del otro. Permite una base de código más organizada y estructurada, ya que los desarrolladores pueden escanear rápidamente el código e identificar posibles problemas o áreas de mejora.
Además, mantener el código dentro de un cierto límite de longitud también puede ayudar con la depuración y las pruebas, ya que minimiza la necesidad de desplazamiento horizontal y facilita la detección de errores.
Ejemplo:
# Good
def my_function(long_arg1, long_arg2,
long_arg3, long_arg4):
result = (
long_arg1 + long_arg2
- long_arg3 * long_arg4
)
return result
# Bad
def my_function(long_arg1, long_arg2, long_arg3, long_arg4): result = long_arg1 + long_arg2 - long_arg3 * long_arg4; return result10.1.3: Importaciones:
Al escribir código, es importante organizar tus importaciones de forma clara y consistente. Colocarlas al principio del archivo facilita que otros desarrolladores comprendan las dependencias externas de tu código. Sin embargo, no basta con simplemente enumerarlas en orden aleatorio. Para maximizar la legibilidad, las importaciones deben separarse por una línea en blanco y organizarse en un orden específico.
Primero, deberías enumerar cualquier importación de la biblioteca estándar que tu código requiera. Estos son módulos integrados que vienen con el lenguaje Python, como "os" o "sys".
Luego, deberías enumerar cualquier importación de terceros que tu código requiera. Estos son módulos externos que has instalado usando un gestor de paquetes como "pip". Ejemplos de módulos de terceros podrían ser "numpy" o "pandas".
Finalmente, deberías enumerar cualquier importación local de la aplicación o biblioteca específica que tu código requiera. Estos son módulos que has escrito tú mismo o que son específicos de tu proyecto.
Siguiendo este esquema de organización, puedes ayudar a garantizar que tu código sea fácil de leer y comprender, incluso para desarrolladores que no estén familiarizados con tu proyecto. ¡Así que no olvides dedicar un poco de tiempo extra a organizar tus importaciones adecuadamente!
Ejemplo:
# Good
import os
import sys
import requests
from my_module import my_function
# Bad
import os, sys
from my_module import my_function
import requests10.1.4: Espacios en blanco:
Al escribir código, es importante usar los espacios en blanco de manera efectiva. Esto significa que, si bien debes evitar el uso excesivo de espacios en blanco, también debes usarlos para separar secciones lógicas de tu código. Por ejemplo, puedes usar una línea en blanco para separar funciones, métodos o definiciones de clases. Al usar los espacios en blanco de esta manera, puedes hacer que tu código sea más organizado y fácil de leer.
Además de separar secciones de código, también es importante usar espacios en blanco alrededor de los operadores y después de las comas en listas, tuplas o diccionarios. Esto hace que el código sea más legible y fácil de entender, especialmente si alguien más necesita revisarlo o modificarlo en el futuro.
Ejemplo:
# Good
my_list = [1, 2, 3, 4]
result = x * y + z
# Bad
my_list=[1,2,3,4]
result=x*y+z10.1.5: Convenciones de nombres:
- Los nombres de variables y funciones deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_variable,my_function). - Las constantes deben estar en MAYÚSCULAS, con las palabras separadas por guiones bajos (por ejemplo,
MY_CONSTANT). - Los nombres de clase deben usar la convención CapWords (PascalCase) (por ejemplo,
MyClass). - Los nombres de método deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_method).
Ejemplo:
# Good
class MyClass:
my_variable = 10
def my_method(self):
pass
# Bad
class myclass:
MyVariable = 10
def MyMethod(self):
pass10.1.6: Comentarios:
Al escribir código, es importante usar comentarios para explicar el propósito del código, especialmente cuando podría ser difícil de entender. Los comentarios ayudan a otros programadores que puedan necesitar trabajar con tu código a comprender cómo funciona y qué hace.
Se recomienda usar comentarios en línea con moderación, ya que agregar demasiados puede dificultar la lectura del código. Al agregar comentarios en línea, es importante separarlos del código con al menos dos espacios.
Comienza siempre los comentarios con mayúscula y termina con punto. Esto ayuda a mantener la consistencia y la legibilidad dentro de tu código, y puede facilitar que otros comprendan lo que estás tratando de lograr.
En resumen, los comentarios son una parte vital de escribir buen código y pueden ayudar a que tu código sea más comprensible y mantenible. ¡Así que no olvides agregar comentarios a tu código!
Ejemplo:
# Good
def my_function():
# Calculate the result based on some logic.
result = 42
return result
# Bad
def my_function():
result = 42 # Calculate the result based on some logic.
return result10.1.7: Docstrings:
El uso de docstrings, o cadenas de texto entre triples comillas, es una excelente manera de proporcionar documentación para sus módulos, clases, funciones y métodos. Esto puede ayudar a otros a comprender el propósito y el uso de su código de manera más efectiva, lo cual puede ser especialmente importante cuando se trabaja en proyectos con otros o se contribuye a proyectos de código abierto.
No solo una buena documentación facilita que otros utilicen y construyan sobre su código, sino que también puede hacer que sea más fácil para usted volver a su propio código más tarde y recordar cómo funciona. De hecho, muchos desarrolladores consideran que una buena documentación es tan importante como el propio código, ya que puede ayudar a asegurar que su código sea mantenible y utilizable a largo plazo. Entonces, si aún no está utilizando docstrings en su código, podría valer la pena tomar el tiempo para comenzar a incorporarlos en sus prácticas de programación.
Ejemplo:
# Good
def my_function(arg1, arg2):
"""
Calculate the sum of two arguments.
Args:
arg1 (int): The first argument.
arg2 (int): The second argument.
Returns:
int: The sum of the two arguments.
"""
return arg1 + arg2
# Bad
def my_function(arg1, arg2):
# Calculate the sum of two arguments
return arg1 + arg2Estas son sólo algunas de las muchas pautas proporcionadas por PEP 8. Se recomienda leer el documento completo de PEP 8 (https://www.python.org/dev/peps/pep-0008/) para familiarizarse con todas las directrices y aplicarlas consistentemente en sus proyectos Python.
Ejercicio 10.1.1: Sangría PEP 8
En este ejercicio, practicará cómo corregir la sangría en un script de Python para seguir las pautas de PEP 8.
Instrucciones:
Corrija la sangría en el script de Python proporcionado. El guión debe tener 4 espacios para cada nivel de sangría.
Solución:
def my_function(arg1, arg2):
result = arg1 + arg2
return result
if __name__ == "__main__":
num1 = 5
num2 = 10
sum_result = my_function(num1, num2)
print(f"The sum of {num1} and {num2} is {sum_result}.")Output:
The sum of 5 and 10 is 15.Exercise 10.1.2: PEP 8 Imports
In this exercise, you'll practice organizing imports according to PEP 8 guidelines.
Instructions:
Reorganize the given imports in the Python script so that they follow the PEP 8 guidelines.
Solution:
import os
import sys
import requests
from my_module import my_function
print("Imports organized according to PEP 8.")Output:
Imports organized according to PEP 8.Nota: La salida variará según su sistema y el "my_module" real que importe.
Ejercicio 10.1.3: Convenciones de Nombres PEP 8
En este ejercicio, practicarás aplicar las convenciones de nombres PEP 8 a un script de Python.
Instrucciones:
Actualiza el script de Python dado para que siga las convenciones de nombres PEP 8 para variables, funciones y clases.
Solución:
class MyClass:
my_variable = 10
def my_method(self):
return self.my_variable * 2
def main():
my_instance = MyClass()
result = my_instance.my_method()
print(f"The result is: {result}")
if __name__ == "__main__":
main()Salida:
The result is: 2010.1 PEP 8 - Guía de estilo para el código Python
A medida que nos acercamos al final de este libro, es importante señalar que las mejores prácticas para los programadores de Python son fundamentales para el éxito de cualquier proyecto. Si bien existen muchas prácticas recomendadas que los programadores pueden seguir, las que se presentan aquí son esenciales para mantener un código eficiente, legible y mantenible. En este capítulo, profundizaremos en PEP 8, la guía de estilo oficial para el código Python, y exploraremos cómo se puede utilizar para mejorar su código.
Además, discutiremos otros temas críticos como la organización, la documentación y las pruebas del código. Es esencial comprender estos conceptos en su totalidad, ya que serán cruciales para garantizar que sus proyectos Python sean un éxito.
PEP 8 es la Propuesta de Mejora de Python que proporciona un conjunto de pautas y convenciones para escribir código Python. El propósito principal de PEP 8 es hacer que el código sea más legible y mantenible al proporcionar un estilo consistente. Aunque PEP 8 no es un requisito estricto, se recomienda encarecidamente seguir estas pautas para garantizar que su código sea fácilmente entendido por otros, e incluso por usted mismo, en el futuro.
Algunos de los aspectos clave de PEP 8 incluyen:
10.1.1: Sangría:
Al escribir código, es importante mantener un formato consistente. Esto se puede lograr utilizando 4 espacios por nivel de sangría, en lugar de mezclar espacios y tabulaciones. Al hacerlo, el código se vuelve más legible y fácil de entender para otras personas que puedan necesitar trabajar con el código en el futuro. Además, un formato consistente puede ayudar a prevenir errores y facilitar la depuración. Por lo tanto, se recomienda encarecidamente utilizar 4 espacios por nivel de sangría para todo el código que escriba.
Ejemplo:
# Good
def my_function(arg1, arg2):
result = arg1 + arg2
return result
# Bad
def my_function(arg1, arg2):
result = arg1 + arg2
return result10.1.2: Longitud máxima de línea:
Una forma de mejorar la legibilidad del código es limitar la cantidad de caracteres por línea. Esto se puede lograr estableciendo una longitud máxima de línea de 79 caracteres. Al hacer esto, el código se vuelve más fácil de leer, especialmente cuando se trabaja con varios archivos uno al lado del otro. Permite una base de código más organizada y estructurada, ya que los desarrolladores pueden escanear rápidamente el código e identificar posibles problemas o áreas de mejora.
Además, mantener el código dentro de un cierto límite de longitud también puede ayudar con la depuración y las pruebas, ya que minimiza la necesidad de desplazamiento horizontal y facilita la detección de errores.
Ejemplo:
# Good
def my_function(long_arg1, long_arg2,
long_arg3, long_arg4):
result = (
long_arg1 + long_arg2
- long_arg3 * long_arg4
)
return result
# Bad
def my_function(long_arg1, long_arg2, long_arg3, long_arg4): result = long_arg1 + long_arg2 - long_arg3 * long_arg4; return result10.1.3: Importaciones:
Al escribir código, es importante organizar tus importaciones de forma clara y consistente. Colocarlas al principio del archivo facilita que otros desarrolladores comprendan las dependencias externas de tu código. Sin embargo, no basta con simplemente enumerarlas en orden aleatorio. Para maximizar la legibilidad, las importaciones deben separarse por una línea en blanco y organizarse en un orden específico.
Primero, deberías enumerar cualquier importación de la biblioteca estándar que tu código requiera. Estos son módulos integrados que vienen con el lenguaje Python, como "os" o "sys".
Luego, deberías enumerar cualquier importación de terceros que tu código requiera. Estos son módulos externos que has instalado usando un gestor de paquetes como "pip". Ejemplos de módulos de terceros podrían ser "numpy" o "pandas".
Finalmente, deberías enumerar cualquier importación local de la aplicación o biblioteca específica que tu código requiera. Estos son módulos que has escrito tú mismo o que son específicos de tu proyecto.
Siguiendo este esquema de organización, puedes ayudar a garantizar que tu código sea fácil de leer y comprender, incluso para desarrolladores que no estén familiarizados con tu proyecto. ¡Así que no olvides dedicar un poco de tiempo extra a organizar tus importaciones adecuadamente!
Ejemplo:
# Good
import os
import sys
import requests
from my_module import my_function
# Bad
import os, sys
from my_module import my_function
import requests10.1.4: Espacios en blanco:
Al escribir código, es importante usar los espacios en blanco de manera efectiva. Esto significa que, si bien debes evitar el uso excesivo de espacios en blanco, también debes usarlos para separar secciones lógicas de tu código. Por ejemplo, puedes usar una línea en blanco para separar funciones, métodos o definiciones de clases. Al usar los espacios en blanco de esta manera, puedes hacer que tu código sea más organizado y fácil de leer.
Además de separar secciones de código, también es importante usar espacios en blanco alrededor de los operadores y después de las comas en listas, tuplas o diccionarios. Esto hace que el código sea más legible y fácil de entender, especialmente si alguien más necesita revisarlo o modificarlo en el futuro.
Ejemplo:
# Good
my_list = [1, 2, 3, 4]
result = x * y + z
# Bad
my_list=[1,2,3,4]
result=x*y+z10.1.5: Convenciones de nombres:
- Los nombres de variables y funciones deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_variable,my_function). - Las constantes deben estar en MAYÚSCULAS, con las palabras separadas por guiones bajos (por ejemplo,
MY_CONSTANT). - Los nombres de clase deben usar la convención CapWords (PascalCase) (por ejemplo,
MyClass). - Los nombres de método deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_method).
Ejemplo:
# Good
class MyClass:
my_variable = 10
def my_method(self):
pass
# Bad
class myclass:
MyVariable = 10
def MyMethod(self):
pass10.1.6: Comentarios:
Al escribir código, es importante usar comentarios para explicar el propósito del código, especialmente cuando podría ser difícil de entender. Los comentarios ayudan a otros programadores que puedan necesitar trabajar con tu código a comprender cómo funciona y qué hace.
Se recomienda usar comentarios en línea con moderación, ya que agregar demasiados puede dificultar la lectura del código. Al agregar comentarios en línea, es importante separarlos del código con al menos dos espacios.
Comienza siempre los comentarios con mayúscula y termina con punto. Esto ayuda a mantener la consistencia y la legibilidad dentro de tu código, y puede facilitar que otros comprendan lo que estás tratando de lograr.
En resumen, los comentarios son una parte vital de escribir buen código y pueden ayudar a que tu código sea más comprensible y mantenible. ¡Así que no olvides agregar comentarios a tu código!
Ejemplo:
# Good
def my_function():
# Calculate the result based on some logic.
result = 42
return result
# Bad
def my_function():
result = 42 # Calculate the result based on some logic.
return result10.1.7: Docstrings:
El uso de docstrings, o cadenas de texto entre triples comillas, es una excelente manera de proporcionar documentación para sus módulos, clases, funciones y métodos. Esto puede ayudar a otros a comprender el propósito y el uso de su código de manera más efectiva, lo cual puede ser especialmente importante cuando se trabaja en proyectos con otros o se contribuye a proyectos de código abierto.
No solo una buena documentación facilita que otros utilicen y construyan sobre su código, sino que también puede hacer que sea más fácil para usted volver a su propio código más tarde y recordar cómo funciona. De hecho, muchos desarrolladores consideran que una buena documentación es tan importante como el propio código, ya que puede ayudar a asegurar que su código sea mantenible y utilizable a largo plazo. Entonces, si aún no está utilizando docstrings en su código, podría valer la pena tomar el tiempo para comenzar a incorporarlos en sus prácticas de programación.
Ejemplo:
# Good
def my_function(arg1, arg2):
"""
Calculate the sum of two arguments.
Args:
arg1 (int): The first argument.
arg2 (int): The second argument.
Returns:
int: The sum of the two arguments.
"""
return arg1 + arg2
# Bad
def my_function(arg1, arg2):
# Calculate the sum of two arguments
return arg1 + arg2Estas son sólo algunas de las muchas pautas proporcionadas por PEP 8. Se recomienda leer el documento completo de PEP 8 (https://www.python.org/dev/peps/pep-0008/) para familiarizarse con todas las directrices y aplicarlas consistentemente en sus proyectos Python.
Ejercicio 10.1.1: Sangría PEP 8
En este ejercicio, practicará cómo corregir la sangría en un script de Python para seguir las pautas de PEP 8.
Instrucciones:
Corrija la sangría en el script de Python proporcionado. El guión debe tener 4 espacios para cada nivel de sangría.
Solución:
def my_function(arg1, arg2):
result = arg1 + arg2
return result
if __name__ == "__main__":
num1 = 5
num2 = 10
sum_result = my_function(num1, num2)
print(f"The sum of {num1} and {num2} is {sum_result}.")Output:
The sum of 5 and 10 is 15.Exercise 10.1.2: PEP 8 Imports
In this exercise, you'll practice organizing imports according to PEP 8 guidelines.
Instructions:
Reorganize the given imports in the Python script so that they follow the PEP 8 guidelines.
Solution:
import os
import sys
import requests
from my_module import my_function
print("Imports organized according to PEP 8.")Output:
Imports organized according to PEP 8.Nota: La salida variará según su sistema y el "my_module" real que importe.
Ejercicio 10.1.3: Convenciones de Nombres PEP 8
En este ejercicio, practicarás aplicar las convenciones de nombres PEP 8 a un script de Python.
Instrucciones:
Actualiza el script de Python dado para que siga las convenciones de nombres PEP 8 para variables, funciones y clases.
Solución:
class MyClass:
my_variable = 10
def my_method(self):
return self.my_variable * 2
def main():
my_instance = MyClass()
result = my_instance.my_method()
print(f"The result is: {result}")
if __name__ == "__main__":
main()Salida:
The result is: 2010.1 PEP 8 - Guía de estilo para el código Python
A medida que nos acercamos al final de este libro, es importante señalar que las mejores prácticas para los programadores de Python son fundamentales para el éxito de cualquier proyecto. Si bien existen muchas prácticas recomendadas que los programadores pueden seguir, las que se presentan aquí son esenciales para mantener un código eficiente, legible y mantenible. En este capítulo, profundizaremos en PEP 8, la guía de estilo oficial para el código Python, y exploraremos cómo se puede utilizar para mejorar su código.
Además, discutiremos otros temas críticos como la organización, la documentación y las pruebas del código. Es esencial comprender estos conceptos en su totalidad, ya que serán cruciales para garantizar que sus proyectos Python sean un éxito.
PEP 8 es la Propuesta de Mejora de Python que proporciona un conjunto de pautas y convenciones para escribir código Python. El propósito principal de PEP 8 es hacer que el código sea más legible y mantenible al proporcionar un estilo consistente. Aunque PEP 8 no es un requisito estricto, se recomienda encarecidamente seguir estas pautas para garantizar que su código sea fácilmente entendido por otros, e incluso por usted mismo, en el futuro.
Algunos de los aspectos clave de PEP 8 incluyen:
10.1.1: Sangría:
Al escribir código, es importante mantener un formato consistente. Esto se puede lograr utilizando 4 espacios por nivel de sangría, en lugar de mezclar espacios y tabulaciones. Al hacerlo, el código se vuelve más legible y fácil de entender para otras personas que puedan necesitar trabajar con el código en el futuro. Además, un formato consistente puede ayudar a prevenir errores y facilitar la depuración. Por lo tanto, se recomienda encarecidamente utilizar 4 espacios por nivel de sangría para todo el código que escriba.
Ejemplo:
# Good
def my_function(arg1, arg2):
result = arg1 + arg2
return result
# Bad
def my_function(arg1, arg2):
result = arg1 + arg2
return result10.1.2: Longitud máxima de línea:
Una forma de mejorar la legibilidad del código es limitar la cantidad de caracteres por línea. Esto se puede lograr estableciendo una longitud máxima de línea de 79 caracteres. Al hacer esto, el código se vuelve más fácil de leer, especialmente cuando se trabaja con varios archivos uno al lado del otro. Permite una base de código más organizada y estructurada, ya que los desarrolladores pueden escanear rápidamente el código e identificar posibles problemas o áreas de mejora.
Además, mantener el código dentro de un cierto límite de longitud también puede ayudar con la depuración y las pruebas, ya que minimiza la necesidad de desplazamiento horizontal y facilita la detección de errores.
Ejemplo:
# Good
def my_function(long_arg1, long_arg2,
long_arg3, long_arg4):
result = (
long_arg1 + long_arg2
- long_arg3 * long_arg4
)
return result
# Bad
def my_function(long_arg1, long_arg2, long_arg3, long_arg4): result = long_arg1 + long_arg2 - long_arg3 * long_arg4; return result10.1.3: Importaciones:
Al escribir código, es importante organizar tus importaciones de forma clara y consistente. Colocarlas al principio del archivo facilita que otros desarrolladores comprendan las dependencias externas de tu código. Sin embargo, no basta con simplemente enumerarlas en orden aleatorio. Para maximizar la legibilidad, las importaciones deben separarse por una línea en blanco y organizarse en un orden específico.
Primero, deberías enumerar cualquier importación de la biblioteca estándar que tu código requiera. Estos son módulos integrados que vienen con el lenguaje Python, como "os" o "sys".
Luego, deberías enumerar cualquier importación de terceros que tu código requiera. Estos son módulos externos que has instalado usando un gestor de paquetes como "pip". Ejemplos de módulos de terceros podrían ser "numpy" o "pandas".
Finalmente, deberías enumerar cualquier importación local de la aplicación o biblioteca específica que tu código requiera. Estos son módulos que has escrito tú mismo o que son específicos de tu proyecto.
Siguiendo este esquema de organización, puedes ayudar a garantizar que tu código sea fácil de leer y comprender, incluso para desarrolladores que no estén familiarizados con tu proyecto. ¡Así que no olvides dedicar un poco de tiempo extra a organizar tus importaciones adecuadamente!
Ejemplo:
# Good
import os
import sys
import requests
from my_module import my_function
# Bad
import os, sys
from my_module import my_function
import requests10.1.4: Espacios en blanco:
Al escribir código, es importante usar los espacios en blanco de manera efectiva. Esto significa que, si bien debes evitar el uso excesivo de espacios en blanco, también debes usarlos para separar secciones lógicas de tu código. Por ejemplo, puedes usar una línea en blanco para separar funciones, métodos o definiciones de clases. Al usar los espacios en blanco de esta manera, puedes hacer que tu código sea más organizado y fácil de leer.
Además de separar secciones de código, también es importante usar espacios en blanco alrededor de los operadores y después de las comas en listas, tuplas o diccionarios. Esto hace que el código sea más legible y fácil de entender, especialmente si alguien más necesita revisarlo o modificarlo en el futuro.
Ejemplo:
# Good
my_list = [1, 2, 3, 4]
result = x * y + z
# Bad
my_list=[1,2,3,4]
result=x*y+z10.1.5: Convenciones de nombres:
- Los nombres de variables y funciones deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_variable,my_function). - Las constantes deben estar en MAYÚSCULAS, con las palabras separadas por guiones bajos (por ejemplo,
MY_CONSTANT). - Los nombres de clase deben usar la convención CapWords (PascalCase) (por ejemplo,
MyClass). - Los nombres de método deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_method).
Ejemplo:
# Good
class MyClass:
my_variable = 10
def my_method(self):
pass
# Bad
class myclass:
MyVariable = 10
def MyMethod(self):
pass10.1.6: Comentarios:
Al escribir código, es importante usar comentarios para explicar el propósito del código, especialmente cuando podría ser difícil de entender. Los comentarios ayudan a otros programadores que puedan necesitar trabajar con tu código a comprender cómo funciona y qué hace.
Se recomienda usar comentarios en línea con moderación, ya que agregar demasiados puede dificultar la lectura del código. Al agregar comentarios en línea, es importante separarlos del código con al menos dos espacios.
Comienza siempre los comentarios con mayúscula y termina con punto. Esto ayuda a mantener la consistencia y la legibilidad dentro de tu código, y puede facilitar que otros comprendan lo que estás tratando de lograr.
En resumen, los comentarios son una parte vital de escribir buen código y pueden ayudar a que tu código sea más comprensible y mantenible. ¡Así que no olvides agregar comentarios a tu código!
Ejemplo:
# Good
def my_function():
# Calculate the result based on some logic.
result = 42
return result
# Bad
def my_function():
result = 42 # Calculate the result based on some logic.
return result10.1.7: Docstrings:
El uso de docstrings, o cadenas de texto entre triples comillas, es una excelente manera de proporcionar documentación para sus módulos, clases, funciones y métodos. Esto puede ayudar a otros a comprender el propósito y el uso de su código de manera más efectiva, lo cual puede ser especialmente importante cuando se trabaja en proyectos con otros o se contribuye a proyectos de código abierto.
No solo una buena documentación facilita que otros utilicen y construyan sobre su código, sino que también puede hacer que sea más fácil para usted volver a su propio código más tarde y recordar cómo funciona. De hecho, muchos desarrolladores consideran que una buena documentación es tan importante como el propio código, ya que puede ayudar a asegurar que su código sea mantenible y utilizable a largo plazo. Entonces, si aún no está utilizando docstrings en su código, podría valer la pena tomar el tiempo para comenzar a incorporarlos en sus prácticas de programación.
Ejemplo:
# Good
def my_function(arg1, arg2):
"""
Calculate the sum of two arguments.
Args:
arg1 (int): The first argument.
arg2 (int): The second argument.
Returns:
int: The sum of the two arguments.
"""
return arg1 + arg2
# Bad
def my_function(arg1, arg2):
# Calculate the sum of two arguments
return arg1 + arg2Estas son sólo algunas de las muchas pautas proporcionadas por PEP 8. Se recomienda leer el documento completo de PEP 8 (https://www.python.org/dev/peps/pep-0008/) para familiarizarse con todas las directrices y aplicarlas consistentemente en sus proyectos Python.
Ejercicio 10.1.1: Sangría PEP 8
En este ejercicio, practicará cómo corregir la sangría en un script de Python para seguir las pautas de PEP 8.
Instrucciones:
Corrija la sangría en el script de Python proporcionado. El guión debe tener 4 espacios para cada nivel de sangría.
Solución:
def my_function(arg1, arg2):
result = arg1 + arg2
return result
if __name__ == "__main__":
num1 = 5
num2 = 10
sum_result = my_function(num1, num2)
print(f"The sum of {num1} and {num2} is {sum_result}.")Output:
The sum of 5 and 10 is 15.Exercise 10.1.2: PEP 8 Imports
In this exercise, you'll practice organizing imports according to PEP 8 guidelines.
Instructions:
Reorganize the given imports in the Python script so that they follow the PEP 8 guidelines.
Solution:
import os
import sys
import requests
from my_module import my_function
print("Imports organized according to PEP 8.")Output:
Imports organized according to PEP 8.Nota: La salida variará según su sistema y el "my_module" real que importe.
Ejercicio 10.1.3: Convenciones de Nombres PEP 8
En este ejercicio, practicarás aplicar las convenciones de nombres PEP 8 a un script de Python.
Instrucciones:
Actualiza el script de Python dado para que siga las convenciones de nombres PEP 8 para variables, funciones y clases.
Solución:
class MyClass:
my_variable = 10
def my_method(self):
return self.my_variable * 2
def main():
my_instance = MyClass()
result = my_instance.my_method()
print(f"The result is: {result}")
if __name__ == "__main__":
main()Salida:
The result is: 2010.1 PEP 8 - Guía de estilo para el código Python
A medida que nos acercamos al final de este libro, es importante señalar que las mejores prácticas para los programadores de Python son fundamentales para el éxito de cualquier proyecto. Si bien existen muchas prácticas recomendadas que los programadores pueden seguir, las que se presentan aquí son esenciales para mantener un código eficiente, legible y mantenible. En este capítulo, profundizaremos en PEP 8, la guía de estilo oficial para el código Python, y exploraremos cómo se puede utilizar para mejorar su código.
Además, discutiremos otros temas críticos como la organización, la documentación y las pruebas del código. Es esencial comprender estos conceptos en su totalidad, ya que serán cruciales para garantizar que sus proyectos Python sean un éxito.
PEP 8 es la Propuesta de Mejora de Python que proporciona un conjunto de pautas y convenciones para escribir código Python. El propósito principal de PEP 8 es hacer que el código sea más legible y mantenible al proporcionar un estilo consistente. Aunque PEP 8 no es un requisito estricto, se recomienda encarecidamente seguir estas pautas para garantizar que su código sea fácilmente entendido por otros, e incluso por usted mismo, en el futuro.
Algunos de los aspectos clave de PEP 8 incluyen:
10.1.1: Sangría:
Al escribir código, es importante mantener un formato consistente. Esto se puede lograr utilizando 4 espacios por nivel de sangría, en lugar de mezclar espacios y tabulaciones. Al hacerlo, el código se vuelve más legible y fácil de entender para otras personas que puedan necesitar trabajar con el código en el futuro. Además, un formato consistente puede ayudar a prevenir errores y facilitar la depuración. Por lo tanto, se recomienda encarecidamente utilizar 4 espacios por nivel de sangría para todo el código que escriba.
Ejemplo:
# Good
def my_function(arg1, arg2):
result = arg1 + arg2
return result
# Bad
def my_function(arg1, arg2):
result = arg1 + arg2
return result10.1.2: Longitud máxima de línea:
Una forma de mejorar la legibilidad del código es limitar la cantidad de caracteres por línea. Esto se puede lograr estableciendo una longitud máxima de línea de 79 caracteres. Al hacer esto, el código se vuelve más fácil de leer, especialmente cuando se trabaja con varios archivos uno al lado del otro. Permite una base de código más organizada y estructurada, ya que los desarrolladores pueden escanear rápidamente el código e identificar posibles problemas o áreas de mejora.
Además, mantener el código dentro de un cierto límite de longitud también puede ayudar con la depuración y las pruebas, ya que minimiza la necesidad de desplazamiento horizontal y facilita la detección de errores.
Ejemplo:
# Good
def my_function(long_arg1, long_arg2,
long_arg3, long_arg4):
result = (
long_arg1 + long_arg2
- long_arg3 * long_arg4
)
return result
# Bad
def my_function(long_arg1, long_arg2, long_arg3, long_arg4): result = long_arg1 + long_arg2 - long_arg3 * long_arg4; return result10.1.3: Importaciones:
Al escribir código, es importante organizar tus importaciones de forma clara y consistente. Colocarlas al principio del archivo facilita que otros desarrolladores comprendan las dependencias externas de tu código. Sin embargo, no basta con simplemente enumerarlas en orden aleatorio. Para maximizar la legibilidad, las importaciones deben separarse por una línea en blanco y organizarse en un orden específico.
Primero, deberías enumerar cualquier importación de la biblioteca estándar que tu código requiera. Estos son módulos integrados que vienen con el lenguaje Python, como "os" o "sys".
Luego, deberías enumerar cualquier importación de terceros que tu código requiera. Estos son módulos externos que has instalado usando un gestor de paquetes como "pip". Ejemplos de módulos de terceros podrían ser "numpy" o "pandas".
Finalmente, deberías enumerar cualquier importación local de la aplicación o biblioteca específica que tu código requiera. Estos son módulos que has escrito tú mismo o que son específicos de tu proyecto.
Siguiendo este esquema de organización, puedes ayudar a garantizar que tu código sea fácil de leer y comprender, incluso para desarrolladores que no estén familiarizados con tu proyecto. ¡Así que no olvides dedicar un poco de tiempo extra a organizar tus importaciones adecuadamente!
Ejemplo:
# Good
import os
import sys
import requests
from my_module import my_function
# Bad
import os, sys
from my_module import my_function
import requests10.1.4: Espacios en blanco:
Al escribir código, es importante usar los espacios en blanco de manera efectiva. Esto significa que, si bien debes evitar el uso excesivo de espacios en blanco, también debes usarlos para separar secciones lógicas de tu código. Por ejemplo, puedes usar una línea en blanco para separar funciones, métodos o definiciones de clases. Al usar los espacios en blanco de esta manera, puedes hacer que tu código sea más organizado y fácil de leer.
Además de separar secciones de código, también es importante usar espacios en blanco alrededor de los operadores y después de las comas en listas, tuplas o diccionarios. Esto hace que el código sea más legible y fácil de entender, especialmente si alguien más necesita revisarlo o modificarlo en el futuro.
Ejemplo:
# Good
my_list = [1, 2, 3, 4]
result = x * y + z
# Bad
my_list=[1,2,3,4]
result=x*y+z10.1.5: Convenciones de nombres:
- Los nombres de variables y funciones deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_variable,my_function). - Las constantes deben estar en MAYÚSCULAS, con las palabras separadas por guiones bajos (por ejemplo,
MY_CONSTANT). - Los nombres de clase deben usar la convención CapWords (PascalCase) (por ejemplo,
MyClass). - Los nombres de método deben estar en minúsculas, con las palabras separadas por guiones bajos (por ejemplo,
my_method).
Ejemplo:
# Good
class MyClass:
my_variable = 10
def my_method(self):
pass
# Bad
class myclass:
MyVariable = 10
def MyMethod(self):
pass10.1.6: Comentarios:
Al escribir código, es importante usar comentarios para explicar el propósito del código, especialmente cuando podría ser difícil de entender. Los comentarios ayudan a otros programadores que puedan necesitar trabajar con tu código a comprender cómo funciona y qué hace.
Se recomienda usar comentarios en línea con moderación, ya que agregar demasiados puede dificultar la lectura del código. Al agregar comentarios en línea, es importante separarlos del código con al menos dos espacios.
Comienza siempre los comentarios con mayúscula y termina con punto. Esto ayuda a mantener la consistencia y la legibilidad dentro de tu código, y puede facilitar que otros comprendan lo que estás tratando de lograr.
En resumen, los comentarios son una parte vital de escribir buen código y pueden ayudar a que tu código sea más comprensible y mantenible. ¡Así que no olvides agregar comentarios a tu código!
Ejemplo:
# Good
def my_function():
# Calculate the result based on some logic.
result = 42
return result
# Bad
def my_function():
result = 42 # Calculate the result based on some logic.
return result10.1.7: Docstrings:
El uso de docstrings, o cadenas de texto entre triples comillas, es una excelente manera de proporcionar documentación para sus módulos, clases, funciones y métodos. Esto puede ayudar a otros a comprender el propósito y el uso de su código de manera más efectiva, lo cual puede ser especialmente importante cuando se trabaja en proyectos con otros o se contribuye a proyectos de código abierto.
No solo una buena documentación facilita que otros utilicen y construyan sobre su código, sino que también puede hacer que sea más fácil para usted volver a su propio código más tarde y recordar cómo funciona. De hecho, muchos desarrolladores consideran que una buena documentación es tan importante como el propio código, ya que puede ayudar a asegurar que su código sea mantenible y utilizable a largo plazo. Entonces, si aún no está utilizando docstrings en su código, podría valer la pena tomar el tiempo para comenzar a incorporarlos en sus prácticas de programación.
Ejemplo:
# Good
def my_function(arg1, arg2):
"""
Calculate the sum of two arguments.
Args:
arg1 (int): The first argument.
arg2 (int): The second argument.
Returns:
int: The sum of the two arguments.
"""
return arg1 + arg2
# Bad
def my_function(arg1, arg2):
# Calculate the sum of two arguments
return arg1 + arg2Estas son sólo algunas de las muchas pautas proporcionadas por PEP 8. Se recomienda leer el documento completo de PEP 8 (https://www.python.org/dev/peps/pep-0008/) para familiarizarse con todas las directrices y aplicarlas consistentemente en sus proyectos Python.
Ejercicio 10.1.1: Sangría PEP 8
En este ejercicio, practicará cómo corregir la sangría en un script de Python para seguir las pautas de PEP 8.
Instrucciones:
Corrija la sangría en el script de Python proporcionado. El guión debe tener 4 espacios para cada nivel de sangría.
Solución:
def my_function(arg1, arg2):
result = arg1 + arg2
return result
if __name__ == "__main__":
num1 = 5
num2 = 10
sum_result = my_function(num1, num2)
print(f"The sum of {num1} and {num2} is {sum_result}.")Output:
The sum of 5 and 10 is 15.Exercise 10.1.2: PEP 8 Imports
In this exercise, you'll practice organizing imports according to PEP 8 guidelines.
Instructions:
Reorganize the given imports in the Python script so that they follow the PEP 8 guidelines.
Solution:
import os
import sys
import requests
from my_module import my_function
print("Imports organized according to PEP 8.")Output:
Imports organized according to PEP 8.Nota: La salida variará según su sistema y el "my_module" real que importe.
Ejercicio 10.1.3: Convenciones de Nombres PEP 8
En este ejercicio, practicarás aplicar las convenciones de nombres PEP 8 a un script de Python.
Instrucciones:
Actualiza el script de Python dado para que siga las convenciones de nombres PEP 8 para variables, funciones y clases.
Solución:
class MyClass:
my_variable = 10
def my_method(self):
return self.my_variable * 2
def main():
my_instance = MyClass()
result = my_instance.my_method()
print(f"The result is: {result}")
if __name__ == "__main__":
main()Salida:
The result is: 20