Cómo comprobar si una lista es un palíndromo en Python

Introducción

En este laboratorio, aprenderás cómo determinar si una lista es un palíndromo en Python. Un palíndromo es una secuencia que se lee igual hacia adelante que hacia atrás. El laboratorio te guía a través de la creación de un script de Python para identificar palíndromos de listas.

Explorarás dos métodos: comparar una lista con su versión invertida utilizando el corte (slicing), y revertir explícitamente la lista para la comparación. El laboratorio proporciona ejemplos de código e instrucciones sobre cómo ejecutar el script e interpretar la salida, demostrando si las listas dadas son palíndromos o no.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/DataStructuresGroup(["Data Structures"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/PythonStandardLibraryGroup(["Python Standard Library"]) python/DataStructuresGroup -.-> python/lists("Lists") python/FunctionsGroup -.-> python/function_definition("Function Definition") python/PythonStandardLibraryGroup -.-> python/data_collections("Data Collections") subgraph Lab Skills python/lists -.-> lab-559532{{"Cómo comprobar si una lista es un palíndromo en Python"}} python/function_definition -.-> lab-559532{{"Cómo comprobar si una lista es un palíndromo en Python"}} python/data_collections -.-> lab-559532{{"Cómo comprobar si una lista es un palíndromo en Python"}} end

Comprender los palíndromos de listas

En este paso, aprenderás sobre los palíndromos de listas y cómo identificarlos en Python. Un palíndromo es una secuencia que se lee igual hacia adelante que hacia atrás. Por ejemplo, la palabra "madam" es un palíndromo. En el contexto de las listas, un palíndromo de lista es una lista cuyos elementos son los mismos cuando se leen desde el principio hasta el final o desde el final hasta el principio.

Comencemos creando un script de Python para explorar los palíndromos de listas.

Abre tu editor de VS Code.
Crea un nuevo archivo llamado palindrome.py en el directorio ~/project.
```
touch ~/project/palindrome.py
```
Abre el archivo palindrome.py en el editor.

Ahora, agreguemos algo de código al archivo palindrome.py para entender cómo comprobar si una lista es un palíndromo.

def is_palindrome(lst):
    return lst == lst[::-1]

## Example lists
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Check if the lists are palindromes
print(f"{list1} is a palindrome: {is_palindrome(list1)}")
print(f"{list2} is a palindrome: {is_palindrome(list2)}")

En este código:

Definimos una función is_palindrome(lst) que toma una lista lst como entrada.
Dentro de la función, comparamos la lista con su versión invertida utilizando el corte (slicing) lst[::-1].
La función devuelve True si la lista es un palíndromo y False en caso contrario.
Creamos dos listas de ejemplo, list1 que es un palíndromo y list2 que no lo es.
Usamos la función print() para mostrar si cada lista es un palíndromo o no.

Para ejecutar el script, ejecuta el siguiente comando en la terminal:

python ~/project/palindrome.py

Deberías ver la siguiente salida:

[1, 2, 3, 2, 1] is a palindrome: True
[1, 2, 3, 4, 5] is a palindrome: False

Esta salida confirma que list1 es un palíndromo y list2 no lo es.

Comparar con la lista invertida

En este paso, explorarás otro método para comprobar si una lista es un palíndromo invirtiendo explícitamente la lista y comparándola con la lista original. Este enfoque proporciona una comprensión más detallada de la comprobación de palíndromos.

Modifiquemos el archivo palindrome.py que creaste en el paso anterior.

Abre el archivo palindrome.py en tu editor de VS Code.
Modifica el contenido del archivo palindrome.py de la siguiente manera:

def is_palindrome(lst):
    reversed_lst = lst[::-1]
    return lst == reversed_lst

## Example lists
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Check if the lists are palindromes
print(f"{list1} is a palindrome: {is_palindrome(list1)}")
print(f"{list2} is a palindrome: {is_palindrome(list2)}")

En este código modificado:

Dentro de la función is_palindrome(lst), creamos una copia invertida de la lista de entrada lst utilizando el corte (slicing) lst[::-1] y la almacenamos en la variable reversed_lst.
Luego comparamos la lista original lst con la lista invertida reversed_lst utilizando el operador de igualdad ==.
La función devuelve True si la lista original es igual a la lista invertida (es decir, es un palíndromo) y False en caso contrario.

Para ejecutar el script, ejecuta el siguiente comando en la terminal:

python ~/project/palindrome.py

Deberías ver la misma salida que en el paso anterior:

[1, 2, 3, 2, 1] is a palindrome: True
[1, 2, 3, 4, 5] is a palindrome: False

Esta salida confirma que list1 es un palíndromo y list2 no lo es, utilizando el método de inversión explícita. Este enfoque hace que la lógica sea más explícita y fácil de entender.

Usar el corte (slicing) para la inversión

En este paso, te centrarás específicamente en cómo se utiliza el corte (slicing) para invertir una lista en Python. El corte es una característica poderosa que te permite extraer porciones de una lista, y también se puede utilizar para crear una copia invertida de la lista.

Volvamos al archivo palindrome.py y examinemos más de cerca la técnica de corte.

Abre el archivo palindrome.py en tu editor de VS Code.
Asegúrate de que el contenido del archivo palindrome.py sea el siguiente:

def is_palindrome(lst):
    reversed_lst = lst[::-1]
    return lst == reversed_lst

## Example lists
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Check if the lists are palindromes
print(f"{list1} is a palindrome: {is_palindrome(list1)}")
print(f"{list2} is a palindrome: {is_palindrome(list2)}")

La parte clave de este código es lst[::-1]. Esta es una operación de corte que crea una copia invertida de la lista. Desglosémosla:

lst[:] crearía una copia de toda la lista.
lst[start:end] crearía un segmento desde el índice start hasta end - 1.
lst[start:end:step] te permite especificar un step (paso). Un paso de -1 significa iterar hacia atrás a través de la lista.
Al omitir start y end y usar un paso de -1 (es decir, lst[::-1]), creas una copia invertida de toda la lista.

Para ilustrar esto mejor, agreguemos algunas declaraciones de impresión para ver el efecto del corte:

def is_palindrome(lst):
    reversed_lst = lst[::-1]
    print(f"Original list: {lst}")
    print(f"Reversed list: {reversed_lst}")
    return lst == reversed_lst

## Example lists
list1 = [1, 2, 3, 2, 1]
list2 = [1, 2, 3, 4, 5]

## Check if the lists are palindromes
print(f"{list1} is a palindrome: {is_palindrome(list1)}")
print(f"{list2} is a palindrome: {is_palindrome(list2)}")

Ahora, ejecuta el script nuevamente:

python ~/project/palindrome.py

Verás las listas originales e invertidas impresas antes del resultado de la comprobación de palíndromos:

Original list: [1, 2, 3, 2, 1]
Reversed list: [1, 2, 3, 2, 1]
[1, 2, 3, 2, 1] is a palindrome: True
Original list: [1, 2, 3, 4, 5]
Reversed list: [5, 4, 3, 2, 1]
[1, 2, 3, 4, 5] is a palindrome: False

Esto demuestra cómo el corte con [::-1] invierte efectivamente la lista, que luego se utiliza para determinar si la lista original es un palíndromo.

Resumen

En este laboratorio, aprendiste cómo identificar palíndromos de listas en Python, que son listas que se leen igual hacia adelante y hacia atrás. Creaste un script palindrome.py que contiene una función is_palindrome(lst) que utiliza el corte (slicing) (lst[::-1]) para invertir eficientemente una lista y compararla con la original, devolviendo True si es un palíndromo y False en caso contrario.

El script se probó con dos listas de ejemplo, list1 (un palíndromo) y list2 (no es un palíndromo), y la salida confirmó la capacidad de la función para identificar correctamente los palíndromos. El laboratorio también introdujo el concepto de invertir explícitamente la lista para la comparación, aunque el contenido proporcionado se truncó.