Tutorial PEP-8: Normas de código en Python

La PEP-8 o Propuesta de Mejora de Python presenta algunos de los puntos clave que puedes utilizar para que tu código sea más organizado y legible. Como dice Guido Van Rossum, creador de Python:

El código se lee mucho más a menudo de lo que se escribe.

En este post, ¡empezarás a explorar PEP-8 con algunos ejemplos de código! Cubrirás los siguientes temas:

• Primero te presentaremos PEP-8, qué es y por qué lo necesitas;
• A continuación, abordarás la sangría, un tema candente entre los programadores. ¿Debes utilizar tabuladores o espacios? Descubrirás la respuesta en esta sección;
• Quizá no te lo esperes, pero existen directrices sobre la longitud máxima de las líneas;
• Además, se propone una forma de tratar las líneas en blanco;
• A continuación, los espacios en blanco en expresiones y sentencias es algo que también puedes abordar fácilmente como principiante;
• ¿Qué es la codificación y por qué la necesitas cuando trabajas con Python? ¿Cuál es la codificación por defecto de Python3? La sección de codificación de la línea de origen se ocupará de todo esto.
• Probablemente realizas importaciones con frecuencia cuando codificas. En esta sección se abordarán temas como el orden de tus importaciones, las importaciones absolutas y relativas, y las importaciones comodín, etc;
• La documentación es esencial para realizar un seguimiento de todos los aspectos de una aplicación y mejora la calidad general del producto final. ¡Los comentarios son esenciales aquí!
• ¿Conoces los nombres de dunder a nivel de modelo? Son especialmente útiles en las cadenas de documentos.
• Por último, también aprenderás más sobre las convenciones de nomenclatura: descubrirás cómo se te ocurren los nombres de las funciones, qué tipo de estilo de nomenclatura utilizarías normalmente y mucho más;
• ¿Cumple tu Código el PEP-8? Es sin duda una pregunta que debes hacerte. Por eso la última sección cubre algunas herramientas que te ayudarán a comprobar tu código para ver si cumple o no las directrices presentadas en este post ¡y las muchas más que no cubrimos aquí!

Introducción a PEP-8

El lenguaje de programación Python se ha convertido en uno de los lenguajes de programación preferidos por muchos. Es un lenguaje relativamente fácil de aprender, es multiparadigma, tiene montones de módulos de código abierto que aumentan la utilidad del lenguaje, y es una herramienta de referencia en la comunidad de la ciencia de datos y el desarrollo web.

Sin embargo, sólo podrás aprovechar las ventajas de Python cuando sepas expresar mejor tus ideas con tu código. Python se hizo con algunos objetivos en mente, estos objetivos se pueden ver cuando escribes import this.

import this
Con la tecnología de

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!
Con la tecnología de

Los anteriores son los 20 principios que utiliza la programación en Python, conocidos como el Zen de Python. También puedes ver "La legibilidad cuenta" en el resultado anterior, que debería ser tu principal preocupación al escribir código: otros programadores o científicos de datos deberían entenderlo y deberían poder contribuir a tu código para que pueda resolver la tarea que tienes entre manos.

Las siguientes secciones te darán más información sobre cómo puedes conseguir lo anterior.

Indentación

Al programar en Python, la indentación es algo que utilizarás sin duda. Sin embargo, debes tener cuidado con él, ya que puede dar lugar a errores de sintaxis. La recomendación es, por tanto, utilizar cuatro espacios para la sangría. Por ejemplo, esta afirmación utiliza cuatro espacios de sangría:

if True:
    print("If works")
Con la tecnología de

Y también este bucle for con la declaración print está sangrado con cuatro espacios:

for element in range(0, 5):
    print(element)
Con la tecnología de

Cuando escribas una expresión grande, es mejor mantenerla alineada verticalmente. Al hacerlo, crearás una "sangría colgante".

Aquí tienes algunos ejemplos de la sangría colgante en expresiones grandes, que muestran algunas variaciones de cómo puedes utilizarla:

1. value = square_of_numbers(num1, num2,
                          num3, num4)
   Con la tecnología de

2. def square_of_number(
        num1, num2, num3, 
        num4):
    return num1**2, num2**2, num3**2, num4**2
   Con la tecnología de

3. value = square_of_numbers(
                 num1, num2,
                 num3, num4)
   Con la tecnología de

