Mejorando la calidad del código Python con comas finales: Un detalle que marca la diferencia

A la hora de escribir código los detalles importan, incluso los aparentemente insignificantes. Uno de estos detalles, el cual suele ser completamente ignorado habitualmente, son las comas finales, conocidas en inglés como “Trailing Commas”. Estas comas son las que se sitúan al final de la última línea en las estructuras como listas, tuplas y diccionarios. Aunque puede parecer un recurso meramente estético, su utilidad va mucho más allá. En esta entrada vamos a ver por qué estás comas finales son un detalle tan importante y por qué puede mejorar la legibilidad y mantenibilidad del código.

¿Qué son las comas finales (“Trailing Commas”)?

Las comas finales, o como se conoce en inglés, “Trailing Commas”, son las comas adicionales que se colocan en la última línea de las estructuras de datos. Esto es, en las listas, tuplas y diccionarios. Aunque su uso es una opción, y no tiene ningún efecto ni en la funcionalidad ni el rendimiento del código, ofrecen importantes ventajas en cuanto a la legibilidad y mantenibilidad. Haciendo que el código sea más limpio y fácil de mantener.

Las ventajas se usar comas finales en Python, u otros lenguajes de programación, se pueden enumerar en el siguiente listado:

Trending

Comandos avanzados de Git y su aplicación

1. Facilita los cambios en el código: Las comas finales hacen que sea más fácil agregar, eliminar o reorganizar elementos en las estructuras como listas sin afectar al código circundante. Esto simplifica los cambios en el código y reduce la posibilidad de introducir errores.
2. Mejora la legibilidad: Al incluir comas finales, se hace más evidente dónde termina la estructura, lo que mejora la legibilidad del código. Un aspecto importante y altamente infravalorado. Lo que resulta especialmente útil en estructuras con varias líneas, donde las comas finales ayudan a identificar claramente el final de la estructura.
3. Formato más adecuado para los sistemas de control de versiones: Al utilizar comas finales, el código se formatea de manera más consistente, lo que facilita el seguimiento de los cambios en sistemas de control de versiones como Git. Registrando como cambio únicamente los valores modificados, no el código circundante. Esto hace que sea más fácil la revisión de los cambios introducidos en cada versión y la colaboración con otros desarrolladores.
4. Reducción de errores de sintaxis: Las comas finales pueden ayudar a prevenir los errores de sintaxis cuando se trabaja con estructuras de datos de varias líneas, como las listas o diccionarios. Al ser una sintaxis clara, homogénea y consistente, las comas finales hacen que sea menos probable cometer errores al escribir o modificar el código.

Ejemplos del uso de comas finales en Python

A continuación, se muestran algunos ejemplos en los que se ilustra la diferencia que existe en el uso o no de comas finales en las estructuras de datos y argumentos de funciones en Python.

#########
# Listas
#########

# Sin comas finales
numeros = [1, 2, 3]
colores = ['rojo', 'verde', 'azul']

# Con comas finales
numeros = [
    1,
    2,
    3,
]
colores = [
    'rojo',
    'verde',
    'azul',
]


#########
# Tuplas
#########

# Sin comas finales
punto = (10, 20)
coordenadas = ((30, 40), (50, 60))

# Con comas finales
punto = (
    10,
    20,
)
coordenadas = (
    (30, 40),
    (50, 60),
)


##########################
# Argumentos de funciones 
##########################

# Sin comas finales
def obtener_precio_descuento(precio, descuento=0):
    return precio * (1 - descuento)

# Con comas finales
def obtener_precio_descuento(
    precio,
    descuento=0,
):
    return precio * (1 - descuento)


##################################################
# Argumentos de funciones con valores por defecto
##################################################

# Sin comas finales
def saludar(nombre='Mundo', saludo='Hola'):
    return f'{saludo}, {nombre}!'

# Con comas finales
def saludar(
    nombre='Mundo',
    saludo='Hola',
):
    return f'{saludo}, {nombre}!'

En estos ejemplos se pueden ver cómo las comas finales se pueden emplear en múltiples contextos en Python, tanto en las estructuras de datos, como las listas o tuplas, como en la definición de los argumentos de las funciones. Mejorando claramente la legibilidad del código cuando se incorporan. Por lo que, al agregar comas finales al código ayuda a que este sea más consistente y fácil de leer, lo que contribuye que este sea más limpio y mantenible.

Conclusiones

Aunque puede parecer algo intrascendente, las comas finales son un detalle importante que puede mejorar la calidad del código. Marcando una diferencia importante en cuanto a su mantenibilidad. Por lo tanto, al prestar el detalle que se merece las comas finales se puede conseguir que el código sea más limpio, claro y fácil de mantener. Mejorando por el camino la eficiencia y efectividad de la tarea de programación.

Imagen de Gundula Vogel en Pixabay