El operador + concatena listas:
1: >>> a = [1, 2, 3]
2: >>> b = [4, 5, 6]
3: >>> c = a + b
4: >>> print c
5: [1, 2, 3, 4, 5, 6]
1: >>> [0] * 4
2: [0, 0, 0, 0]
3: >>> [1, 2, 3] * 3
4: [1, 2, 3, 1, 2, 3, 1, 2, 3]
En el primer ejemplo la lista [0] contiene un solo elemento que es repetido cuatro veces. En el segundo ejemplo, la lista [1, 2, 3] se repite tres veces.
Las operaciones de porciones que vimos en la Sección 7.4 también funcionan en sobre las listas:
1: >>> lista = ['a', 'b', 'c', 'd', 'e', 'f']
2: >>> lista[1:3]
3: ['b', 'c']
4: >>> lista[:4]
5: ['a', 'b', 'c', 'd']
6: >>> lista[3:]
7: ['d', 'e', 'f']
8: >>> lista[:]
9: ['a', 'b', 'c', 'd', 'e', 'f']
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:
1: >>> fruta = ["pl¶atano", "manzana", "membrillo"]
2: >>> fruta[0] = "pera"
3: >>> fruta[-1] = "naranja"
4: >>> print fruta
5: ['pera', 'manzana', 'naranja']
Con el operador de porción podemos reemplazar varios elementos a la vez:
1: >>> lista = ['a', 'b', 'c', 'd', 'e', 'f']
2: >>> lista[1:3] = ['x', 'y']
3: >>> print lista
4: ['a', 'x', 'y', 'd', 'e', 'f']
Además, puede eliminar elementos de una lista asignándoles la lista vacía:
1: >>> lista = ['a', 'b', 'c', 'd', 'e', 'f']
2: >>> lista[1:3] = []
3: >>> lista
4: ['a', 'd', 'e', 'f']
Y puede añadir elementos a la lista embutiéndolos en una porción vacía en la posición deseada:
1: >>> lista = ['a', 'd', 'f']
2: >>> lista[1:1] = ['b', 'c']
3: >>> print lista
4: ['a', 'b', 'c', 'd', 'f']
5: >>> lista[4:4] = ['e']
6: >>> print lista
7: ['a', 'b', 'c', 'd', 'e', 'f']
Si ejecutamos estas sentencias de asignación:
1: a = "banana"
2: b = "banana"
Esta claro que a y b apuntan ambos a cadenas con las letras “banana“. Pero no podemos saber si están apuntando a la misma cadena.
Hay dos posibles estados:
En un caso, a y 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 objetos. Un objeto es una cosa a la que se puede referir una variable.
Cada objeto tiene un identificador único, que podemos obtener por medio de la función id. Imprimiendo los identificadores de a y b podemos saber si apuntan al mismo objeto.
1: >>> id(a)
2: 135044008
3: >>> id(b)
4: 135044008
Curiosamente, las listas se comportan de otra manera. Cuando crea dos listas, obtiene dos objetos:
1: >>> a = [1, 2, 3]
2: >>> b = [1, 2, 3]
3: >>> id(a)
4: 135045528
5: >>> id(b)
6: 135041704
De manera que el diagrama de estado sería tal como este:
a y b tienen el mismo valor, pero no se refieren al mismo objeto.
Como las variables apuntan a objetos, si asigna una variable a otra, ambas variables se refieren al mismo objeto:
1: >>> a = [1, 2, 3]
2: >>> b = a
En este caso, el diagrama de estados sería como este:
Como la misma lista tiene dos nombres diferentes, a y b, podemos decir que se le ha puesto un alias. Los cambios hechos a un alias afectan al otro:
1: >>> b[0] = 5
2: >>> print a
3: [5, 2, 3]
Aunque este comportamiento puede ser útil, a veces es inesperado o indeseable.
En general, es mas 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.
Si queremos modificar una lista y mantener una copia del original, necesitaremos ser capaces de hacer una copia de la lista en sí, no solo de su referencia. Este proceso a veces se denomina clonado, para evitar la ambigüedad de la palabra ”copia”.
La forma mas fácil de clonar una lista es por medio del operador de porción:
1: >>> a = [1, 2, 3]
2: >>> b = []
3: >>> b[:] = a[:]
4: >>> print b
5: [1, 2, 3]
La extracción de una porción de a crea una nueva lista. En este caso, la porción consta de la lista completa.
Ahora tenemos libertad de hacer cambios en b sin preocuparnos de a:
1: >>> b[0] = 5
2: >>> print a
3: [1, 2, 3]
Como ejercicio, dibuje un diagrama de estado de a y b antes y después del cambio.
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 cabeza toma una lista como parámetro y devuelve el primer elemento.
1: def cabeza(lista):
2: return lista[0]
Así es como se usa.
1: >>> numeros = [1,2,3]
2: >>> cabeza(numeros)
3: 1
El parámetro lista y la variable números son alias de un mismo objeto. El diagrama de estado es así:
Como el objeto lista esta compartido por dos marcos, lo dibujamos entre ambos.
Si la función modifica una lista pasada como parámetro, el que hizo la llamada vera el cambio. borra cabeza elimina el primer elemento de una lista.
1: def borra_cabeza(lista):
2: del lista[0]
Aquí vemos el uso de borra cabeza:
Si una función devuelve una lista, de
1: >>> numeros = [1,2,3]
2: >>> borra_cabeza(numeros)
3: >>> print numeros
4: [2, 3]
vuelve una referencia a la lista. Por ejemplo, cola devuelve una lista que contiene todos los elementos de una lista dada, excepto el primero.
1: def cola(lista):
2: return lista[1:]
Aquí vemos como se usa cola:
1: >>> numeros = [1,2,3]
2: >>> resto = cola(numeros)
3: >>> print resto
4: >>> [2, 3]
Como el valor de retorno se creo con una porción, es una lista. La creación de rest, así como cualquier cambio posterior en rest, no afectara a numbers.
Es común usar listas anidadas para representar matrices. Por ejemplo, la matriz:
1 2 3
7 8 9
4 5 6
puede ser representada como:
1: >>> matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
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:
1: >>> matriz[1]
2: [4, 5, 6]
1: >>> matriz[1][1]
2: 5
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 filas. Mas adelante veremos una alternativa mas radical usando un diccionario.
Dos de las funciones mas útiles del modulo string tienen que ver con listas de cadenas. La función split divide una cadena en una lista de palabras. Por defecto, cualquier numero de caracteres de espacio en blanco se considera un límite de palabra:
1: >>> import string
2: >>> cancion = "La lluvia en Sevilla..."
3: >>> string.split(cancion)
4: ['La', 'lluvia', 'en', 'Sevilla...']
Se puede usar un argumento opcional llamado delimitador para especificar que caracteres se usaran como límites de palabra. El siguiente ejemplo usa la cadena ll como delimitador:
1: >>> string.split(cancion, 'll')
2: ['La ', 'uvia en Sevi', 'a...']
Observe que el delimitador no aparece en la lista.
La función join es la inversa de split. Toma una lista de cadenas y concatena
los elementos con un espacio entre cada par:
1: >>> lista = ['La', 'lluvia', 'en', 'Sevilla...']
2: >>> string.join(lista)
3: 'La lluvia en Sevilla...'
Como split, join acepta un delimitador opcional que se inserta entre los elementos. El delimitador por defecto es el espacio.
1: >>> string.join(lista, '_')
2: 'La_lluvia_en_Sevilla...'
A modo de ejercicio, describa la relación que hay entre
string.join(string.split(cancion)) y canción. ¿Esla misma para todas las cadenas?
¿Cuando sería diferente?
lista: Una colección de objetos con nombre, en la que cada objeto es identificado por un índice.
índice: Una variable o valor enteros que se usan para indicar un elemento de una lista.
elemento: Uno de los valores de una lista (u otra secuencia). El operador corchete selecciona elementos de una lista.
secuencia: Cualquier tipo de datos que consista en un conjunto ordenado de elementos, con cada elemento identificado por un índice.
lista anidada: Una lista que es elemento de otra lista.
recorrido de lista: Acceso secuencial a cada elemento de una lista.
objeto: Una cosa a la que se puede referir una variable.
alias: Múltiples variables que contienen referencias al mismo objeto.
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.
delimitador: Un carácter o cadena utilizado para indicar donde debe cortarse una cadena.
Creado con WordPress & Tema de Anders Norén