Escritura de Código Pytónico y Buenas Prácticas en Python

Resumen

¿Por qué es importante escribir código Pytónico?

Escribir código Pytónico es fundamental para cualquier desarrollador que aspire a trabajar en proyectos grandes y colaborativos. No se trata solo de hacer que el código funcione, sino de garantizar que sea claro, eficiente y mantenible. Al dominar estas habilidades, un desarrollador no solo mejora su capacidad para colaborar con otros, sino que también contribuye significativamente a la calidad de los proyectos. Este enfoque resalta la importancia de seguir las mejores prácticas de Python, un lenguaje celebrado por su simplicidad y legibilidad.

¿Qué es el código Pytónico?

El término "código Pytónico" se refiere a la aplicación de las mejores prácticas y convenciones del lenguaje Python. Siguiendo estas pautas, los desarrolladores pueden escribir código que sea:

Simple y directo: Resolver problemas de la manera más clara y sencilla posible.
Legible: Permitir que cualquier desarrollador pueda entender el código rápidamente.
Eficiente: A pesar de que Python no es el lenguaje más rápido, es crucial crear soluciones optimizadas.

Ejemplo de mejora Pytónica

Consideremos un caso común de iteración en código no optimizado. Podemos transformar un bucle for tradicional que calcula cuadrados de números usando list comprehension. Este enfoque simplifica y optimiza el proceso, mejorando tanto la legibilidad como la eficiencia.

# Código lento y poco eficiente
numeros = [1, 2, 3, 4, 5]
cuadrados = []
for numero in numeros:
    cuadrados.append(numero ** 2)

# Código Pytónico usando list comprehension
cuadrados = [numero ** 2 for numero in numeros]

¿Cómo seguir las convenciones PEP8?

PEP8 es el documento oficial que establece las convenciones de estilo para Python, seguido por la industria entera. Estas convenciones nos guían para escribir un código que sea limpio y fácil de mantener.

Ejemplos de PEP8 en acción

Nombres de clases: Utilizar CamelCase. Ejemplo: Calculadora.
Nombres de funciones y variables: Usar snake_case, separando palabras con guiones bajos. Ejemplo: sumar_numeros.
Indentación: Aplicar cuatro espacios por nivel de indentación.
Longitud de línea: Mantener las líneas de código dentro de los 79 caracteres.
Espaciado: Incluir espacios antes y después de operadores y después de comas en listas de parámetros.

class Calculadora:
    def sumar(self, a, b):
        return a + b

¿Cuáles son los principios de un Pythonista?

Un verdadero Pythonista sigue tres principios clave para escribir código de calidad:

Simplicidad: Siempre buscar la solución más simple y directa.
Claridad: Asegurar que el código sea fácilmente comprensible por cualquier miembro del equipo.
Eficiencia: Desarrollar las soluciones más efectivas dentro de las capacidades de Python.

Reto para el desarrollo Pytónico

Para consolidar tus habilidades y aplicar lo aprendido, toma un fragmento de código y aplica estos principios. Notarás la diferencia en claridad y eficiencia, y estarás más preparado para trabajar en proyectos de alto nivel. ¡Adelante! Sigue explorando el mundo de Python y sus buenas prácticas, mejorando día a día tu código.

Mario Alexander Vargas Celis

student•

Escribir código Pythonico y profesional implica seguir ciertas convenciones y mejores prácticas que mejoran la legibilidad, mantenibilidad y eficiencia del código. Aquí hay algunas pautas y ejemplos:

### 1. **Nombres Significativos**

Usa nombres claros y descriptivos para variables, funciones y clases.


def calculate\_area(radius):

&#x20;   """Calcula el área de un círculo dado su radio."""

&#x20;   import math

&#x20;   return math.pi \* radius \*\* 2

### 2. **Funciones y Métodos Breves**

Las funciones deben realizar una única tarea y ser lo más cortas posible.


def is\_even(number):

&#x20;   """Devuelve True si el número es par, de lo contrario False."""

&#x20;   return number % 2 == 0

### 3. **Uso de Docstrings**

Documenta tus funciones y clases usando docstrings para describir su propósito y uso.


class Circle:

&#x20;   """Clase que representa un círculo."""



&#x20;   def \_\_init\_\_(self, radius):

&#x20;       """Inicializa el círculo con un radio."""

&#x20;       self.radius = radius



&#x20;   def area(self):

&#x20;       """Calcula el área del círculo."""

&#x20;       import math

&#x20;       return math.pi \* (self.radius \*\* 2)

