Creación de una cadena usando un bucle — Python: Listas

La creación de una cadena usando un bucle es una tarea que ocurre con frecuencia en la práctica. Un ejemplo típico es una función que ayuda a generar listas HTML. Toma una colección de elementos como entrada y devuelve una lista HTML de ellos:

coll = ['milk', 'butter']

build_HTML_list(coll)
# <ul><li>milk</li><li>butter</li></ul>

Aquí está una forma muy directa de resolver este problema:

1. Crear una variable result y escribir<ul> en ella.
2. Recorrer los elementos de la colección con un bucle y agregar el elemento <li> actual a la cadena resultante.
3. Al final, agregar </ul> y devolver result de la función.

def build_HTML_list(coll):
  result = '<ul>'
  for item in coll:
    result = f'{result}<li>{item}</li>'
    # o así: result += '<li>{item}</li>'
  result = f'{result}</ul>'

  return result

coll = ['milk', 'butter']

print(build_HTML_list(coll))
# => <ul><li>milk</li><li>butter</li></ul>

Este método funciona, pero es muy ineficiente en la mayoría de lenguajes de programación. Cada vez que concatenas o interpolas, se crea una nueva cadena, lo que consume mucha memoria y puede afectar el rendimiento. Aunque en muchos casos esto no es un problema por el poco volumen de datos, usar un enfoque más eficiente es sencillo y recomendable desde el principio.

La forma precisa de hacerlo, en el caso de los lenguajes dinámicos, es formar una lista que luego se puede convertir a un formato de cadena utilizando el método join():

def build_HTML_list(coll):
  parts = []
  for item in coll:
    parts.append(f'<li>{item}</li>')

  # El método join une los elementos de la lista en una cadena
  # El valor de la cadena se utiliza como delimitador entre los valores.
  inner_value = ''.join(parts)
  result = f'<ul>{inner_value}</ul>'
  return result

El tamaño del código casi no ha cambiado, pero la forma en que se obtiene el resultado es distinta. En lugar de una cadena, primero se forma una lista que luego se convierte en una cadena usando el método .join(). Este enfoque también tiene algunas ventajas adicionales:

• Este código es más fácil de depurar. Los datos, presentados como una lista, pueden ser organizados visualmente y programáticamente.
• Una lista es una estructura con la que se pueden manipular datos. No se puede hacer mucho con una cadena ya formada.

Ajustando el delimitador, las cadenas se pueden unir de diferentes formas. Por ejemplo, con una coma y un espacio:

parts = ['python', 'PHP', 'Python']
output = ', '.join(parts)

print(output) # => python, PHP, Python

Si se necesita imprimir cada palabra en una nueva línea, se usa el símbolo de nueva línea '\n' como delimitador:

parts = ['python', 'PHP', 'Python']

# Ahora cada palabra comenzará en una nueva línea
output = '\n'.join(parts)

print(output)
# => python
# => PHP
# => Python

El último ejemplo es especialmente importante. Los principiantes a menudo cometen el error de agregar un salto de línea al formar la lista, en lugar de en join(). Esto es lo que parece con nuestra función build_HTML_list().

Correcto:

def build_HTML_list(coll):
  parts = []
  for item in coll:
    parts.append(f'<li>{item}</li>')
  inner_value = '\n'.join(parts) # salto de línea
  result = f'<ul>{inner_value}</ul>'
  return result

coll = ['milk', 'butter']

build_HTML_list(coll)
print # => <ul><li>milk</li>
print # => <li>butter</li></ul>

Incorrecto:

def build_HTML_list(coll):
  parts = []
  for item in coll:
    parts.append(f'\n<li>{item}</li>')
  inner_value = ''.join(parts) # no hay delimitador
  result = f'<ul>{inner_value}</ul>'
  return result

coll = ['milk', 'butter']

build_HTML_list(coll)
print # => <ul>
print # => <li>milk</li>
print # => <li>butter</li></ul>

Materiales adicionales

1. 📖 Joel Spolsky. Back to Basics (versión en inglés)