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]
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 = []
[]
Una ventaja de Python es que proporciona operadores y funciones similares para trabajar con
>>> a = [1, 2, 3]
>>> len(a)
3
>>> len([0, 1, 10, 5])
4
>>> len([10])
1
>>> 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
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
>>> [1, 2, 3][0]
1
En este ejemplo, el primer par de corchetes indica el principio y final de la lista (formada
EJERCICIOS:
214 ¿Qué aparecerá por pantalla al evaluar la expresión [1][0]? ¿Y al evaluar la expresión
>>> [1][0]
1
>>> [][0]
Traceback (most recent call last):
De todos modos, no te preocupes por esa notación un tanto confusa: lo normal es que accedas
>>> 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.
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 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
>>> [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
Los operadores de comparación también trabajan con listas. Parece claro cómo se comportarán
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
Como 2 < 3, el resultado es True, sin necesidad de efectuar ninguna comparación adicional.
218 ¿Sabrías decir que resultados se mostrarán al ejecutar estas sentencias?
>>> [1, 2] < [1, 2]
1. >>> [1,2]<[1,2]
>>> [1, 2, 3] < [1, 2]
2. >>> [1,2,3]<[1,2]
>>> [1, 1] < [1, 2]
3. >>> [1,1]<[1,2]
>>> [1, 3] < [1, 2]
4. >>> [1,3]<[1,2]
>>> [10, 20, 30] > [1, 2, 3]
5. >>> [1,20,30]>[1,2,3]
>>> [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]
>>> [1, 20, 30] > [1, 2, 3]
8. >>> [1,20,30]>[1,2,3]
>>> [0, 2, 3] <= [1, 2, 3]
9. >>> [0,2,3]<=[1,2,3]
>>> [1] < [2, 3]
10. >>> [1]<[2,3]
>>> [1] < [1, 2]
11. >>> [1]<[1,2]
>>> [1, 2] < [0]
12. >>> [1,2]<[0]