Fundamentos de la Programación

#05 – Estructuras de Datos (I)

Continuamos con este curso de Fundamentos de la Programación, y ahora que ya sabemos como alterar el flujo del programa, va siendo hora de conocer nuevas formas de almacenar datos, y con ello ampliar las posibilidades de nuestro código. En esta primera parte, veremos las listas.

Listas (I)

Básicamente, una lista es una secuencia de elementos de igual o distinto tipo. Las listas se escriben entre corchetes ([]), y separando los elementos mediante una coma. Resultan muy útiles al trabajar con elementos relacionados entre si. Quizás el ejemplo más representativo pueda ser un vector.

numeros = [1, 2, 3, 4, 5]
nombres = ["Pepe", "Juan", "María"]
notas = ["María", 8, "Pepe", 5]

Propiedades de las Listas

Las listas poseen una serie de operadores y funciones muy útiles ya definidas en Python. La primera de la que vamos a hablar es la función len(). Esta función devuelve la cantidad de elementos que contiene una lista.

a = [1, 2, 3]
print(len(a))

Este código mostraría por pantalla la longitud de la lista a, la cual equivale a 3. En caso de tratarse de una lista vacía, la función len() devolvería 0.

Otros operadores son + (concatenación) y * (repetición). Estos funcionan igual que con las cadenas, ya que, al fin y al cabo, una cadena es una lista de carácteres.

Para poder acceder a un elemento determinado, utilizamos el operador []. Veamos el siguiente código:

a = [1, 2, 3]
print(a[0])
print(a[-1])
print(a[3])
  • La posición [0] mostrará por pantalla un 1. En Python, y en la gran mayoría de lenguajes de programación, las listas/secuencias comienzan en la posición 0. No lo olvidéis, ya que esto puede causar errores tontos que luego cuesta identificar.
  • Continuando, la posición [-1] mostrará por pantalla un 3. ¿Adivináis por qué? En Python podemos acceder a posiciones negativas, comenzando estas de forma inversa por el final.
  • Por último, al intentar acceder a la posición [3], el interprete dejará de funcionar y mostrará un error por pantalla. ¿La razón? Hemos intentado acceder a una posición que no existe. En este caso, la posición [3] equivaldría al cuarto elemento de la lista, pero sólo tiene tres. Mucho cuidado al intentar acceder a posiciones superiores a la longitud de la lista.

Otra característica útil de las listas es su relación con la función range(), que ya vimos en los bucles. Podemos construir una lista a partir de dicha función, y utilizar una lista en la condición del bucle for, para acceder uno por uno a todos los elementos de la lista. El siguiente código muestra por pantalla los números del 1 al 5:

a = range(1, 6)
for i in a:
    print(i)

Comparando Listas

A la hora de comparar dos listas para ver si son o no iguales, se tienen en cuenta dos factores:

  • En primer lugar, la longitud de las mismas. Si la longitud es diferente, el operador == devolverá False.
  • Si la longitud coincide, se comparará cada elemento individualmente de izquierda a derecha, siendo ambas listas iguales si todos sus elementos son iguales.
  • Para los operadores <, >, <= y >=, la cosa es parecida. Se comprueban uno a uno los elementos, si son iguales, se pasa al siguiente; si no lo son, se devuelve el resultado de compararlos con el operador que corresponda.

Operador is

Este es un operador especial, que comprueba si dos listas son la misma lista (no si son iguales). Para esto, tenemos que hacer un pequeño paréntesis, y ver cómo se almacena la información en memoria. Cuando creamos una variable, lo que esa variable en si contiene realmente es la dirección de memoria donde está almacenado el elemento al que hace referencia. Es decir, una variable apunta a un espacio en memoria. Por ello, pueden haber más de una variable que apunte a la misma dirección, y ambas variables modificarán el mismo espacio en memoria. Veamos un ejemplo:

a = [1, 2, 3]
b = [1, 2, 3]
c = a
Variables y Listas en memoria.

La anterior imagen representa como quedarían en memoria las listas definidas. Al compararlas entre ellas mediante el operador ==, siempre obtendremos el valor True, ya que todas contienen los mismos elementos. No obstante, el operador is devolverá False al comparar a y b, mientras que True al comparar a y c, ya que ambas variables apuntan a la misma lista. ¡PERO OJO! Como a y c apuntan a la misma lista, ambas la modifican. Esto puede llevar a errores pues podemos llegar a pensar que como estamos operando con la lista c, la lista a no se modifica. ¿Se puede evitar? Eso lo veremos más adelante.

Operando con Listas

Añadir elemento

Podemos añadir nuevos elementos a una lista ya creada de dos formas distintas:

  • Mediante el operador +, junto con una lista nueva.
  • Mediante la función append().
a = [1, 2, 3]
a = a + [4] #[1, 2, 3, 4]
a.append(5) #[1, 2, 3, 4, 5]

¿Son lo mismo ambas formas? ¡NO! El operador + devuelve una nueva lista, que contiene los elementos previos más los añadidos. La función append() modifica la lista en si. Es decir, con + estamos creando una nueva lista en memoria, y a continuación haciendo que la variable asignada apunte a la misma. Con la función append() modificamos la dirección de memoria a la que ya apunta la variable. ¿Entonces no es mejor usar siempre + y así evitar errores de direccionamiento? Pues no siempre, ya que la función append() es más eficiente y nos ahorra tiempo de cálculo.

Crear desde teclado

Con lo visto hasta ahora, sabemos generar listas a partir del código en si. Pero, lógicamente, lo que nos interesa es poder crearlas a partir de los datos que el propio usuario desee. Lamentablemente, no existe ni un operador ni una función que nos genere una lista directamente, por lo que hay que hacer las cosas paso a paso. El siguiente código crea una lista de enteros introducida por el usuario.

lista = []
longitud = int(input("Longitud de la lista: ")

for i in range(longitud):
    elemento = int(input("Introduce el elemento "+str(i)+": "))
    lista.append(elemento)

NOTA: En este ejemplo había un error. A la función input() sólo se le puede pasar como argumento una cadena, por lo que es necesario concadenar todos los elementos, en lugar de separarlos con comas (como en otros lenguajes).

Borrar elemento

Para poder borrar elementos, debemos utilizar el método del (delete). Su uso es muy sencillo:

a = [1, 2, 3]
del a[1] # ahora la lista vale [1, 3]

Hay que tener cuidado al utilizar este método, ya que al borrar un elemento, la longitud de la lista disminuye en 1, y es posible que eso nos ocasione que queramos acceder a posiciones fuera de rango si no tenemos en cuenta este cambio.

Pertenencia a una lista

Para saber si un elemento pertenece a una lista, contamos con el operador in. Este devuelve True o False según pertenezca o no.

a = [1, 2, 3]
elemento = int(input("Introduce un entero: "))

if(elemento in a):
    print("Pertenece")
else:
    print("No Pertenece")

Finalizamos esta entrada, donde se han presentado las listas. Esta estructura es muy importante, ya que nos permite almacenar datos relacionados entre si. En la próxima entrada veremos uno de los ejercicios más comunes sobre listas: ordenarlas. Mientras tanto, tenéis el ejercicio 5 disponible para ir practicando.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

back to top