Cómo invertir una lista en Python

En este tutorial, echamos un vistazo a cómo revertir una lista en Python, utilizando los métodos integrados como reverse() y reversed(), así como los nuestros.

Introducción

Python es un lenguaje flexible, y normalmente hay varias formas de realizar la misma tarea de baja categoría. La elección de un enfoque puede depender de la complejidad del tiempo o del espacio, o simplemente de su preferencia personal.

Las estructuras de datos de Python son bastante prácticas e intuitivas, y es fácil trabajar con sus funcionalidades integradas. En este artículo, veremos cómo revertir una lista en Python. Una Lista de Python es una estructura tipo matriz heterogénea (puede contener diferentes tipos) que almacena referencias a objetos en la memoria.

Al manipular una lista, podemos crear una nueva lista modificada o cambiar la lista original in situ. Veremos las diferencias en estos a medida que avanzamos en el artículo.

Invertir una lista usando el método reverse()

Python tiene una poderosa biblioteca integrada de métodos cuando se trata de manipular datos en estructuras de datos. Con el fin de invertir una lista, podemos utilizar el método integrado reverse().

Nota: El método reverse() invierte la lista in situ. Invertir una lista in situ significa que se cambia la lista original, en lugar de crear una nueva lista invertida.

Debido a esto, no podemos asignar el objeto resultante a una nueva variable, y si desea mantener la lista original en la memoria, deberá copiarla antes de invertirla:

1
2
3
4
5
6
my_list = [1, 2, 3, 4]
my_list.reverse()
print(my_list) # Output: [4, 3, 2, 1]

new_list = my_list.reverse()
print(new_list) # Output: None

No hay valor de retorno: la lista se invierte en el lugar. Sin embargo, podemos copiarlo() antes de invertirlo:

1
2
3
4
5
6
7
list_1 = [1, 2, 3, 4]
list_2 = list_1.copy()

list_1.reverse()

print('Reversed list: ', list_1)
print('Saved original list: ', list_2)

Esto resulta en

1
2
Reversed list:  [4, 3, 2, 1]
Saved original list:  [1, 2, 3, 4]

Invertir una lista usando Slice Notation

The slice notation allows us to slice and reproduce parts of various collections or collection-based objects in Python, such as Liza, Instrumentos de cuerda, tuplas and Matrices NumPy.

Cuando cortas una lista, se devuelve una porción de esa lista, y se incluye cada elemento pasoésimo:

1
2
3
4
5
6
7
8
my_list = [1, 2, 3, 4, 5, 6]

# list[start:end:step]
segment_1 = my_list[1:5:1]
segment_2 = my_list[1:5:2]

print(segment_1)
print(segment_2)

Esto resulta en:

1
2
[2, 3, 4, 5]
[2, 4]

Al omitir los argumentos start y end, puede incluir la colección completa. Y al establecer el ‘paso’ en un número negativo, iteras a través de la colección al revés. Naturalmente, si combina estos juntos:

1
2
3
4
5
original_list = [1, 2, 3, 4, 5, 6]

reversed_list = original_list[::-1]
print('Original list: ', original_list)
print('Reversed list: ', reversed_list)

Esto resulta en:

1
2
Original list:  [1, 2, 3, 4, 5, 6]
Reversed list:  [6, 5, 4, 3, 2, 1]

La Slice Notation no afecta en absoluto a la lista original, por lo que original_list permanece igual incluso después de la operación.

Invertir una lista usando el método slice()

El método slice() acepta los mismos parámetros: start, end y step, y realiza prácticamente la misma operación que la Notación Slice. Sin embargo, en lugar de omitir los argumentos start y end, puede pasar Ninguno.

Su tipo de retorno es un objeto Slice, que luego se puede usar para dividir una colección de acuerdo con su contenido. No se llama en la colección que está cortando: está pasando el objeto Slice después de la creación, lo que le permite crear un único objeto reutilizable y al que se puede llamar para muchas colecciones diferentes.

Se transpila internamente en Slice Notation, por lo que el resultado final es el mismo:

1
2
3
4
5
6
original_list = [1, 2, 3, 4, 5, 6]

slice_obj = slice(None, None, -1)

print('slice_obj type:', type(slice_obj))
print('Reversed list:', original_list[slice_obj])

Esto resulta en:

1
2
slice_obj type: <class 'slice'>
Reversed list: [6, 5, 4, 3, 2, 1]

Invertir una lista usando un For Loop

Dependiendo de si queremos mantener la lista original intacta o no, podemos “sacar()” elementos de la lista original y agregarlos a una nueva, o simplemente podemos agregarlos en orden inverso.

pop() elimina el último elemento de una colección y lo devuelve. Podemos combinar el método append() con esto para agregar directamente el elemento eliminado a una nueva lista, lo que da como resultado una lista invertida:

1
2
3
4
5
6
7
original_list = [1, 2, 3, 4] 
reversed_list = []

for i in range(len(original_list)):
    reversed_list.append(original_list.pop())

print(reversed_list) # Output: [4, 3, 2, 1]

Alternativamente, podemos iterar a través de la lista hacia atrás, hasta el índice -1 (no inclusivo) y agregar cada elemento que vemos a lo largo de esa lista. El método range() acepta 3 argumentos: start, end y step, que se pueden volver a utilizar de la misma manera que antes:

1
2
3
4
5
6
7
original_list = [1, 2, 3, 4]
reversed_list = []

for i in range(len(original_list)-1, -1, -1):
    reversed_list.append(original_list[i])

print(reversed_list) # Output: [4, 3, 2, 1]

Invertir una lista usando el método reversed()

Dado que iterar con un paso negativo y luego acceder a cada elemento en la lista original es un poco detallado, se agregó el método reversed (), que hace que sea mucho más fácil implementar manualmente la lógica de inversión, en caso de que desee agregar su propia gíralo.

El método reversed() devuelve un iterador, iterando sobre la colección en orden inverso, y podemos agregar fácilmente estos elementos en una nueva lista:

1
2
3
4
5
6
7
8
original_list = [1, 2, 3, 4]
new_list = []

for i in reversed(original_list):
    new_list.append(i)
    
print(new_list) # Output: [4, 3, 2, 1]
print(original_list) # Output: [1, 2, 3, 4] --> Original hasn't changed

Conclusión

Dependiendo de si necesita una nueva lista invertida, una lista invertida en el lugar, así como si desea que la lógica se encargue por usted, o si desea tener la flexibilidad de agregar operaciones o giros adicionales durante la inversión: hay varias formas de invertir una lista en Python.

En este tutorial, hemos repasado estos escenarios, destacando la diferencia entre cada uno.

Licensed under CC BY-NC-SA 4.0