Estilo de Código PEP 8 en Python

Introducción

En este laboratorio, aprenderá a aplicar la guía de estilo PEP 8 a su código Python. PEP 8 es la guía de estilo oficial para Python, que proporciona un conjunto de recomendaciones para escribir código legible y consistente. Seguir estas directrices hace que su código sea más fácil de leer tanto para usted como para otros.

Practicará la implementación de reglas clave de PEP 8 para la indentación, la longitud de la línea, el espaciado y las convenciones de nomenclatura. También aprenderá a utilizar la herramienta autopep8 para formatear automáticamente su código, ahorrándole tiempo y asegurando el cumplimiento de los estándares de la comunidad.

Comprender la Indentación y la Longitud de Línea de PEP 8

Una sangría (indentación) adecuada y la longitud de línea son fundamentales para un código Python legible. En este paso, aprenderá y aplicará las directrices de PEP 8 para estos dos aspectos.

Sangría (Indentation): PEP 8 recomienda usar 4 espacios por nivel de sangría. Esta es una convención sólida en la comunidad Python.

Longitud de Línea (Line Length): PEP 8 sugiere limitar todas las líneas a un máximo de 79 caracteres. Para docstrings y comentarios, el límite es de 72 caracteres. Esto mejora la legibilidad, especialmente en pantallas más pequeñas o al comparar código lado a lado.

Pongamos esto en práctica. En el explorador de archivos de la izquierda, busque y abra el archivo indentation_example.py. El código interior demuestra la sangría correcta para definiciones de funciones y sentencias de múltiples líneas.

## Correct indentation using 4 spaces.
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

## Define some variables for demonstration.
var_one = "first"
var_two = "second"
var_three = "third"
var_four = "fourth"

## Aligning with the opening delimiter.
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

## Using a hanging indent. The first line has no arguments,
## and subsequent lines are indented to distinguish them.
bar = long_function_name(
    var_one, var_two,
    var_three, var_four)

## A multi-line list.
my_list = [
    1, 2, 3,
    4, 5, 6,
]

## Calling the functions to produce output.
long_function_name("first call", "second", "third", "fourth")
foo = long_function_name("second call", "second", "third", "fourth")
bar = long_function_name("third call", "second", "third", "fourth")

Después de revisar el código, ejecute el script para ver su salida. Abra la terminal en la parte inferior del WebIDE y ejecute el siguiente comando:

python ~/project/indentation_example.py

El script se ejecutará e imprimirá el primer argumento de cada llamada a la función. La salida será:

first call
second call
third call

Este ejercicio demuestra cómo una sangría consistente hace que las llamadas a funciones complejas y las estructuras de datos sean mucho más fáciles de leer.

Practicar Espaciado y Convenciones de Nomenclatura

El espaciado consistente y las convenciones de nomenclatura claras también son cruciales para la legibilidad del código. Este paso cubre las reglas de PEP 8 para ambos.

Espaciado:

• Use un solo espacio alrededor de la mayoría de los operadores (=, +=, ==, <, >).
• Use un espacio después de las comas en listas, tuplas y argumentos de funciones.
• Evite espacios adicionales inmediatamente dentro de paréntesis, corchetes o llaves.

Convenciones de Nomenclatura:

• snake_case: Úselo para funciones y variables (ejemplo: my_function, user_name).
• PascalCase: Úselo para nombres de clases (ejemplo: MyClass).
• UPPERCASE_SNAKE_CASE: Úselo para constantes (ejemplo: MAX_CONNECTIONS).

Veamos estas reglas en acción. En el explorador de archivos, abra el archivo style_guide_example.py. El código incluye ejemplos de espaciado y nomenclatura correctos, con versiones incorrectas comentadas para su comparación.

## A constant
MAX_OVERFLOW = 100

## A class name in PascalCase
class MySampleClass:
    def __init__(self, name):
        ## A variable name in snake_case
        self.instance_name = name

    ## A function name in snake_case
    def sample_method(self, var_one, var_two):
        ## Correct spacing around operators and after comma
        result = var_one + var_two
        print(self.instance_name, result)

## --- Incorrect examples for comparison ---
## class mySampleClass:
##     def SampleMethod(self, varOne, varTwo):
##         result=varOne+varTwo
##         print(self.instance_name,result)

## Create an object and call the method
my_object = MySampleClass("TestObject")
my_object.sample_method(10, 5)

Guarde el archivo si realizó algún cambio y ejecútelo desde la terminal:

python ~/project/style_guide_example.py

La salida mostrará el nombre del objeto y el resultado del cálculo:

TestObject 15