### 4. **Listas por Comprensión**

Usa listas por comprensión para crear listas de manera más clara y eficiente.


squares = \[x\*\*2 for x in range(10)]

### 5. **Manejo de Errores**

Usa excepciones para manejar errores de forma limpia.


def divide(a, b):

&#x20;   """Divide dos números, manejando división por cero."""

&#x20;   try:

&#x20;       return a / b

&#x20;   except ZeroDivisionError:

&#x20;       return "No se puede dividir entre cero."

### 6. **Uso de with para Recursos**

Utiliza el manejo de contexto with para asegurarte de que los recursos se liberan adecuadamente.


with open('archivo.txt', 'r') as file:

&#x20;   contenido = file.read()

### 7. **Organización del Código**

Organiza tu código en módulos y paquetes. Mantén una estructura lógica y usa un archivo \_\_init\_\_.py si es necesario.

### 8. **Formato de Código**

Usa herramientas como black o flake8 para formatear tu código y mantener la consistencia.

### Ejemplo Completo

Aquí tienes un ejemplo completo que sigue las buenas prácticas:


import math



class Circle:

&#x20;   """Clase que representa un círculo."""



&#x20;   def \_\_init\_\_(self, radius):

&#x20;       """Inicializa el círculo con un radio."""

&#x20;       self.radius = radius



&#x20;   def area(self):

&#x20;       """Calcula el área del círculo."""

&#x20;       return math.pi \* (self.radius \*\* 2)



def main():

&#x20;   """Función principal del script."""

&#x20;   radius = float(input("Introduce el radio del círculo: "))

&#x20;   circle = Circle(radius)

&#x20;   print(f"El área del círculo es: {circle.area():.2f}")



if \_\_name\_\_ == "\_\_main\_\_":

&#x20;   main()

Este ejemplo muestra cómo estructurar el código de manera clara, usar docstrings, y manejar la entrada del usuario de forma segura y eficiente.

Alexis Dorado Muñoz

student•

Muchas gracias por tu aporte

Pedro Iván Juárez Cornejo

student•

Veo muy bien esta clase, son cosas que parecieran obvias, pero luego uno se encuentra con cada cosa tan horrorosa que te preguntas que pensaba la persona que escribio ese codigo jajajaja.

Yo aplico muchas de estas buenas practicas de las que mencionas sin importar el lenguaje de programacion

Alexis Dorado Muñoz

student•

Gracias por tu aporte

javier cuatzo cantú

student•

buenas practicas de programación:

iniciar las variables en mayúsculas
dividir las palabras con _
dejar 4 niveles de identacion cada que separemos una clase, función etc
después de una coma dejar un espacio

Además nuestro código deberá siempre reflejar:

simplicidad
claridad
eficiencia

Carlos Adrián Serrano Samayoa

student•

Escribir código Pythonico y profesional

Sirve principalmente para hacer código lo más comprensible con el objetivo de que colaboradores puedan modificarlo sin problemas

davidlopezfuentes

student•

class BankAccount:
    def __init__(self, account_holder, balance):
        self.account_holder = account_holder
        self.balance = balance
        self.is_active = True
```class BankAccount:    def \_\_init\_\_(self, account\_holder, balance):        *self*.account\_holder = account\_holder        *self*.balance = balance        *self*.is\_active = True

Julián Cárdenas

student•

import random
#Crear rango de datos aleatorios
random_h = random.randint(1,10)
print(random_h)
#Elección aleatorio de colores
colors = ['Rojo', 'Azul', 'Verde']
random_color = random.choice(colors)
print(random_color)

#Barajar una lista de cartas
cards = ['As', 'Rey', 'Reina', 'Jota', '10']
random.shuffle(cards)
print(cards)
```import random#Crear rango de datos aleatoriosrandom\_h = random.randint(1,10)print(random\_h)#Elección aleatorio de colorescolors = \['Rojo', 'Azul', 'Verde']random\_color = random.choice(colors)print(random\_color)
\#Barajar una lista de cartascards = \['As', 'Rey', 'Reina', 'Jota', '10']random.shuffle(cards)print(cards)

Andres Montes

student•

class Calcular:
    def suma(self, nums:list[int|float]) -> int | float:
        return sum(nums)
calc = Calcular()
print(calc.suma([2, 4]))

Kevin I. Villar

student•

🟥 Ejemplo no pitónico

Queremos contar cuántas palabras únicas hay en un texto y mostrarlas ordenadas:

