Manipular Listas en Python

PythonBeginner
Practicar Ahora

Introducción

En este laboratorio, obtendrá experiencia práctica manipulando listas en Python. Las listas son una estructura de datos fundamental para almacenar colecciones ordenadas de elementos. Aprenderá a crear, acceder, añadir, eliminar y modificar elementos de una lista.

Además, este laboratorio le guiará a través de operaciones más avanzadas como ordenar, consultar e anidar listas. Al finalizar este laboratorio, tendrá una comprensión sólida de cómo trabajar eficazmente con listas para gestionar y procesar datos en sus programas de Python.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 100%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.

Crear y Acceder a Listas

En este paso, aprenderá a crear listas y a acceder a sus elementos. Las listas son colecciones ordenadas y mutables de elementos, y son uno de los tipos de datos más versátiles de Python.

Las listas se crean utilizando corchetes [], con los elementos separados por comas. Comencemos creando algunas listas.

En el explorador de archivos del WebIDE a la izquierda, busque y abra el archivo list_creation.py ubicado en el directorio ~/project. Agregue el siguiente código al archivo:

## Create an empty list
empty_list = []
print("Empty list:", empty_list)
print("Type of empty_list:", type(empty_list))

## Create a list of numbers
numbers = [10, 20, 30, 40, 50]
print("Numbers list:", numbers)

## Lists can contain elements of different data types
mixed_list = [1, 'hello', 3.14, True]
print("Mixed data type list:", mixed_list)

## You can also create a list from another iterable, like a string
string_list = list("python")
print("List from a string:", string_list)

Después de agregar el código, guarde el archivo. Para ejecutar el script, abra la terminal integrada en el WebIDE y ejecute el siguiente comando:

python ~/project/list_creation.py

Debería ver la siguiente salida, que demuestra diferentes formas de crear una lista:

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

A continuación, exploremos cómo acceder a los elementos dentro de una lista. Puede acceder a los elementos por su índice (posición). La indexación de listas comienza en 0. También puede usar índices negativos, donde -1 se refiere al último elemento.

El slicing (rebanado) le permite acceder a un rango de elementos. La sintaxis es list[start:stop:step].

Agregue el siguiente código al final de su archivo list_creation.py:

## Accessing list elements
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi']
print("\n--- Accessing Elements ---")
print("Fruits list:", fruits)

## Access the first element (index 0)
print("First element:", fruits[0])

## Access the last element (index -1)
print("Last element:", fruits[-1])

## Slicing: get elements from index 1 up to (but not including) index 4
print("Slice [1:4]:", fruits[1:4])

## Slicing: get all elements from the beginning up to index 3
print("Slice [:3]:", fruits[:3])

## Slicing: get all elements from index 2 to the end
print("Slice [2:]:", fruits[2:])

## Slicing: get a copy of the entire list
print("Slice [:] (a copy):", fruits[:])

## Slicing with a step: get every second element
print("Slice [::2]:", fruits[::2])

## Slicing to reverse the list
print("Reversed list [::-1]:", fruits[::-1])

Guarde el archivo y ejecute el script nuevamente desde la terminal:

python ~/project/list_creation.py

Observe la nueva salida para comprender cómo funcionan la indexación y el slicing:

Empty list: []
Type of empty_list: <class 'list'>
Numbers list: [10, 20, 30, 40, 50]
Mixed data type list: [1, 'hello', 3.14, True]
List from a string: ['p', 'y', 't', 'h', 'o', 'n']

--- Accessing Elements ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi']
First element: orange
Last element: kiwi
Slice [1:4]: ['apple', 'pear', 'banana']
Slice [:3]: ['orange', 'apple', 'pear']
Slice [2:]: ['pear', 'banana', 'kiwi']
Slice [:] (a copy): ['orange', 'apple', 'pear', 'banana', 'kiwi']
Slice [::2]: ['orange', 'pear', 'kiwi']
Reversed list [::-1]: ['kiwi', 'banana', 'pear', 'apple', 'orange']

