PROGRAMACION: RESUMEN DE LISTAS

CAPITULO 5.2

LISTAS

El concepto de secuencia es muy potente y no se limita a las cadenas. Python nos permite definir secuencias de valores de cualquier tipo. Por ejemplo, podemos definir secuencias de números enteros o flotantes, o incluso de cadenas. Hablamos entonces de listas. En una lista podemos, por ejemplo, registrar las notas de los estudiantes de una clase, la evolución de la temperatura hora a hora, los coeficientes de un polinomio, la relación de nombres de personas asistentes a una reunión, etc.
Python sigue una notación especial para representar las listas. Los valores de una lista deben estar encerrados entre corchetes y separados por comas. He aquí una lista con los números del 1 al 3:

>>> [1, 2, 3]

[1, 2, 3]

Podemos asignar listas a variables:

>>> a = [1, 2, 3]

>>> a

[1, 2, 3]

Los elementos que forman una lista también pueden ser cadenas.

>>> nombres = [’Juan’, ’Antonia’, ’Luis’, ’María’]

Y también podemos usar expresiones para calcular el valor de cada elemento de una lista:

>>> a = [1, 1+1, 6/2] _

>>> a _

[1, 2, 3]

La asignación a una variable del contenido de otra variable que almacena una (referencia a
una) lista supone la copia de, únicamente, su referencia, así que ambas acaban apuntando a la misma zona de memoria:

>>> a = [1, 2, 3]

>>> b = a

La lista que contiene un sólo elemento presenta un aspecto curioso:

>>> a = [10]

>>> b = 10

Observa que no es lo mismo [10] que 10. [10] es la lista cuyo único elemento es el entero 10, y

10 es el entero 10. Gráficamente lo hemos destacado enmarcando la lista y disponiendo encima

de la celda su índice. Si pedimos a Python que nos muestre el contenido de las variables a y b,

veremos que la representación de la lista que contiene un escalar y la del escalar son diferentes:

>>> print a

[10]

>>> print b

10

La lista siempre se muestra encerrada entre corchetes.
Del mismo modo que hay una cadena vacía, existe también una lista vacía. La lista vacía se
denota así: [] y la representamos gríficamente como la cadena vacía:

>>> a = []

>>> print a

[]

COSAS QUE SIN DARNOS CUENTA YA SABEMOS SOBRE LAS LISTAS!!!

Una ventaja de Python es que proporciona operadores y funciones similares para trabajar con tipos de datos similares. Las cadenas y las listas tienen algo en com´un: ambas son secuencias de datos, así pues, muchos de los operadores y funciones que trabajan sobre cadenas también lo hacen sobre listas. Por ejemplo, la función len, aplicada sobre una lista, nos dice cuántos elementos la integran:

>>> a = [1, 2, 3]

>>> len(a)

3

>>> len([0, 1, 10, 5])

4

>>> len([10])

1

La longitud de la lista vacía es 0:

>>> len([]) 
0

El operador + concatena listas:

>>> [1, 2] + [3, 4]

[1, 2, 3, 4]

>>> a = [1, 2, 3]

>>> [10, 20] + a

[10, 20, 1, 2, 3]

y el operador * repite un número dado de veces una lista:

>>> [1, 2] * 3

[1, 2, 1, 2, 1, 2]

>>> a = [1, 2, 3]

>>> b = [10, 20] + a * 2

>>> b

[10, 20, 1, 2, 3, 1, 2, 3]

Has de tener en cuenta que tanto + como * generan nuevas listas, sin modificar las originales.

Observa este ejemplo:

>>> a = [1, 2, 3]

>>> b = a + [4] _

>>> c = b

¿Ves? La asignación a b deja intacta la lista a porque apunta al resultado de concatenar algo a a. La operación de concatenación no modifica la lista original: reserva memoria para una nueva lista con tantos elementos como resultan de sumar la longitud de las listas concatenadas y, a continuación, copia los elementos de la primera lista seguidos por los de la segunda lista en la nueva zona de memoria. Como asignamos a b el resultado de la concatenación, tenemos que b apunta a la lista recién creada. La tercera sentencia es una simple asignación a c, así quePython se limita a copiar la referencia.

El operador de indexación también es aplicable a las listas:

>>> a = [1, 2, 3]

>>> a[1]

2

>>> a[len(a)-1]

3

>>> a[-1]

3

A veces, el operador de indexación puede dar lugar a expresiones algo confusas a primera vista:

>>> [1, 2, 3][0]

1

En este ejemplo, el primer par de corchetes indica el principio y final de la lista (formada por el 1, el 2 y el 3) y el segundo par indica el ñindice del elemento al que deseamos acceder (el primero, es decir, el de índice 0).

EJERCICIOS:

214 ¿Qué aparecerá por pantalla al evaluar la expresión [1][0]? ¿Y al evaluar la expresión [][0]?

>>> [1][0]

1

>>> [][0]

Traceback (most recent call last):File "", line 1, in [][0] IndexError: list index out of range