# No pitónico
texto = "python es genial y python es divertido"

palabras = texto.split(" ")
palabras_unicas = []
for p in palabras:
    if p not in palabras_unicas:
        palabras_unicas.append(p)

palabras_unicas.sort()

print("Número de palabras únicas:", len(palabras_unicas))
for palabra in palabras_unicas:
    print(palabra)

🟩 Ejemplo pitónico

# Pitónico
texto = "python es genial y python es divertido"

palabras_unicas = sorted(set(texto.split()))

print(f"Número de palabras únicas: {len(palabras_unicas)}")
print("\n".join(palabras_unicas))

Agustín Alberto Leiva

student•

agustin-arg/Curso-Python

Convenciones principales de PEP8:

1. Indentación

Usa 4 espacios por nivel de indentación (no tabuladores).

def mi_funcion():
    valor = 10
    if valor > 5:
        print(valor)

2. Longitud de línea

Máximo 79 caracteres por línea. Máximo 72 caracteres para líneas de comentarios/docstrings.

# Este comentario tiene menos de 72 caracteres.
variable = 'Este string tiene menos de 79 caracteres por línea.'

3. Espacios en blanco

No pongas espacios en blanco al final de las líneas.
Separa funciones y clases con dos líneas en blanco.
Dentro de las funciones, separa grupos de código con una línea en blanco.
No pongas espacios antes de los paréntesis ni corchetes:

def funcion(arg):
    lista = [1, 2, 3]

x = 1
dict['key'] = value
func(param=1)

4. Nombres de variables y funciones

Nombres de variables y funciones: minúsculas, con palabras separadas por guión bajo (snake_case).
Nombres de clases: CamelCase.
Constantes: MAYÚSCULAS con guiones bajos (CONSTANTE_GLOBAL).

mi_variable = 5
def mi_funcion():
    pass
class MiClaseEjemplo:
    pass
PI = 3.1416

5. Importaciones

Importa módulos estándar primero, luego módulos de terceros, y finalmente módulos propios.
Importa cada módulo en una línea separada.
Usa importaciones absolutas preferentemente.

import os
import sys
import numpy as np
import mi_modulo

6. Documentación

Usa docstrings para documentar módulos, funciones, clases y métodos.
Los comentarios deben ser claros y relevantes.

def suma(a, b):
    """Suma dos números y devuelve el resultado."""
    # Sumar los valores
    return a + b

7. Espaciado en expresiones

Evita espacios innecesarios dentro de paréntesis, corchetes o llaves.
No uses más de un espacio para alinear asignaciones.

lista = [1, 2, 3]
diccionario = {'a': 1, 'b': 2}
x = 5
y = 10

8. Comparaciones con None

Usa is o is not para comparar con None:

valor = None
if valor is None:
    print('Valor es None')

9. Funciones y clases

Las definiciones de funciones y clases deben ir separadas por dos líneas en blanco.
Métodos dentro de una clase se separan por una sola línea en blanco.

def funcion_uno():
    pass


def funcion_dos():
    pass


class MiClase:
    def metodo_uno(self):
        pass

    def metodo_dos(self):
        pass

10. Comillas

Usa comillas simples o dobles de forma consistente.

mensaje = 'Hola mundo'
otro_mensaje = "Hola mundo"

11. Encoding

Coloca la declaración de encoding en la primera o segunda línea si no es UTF-8.

# -*- coding: latin-1 -*-

12. Espacio en blanco en listas/comas

No pongas espacios antes de la coma, pero sí después.

lista = [1, 2, 3]

13. Bloques de código

Usa una sola instrucción por línea.

x = 1
y = 2
print(x)
print(y)

14. Condiciones

Evita condiciones como if x == True:. Mejor usar if x: o if not x:.

activo = True
if activo:
    print('Está activo')
if not activo:
    print('No está activo')

15. Excepciones

Usa la sintaxis moderna:

try:
    resultado = 10 / 0
except Exception as e:
    print('Ocurrió un error:', e)

Giovanni Castro Agustín

student•

¿A que te refieres con que python no es el lenguaje más eficiente?

Julian Camilo Sanchez Sosa

student•

Creo que se refiere a su rendimiento en comparación con lenguajes como C o C++.

"Python es un lenguaje interpretado; significa que su ejecución es más lenta debido a la naturaleza dinámica de su tipado y a la sobrecarga del intérprete."

Juan Sebastián Sánchez Fernández

student•

Considero que las buenas prácticas son estándares importantes en el mundo profesional de los lenguajes de programación