4. list_of_people = [
    "Rama",
    "John",
    "Shiva"
   ]
   Con la tecnología de

5. dict_of_people_ages = {
    "ram": 25,
    "john": 29,
    "shiva": 26
   }
   Con la tecnología de

Todos los desarrolladores que trabajan con Python u otro lenguaje de programación se preguntan en algún momento si utilizar tabuladores o espacios para la sangría. La diferencia entre tabuladores y espacios es un debate continuo en la comunidad. Consulta, por ejemplo, este artículo de Stackoverflow.

Generalmente, los espacios son el medio de indentación preferido, pero si encuentras algunos scripts de Python que ya utilizan las tabulaciones, deberías seguir haciendo la indentación con tabulaciones. De lo contrario, debes cambiar la sangría de todas las expresiones de tu script con espacios.

Ten en cuenta que Python 3 no permite mezclar tabuladores y espacios para la sangría. Por eso debes elegir una de las dos y quedarte con ella.

Longitud máxima de la línea

En general, es bueno que tu código Python tenga una longitud de línea de 79 caracteres.

Seguir este número objetivo tiene muchas ventajas. Un par de ellas son las siguientes:

• Es posible abrir archivos uno al lado del otro para compararlos;
• Puedes ver toda la expresión sin desplazarte horizontalmente, lo que contribuye a una mejor legibilidad y comprensión del código.

Los comentarios deben tener 72 caracteres de longitud de línea. Más adelante en este tutorial aprenderás más sobre las convenciones más comunes para los comentarios.

Al final, depende de ti qué convenciones y estilo de codificación te gusta seguir si trabajas en un grupo pequeño, y es aceptable que la mayoría de los desarrolladores se desvíen de la directriz de longitud máxima de línea. Sin embargo, si estás haciendo o contribuyendo a un proyecto de código abierto, probablemente querrás y/o necesitarás cumplir la regla de longitud máxima de línea que establece PEP-8.

Al utilizar el operador +, puedes utilizar mejor un salto de línea adecuado, lo que facilita la comprensión de tu código:

También puedes escribir:

total = A
        + B
        + C
Con la tecnología de

En resumen, puedes añadir una pausa antes o después de un operador binario, siempre que seas coherente. Si estás escribiendo código nuevo, debes intentar seguir la última opción presentada, en la que añades una pausa antes del operador binario.

Líneas en blanco

En los scripts de Python, la función de nivel superior y las clases están separadas por dos líneas en blanco. Las definiciones de métodos dentro de las clases deben ir separadas por una línea en blanco. Puedes verlo claramente en el siguiente ejemplo:

import unittest

class SwapTestSuite(unittest.TestCase):
    """
        Swap Operation Test Case
    """
    def setUp(self):
        self.a = 1
        self.b = 2

    def test_swap_operations(self):
        instance = Swap(self.a,self.b)
        value1, value2 =instance.get_swap_values()
        self.assertEqual(self.a, value2)
        self.assertEqual(self.b, value1)


class OddOrEvenTestSuite(unittest.TestCase):
    """
        This is the Odd or Even Test case Suite
    """
    def setUp(self):
        self.value1 = 1
        self.value2 = 2

    def test_odd_even_operations(self):
        instance1 = OddOrEven(self.value1)
        instance2 = OddOrEven(self.value2)
        message1 = instance1.get_odd_or_even()
        message2 = instance2.get_odd_or_even()
        self.assertEqual(message1, 'Odd')
        self.assertEqual(message2, 'Even')Con la tecnología de

Las clases SwapTestSuite y OddOrEvenTestSuite están separadas por dos líneas en blanco, mientras que las definiciones de métodos, como .setUp() y .test_swap_operations() sólo tienen una línea en blanco para separarlas. El código se ejecutará correctamente, pero no generará ninguna salida, ya que le falta el código necesario para ejecutar la prueba unitaria (sólo es una muestra de buenas prácticas).

Espacios en blanco en expresiones y sentencias

Debes intentar evitar los espacios en blanco cuando veas que tu código está escrito como en los siguientes ejemplos:

Estos ejemplos se tomaron del PEP-8.

Codificación del archivo fuente