Ahora ha aprendido a crear listas y a acceder a su contenido.

Modificar Listas: Añadir, Eliminar y Cambiar Elementos

En este paso, aprenderá a modificar listas. Dado que las listas son mutables, puede añadir, eliminar o cambiar sus elementos después de haber sido creadas.

Primero, centrémonos en añadir elementos. Python proporciona varios métodos:

  • append(): Añade un único elemento al final de la lista.
  • extend(): Añade todos los elementos de un iterable (como otra lista) al final.
  • insert(): Añade un elemento en un índice específico.

Abra el archivo list_modification.py desde el explorador de archivos del WebIDE. Agregue el siguiente código:

## --- Adding Elements ---
my_list = [1, 2, 3]
print("Original list:", my_list)

## Add an element using append()
my_list.append(4)
print("After append(4):", my_list)

## Add multiple elements using extend()
my_list.extend([5, 6])
print("After extend([5, 6]):", my_list)

## Insert an element at a specific position
my_list.insert(1, 1.5) ## Insert 1.5 at index 1
print("After insert(1, 1.5):", my_list)

Guarde el archivo y ejecútelo desde la terminal:

python ~/project/list_modification.py

Su salida debería mostrar la lista creciendo con cada operación:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6]

A continuación, practicaremos la eliminación de elementos. Los métodos clave incluyen:

  • remove(): Elimina la primera aparición de un valor especificado.
  • pop(): Elimina y devuelve el elemento en un índice dado (o el último elemento si no se especifica ningún índice).
  • del: Una sentencia para eliminar un elemento o un slice (rebanada) por índice.
  • clear(): Elimina todos los elementos de la lista.

Agregue el siguiente código al final de list_modification.py:

## --- Removing Elements ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
print("\n--- Removing Elements ---")
print("Original fruits list:", fruits)

## Remove the last element using pop()
popped_item = fruits.pop()
print("After pop():", fruits)
print("Popped item:", popped_item)

## Remove an element by its value using remove()
fruits.remove('pear')
print("After remove('pear'):", fruits)

## Remove an element by its index using del
del fruits[1] ## Deletes 'apple' at index 1
print("After del fruits[1]:", fruits)

## Clear all elements from the list
fruits.clear()
print("After clear():", fruits)

Finalmente, puede cambiar elementos existentes asignando un nuevo valor a un índice o a un slice. Agregue este último bloque de código a list_modification.py:

## --- Changing Elements ---
letters = ['a', 'b', 'c', 'd', 'e']
print("\n--- Changing Elements ---")
print("Original letters list:", letters)

## Change a single element
letters[0] = 'A'
print("After changing index 0:", letters)

## Change a slice of elements
letters[1:3] = ['B', 'C']
print("After changing slice [1:3]:", letters)

Guarde el archivo y ejecute el script una vez más:

python ~/project/list_modification.py

La salida completa demostrará todas las técnicas de modificación que ha aprendido:

Original list: [1, 2, 3]
After append(4): [1, 2, 3, 4]
After extend([5, 6]): [1, 2, 3, 4, 5, 6]
After insert(1, 1.5): [1, 1.5, 2, 3, 4, 5, 6]

--- Removing Elements ---
Original fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple']
After pop(): ['orange', 'apple', 'pear', 'banana', 'kiwi']
Popped item: apple
After remove('pear'): ['orange', 'apple', 'banana', 'kiwi']
After del fruits[1]: ['orange', 'banana', 'kiwi']
After clear(): []

--- Changing Elements ---
Original letters list: ['a', 'b', 'c', 'd', 'e']
After changing index 0: ['A', 'b', 'c', 'd', 'e']
After changing slice [1:3]: ['A', 'B', 'C', 'd', 'e']

Ahora domina cómo añadir, eliminar y cambiar elementos en una lista de Python.

Operaciones Avanzadas con Listas: Ordenación, Consulta y Anidamiento