Jhon Freddy Tavera Blandon

student•

Cumple con PEP8

PEP8 es la guía oficial de estilo de Python.

Usa 4 espacios por nivel de indentación.
Líneas de hasta 79 caracteres.
Espacios entre operadores, no después de paréntesis.

Usa herramientas como:

flake8
black
pylint

Héctor Omar Hernández Godoy

student•

¿Qué es PEP 8?

PEP 8 (Python Enhancement Proposal 8) es la guía de estilo oficial para escribir código Python. Es un conjunto de reglas y recomendaciones sobre cómo formatear tu código para que sea limpio, legible y consistente. Piensa en ello como las "buenas prácticas" para escribir código Python que sea fácil de entender por otros programadores (¡incluyéndote a ti mismo en el futuro!).

¿Por qué es importante PEP 8?

Legibilidad: Un código consistente y bien formateado es mucho más fácil de leer y entender, tanto para ti como para otras personas que puedan trabajar en tu proyecto.
Colaboración: Cuando trabajas en equipo, si todos siguen las mismas reglas de estilo, el código del proyecto se ve y se siente uniforme, lo que facilita la colaboración y reduce los conflictos.
Mantenimiento: El código legible es más fácil de mantener y depurar (encontrar y corregir errores).
Profesionalismo: Seguir PEP 8 es una señal de que eres un programador cuidadoso y profesional.

Algunos ejemplos de lo que cubre PEP 8:

Indentación: Usar 4 espacios para cada nivel de indentación (nunca tabulaciones).
Longitud de línea: Limitar las líneas a 79 caracteres para que el código sea fácil de leer en cualquier pantalla.
Nomenclatura: Cómo nombrar variables (mi_variable), funciones (mi_funcion), clases (MiClase), constantes (MI_CONSTANTE), etc.
Espacios en blanco: Cuándo usar espacios alrededor de operadores, después de comas, etc.
Líneas en blanco: Cuántas líneas en blanco dejar entre funciones, clases y métodos.
Comentarios: Cómo escribir comentarios útiles y cuándo usarlos.
Importaciones: Cómo organizar las sentencias import al principio de tus archivos.

Héctor Omar Hernández Godoy

student•

Súper, es como una segunda parte del curso y con nuevo look :)

Cristofer Vargas Morales

student•

Aquí un ejemplo para retornar una frase al revés.

Código No Pyhtónico - usando recursividad

## No Pythónico - Usando recursividad
def voltear_palabra(frase):
    frase_nueva = ""
    n = len(frase)
    if(n == 0):
        return frase_nueva
    else:
        n-= 1
        frase_nueva = frase_nueva + frase[n]
        return frase_nueva + voltear_palabra(frase[0:n])
    
frase_original = "Bienvenido a Python"
frase_invertida = voltear_palabra(frase_original)
print("No Pythónico")
print("Frase invertida: ", frase_invertida)

Usando Código Pythónico - Comprehension List

## Pythónico - Usando Comprehension List
frase_original = "Bienvenido a Python"
frase_invertida = [caracter for caracter in reversed(frase_original)]
print("Pythónico")
print("Frase invertida: ", ''.join(frase_invertida))

Resultados:

Rubén Orozco

student•

#PEP 8

# camel case nombre de clases

# funciones, variables snake case

# indentación 4 espacios

# longitud de línea sugerida 79 por línea

# espaciado de operador, un espacio antes y uno después

Juan Acevedo

student•

yo soy mas de

squares = [x**2 for x in numbers]
print(squares)

LEONARD CUENCA

student•

# Resumen de PEP 8: Guía de Estilo para Código Python PEP 8 es una guía de estilo que busca mejorar la legibilidad y consistencia del código Python. Seguir estas convenciones facilita la colaboración y el mantenimiento del código.

## 1. Disposición del Código

- * **Indentación:** Usar 4 espacios por nivel de indentación. No usar tabulaciones. *

- **Longitud de Línea:** Limitar todas las líneas a un máximo de 79 caracteres. Para comentarios largos o cadenas de texto, se recomienda un máximo de 72 caracteres.

- * **Líneas en Blanco:** * Separar las definiciones de funciones y clases de nivel superior con dos líneas en blanco.

- * Dentro de una clase, separar los métodos con una línea en blanco.

- * Usar líneas en blanco con moderación dentro de las funciones para separar secciones lógicas.