Un ordenador no puede almacenar "letras", "números", "imágenes" ni ninguna otra cosa; sólo puede almacenar y trabajar con bits, que sólo pueden tener valores binarios: yes o no, true o false, 1 o 0, etc. Como ya sabes, un ordenador funciona con electricidad; esto significa que un bit "real" es la presencia o ausencia de un pitido de electricidad. Normalmente representarías esta (falta de) presencia con 1 y 0.

Para utilizar bits para representar cualquier otra cosa que no sean bits, necesitas un conjunto de reglas. Tienes que convertir una secuencia de bits en algo como letras, números e imágenes utilizando un esquema de codificación o codificación. Ejemplos de esquemas de codificación son ASCII, UTF-8, etc:

• El Código Estándar Americano para el Intercambio de Información (ASCII) es el formato más común para archivos de texto en ordenadores y en Internet. En este tipo de archivos, cada carácter alfabético, numérico o especial se representa con un número binario de 7 bits (una cadena de siete 0 ó 1).
• El Estándar Mundial de Caracteres Unicode, o Unicode abreviado, es un sistema para "el intercambio, procesamiento y visualización de los textos escritos de las diversas lenguas del mundo moderno". En resumen, Unicode está diseñado para dar cabida a todos los sistemas de escritura conocidos del mundo. Unicode emplea actualmente tres codificaciones diferentes para representar los conjuntos de caracteres Unicode: UTF-8, UTF-16 y UTF-32.
  • UTF-16 es una codificación Unicode de longitud variable: los puntos de código se codifican con una o dos unidades de código de 16 bits.
  • UTF-8 es otro tipo de codificación Unicode de longitud variable, que utiliza de uno a cuatro bytes de 8 bits.
  • UTF-32 es una codificación de longitud fija que utiliza exactamente 32 bits por punto de código Unicode.

Consejo: si quieres saber más sobre codificación, consulta este post.

¿Por qué es importante?

Habrás comprobado que las cadenas son uno de los tipos de datos más utilizados en Python. Como es de esperar, habrá un momento en que quieras trabajar con cadenas que contengan o estén formadas totalmente por caracteres que no formen parte del conjunto ASCII estándar. Después de todo, puede ocurrir que tengas que trabajar con textos que contengan caracteres acentuados, como á, ž, ç etc.

Ahora, en Python 3, UTF-8 es la codificación fuente por defecto. Pero, para los que utilicéis Python 2, probablemente ya sabréis que allí el valor por defecto es ASCII.

Pero, ¿qué ocurre si tienes una cadena que contiene un carácter no ASCII, como "Flügel"?

Cuando hagas referencia a la cadena en Python 2, obtendrás lo siguiente:

>>> s 
'Fl\xfcgel'
Con la tecnología de

¡Esto no se parece a tu cuerda! ¿Qué ocurre cuando lo imprimes?

>>> print(s)
Flügel
Con la tecnología de

La impresión te dio el valor que asignaste a la variable. Se codificó el carácter no ASCII ÃŒ. Por eso te devolvió \xfc cuando hiciste referencia a la cadena. Para ello, puedes utilizar los métodos de cadena .encode() y .decode(). El primero devuelve una versión en cadena de 8 bits de la cadena Unicode, codificada en la codificación solicitada, mientras que el segundo interpreta la cadena utilizando la codificación dada.

Importaciones

Importar bibliotecas y/o módulos es algo que harás a menudo cuando trabajes con Python para la ciencia de datos. Como ya sabrás, siempre debes importar bibliotecas al principio de tu guión.

Ten en cuenta que si haces muchas importaciones, debes asegurarte de indicar cada importación en una sola línea.

Echa un vistazo a la siguiente tabla para entenderlo un poco mejor:

Además, debes tener en cuenta que hay un orden que debes respetar cuando importes bibliotecas. En general, puedes seguir este orden:

1. Importación de bibliotecas estándar.
2. Importaciones de terceros relacionadas.
3. Importaciones locales específicas de la aplicación/biblioteca.

Importaciones absolutas y relativas

A continuación, conviene conocer la diferencia entre importaciones absolutas y relativas. En general, en Python se prefieren las importaciones absolutas, ya que aumentan la legibilidad. Sin embargo, a medida que tu aplicación se vuelva más compleja, puedes seguir utilizando también las importaciones relativas. Las importaciones relativas implícitas no deben utilizarse nunca y se han eliminado en Python 3.