De todos modos, no te preocupes por esa notación un tanto confusa: lo normal es que accedas a los elementos de listas que están almacenadas en variables, con lo que rara vez tendrás dudas.

>>> a = [1, 2, 3]

>>> a[0]

1

También el operador de corte es aplicable a las listas:

>>> a = [1, 2, 3]

>>> a[1:-1]

[2]

>>> a[1:]

[2, 3]

Si deseas asegurarte de que trabajas con una copia de una lista y no con la misma lista (a través
de una referencia) utiliza el operador de corte en la asignación.

EJERCICIOS

215 Hemos asignado a x la lista [1, 2, 3] y ahora queremos asignar a y una copia.

Podr´ıamos hacer y = x[:], pero parece que y = x + [] tambi´en funciona. ¿Es as´ı? ¿Por qu´e?

>>> x=[1,2,3]

>>> y=x[:]

>>> print y

[1, 2, 3]

Otra forma:

>>> x=[1,2,3]

>>> y=x+[]

>>> print y

[1, 2, 3]

El iterador for-in también recorre los elementos de una lista:

>>> for i in [1, 2, 3]:

... print i

...

1

2

3

De hecho, ya hemos utilizado bucles que iteran sobre listas. Cuando utilizamos un bucle for-in del modo convencional, es decir, haciendo uso de range, estamos recorriendo una lista:

>>> for i in range(1, 4):

... print i

...

1

2

3

Y es que range(1, 4) construye y devuelve la lista [1, 2, 3]:

>>> a = range(1, 4)

>>> print a

[1, 2, 3]

Una forma corriente de construir listas que contienen réplicas de un mismo valor se ayuda del operador *. Supongamos que necesitamos una lista de 10 elementos, todos los cuales valen 0. Podemos hacerlo así:

>>> [0] * 10

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

EJERCICIOS:

216 ¿Qué aparecería por pantalla al ejecutar este programa?

1 print ’Principio’

2 for i in []:

3 print ’paso’, i

4 print ’y fin’

print 'principio'

for i in []:

print 'paso', i

print 'y fin'

raw_input()

RESULTADO

>>>

principio

y fin

217 ¿Qué aparecería por pantalla al ejecutar este programa?

1 for i in [1] * 10:

2 print i

>>> for i in [1]*10:

print i

1

1

1

1

1

1

1

1

1

1

COMPARACION DE LISTAS

Los operadores de comparación también trabajan con listas. Parece claro cómo se comportarán operadores como el de igualdad (==) o el de desigualdad (!=): si las listas son de talla diferente, resolviendo que las listas son diferentes; y si miden lo mismo, comparando elemento a elemento de izquierda a derecha y resolviendo que las dos listas son iguales si todos sus elementos son iguales, y diferentes si hay algún elemento distinto.

Hagamos un par de pruebas con el intérprete de Python:

>>> [1, 2, 3] == [1, 2]

False

>>> [1, 2, 3] == [1, 2, 3]

True

>>> [1, 2, 3] == [1, 2, 4]

False

Los operadores <, >, <= y >= también funcionan con listas. ¿Cómo? Del mismo modo que con las cadenas, pues al fin y al cabo, tanto cadenas como listas son secuencias. Tomemos, por ejempo, el operador < al comparar las listas [1, 2, 3] y [1, 3, 2], es decir, al evaluar la expresión [1, 2, 3] < [1, 3, 2]. Se empieza por comparar los primeros elementos de ambas listas. Como no es cierto que 1 < 1, pasamos a comparar los respectivos segundos elementos.

Como 2 < 3, el resultado es True, sin necesidad de efectuar ninguna comparación adicional.

EJERCICIOS:

218 ¿Sabrías decir que resultados se mostrarán al ejecutar estas sentencias?

>>> [1, 2] < [1, 2]

1. >>> [1,2]<[1,2]

False

>>> [1, 2, 3] < [1, 2]

2. >>> [1,2,3]<[1,2]

False

>>> [1, 1] < [1, 2]

3. >>> [1,1]<[1,2]

True

>>> [1, 3] < [1, 2]

4. >>> [1,3]<[1,2]

False

True

>>> [10, 20, 30] > [1, 2, 3]

5. >>> [1,20,30]>[1,2,3]

True

>>> [10, 20, 3] > [1, 2, 3]

6. >>> [10,20,3]>[1,2,3]

True

>>> [10, 2, 3] > [1, 2, 3]

7. >>> [10,2,3]>[1,2,3]

True

>>> [1, 20, 30] > [1, 2, 3]

8. >>> [1,20,30]>[1,2,3]

True

>>> [0, 2, 3] <= [1, 2, 3]

9. >>> [0,2,3]<=[1,2,3]

True

>>> [1] < [2, 3]

10. >>> [1]<[2,3]

True

>>> [1] < [1, 2]

11. >>> [1]<[1,2]

True

>>> [1, 2] < [0]

12. >>> [1,2]<[0]

False