En este paso final, explorará operaciones de lista más avanzadas, incluyendo el ordenamiento (sorting), la consulta de información y el trabajo con listas anidadas (nested lists).

Comencemos con el ordenamiento. El método sort() modifica la lista en su lugar (in-place). Puede ordenar en orden ascendente o descendente.

Abra el archivo list_operations.py en el WebIDE. Agregue el siguiente código para demostrar el ordenamiento:

## --- Sorting Lists ---
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print("--- Sorting Lists ---")
print("Original numbers list:", numbers)

## Sort the list in-place (ascending)
numbers.sort()
print("After sort():", numbers)

## Sort the list in descending order
numbers.sort(reverse=True)
print("After sort(reverse=True):", numbers)

## The reverse() method simply reverses the order, it does not sort
letters = ['a', 'b', 'c', 'd']
print("\nOriginal letters list:", letters)
letters.reverse()
print("After reverse():", letters)

Guarde el archivo y ejecútelo desde la terminal:

python ~/project/list_operations.py

La salida muestra las listas ordenadas e invertidas:

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]

Original letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

A continuación, consultaremos una lista para encontrar información.

  • count(): Devuelve el número de veces que aparece un valor.
  • index(): Devuelve el índice de la primera aparición de un valor.

Agregue el siguiente código a list_operations.py:

## --- Querying Lists ---
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print("\n--- Querying Lists ---")
print("Fruits list:", fruits)

## Count the occurrences of an element
apple_count = fruits.count('apple')
print("Count of 'apple':", apple_count)

## Find the index of the first occurrence of an element
banana_index = fruits.index('banana')
print("Index of first 'banana':", banana_index)

Finalmente, veamos las listas anidadas. Una lista anidada es una lista que contiene otras listas como sus elementos. Esto es útil para crear estructuras 2D como una matriz o una cuadrícula.

Agregue este bloque de código final a list_operations.py:

## --- Nested Lists ---
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print("\n--- Nested Lists ---")
print("Matrix:", matrix)

## Access an entire inner list (a row)
first_row = matrix[0]
print("First row:", first_row)

## Access a specific element in the nested list
## To get the element '6', we access row 1, then column 2
element = matrix[1][2]
print("Element at matrix[1][2]:", element)

Guarde el archivo y ejecute el script por última vez:

python ~/project/list_operations.py

La salida completa demostrará el ordenamiento, la consulta y el acceso a listas anidadas:

--- Sorting Lists ---
Original numbers list: [3, 1, 4, 1, 5, 9, 2, 6]
After sort(): [1, 1, 2, 3, 4, 5, 6, 9]
After sort(reverse=True): [9, 6, 5, 4, 3, 2, 1, 1]

Original letters list: ['a', 'b', 'c', 'd']
After reverse(): ['d', 'c', 'b', 'a']

--- Querying Lists ---
Fruits list: ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
Count of 'apple': 2
Index of first 'banana': 3

--- Nested Lists ---
Matrix: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
First row: [1, 2, 3]
Element at matrix[1][2]: 6

Ahora ha dominado varias técnicas avanzadas para trabajar con listas de Python.

Resumen

En este laboratorio, ha aprendido los fundamentos de la manipulación de listas en Python. Comenzó creando listas usando corchetes [] y el constructor list(). Practicó el acceso a los elementos de la lista mediante indexación (indexing) y segmentación (slicing), lo cual es esencial para recuperar elementos específicos o subconjuntos de una lista.

Luego exploró cómo modificar listas añadiendo elementos con append(), extend() e insert(), eliminando elementos con remove(), pop() y del, y cambiando elementos mediante asignación por índice y segmento. Finalmente, cubrió operaciones avanzadas, incluyendo el ordenamiento en su lugar (in-place sorting) con sort(), la inversión con reverse(), la consulta con count() e index(), y la estructuración de datos con listas anidadas (nested lists). Ahora está bien equipado para utilizar listas de manera efectiva en sus proyectos de Python.