Pero, ¿qué son estas importaciones absolutas y relativas?

• Una importación absoluta es una importación que utiliza la ruta absoluta de la función o clase, separada por .. Por ejemplo,

    import sklearn.linear_model.LogisticRegression
  Con la tecnología de

• Una importación relativa es una importación relativa a la posición actual en la que se encuentra tu archivo Python. Podrías utilizar este tipo de importación si la estructura de tu proyecto está creciendo, ya que hará que tu proyecto sea más legible. Eso significa que, si tienes una estructura de proyecto Python como la siguiente

    .
    ├── __init__.py
    ├── __init__.pyc
    ├── __pycache__
    │   ├── __init__.cpython-35.pyc
    │   ├── bubble_sort.cpython-35.pyc
    │   ├── selection_sort.cpython-35.pyc
    ├── bubble_sort.py
    ├── heap_sort.py
    ├── insertion_sort.py
    ├── insertion_sort.pyc
    ├── merge_sort.py
    ├── merge_sort.pyc
    ├── quick_sort.py
    ├── radix_sort.py
    ├── selection_sort.py
    ├── selection_sort.pyc
    ├── shell_sort.py
    ├── tests
    │   ├── test1.py
  Con la tecnología de

Podrías utilizar una importación relativa para importar el algoritmo de ordenación burbuja BubbleSort, almacenado en bubble_sort.py en test1. Sería así:

from ..bubble_sort import BubbleSort
Con la tecnología de

Si quieres saber más sobre importaciones absolutas y relativas, puedes consultar la PEP 328.

Importaciones comodín

Por último, debes intentar evitar las importaciones comodín, porque no aportan legibilidad; por ejemplo, no puedes saber qué clases, métodos o variables utilizas de tu módulo:

from scikit import *Con la tecnología de

Comentarios

Los comentarios se utilizan para documentar el código en Python. Aumentan la comprensión del código. Hay muchas herramientas que puedes utilizar para generar documentación, como comentarios y docstrings, para tu propio módulo. Los comentarios deben ser más detallados para que, cuando alguien lea el código, comprenda correctamente el código y cómo se utiliza con otras partes del código.

Los comentarios comienzan con el símbolo #. Todo lo que se escriba después del hashtag no será ejecutado por el intérprete. Por ejemplo, el siguiente fragmento de código sólo devolverá "This is a Python comment".

# This is a Python single line comment
print("This is a Python comment")
Con la tecnología de

Recuerda: ¡en la sección anterior leíste que los comentarios deben tener 72 caracteres de longitud de línea!

Dicho esto, hay tres tipos de comentarios:

• Utiliza comentarios en bloque para explicar el código más complejo o desconocido para los demás. Suelen ser comentarios más largos y se aplican a parte o a todo el código que sigue. Los comentarios de bloque están sangrados al mismo nivel que el código. Cada línea de un comentario en bloque comienza con la etiqueta # y un espacio. Si necesitas utilizar más de un párrafo, deben ir separados por una línea que contenga un único #.

Echa un vistazo al siguiente extracto, extraído de la biblioteca scikit-learn , para entender cómo son estos comentarios:

   if Gram is None or Gram is False:
        Gram = None
        if copy_X:
            # force copy. setting the array to be fortran-ordered
            # speeds up the calculation of the (partial) Gram matrix
            # and allows to easily swap columns
            X = X.copy('F')
Con la tecnología de

• Debes utilizar los comentarios en línea con moderación, aunque pueden ser eficaces cuando necesites explicar algunas partes de tu código. También pueden ayudarte a recordar lo que significa una línea concreta de código o pueden resultarte útiles cuando colabores con alguien que no esté familiarizado con todos los aspectos de tu código. Utiliza comentarios en línea en la misma línea de una sentencia, a continuación del propio código. Estos comentarios también empiezan por # y un espacio.

Por ejemplo:

counter = 0  # initialize the counter
Con la tecnología de

• Escribe cadenas de documentación o docstrings al principio de los módulos, archivos, clases y métodos públicos. Este tipo de comentarios empiezan por """ y terminan por """:

    """
        This module is intended to provide functions for scientific computing 
    """Con la tecnología de

Nombres de dominio a nivel de módulo