* **Importaciones:** * Importar cada módulo en una línea separada. * Los imports siempre deben colocarse en la parte superior del archivo, justo después de cualquier comentario o docstring del módulo. * Agrupar los imports en el siguiente orden: 1. Librerías estándar. 2. Librerías de terceros. 3. Importaciones locales/del mismo proyecto. * Dejar una línea en blanco entre cada grupo de imports.

* **Espacios en Expresiones y Sentencias:** * **Dentro de paréntesis, corchetes o llaves:** No usar espacios. spam(ham\[1], {eggs: 2}) *

**Antes de una coma, punto y coma o dos puntos:** No usar espacios.

* **Después de una coma o punto y coma:** Usar un espacio.

* **Alrededor de operadores binarios:** Usar un espacio a cada lado (asignación =, comparaciones ==, <, >, !=, in, not in, is, is not, booleanos and, or, not).

* **Excepciones:** * No usar espacios alrededor del signo igual cuando se usa para definir un argumento con un valor por defecto. def complex(real, imag=0.0):

* No usar espacios alrededor del operador binario con diferente prioridad. i = i + 1 (correcto), i=i+1 (incorrecto).

* **Llamadas a funciones:** No usar espacios entre el nombre de la función y el paréntesis de apertura. spam(1) (correcto), spam (1) (incorrecto).

* **Indexación/Slicing:** No usar espacios dentro de los corchetes. ham\[1:9], ham\[i:i+1:2]

## 2. Nombres * **Convenciones Generales:** * Evitar nombres de un solo carácter, excepto para contadores en bucles o variables matemáticas.

* Usar nombres descriptivos y concisos. * **Estilos de Nombres:** * **lowercase:** Para variables, funciones y métodos. * **lowercase\_with\_underscores:** Para variables, funciones y métodos (recomendado). * **UPPERCASE\_WITH\_UNDERSCORES:** Para constantes. * **CapitalizedWords (o CamelCase):** Para nombres de clases. * **\_single\_leading\_underscore:** Para indicar miembros internos no públicos. * **\_\_double\_leading\_underscore:** Para invocar el mecanismo de name mangling de Python (evitar su uso innecesario). * **\_\_double\_leading\_and\_trailing\_underscore\_\_:** Para nombres mágicos o atributos especiales. * **Evitar:** * Usar nombres que sean palabras clave de Python. * Usar caracteres l (ele minúscula), O (o mayúscula) o I (i mayúscula) como nombres de variables de un solo carácter, ya que pueden confundirse con los números uno y cero.

## 3. Comentarios * **Comentarios de Bloque:** * Generalmente aplican a algo del código que les sigue. * Indentados al mismo nivel que el código al que se refieren. * Comienzan con # y un espacio. * Separar párrafos dentro de un comentario de bloque con una línea en blanco que contenga un # único. * **Comentarios en Línea:** * Usar con moderación. * Deben estar separados por al menos dos espacios de la sentencia. * Comienzan con # y un espacio. * No deben ser obvios o explicar lo que el código ya hace. * **Docstrings:** * Escribir docstrings para todos los módulos, funciones, clases y métodos públicos. * Los docstrings de una línea se delimitan con triples comillas dobles ("""Docstring de una línea."""). * Los docstrings multilínea se delimitan con triples comillas dobles. El primer párrafo debe ser un resumen conciso del objeto. Dejar una línea en blanco después del párrafo de resumen. Los párrafos siguientes pueden detallar la convención de llamada, los efectos secundarios, etc. ## 4. Otras Recomendaciones * **Espacios alrededor de operadores:** Usar un espacio alrededor de operadores binarios, operadores de asignación y comparaciones. * **No comparar booleanos con True o False usando ==:** Usar if is\_active: en lugar de if is\_active == True:. * **No usar comparaciones de tipo directamente:** Usar isinstance() en lugar de comparar type(obj) is Type. * **Manejo de Excepciones:** Especificar excepciones concretas en las cláusulas except. Usar except Exception as e: con precaución. * **Retorno Consistente:** Si una función tiene una sentencia return, todas las rutas de ejecución deben tener una sentencia return. Si una función no devuelve explícitamente un valor, debe devolver implícitamente None.

William Alfredo Bermudez Leal

student•

Tambien se puede hacer con strings:

names = ["Juan", "Maria", "Pedro", "Ana"] upper_names = [name.upper() for name in names]print(upper_names)

William Alfredo Bermudez Leal

student•

#Tambien se puede hacer con strings

names = ["Juan", "Maria", "Pedro", "Ana"] upper_names = [name.upper() for name in names]print(upper_names)