Listas

Contenido

Listas#

Las listas son un tipo de objeto que nos permite guardar una secuencia de otros objetos, actualizarlos, añadir nuevos y borrarlos. A diferencia de todos los tipos que hemos visto hasta ahora, las listas con objetos mutables, es decir, pueden cambiar durante la ejecución de nuestro programa.

Para crear una lista en Python usamos corchetes y escribimos sus elementos separados por comas [item1, item2, ..., itemN]. Los objetos de una lista no tienen por qué ser del mismo tipo de objeto

[3.5, None, "foo"]

[3.5, None, 'foo']

type([1, 2, 3])

list

# lista vacía
[]

[]

Puedes incluir variables y expresiones en la definición de la lista. Python evaluará dichas expresiones y luego construirá la lista.

x = "foo"
[2 < 3, x.capitalize(), 5**2, [1, 2]]

[True, 'Foo', 25, [1, 2]]

El tipo list puede ser utilizado para convertir otros tipos de objetos a listas, en concreto aquellos que sean iterables, cosa que definiremos más adelante.

list("hello world")

['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

list(1)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-6-7ade7017386b> in <module>
----> 1 list(1)

TypeError: 'int' object is not iterable

list([1])

[1]

Las listas son iterables#

Los objetos iterables son aquellos compatibles con operaciones de iteración, la más común de ellas el buque for, que veremos más adelante. Otros objetos iterables pueden ser las tuplas, los diccionarios, los conjuntos, los rangos, los generadores, los arrays de numpy etc. Dado un iterable s, podemos realizar las siguientes operaciones

Operación	Descripción
`for vars in s:`	Iteración
`x, y, ... = s`	Deshacer en variables
`x in s` `x not in s`	Pertenencia
`[a, *s, b]`	Expandir

Veamos algunos ejemplos

items = [3, 4, 5]
x, y, z = items
print(x, y, z)

3 4 5

"a" in items

False

a = [1, 2, *items, 6]
a

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

Existen muchas funciones predefinidas que aceptan un iterable como argumento, aquí exponemos algunas de ellas

Función	Descripción
`list(s)`	Crea una lista a partir de `s`
`tuple(s)`	Crea una tupla a partir de `s`
`set(s)`	Crea una conjunto a partir de `s`
`min(s, [,key])`	Mínimo de `s`
`max(s, [,key])`	Máximo de `s`
`any(s)`	Devuelve `True` si algún item de `s` es verdadero
`all(s)`	Devuelve `True` si todos los items de `s` son verdaderos
`sum(s, [, initial])`	Suma de `s`
`sorted(s, [, key])`	Crea una lista ordenada

Las listas son secuencias#

Al igual que las cadenas, las listas son secuencias, por lo que el orden de sus objetos es importante y podemos acceder a los mismo mediante un índice entero que empieza en cero.

# El orden importa
[1, "a", True] == ["a", 1, True]

False

Podemos utilizar la misma sintaxis de indexado que vimos con las cadenas utilizando corchetes y :.

En las secuencias, el método que nos da la longitud del objeto es len

x = [2, 4, 6, 8, 10]
len(x)

x = "hello world"
len(x)

x = 1
len(x)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-11-d7736ab3e6ed> in <module>
      1 x = 1
----> 2 len(x)

TypeError: object of type 'int' has no len()

Las listas son mutables#

Las listas son utilizadas cuando queramos almacenar datos que pueden cambiar o deben actualizarse, ya que las listas pueden cambiar una vez han sido creadas, o dicho de otro modo, son objetos mutables. Veámoslo con un ejemplo

x = [2, 4, 6, 8, 10]
y = [2, 4, 6, 8, 10]

# asignamos una cadena al segundo objeto de x
x[1] = "apple"
x

[2, 'apple', 6, 8, 10]

# podemos realizar asignaciones a nivel de lista
y[1:4] = [-3, -4, -5]
y

[2, -3, -4, -5, 10]

Dos métodos muy utilizados a la hora de manipular listas son el append que nos permiten añadir un elemento a la cola de lista y extend para añadir varios

x = [2, 4, 6, 8, 10]
x.append("foo")
x

[2, 4, 6, 8, 10, 'foo']

# a extend tenemos que pasarle una lista de objetos
x.extend([True, False, None])
x

[2, 4, 6, 8, 10, 'foo', True, False, None]

Estos métodos realizan las operaciones inplace, es decir, modifican el objeto sin necesidad de tener que asignarlo. No tiene sentido escribir algo como x = x.append("foo"), de hecho el método append devuelve None

Otros métodos que pueden ser útiles con listas son

pop(n): devuelve el elemento n-ésimo y lo borra de la lista. Devuelve un IndexError si n está fuera del índice.
remove(a): borra el primer elemento cuyo valor coincida con a. Devuelve un ValueError si no encuentra el valor.
insert(n, a): inserta el objeto a en la posición n-ésima de la lista

x = ["a", "b", "c", "d"]
x.pop(2)

'c'

['a', 'b', 'd']

x.append("a")
x

['a', 'b', 'd', 'a']

x.remove("a")

['b', 'd', 'a']

x.insert(2, None)
x

['b', 'd', None, 'a']

Podemos concatenar listas usando el operador +. En caso de tener listas anidadas, es posible aplicar directamente más de una operación de indexado.

x = [[1, "foo"], ["bar", None], True, 3.5]
x[1][0]

'bar'

Exercise 11

Modifica la siguiente lista

l = [[1, "foo"], ["bar", None], True, 3.5]

para obtener

[[1, "baz"], ["bar", None], True, -1.5, [0, 1, 0]]

Exercise 12

Condiera una lista s y definamos

r = list(s)
t = s

Indica si las siguientes expresiones son verdaderas o falsas

r == s
r is s
s is t

Para el siguiente ejercicio, puedes utilizar el módulo time o el comando mágico de jupyter %%time para obtener el tiempo de ejecución de una celdilla.

%%time

3**999

CPU times: user 9 µs, sys: 0 ns, total: 9 µs
Wall time: 13.4 µs

440690273160268878963485086584048121988474010917382722554973456075609532448901633180259437950202687321303259232290860785316984860700206303955114241752651224675873408399440267959338258076321613758130133372529539347042982605207698146020522057684695558163502059375160114801849018132346298605821789418305378740276756187926194096742805466102629298972852134694966312536457747390615453312898505588339646862703020142029890479621367604783461882915721944003538122044057700922967618406667

import time

start = time.time()
3**999
end = time.time()
print(f"Execution time: {end - start:0.8f} seconds")

Execution time: 0.00009036 seconds

Exercise 13

Usando la estructura list(range(n)), crea listas de diferentes tamaños y estima la complejidad computacional en cuanto a tiempo de cómputo de comprobar la pertenencia a una lista.