Ahora que has leído lo que son las docstrings, también debes saber que los subrayados a nivel de módulo, o nombres con dos guiones bajos iniciales y dos finales, son muy eficaces en Python. Son los nombres especiales que Python define para no entrar en conflicto con las funciones o nombres definidos por el usuario. Para más información, puedes consultar este artículo.

Un dunder a nivel de módulo como (__all__, __author__, __version__) debe colocarse en el docstring principal del módulo y debe estar antes de todas las declaraciones import. Debes definir las importaciones de from __future__ antes que cualquier otro código, excepto los docstrings:

"""
    Algos module consists of all the basic algorithms and their implementation
"""

from __future__ import print

__all__ = ['searching', 'sorting']
__version__ = '0.0.1'
__author__ = 'Chitrank Dixit'

import os
import sys
Con la tecnología de

Consejo: consulta las siguientes convenciones para escribir docstrings.

Convenciones de nomenclatura

Cuando programes en Python, seguramente utilizarás una convención de nomenclatura, un conjunto de reglas para elegir la secuencia de caracteres que debe utilizarse para los identificadores que denotan variables, tipos, funciones y otras entidades en el código fuente y la documentación.

Si no estás seguro de qué estilos de denominación existen, ten en cuenta los siguientes:

• b o una sola letra minúscula;
• B o una sola letra mayúscula;
• lowercase
• UPPERCASE
• lower_case_with_underscores
• UPPER_CASE_WITH_UNDERSCORES
• CapitalizedWordsque también se conoce como CapWords, CamelCase o StudlyCaps.
• mixedCase
• Capitalized_Words_With_Underscores
• _single_leading_underscore: indicador débil de "uso interno". por ejemplo, from M import * no importa objetos cuyo nombre empiece por guión bajo.
• single_trailing_underscore_: utilizado por convención para evitar conflictos con palabras clave de Python, por ejemplo, Tkinter.Toplevel(master, class_='ClassName')
• __double_leading_underscore: al nombrar un atributo de clase, invoca la manipulación de nombres (dentro de la clase FooBar, __boo se convierte en _FooBar__boo).
• __double_leading_and_trailing_underscore__: objetos o atributos "mágicos" que viven en espacios de nombres controlados por el usuario. Por ejemplo, __init__, __import__ o __file__. Nunca debes inventar esos nombres, sino utilizarlos sólo como están documentados.

Convenciones generales de nomenclatura

La tabla siguiente te muestra algunas pautas generales sobre cómo nombrar tus identificadores:

• No utilices "l", "O" o "I" como nombre de una variable: estos caracteres tienen un aspecto similar al cero (0) y (1) en algunos tipos de letra.
• En general, es bueno utilizar nombres cortos si es posible. En algunos casos, puedes utilizar guiones bajos para mejorar la legibilidad.

Si quieres saber más sobre las excepciones a las convenciones generales de nomenclatura, consulta este artículo.

¿Cumple tu Código el PEP-8?

Después de aprender más sobre PEP-8, probablemente te preguntes cómo puedes comprobar si tu código cumple realmente estas directrices (¡y otras más que no se han tratado en este tutorial!).

Además de echar un vistazo a PEP-8 y aprender más sobre él, deberías considerar la posibilidad de echar un vistazo al práctico módulo pep8, al paquete coala y a otras alternativas que se describen en las siguientes secciones.

Python pep8 Paquete

El paquete pep8 puede utilizarse para comprobar la incompatibilidad PEP-8 en tu código Python y sugerir cambios para que siga las directrices PEP-8. Puedes instalar el módulo pep8 utilizando pip ejecutando el siguiente comando:

pip install pep8Con la tecnología de

Para demostrar cómo funciona pep8, crea un nuevo archivo Python llamado example.py con el siguiente código:

def my_function(a, b):
    print("The sum of a and b is: ", a + b)

a = 1
b = 2

my_function(a,b)Con la tecnología de

Guarda el archivo y, a continuación, ejecuta el comando pep8 sobre él en tu terminal o símbolo del sistema de la siguiente manera:

pep8 example.pyCon la tecnología de

Esto mostrará las incompatibilidades PEP-8 que pep8 haya detectado en el código, de la siguiente manera:

