Chapter 8

Listas

Una lista es un conjunto ordenado de valores, en el cual cada valor va identificado por un índice. Los valores que constituyen una lista son sus elementos. Las listas son similares a las cadenas de texto (\emph{strings), que son conjuntos ordenados de caracteres, excepto en que los elementos de una lista pueden ser de cualquier tipo. Las listas y las cadenas, y otras cosas que se comportan como conjuntos ordenados, se llaman \textbf{secuencias}. \section{Valores de una lista} Hay varias maneras de crear una nueva lista; la más sencilla es encerrar sus elementos entre corchetes: \begin{verbatim} [10, 20, 30, 40] ["spam", "elástico", "golondrina"] \end{verbatim} El primer ejemplo es una lista de cuatro enteros. El segundo es una lista de tres cadenas de texto. Los elementos de una lista no tienen por qué ser del mismo tipo. La siguiente lista contiene una cadena, un número con decimales y un entero, y, maravilla de las maravillas, otra lista: \begin{verbatim} ["hola", 2.0, 5, [10, 20]] \end{verbatim} Se dice que una lista dentro de otra lista está \textbf{anidada}.\index{listas!anidadas} Las listas que contienen números enteros consecutivos son comunes, de manera que Python proporciona una manera sencilla de crearlas: \begin{verbatim} >>> range(1,5) [1, 2, 3, 4] \end{verbatim} La función \texttt{range} toma dos argumentos y devuelve una lista que contiene todos los enteros entre el primero y el segundo, ¡incluyendo el primero pero no el segundo! Hay dos formas alternativas para \texttt{range}. Con un solo argumento, crea una lista que empieza desde 0: \begin{verbatim} >>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] \end{verbatim} Si hay un tercer argumento, especificará el espacio entre dos valores sucesivos; a esto se le llama \emph{paso} (\emph{step}). Este ejemplo cuenta de 1 a 10 de dos en dos (con pasos de 2). \begin{verbatim} >>> range(1, 10, 2) [1, 3, 5, 7, 9] \end{verbatim} Para terminar, hay una lista especial que no contiene elementos. Se la llama lista vacía y se representa \texttt{{[}{]}}. Con todas estas maneras para crear listas, sería decepcionante que no pudiéramos asignar valores de listas a variables o pasar listas como parámetros a funciones. Por supuesto que podemos. \begin{verbatim} vocabulario = ["mejorar", "castigar", "defenestrar"] numeros = [17, 123] vacio = [] print vocabulario, numeros, vacio ['mejorar', 'castigar', 'defenestrar'] [17, 123] [] \end{verbatim} \section{Acceso a los elementos} \index{lista!elemento} \index{acceso} La sintaxis para acceder a los elementos de una lista es la misma que para acceder a los caracteres de una cadena: el operador corchetes \texttt{{[}{]}}. La expresión dentro de los corchetes especifica el índice. Recuerde que los índices siempre comienzan en cero: \begin{verbatim} print numeros[0] numeros[1] = 5 \end{verbatim} El operador \texttt{{[}{]}} puede aparecer en cualquier parte de una expresión. Cuando aparece a la izquierda de una asignación, cambia uno de los elementos de la lista, de manera que el ``unésimo'' elemento de \texttt{numeros}, que era 123, ahora es 5. Se puede usar como índice cualquier expresión entera. \begin{verbatim} >>> numeros[3-2] 5 >>> numeros[1.0] TypeError: sequence index must be integer \end{verbatim} Si intenta acceder (leer o modificar) un elemento que no existe, obtendrá un error en tiempo de ejecución: \index{error en tiempo de ejecución} \begin{verbatim} >>> numeros[2] = 5 IndexError: list assignment index out of range \end{verbatim} Si se da un índice negativo, se cuenta hacia atrás desde el final de la lista. \begin{verbatim} >>> numeros[-1] 5 >>> numeros[-2] 17 >>> numeros[-3] IndexError: list index out of range \end{verbatim} \texttt{numeros{[}-1{]}} es el último elemento de la lista, \texttt{numeros{[}-2{]}} es el penúltimo, y \texttt{numeros{[}-3{]}} no existe. Es muy habitual usar una varible de bucle como índice para una lista: \begin{verbatim} jinetes = ["guerra", "hambre", "peste", "muerte"] i = 0 while i < 4: print jinetes[i] i = i + 1 \end{verbatim} Este bucle \texttt{while} cuenta desde 0 hasta 4. Cuando la variable de bucle vale 4, la condición falla y acaba el bucle. Por tanto, el cuerpo del bucle sólo se ejecuta cuando \texttt{i} es 0, 1, 2 y 3. Cada vez que recorremos el bucle, la variable \texttt{i} se usa como índice de la lista, imprimiendo el elemento \texttt{i}-ésimo. Esta plantilla de computación se llama \textbf{recorrido de lista}. \index{lista!recorrido} \index{recorrido!lista} \section{Longitud (tamaño) de una lista} \index{longitud} \index{lista!longitud} La función \texttt{len} toma una lista y devuelve su tamaño. Es una buena idea usar este valor como límite superior de un bucle, en lugar de una constante. De esta manera, si el tamaño de la lista cambia, no habrá que estar haciendo cambios en todos los bucles; funcionarán correctamente con cualquier tamaño de lista. \begin{verbatim} jinetes = ["guerra", "hambre", "peste", "muerte"] i = 0 while i < len(jinetes): print jinetes[i] i = i + 1 \end{verbatim} La última vez que se ejecuta el cuerpo del bucle, \texttt{i} es \texttt{len(jinetes) - 1}, que es el índice del último elemento. Cuando \texttt{i} se iguala a \texttt{len(jinetes)}, la condición falla y no se ejecuta el cuerpo, lo que es una cosa buena, ya que \texttt{len(jinetes)} no es un índice legal. Aunque una lista puede contener otra lista como elemento, la lista anidada cuenta como un elemento sencillo. El tamaño de esta lista es 4: \begin{verbatim} ['spam!', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]] \end{verbatim} \begin{quote} {\em Como ejercicio, escriba un bucle que recorra la lista anterior e imprima la longitud de cada elemento. ¿qué ocurre si envía un entero a \texttt{len}?} \end{quote} \section{Pertenencia a una lista} \index{lista!pertenencia} \index{operador in} \index{operador!in} {\tt in} es un operador booleano que comprueba la pertenencia a una secuencia. Lo usamos en la Sección~\ref{in} con las cadenas, pero también funciona con las listas y otras secuencias: \beforeverb \begin{verbatim} >>> jinetes = ['guerra', 'hambre', 'peste', 'muerte'] >>> 'peste' in jinetes 1 >>> 'libertinaje' in jinetes 0 \end{verbatim} \afterverb Como ``peste'' es un miembro de la lista \texttt{jinetes}, el operador \texttt{in} devuelve verdadero. Como ``libertinaje'' no está en la lista, \texttt{in} devuelve falso. Podemos usar \texttt{not} en combinación con \texttt{in} para comprobar si un elemento no es miembro de una lista: \beforeverb \begin{verbatim} >>> 'libertinaje' not in jinetes 1 \end{verbatim} \afterverb \section{Listas y bucles \texttt{for}} \index{bucle for} \index{lista!bucle for} \index{recorrido} El bucle \texttt{for} que vimos en la Sección~\ref{for} también funciona con las listas. La sintaxis generalizada de un bucle \texttt{for} es: \begin{verbatim} for VARIABLE in LISTA: CUERPO \end{verbatim} Esta sentencia es equivalente a: \begin{verbatim} i = 0 while i < len(LISTA): VARIABLE = LISTA[i] CUERPO i = i + 1 \end{verbatim} El bucle \texttt{for} es más conciso porque podemos eliminar la variable de bucle, \verb|i|. Aquí tenemos el bucle anterior con un bucle \texttt{for}: \begin{verbatim} for jinete in jinetes: print jinete \end{verbatim} Más aún, casi se lee igual que en español, {}``Para (cada) jinete en (la lista de) jinetes, imprime (el nombre del) jinete''. Se puede usar cualquier expresión de lista en un bucle \texttt{for}: \begin{verbatim} for numero in range(20): if numero % 2 == 0: print numero for fruta in ["plátano", "manzana", "membrillo"]: print "Me gusta comer " + fruta + "s!" \end{verbatim} El primer ejemplo imprime todos los números pares entre el 0 y el 19. El segundo ejemplo expresa su entusiasmo por diferentes frutas. \section{Operaciones con listas} \index{operaciones con listas} \index{listas!operaciones con} \index{operadores!para listas} \index{operaciones!con listas} El operador \texttt{+} concatena listas: \begin{verbatim} >>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> c = a + b >>> print c [1, 2, 3, 4, 5, 6] \end{verbatim} De forma similar, el operador \texttt{{*}} repite una lista un número dado de veces: \index{repetici'on!lista} \begin{verbatim} >>> [0] * 4 [0, 0, 0, 0] >>> [1, 2, 3] * 3 [1, 2, 3, 1, 2, 3, 1, 2, 3] \end{verbatim} En el primer ejemplo la lista \texttt{{[}0{]}} contiene un solo elemento que es repetido cuatro veces. En el segundo ejemplo, la lista \texttt{{[}1, 2, 3{]}} se repite tres veces. \section{Porciones (slices)} \index{porciones} \index{lista!porciones} Las operaciones de porciones que vimos en la Sección~\ref{slice} también funcionan en sobre las listas: \begin{verbatim} >>> lista = ['a', 'b', 'c', 'd', 'e', 'f'] >>> lista[1:3] ['b', 'c'] >>> lista[:4] ['a', 'b', 'c', 'd'] >>> lista[3:] ['d', 'e', 'f'] >>> lista[:] ['a', 'b', 'c', 'd', 'e', 'f'] \end{verbatim} \section{Las listas son mutables} \index{mutable!lista} \index{lista!mutable} A diferencia de las cadenas, las listas son mutables, lo que significa que podemos cambiar sus elementos. Podemos modificar uno de sus elementos usando el operador corchetes en el lado izquierdo de una asignación: \beforeverb \begin{verbatim} >>> fruta = ["plátano", "manzana", "membrillo"] >>> fruta[0] = "pera" >>> fruta[-1] = "naranja" >>> print fruta ['pera', 'manzana', 'naranja'] \end{verbatim} \afterverb Con el operador de porción podemos reemplazar varios elementos a la vez: \begin{verbatim} >>> lista = ['a', 'b', 'c', 'd', 'e', 'f'] >>> lista[1:3] = ['x', 'y'] >>> print lista ['a', 'x', 'y', 'd', 'e', 'f'] \end{verbatim} Además, puede eliminar elementos de una lista asignándoles la lista vacía: \begin{verbatim} >>> lista = ['a', 'b', 'c', 'd', 'e', 'f'] >>> lista[1:3] = [] >>> lista ['a', 'd', 'e', 'f'] \end{verbatim} Y puede añadir elementos a la lista embutiéndolos en una porción vacía en la posición deseada: \begin{verbatim} >>> lista = ['a', 'd', 'f'] >>> lista[1:1] = ['b', 'c'] >>> print lista ['a', 'b', 'c', 'd', 'f'] >>> lista[4:4] = ['e'] >>> print lista ['a', 'b', 'c', 'd', 'e', 'f'] \end{verbatim} \section{Borrado en una lista} \index{borrado!lista} \index{borrado en una lista} El uso de porciones para borrar elementos de una lista puede ser extraño, y por ello propicio a los errores. Python nos da una alternativa que resulta más legible. {\tt del} elimina un elemento de una lista: \beforeverb \begin{verbatim} >>> a = ['uno', 'dos', 'tres'] >>> del a[1] >>> a ['uno', 'tres'] \end{verbatim} \afterverb % Como podría esperar, {\tt del} maneja índices negativos y provoca un error en tiempo de ejecución sin el índice está fuera de límites. Puede usar una porción como índice para {\tt del}: \beforeverb \begin{verbatim} >>> lista = ['a', 'b', 'c', 'd', 'e', 'f'] >>> del lista[1:5] >>> print lista ['a', 'f'] \end{verbatim} \afterverb % Como es habitual, las porciones seleccionan todos los elementos hasta, pero no incluído, el segundo índice. \section{Objetos y valores} \index{objeto} \index{valor} Si ejecutamos estas sentencias de asignación: \begin{verbatim} a = "banana" b = "banana" \end{verbatim} Está claro que \texttt{a} y \texttt{b} apuntan ambos a cadenas con las letras \texttt{\char`\"{}banana\char`\"{}}. Pero no podemos saber si están apuntando a {\em la misma} cadena. Hay dos posibles estados: \vspace{0.1in} \centerline{\includegraphics{../illustrations/list1.eps} } \vspace{0.1in} En un caso, \texttt{a} y \texttt{b} se refieren a dos cosas diferentes que tienen el mismo valor. En el segundo caso, se refieren a la misma cosa. Estas {}``cosas'' tienen nombres; se les denomina \textbf{objetos}. Un objeto es una cosa a la que se puede referir una variable. Cada objeto tiene un \textbf{identificador} único, que podemos obtener por medio de la función \texttt{id}. Imprimiendo los identificadores de \texttt{a} y \texttt{b} podemos saber si apuntan al mismo objeto. \begin{verbatim} >>> id(a) 135044008 >>> id(b) 135044008 \end{verbatim} En este caso, las dos veces obtenemos el mismo identificador, lo que significa que Python sólo creó una cadena y ambas variables, \texttt{a} y \texttt{b}, apuntan a ella. Como las cadenas de texto son inmutables, no hay diferencia práctica entre los dos posibles estados. Para tipos mutables como las listas, sí que importa. Curiosamente, las listas se comportan de otra manera. Cuando crea dos listas, obtiene dos objetos: \begin{verbatim} >>> a = [1, 2, 3] >>> b = [1, 2, 3] >>> id(a) 135045528 >>> id(b) 135041704 \end{verbatim} De manera que el diagrama de estado sería tal como éste: \vspace{0.1in} \centerline{\includegraphics{../illustrations/list2.eps} } \vspace{0.1in} \texttt{a} y \texttt{b} tienen el mismo valor, pero no se refieren al mismo objeto. \section{Alias (poner sobrenombres)} \index{alias} \index{referencias!alias} Como las variables apuntan a objetos, si asigna una variable a otra, ambas variables se refieren al mismo objeto: \begin{verbatim} >>> a = [1, 2, 3] >>> b = a \end{verbatim} En este caso, el diagrama de estados sería como éste: \vspace{0.1in} \centerline{\includegraphics{../illustrations/list3.eps} } \vspace{0.1in} Como la misma lista tiene dos nombres diferentes, \texttt{a} y \texttt{b}, podemos decir que se le ha puesto un \textbf{alias}. Los cambios hechos a un alias afectan al otro: \begin{verbatim} >>> b[0] = 5 >>> print a [5, 2, 3] \end{verbatim} Aunque este comportamiento puede ser útil, a veces es inesperado o indeseable. En general, es más seguro evitar los alias cuando trabajemos con objetos mutables. Por supuesto, no hay problema con los objetos inmutables. Por ello Python se toma la libertad de poner alias a las cadenas cuando ve una oportunidad de economizar. \section{Clonar listas} \index{listas!clonado} \index{clonado} Si queremos modificar una lista y mantener una copia del original, necesitaremos ser capaces de hacer una copia de la lista en sí, no sólo de su referencia. Este proceso a veces se denomina \textbf{clonado}, para evitar la ambigüedad de la palabra ``copia''. La forma más fácil de clonar una lista es por medio del operador de porción: \begin{verbatim} >>> a = [1, 2, 3] >>> b = [] >>> b[:] = a[:] >>> print b [1, 2, 3] \end{verbatim} La extracción de una porción de \texttt{a} crea una nueva lista. En este caso, la porción consta de la lista completa. Ahora tenemos libertad de hacer cambios en \texttt{b} sin preocuparnos de \texttt{a}: \begin{verbatim} >>> b[0] = 5 >>> print a [1, 2, 3] \end{verbatim} \begin{quote} \emph{Como ejercicio, dibuje un diagrama de estado de \texttt{a} y \texttt{b} antes y despues del cambio.} \end{quote} \section{Listas como parámeteros} \index{listas!como parámetros} \index{parámetro} \index{parámetro!lista} Cuando se pasa una lista como argumento, en realidad se pasa una referencia a ella, no una copia de la lista. Por ejemplo, la función \texttt{cabeza} toma una lista como parámetro y devuelve el primer elemento. \begin{verbatim} def cabeza(lista): return lista[0] \end{verbatim} Así es como se usa. \begin{verbatim} >>> numeros = [1,2,3] >>> cabeza(numeros) 1 \end{verbatim} El parámetro \texttt{lista} y la variable \texttt{numeros} son alias de un mismo objeto. El diagrama de estado es así: \beforefig \centerline{\psfig{figure=../illustrations/stack5.eps}} \afterfig Como el objeto lista está compartido por dos marcos, lo dibujamos entre ambos. Si la función modifica una lista pasada como parámetro, el que hizo la llamada verá el cambio. \texttt{borra\_cabeza} elimina el primer elemento de una lista. \begin{verbatim} def borra_cabeza(lista): del lista[0] \end{verbatim} Aquí vemos el uso de \texttt{borra\_cabeza}: \begin{verbatim} >>> numeros = [1,2,3] >>> borra_cabeza(numeros) >>> print numeros [2, 3] \end{verbatim} Si una función devuelve una lista, devuelve una referencia a la lista. Por ejemplo, \texttt{cola} devuelve una lista que contiene todos los elementos de una lista dada, excepto el primero. \begin{verbatim} def cola(lista): return lista[1:] \end{verbatim} Aquí vemos cómo se usa \texttt{cola}: \begin{verbatim} >>> numeros = [1,2,3] >>> resto = cola(numeros) >>> print resto >>> [2, 3] \end{verbatim} Como el valor de retorno se creó con una porción, es una lista. La creación de \texttt{rest}, así como cualquier cambio posterior en \texttt{rest}, no afectará a \texttt{numbers}. \section{Listas anidadas} \label{nested lists} \index{listas anidadas} \index{listas!anidadas} Una lista anidada es una lista que aparece como elemento dentro de otra lista. En esta lista, el tri-ésimo elemento es una lista anidada: \begin{verbatim} >>> lista = ["hola", 2.0, 5, [10, 20]] \end{verbatim} Si imprimimos \texttt{lista{[}3{]}}, obtendremos \texttt{{[}10, 20{]}}. Para extraer los elementos de la lista anidada, podemos proceder en dos pasos: \begin{verbatim} >>> elt = lista[3] >>> elt[0] 10 \end{verbatim} O podemos combinarlos: \begin{verbatim} >>> lista[3][1] 20 \end{verbatim} Los operadores corchete se evalúan de izquierda a derecha, así que esta expresión saca el tri-ésimo elemento de \texttt{lista} y luego extrae el unésimo elemento de ella. \section{Matrices} \index{matriz} \index{lista!anidada} Es común usar listas anidadas para representar matrices. Por ejemplo, la matriz: \vspace{0.1in} \centerline{\includegraphics{../illustrations/matrix.eps} } \vspace{0.1in} puede ser representada como: \begin{verbatim} >>> matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] \end{verbatim} \texttt{matriz} es una lista con tres elementos, siendo cada elemento una fila de la matriz. Podemos elegir una fila entera de la matriz de la forma normal: \begin{verbatim} >>> matriz[1] [4, 5, 6] \end{verbatim} O tomar sólo un elemento de la matriz usando la forma de doble índice: \begin{verbatim} >>> matriz[1][1] 5 \end{verbatim} El primer índice escoge la fila y el segundo la columna. Aunque esta manera de representar matrices es común, no es la única posibilidad. Una pequeña variación consiste en usar una lista de columnas en lugar de flas. Más adelante veremos una alternativa más radical usando un diccionario. \index{diccionario} \index{fila} \index{columna} \section{Cadenas y listas} \index{funci'on split} \index{funci'on join} Dos de las funciones más útiles del módulo \texttt{string} tienen que ver con listas de cadenas. La función \texttt{split} divide una cadena en una lista de palabras. Por defecto, cualquier número de caracteres de espacio en blanco se considera un límite de palabra: \beforeverb \begin{verbatim} >>> import string >>> cancion = "La lluvia en Sevilla..." >>> string.split(cancion) ['La', 'lluvia', 'en', 'Sevilla...'] \end{verbatim} \afterverb % Se puede usar un argumento opcional llamado \textbf{delimitador} para especificar qué caracteres se usarán como límites de palabra. El siguiente ejemplo usa la cadena \texttt{ll} como delimitador: \beforeverb \begin{verbatim} >>> string.split(cancion, 'll') ['La ', 'uvia en Sevi', 'a...'] \end{verbatim} \afterverb % Observe que el delimitador no aparece en la lista. La función \texttt{join} es la inversa de \texttt{split}. Toma una lista de cadenas y concatena los elementos con un espacio entre cada par: \beforeverb \begin{verbatim} >>> lista = ['La', 'lluvia', 'en', 'Sevilla...'] >>> string.join(lista) 'La lluvia en Sevilla...' \end{verbatim} \afterverb % Como \texttt{split}, \texttt{join} acepta un delimitador opcional que se inserta entre los elementos. El delimitador por defecto es el espacio. \beforeverb \begin{verbatim} >>> string.join(lista, '_') 'La_lluvia_en_Sevilla...' \end{verbatim} \afterverb \begin{quote} \begin{quote} {\em A modo de ejercicio, describa la relación que hay entre \texttt{string.join(string.split(cancion))} y {\tt cancion}. ¿Es la misma para todas las cadenas? ¿Cuándo sería diferente?} \end{quote} \end{quote} \section{Glosario} \begin{description} \item [lista:] Una colección de objetos con nombre, en la que cada objeto es identificado por un índice. \item [índice:] Una variable o valor enteros que se usan para indicar un elemento de una lista. \item[elemento:] Uno de los valores de una lista (u otra secuencia). El operador corchete selecciona elementos de una lista. \item [secuencia:] Cualquier tipo de datos que consita en un conjunto ordenado de elementos, con cada elemento identificado por un índice. \item [lista~anidada:] Una lista que es elemento de otra lista. \item [recorrido~de~lista:] Acceso secuencial a cada elemento de una lista. \item [objeto:] Una cosa a la que se puede referir una variable. \item [alias:] Múltiples variables que contienen referencias al mismo objeto. \item[clonar:] Crear un objeto nuevo que tiene el mismo valor que un objeto ya existente. Copiar una referencia a un objeto crea un alias, pero no clona el objeto. \item[delimitador:] Un carácter o cadena utilizado para indicar dónde debe cortarse una cadena. \index{lista} \index{índice} \index{secuencia} \index{elemento} \index{lista anidada} \index{recorrido de lista} \index{objeto} \index{alias} \index{clonar} \index{delimitador} \end{description} %\end{document}