Resumen y Ejercicios del Capitulo de "LISTAS"

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´on 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]
5 Tipos estructurados: secuencias
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]
Python almacena las listas del mismo modo que las cadenas: mediante referencias (punteros)
a la secuencia de elementos. Así, el útimo ejemplo hace que la memoria presente un aspecto
como el que muestra el siguiente diagrama:
a 1
0
2
1
3
2
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 _
a 1
0
2
1
3
2
b

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ún: 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 _
La memoria queda así:
a 1
0
2
1
3
2
b 1
0
2
1
3
2
4
3
c
¿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 lanueva zona de memoria.

Ejercicio:

114 ¿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´an 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]
Has de tener en cuenta que un corte siempre se extrae copiando un fragmento de la lista,
por lo que comporta la reserva de memoria para crear una nueva lista. Analiza la siguiente
secuencia de acciones y sus efectos sobre la memoria:

>>> a = [1, 2, 3, 4, 5] _
a 1
0
2
1
3
2
4
3
5

>>> b = a[1:3] _
a 1
0
2
1
3
2
4
3
5
4
b 2
0
3
1
>>> c = a _
a 1
0
2
1
3
2
4
3
5
4
b 2
0
3
1
c

>>> d = a[:] _
a 1
0
2
1
3
2
4
3
5
4
b 2
0
3
1
c
d 1
0
2
1
3
2
4
3
5
4
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.

Ejercicio:

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én funciona. ¿Es así? ¿Por qué?

x=[1,2,3]

y =x[:]

>>[1,2,3]

x=[1,2,3]

y=x+[]

>>[1,2,3]

El iterador for-in tambi´en 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´eplicas 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]

Ejercico:

216 ¿Qu´e aparecer´a por pantalla al ejecutar este programa?
print ’Principio’
for i in []:
print ’paso’, i
print ’y fin’

>>principio

y fin

217 ¿Qué aparecerá por pantalla al ejecutar este programa?
for i in [1] * 10:
print i

>>1

1

1

1

1

1

1

1

1

1

Comparación 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 <>

Ejercico:

218 ¿Sabr´ıas decir que resultados se mostrar´an al ejecutar estas sentencias?
1. [1, 2] < [1, 2] _

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

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

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

5. [10, 20, 30] > [1, 2, 3] _
6. [10, 20, 3] > [1, 2, 3] _
7. [10, 2, 3] > [1, 2, 3] _
8. [1, 20, 30] > [1, 2, 3] _
9. [0, 2, 3] <= [1, 2, 3] _

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

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

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

1.false

2.false

3.true

4.false

5.true

6.true

7.true

8.true

9.true

10.true

11.true

12.false

219 Diseña un programa que tras asignar dos listas a sendas variables nos diga si la primera es menor que la segunda. No puedes utilizar operadores de comparación entre listas para implementar el programa.

**no tngo ni la mas minima idea d como hacerlo**

El operador is:
Hemos visto que las listas conllevan una forma de reservar memoria curiosa: en ocasiones, dos
variables apuntan a una misma zona de memoria y en ocasiones no, incluso cuando los datos
de ambas variables son idénticos. Fíjate en este ejemplo:
>>> a = [1, 2, 3] _
>>> b = [1, 2, 3] _
>>> c = a _
Ya hemos visto que, tras efectuar las asignaciones, la memoria quedará así:
a 1
0
2
1
3
2
b 1
0
2
1
3
2
c
¿Qué ocurre si comparamos entre sí los diferentes elementos?
>>> a == b _
True
>>> a == c _
True
Efectivamente: siempre dice que se trata de listas iguales, y es cierto. S´ı, pero, ¿no son ((m´as
iguales)) las listas a y c que las listas a y b? A fin de cuentas, tanto a como c apuntan exactamente
a la misma zona de memoria, mientras que b apunta a una zona distinta. Python dispone de
un operador de comparaci´on especial que a´un no te hemos presentado: is (en espa˜nol, ((es))). El
operador is devuelve True si dos objetos son en realidad el mismo objeto, es decir, si residen
ambos en la misma zona de memoria, y False en caso contrario.
>>> a is b _
False
>>> a is c _
True
Python reserva nuevos bloques de memoria conforme eval´ua expresiones. Observa este ejemplo:
>>> a = [1, 2] _
>>> a is [1, 2] _
False
>>> a == [1, 2] _
True
La segunda orden compara la lista almacenada en a, que se cre´o al evaluar una expresi´on
en la orden anterior, con la lista [1, 2] que se crea en ese mismo instante, as´ı que is nos dice
que ocupan posiciones de memoria diferentes. El operador == sigue devolviendo el valor True,
pues aunque sean objetos diferentes son equivalentes elemento a elemento.

Ejercicio:

220 ¿Qué ocurrirá al ejecutar estas órdenes Python?
>>> a = [1, 2, 3]
>>> a is a
>>> a + [] is a
>>> a + [] == a

a = [1, 2, 3]

a is a

>> true

a + [] is a

>>false

a + [] == a

>>SyntaxError: invalid syntax

Ejercicio:

221. Explica, con la ayuda de un gráfico que represente la memoria, los resultados de evaluar
estas expresiones:
>>> a = [1, 2, 1]
>>> b = [1, 2, 1]
>>> (a[0] is b[0]) and (a[1] is b[1]) and (a[2] is b[2])
True
>>> a == b
True
>>> a is b
False

Ejercicio:

222. ¿Qué ocurrirá al ejecutar estas órdenes Python?
1. [1, 2] == [1, 2] _
2. [1, 2] is [1, 2] _
3.a = [1, 2, 3] _
b = [a[0], a[1], a[2]] _
a == b _
4. a is b _
5. a[0] == b[1] _
6. b is [b[0], b[1], b[2]] _

1. true

2.false

3.true

4.false

5.false

6.false

Ejercicio:

223 Que se muestra por pantalla como respuesta a cada una de estas sentencias Python:
1. a = [1, 2, 3, 4, 5] _
b = a[1:3] _
c = a _
d = a[:] _
a == c _
2. a == d _
3. c == d _
4. a == b _
5. a is c _
6. a is d _
7. c is d _

8. a is b _

1. true

2.true

3.true

4.false

5.true

6.false

7.false

8.false