example.py:1:1: E302 expected 2 blank lines, found 0
example.py:3:5: E225 missing whitespace around operator
example.py:5:5: E225 missing whitespace around operatorCon la tecnología de

La primera línea de salida indica que debería haber dos líneas en blanco antes de la definición de la función en la línea 1. Las dos líneas siguientes indican que debe haber espacios en blanco alrededor del operador de suma en la sentencia print y en las sentencias de asignación.

Para solucionar estos problemas, puedes modificar el código como se indica a continuación:

def my_function(a, b):
    print("The sum of a and b is:", a + b)

a = 1
b = 2

my_function(a, b)Con la tecnología de

Ahora, cuando vuelvas a ejecutar pep8 example.py, no debería salir nada, lo que indica que el código cumple ahora con PEP-8.

También puedes ver el código fuente donde se encuentra la incompatibilidad con el argumento --show-source:

$ pep8 --show-source --show-pep8 testsuite/E40.py
testsuite/E40.py:2:10: E401 multiple imports on one line
import os, sys
         ^
    Imports should usually be on separate lines.

    Okay: import os\nimport sys
    E401: import sys, os
Con la tecnología de

O puedes mostrar la frecuencia con la que se ha encontrado cada error añadiendo --statistics:

$ pep8 --statistics -qq Python-2.5/Lib
232     E201 whitespace after '['
599     E202 whitespace before ')'
631     E203 whitespace before ','
842     E211 whitespace before '('
2531    E221 multiple spaces before operator
4473    E301 expected 1 blank line, found 0
4006    E302 expected 2 blank lines, found 1
165     E303 too many blank lines (4)
325     E401 multiple imports on one line
3615    E501 line too long (82 characters)
612     W601 .has_key() is deprecated, use 'in'
1188    W602 deprecated form of raising exception
Con la tecnología de

Consejo: asegúrate también de consultar otros módulos, como flake8, autopep8 o pylint¡!

Analizar tu código con coala

coala proporciona linting y corrección para todos los lenguajes, pero aquí te preocupa más la programación en Python, puedes instalar coala utilizando pip:

$ pip3 install coala-bears
Con la tecnología de

En el fragmento de código anterior, ves que en realidad instalas coala-bears: bears son plugins o módulos sencillos que amplían la capacidad de tu coala y varían de un idioma a otro. En este caso, te conviene utilizar pep8bear, que encuentra el código incompatible con PEP-8 y lo corrige in situ. Definitivamente, deberías plantearte utilizarlo para comprobar tu código Python.

$ coala -S python.bears=PEP8Bear python.files=\*\*/\*.py \
python.default_actions=PEP8Bear:ApplyPatchAction --save
# other output ...
Executing section python...
[INFO][11:03:37] Applied 'ApplyPatchAction' for 'PEP8Bear'.
[INFO][11:03:37] Applied 'ApplyPatchAction' for 'PEP8Bear'.
Con la tecnología de

pep8online: Comprueba tu código Python en línea

Además del práctico módulo pep8 y del paquete coala, también puedes comprobar si tu código Python es compatible con PEP-8 visitando pep8online. Este sitio tiene un editor en línea que te permite simplemente pegar tu código, ¡y pulsar el botón "Comprobar código"! Como resultado, obtendrás información sobre lo que necesitas mejorar. ¡Bonito y práctico!

Conclusión

Cuando utilizas Python, a veces no te preocupas por la calidad del código debido a la ansiedad de lanzar funciones más rápidamente. Sin embargo, las prácticas descritas en este tutorial -y muchas otras que no se han tratado aquí- deberían formar parte de tu ciclo de desarrollo-evaluación-prueba-despliegue. Esto beneficia a todos los que trabajan en el proyecto para comprenderlo y la mayoría de las veces se pueden hacer cambios en el código sin tener que profundizar y comprender el código iniciando depuradores. Si trabajas en un proyecto de código abierto, tus colaboradores encontrarán la PEP-8 una bendición y entenderán mejor tu código, ya que es la norma universal que siguen todos los desarrolladores de Python.

Ahora que has repasado este tutorial, ¡es una muy buena idea que compruebes el PEP-8 por ti mismo! Hay mucho más por descubrir.

Si tienes más consejos sobre cómo cumplir con PEP-8 o si crees que nos hemos dejado algo importante en este artículo, no dudes en hacérnoslo saber @DataCamp.