Ejemplo 1.14. Definición de una lista

>>> li = ["a", "b", "mpilgrim", "z", "example"] 
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[0]                                       
'a'
>>> li[4]                                       
'example'

	En primer lugar, definimos una lista de cinco elementos. Advierta que mantienen el orden original. Esto no es por azar. Una lista es un conjunto ordenado de elementos encerrados entre corchetes.
	Una lista puede utilizarse como un array con primer índice 0. El primer elemento de una lista no vacía es siempre li[0].
	El último elemento en esta lista de cinco es li[4], porque las listas siempre tienen como primer índice 0.

Ejemplo 1.15. Índices negativos en una lista

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[-1] 
'example'
>>> li[-3] 
'mpilgrim'

	Un índice negativo da acceso a los elementos del final de la lista, contando hacia atrás. El último elemento de cualquier lista no vacía es siempre li[-1].
	Si los índices negativos le resultan confusos, piénselo de este modo: li[n] == li[n - len(li)]. De modo que en esta lista, li[2] == li[2 - 5] == li[-3].

Ejemplo 1.16. Porciones de una lista

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[1:3]  
['b', 'mpilgrim']
>>> li[1:-1] 
['b', 'mpilgrim', 'z']
>>> li[0:3]  
['a', 'b', 'mpilgrim']

	Se puede obtener un subconjunto de una lista, llamado “porción”, especificando dos índices. El valor de retorno es una nueva lista que contiene todos los elementos de la lista original, en orden, empezando con el primer índice de la porción (en este caso li[1]), hasta el segundo índice de la porción (en este caso li[3]), pero sin incluir éste.
	Las porciones funcionan si uno o ambos índices son negativos. Si le ayuda, el primer índice de la porción especifica el primer elemento que se desea obtener, y el segundo índice especifica el primer elemento que no se desea obtener. El valor de retorno es lo que hay entre medias.
	Las listas comienzan en el índice 0, de manera que li[0:3] devuelve los tres primeros elementos de la lista, desde li[0] hasta li[3], sin incluir éste.

Ejemplo 1.17. Atajos para hacer porciones

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[:3] 
['a', 'b', 'mpilgrim']
>>> li[3:] 
['z', 'example']
>>> li[:]  
['a', 'b', 'mpilgrim', 'z', 'example']

	Si uno de los índices es 0, puede omitirse, y se sobreentiende. De modo que li[:3] es lo mismo que li[0:3] en el ejemplo anterior.
	Advierta aquí la simetría. En esta lista de cinco elementos, li[:3] devuelve los tres primeros elementos, y li[3:] devuelve los dos últimos. De hecho, li[:n] devolverá siempre los n primeros elementos, y li[n:] devolverá el resto.
	Si ambos índices se omiten, se incluirán todos los elementos de la lista. Pero esta lista no es la original; es una nueva lista que resulta tener los mismos elementos. li[:] es una forma abreviada para hacer una copia completa de una lista.

Ejemplo 1.18. Adición de elementos a una lista

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li.append("new")               
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']
>>> li.insert(2, "new")            
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
>>> li.extend(["two", "elements"]) 
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

	append añade un elemento al final de la lista.
	insert inserta un elemento en una lista. El argumento numérico es el índice del primer elemento que será desplazado de su posición. Advierta que los elementos de la lista no tienen que ser únicos; ahora hay dos elementos separados con el mismo valor, li[2] y li[6].
	extend concatena listas. Advierta que no se llama a extend con varios argumentos; debe llamarse con un único argumento: una lista. En este caso, la lista tiene dos elementos.

Ejemplo 1.19. Búsqueda en una lista

>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.index("example") 
5
>>> li.index("new")     
2
>>> li.index("c")       
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
ValueError: list.index(x): x not in list
>>> "c" in li           
0

	index encuentra la primera aparición de un valor en la lista y devuelve su índice.
	index encuentra la primera aparición de un valor en la lista. En este caso, new aparece dos veces en la lista, en li[2] y en li[6], pero index devuelve sólo el primer índice, 2.
	Si el valor no se encuentra en la lista, Python lanza una excepción. Esto es notablemente distinto de la mayoría de los lenguajes, que devolverán un índice no válido. Aunque esto parezca molesto, es bueno, ya que significa que su programa terminará en el lugar donde se origina el problema, y no más adelante cuando se intente utilizar el índice no válido.
	Para comprobar si un valor está en la lista, utilice in, que devuelve 1 si se encuentra el valor y 0 si no.

Ejemplo 1.20. Eliminación de elementos de una lista

>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.remove("z")   
>>> li
['a', 'b', 'new', 'mpilgrim', 'example', 'new', 'two', 'elements']
>>> li.remove("new") 
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']
>>> li.remove("c")   
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
ValueError: list.remove(x): x not in list
>>> li.pop()         
'elements'
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two']

	remove elimina la primera aparición de un valor en una lista.
	remove elimina sólo la primera aparición de un valor. En este caso, new aparece dos veces en la lista, pero li.remove("new") sólo elimina la primera.
	Si el valor no se encuentra en la lista, Python lanza una excepción. Esto imita el comportamiento del método index.
	pop es un animal curioso. Hace dos cosas: elimina el último elemento de la lista, y devuelve el valor que ha eliminado. Advierta que esto es diferente de li[-1], que devuelve el valor sin modificar la lista, y de li.remove(valor), que modifica la lista sin devolver ningún valor.

Ejemplo 1.21. Operadores de lista

>>> li = ['a', 'b', 'mpilgrim']
>>> li = li + ['example', 'new'] 
>>> li
['a', 'b', 'mpilgrim', 'example', 'new']
>>> li += ['two']                
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two']
>>> li = [1, 2] * 3              
>>> li
[1, 2, 1, 2, 1, 2]

	Las listas se pueden concatenar también con el operador +. lista = lista + otralista equivale a lista.extend(otralista) . Pero el operador + devuelve la nueva lista como valor, mientras que extend sólo modifica una lista existente.
	Python admite el operador +=. li += ['two'] equivale a li = li + ['two']. El operador += funciona con listas, cadenas y enteros, y puede sobrecargarse para funcionar con clases definidas por el usuario. (Veremos más sobre clases en el capítulo 3).
	El operador * funciona con listas como repetidor. li = [1, 2] * 3 equivale a li = [1, 2] + [1, 2] + [1, 2], que concatena las tres listas en una.