Al seguir estas reglas de espaciado y nomenclatura, hace que la estructura y el propósito de su código sean inmediatamente más claros para cualquier lector.

Usar autopep8 para Formato Automático

Formatear el código manualmente puede ser tedioso. Afortunadamente, existen herramientas para automatizar este proceso. En este paso, instalará y utilizará autopep8, una herramienta popular que reformatea automáticamente el código Python para que cumpla con la guía de estilo PEP 8.

Primero, necesita instalar el paquete autopep8. Abra la terminal y ejecute el siguiente comando. Se utiliza sudo para instalarlo a nivel de sistema.

sudo pip3 install autopep8

El proceso de instalación comenzará y debería ver una salida que confirme su instalación exitosa:

Collecting autopep8
...
Successfully installed autopep8-X.Y.Z

A continuación, trabajaremos con un archivo Python que tiene un formato deliberadamente deficiente. En el explorador de archivos, abra unformatted_code.py y examine su contenido:

a=1
b=2;
def  my_function ( arg1 , arg2 = 0 ):
    result = arg1+arg2
    print( result)

Este código tiene varios problemas de estilo: espaciado inconsistente, un punto y coma redundante y espacios adicionales en la definición de la función.

Ahora, usemos autopep8 para corregirlo. La bandera --in-place indica a la herramienta que modifique el archivo directamente. Ejecute este comando en su terminal:

autopep8 --in-place ~/project/unformatted_code.py

Una vez que el comando finalice, abra unformatted_code.py nuevamente en el editor. Verá que el código se ha limpiado automáticamente:

a = 1
b = 2


def my_function(arg1, arg2=0):
    result = arg1 + arg2
    print(result)

Observe cómo autopep8 corrigió el espaciado, eliminó el punto y coma y agregó dos líneas en blanco antes de la definición de la función, según lo recomendado por PEP 8. Usar un formateador automático como autopep8 es una forma muy eficiente de mantener un estilo de código consistente en todos sus proyectos.

Uniendo Todo: Refactorización de un Script

Ahora es el momento de aplicar todo lo que ha aprendido. En este paso, refactorizará manualmente un script que viola varias pautas de PEP 8. Este ejercicio pondrá a prueba su comprensión de la indentación, el espaciado y las convenciones de nomenclatura.

Primero, abra refactor_challenge.py desde el explorador de archivos. Contiene el siguiente código, que calcula el área de un rectángulo pero está escrito con un estilo deficiente.

## This script calculates the area of a rectangle and prints it.
def CalculateArea(width,height):
    Area = width*height ## calculate area
    return Area

w = 10
h = 5
rectangle_area=CalculateArea(w,h)
print("The area of the rectangle is:",rectangle_area)

Su tarea es editar manualmente este código en el editor para que cumpla con PEP 8. Busque problemas con:

1. Nomenclatura de Funciones: Los nombres de las funciones deben estar en snake_case.
2. Nomenclatura de Variables: Los nombres de las variables también deben estar en snake_case.
3. Espaciado: Verifique el espaciado adecuado alrededor de los operadores y después de las comas.
4. Comentarios: Los comentarios en línea deben tener un espacio después del #.

Tómese un momento para refactorizar el código usted mismo. Una vez que haya terminado, su código debería verse similar a esto:

## This script calculates the area of a rectangle and prints it.
def calculate_area(width, height):
    """Calculate and return the area of a rectangle."""
    area = width * height  ## calculate area
    return area


w = 10
h = 5
rectangle_area = calculate_area(w, h)
print("The area of the rectangle is:", rectangle_area)

Observe los cambios: CalculateArea se convirtió en calculate_area, Area se convirtió en area, y el espaciado se corrigió. También agregamos una docstring (cadena de documentación) a la función, que es una mejor práctica para explicar lo que hace una función.

Guarde sus cambios y ejecute el script para asegurarse de que todavía funciona correctamente:

python ~/project/refactor_challenge.py

La salida debería ser:

The area of the rectangle is: 50

Este ejercicio demuestra que refactorizar por estilo no cambia lo que hace el código, pero mejora drásticamente su legibilidad y mantenibilidad.

Resumen

En este laboratorio, ha aprendido los fundamentos de la guía de estilo PEP 8 para Python. Practicó la aplicación de reglas para la indentación, la longitud de línea, el espaciado y las convenciones de nomenclatura. También descubrió el poder de autopep8 para formatear automáticamente su código y cumplir con estos estándares. Al completar un desafío final de refactorización, unió todos estos conceptos para transformar un script mal estilizado en código Python limpio, legible y mantenible. Adherirse a PEP 8 es una práctica clave para cualquier desarrollador profesional de Python, ya que fomenta la colaboración y mejora la calidad del código.