03 - Curso de Python - Listas Tuplas y Diccionarios en Python

Cualquier duda suelo atender en este foro de python

Todo el código de este curso de Python gratuito está en github https://github.com/chuidiang/chuidiang-ejemplos/tree/master/PYTHON/curso-python. Hay algún fichero de ejemplo en el directorio correspondiente a este capítulo, pero no lo vamos a seguir aquí exactamente. Usaremos la línea comandos python para ir escribiendo los ejemplos.

Anterior: 02 - Curso de Python - Variables -- Índice: Curso de Python -- Siguiente: 04 - Curso de Python - Condicionales y bucles en Python.

Secuencias

En python una secuencia es una lista de elementos (valores, datos, etc) a cuyos elementos se puede acceder por su posición, siendo el primero el de la posición 0 y los siguientes el 1,2,3, etc.

Hay secuencias inmutables, es decir, una vez creadas, no podemos moficiar sus elementos, ni añadir ni borrar más. Otras son mutables, es decir, una vez creada podemos añadir más elementos, borrarlos o cambiarlos por otros.

Las secuencias mutables son: Listas y arrays de bytes.

Las secuencias inmutables son: Tuplas, conjuntos y bytes.

Operaciones comunes en todas las secuencias

Todas las secuencias tienen un conjunto de operaciones que son comunes. Son operaciones para saber si un elmento está dentro de la secuencia, para acceder a un elemento en determinada posición, etc. Son las siguientes

Operacion	Resultado
x in s	True si el elemento x está dentro de la secuencia s.
x not in s	False si el elemento x no está en la secuencia s.
s + t	Da una secuencia única con los elementos de ambas.
s * n or n * s	si n es un número entero, se obtiene una secuencia que es resultado de repetir la secuencia s n veces.
s[i]	Empezando con i=0, el i-ésimo elemento de la secuencia.
s[i:j]	Los elementos desde la i-ésima posición hasta la posición j, excluida este último.
s[i:j:k]	Como el anterior, pero de k en k elementos. Por ejemplo, si decimos s[1:10:2] obtenemos los elementos del 1 al 10 saltando de 2 en 2, es decir, el 1, el 3, el 5 ..
len(s)	Número de elementos en la secuencia s.
min(s)	El elemento más pequeño de la secuencia, siempre que todos los elementos sean del mismo tipo y por tanto, puedan compararse entre sí.
max(s)	El elemento más grande de la secuencia, siempre que todos los elementos sean del mismo tipo y por tanto, puedan compararse entre sí.
s.index(x[, i[, j]])	Devuelve la posición del elemento x dentro de la secuencia. Si ponemos un segundo parámetro i, buscará a partir de esa posición. Si ponemos un parámetro j, buscará hasta esa posición, excluida.
s.count(x)	Número de veces que el elemento x está dentro de la secuencia.

No te preocupes, en la primera secuencia que tratamos, las listas, vamos a ver ejemplos de todo esto para que quede más claro. Como es común, no lo repetiremos en tuplas.

Listas

Una lista en python es una secuencia de valores que tiene las siguientes características

• Los valores pueden ser de distintos tipos.
• Podemos modificar la lista añadiendo, eliminando y modificando elementos, es decir, es una secuencia mutable.
• Los valores están ordenados, es decir, hay un valor que es el primero de la lista, otro el segundo, etc.

Creación de la lista

Para crear una lista basta poner la lista de valores entre corchetes [].

>>> lista = []
>>> lista
[]

>>> lista = ['a',1,True]
>>> lista
['a',1,True]

En el primer caso estamos creando una lista vacía sin elementos. En el segundo una lista con tres elementos: una cadena de texto, un número y un booleano.

Acceso a los elementos de la lista

Se puede acceder a un elemento de la lista poniendo entre corchetes su posición

>>> lista = ['a',1,True]
>>> lista[2]
True
>>> lista[1] = 'modificado'
>>> lista[1]
'modificado'
>>> lista
['a', 'modificado', True]

En la primera línea sacamos por pantalla el valor en la posición 2. Como la primera posición es la cero, estaríamos sacando el True de ['a',1,True]. En la segunda línea estamos modificando el valor en la posición 1, es decir, estamos cambiando el 1 de ['a',1,True] por 'modificado', quedando después de la operación como ['a','modificado',True]

Si ponemos la posición negativa, python entiende que estamos contando desde el final de la lista hacia el principio.

>>> lista = [1,2,3,4,5]
>>> lista[-1]
5

Se puede acceder a rangos completos, poniendo entre corchetes dos índices, el primero y el último del rango, separados por dos puntos. El último del rango queda excluido.

>>> lista = [1,2,3,4,5]
>>> # Sacamos rango 1 a 3, excluido el 3.
>>> lista[1:3]
[2, 3]

>>> # Modificamos valores del rango
>>> lista[1:3] = ['modificado','alterado']
>>> lista
[1, 'modificado', 'alterado', 4, 5]

>>> # Asignamos valores del rango a variables sueltas
>>> a,b = lista[1:3]
>>> a
'modificado'
>>> b
'alterado'
>>>

lista[1:3] devuelve los elementos desde el de posición 1, hasta el de posición 3 excluido. Es decir, de [1,2,3,4,5] devuelve el [2, 3].

En la asignación, mete los elementos de la lista ['modificado','alterado'] en los elementos 1 y 2 de lista.

En la segunda asignación, mete cada elemento del rango de la lista en una de las variables, es decir, el elemento de la posición 1 en la variable a y el elemento de la posición en la variable b.

En estas asignaciones, ¿qué pasa si hay más elementos en un lado o en otro?. En el primer caso, cuando se asignan valores a un rnago, va reemplazando dentro del rango de la lista hastas donde puede e inserta justo detrás los siguientes elementos

>>> lista=[1,2,3,4]
>>> # Metemos menos elementos que los que tiene el rango.
>>> lista[1:3]=[9]
>>> lista
[1, 9, 4]

>>> lista=[1,2,3,4]
>>> # Metemos mas elementos que los que tiene el rango.
>>> lista[1:3]=[9,9,9,9,9]
>>> lista
[1, 9, 9, 9, 9, 9, 4]

Si hay menos, reemplaza y elimina los que le sobran del rango. Vemos que ha eliminado el 3. Si hay más, reemplaza dos e inserta el resto, vemos que ha reemplazado el 2 y el 3 por nueves y ha añadido el resto de nueves.

En el segundo caso, con las variables, si hay más o menos variales que el rango del lado derecho, da error.

>>> lista=[1,2,3,4]
>>> a,b=lista[1:2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 2, got 1)

Adicionalmente, si en el rango [1:2] dejamos sin poner uno de los índices, python entiende que es

• Desde el primer elmento (el 0) en caso de no poner el primer número del rango.
• Hasta el último elemento en el caso de no poner el segundo número del rango.

>>> lista[:]
[1, 2, 3, 4]

>>> lista[:2]
[1, 2]

>>> lista[2:]
[3, 4]

Verificar si un elemento está en la lista

Podemos ver si un elemento está o no en la lista con los operadores in y not in

>>> lista = [1,2,3,'a','b','c']
>>> 'a' in lista
True
>>> 5 in lista
False
>>> 'd' not in lista
True
>>> 1 not in lista
False
>>>

Añadir elementos a la lista

Para añadir un elemento al final de la lista, podemos usar la funcion append()

>>> lista=[1,2,3,4]
>>> lista.append("anadido")
>>> lista
[1, 2, 3, 4, 'anadido']

Si queremos insetar entre medias, podemos usar la función insert() indicando la posición.

>>> lista=[1,2,4,5]
>>> lista.insert(2,"insertado")
>>> lista
[1, 2, 'insertado', 4, 5]

Eliminar elementos de la lista

Tenemos dos funciones para esto: remove() y pop(). La primera elmina un elemento pasando como parámetro dicho elemento. La segunda elimina el elemento indicando su posición.

>>> lista=['a','b','c','d','e']
>>> # Elimina la 'b'
>>> lista.remove('b')
>>> lista
['a', 'c', 'd', 'e']

>>> # Elimina el cuarto elemento, la funcion pop() lo devuelve
>>> lista.pop(3)
'e'
>>> lista
['a', 'c', 'd']

>>> # Elimina el ultimo elemento y lo devuelve.
>>> lista.pop()
'd'
>>> lista
['a', 'c']

La función pop() devuelve el elemento eliminado. Si en la función pop() no indicamos posición, elimina el último elemento de la lista.

Operaciones con listas

Si sumamos dos listas, obtenemos una lista con los elementos de las dos. Si multipliamos una lista por un número n, obtenemos una lista resultado de repetir la lista n veces.

>>> lista1=[1,2,3]
>>> lista2=['a','b','c']
>>> # Simamos las listas
>>> lista1+lista2
[1, 2, 3, 'a', 'b', 'c']

>>> # Multiplicamos la lista por 3
>>> lista1*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

También podemos ordenar la lista usando su función sort(). Esta función da error si todos los elementos no son del mismo tipo y por tanto no se pueden ordenar.

>>> lista=[3,3,2,1]
>>> # Ordenamos una lista con todos los elementos del mismo tipo.
>>> lista.sort()
>>> lista
[1, 2, 3, 3]
>>> lista=[6,'a',True]
>>> # Intentamos ordenar una lista en que no todos los elementos son del mismo tipo.
>>> lista.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'

La función clear() borra el contenido de la lista

>>> lista=[1,2,3,4]
>>> lista
[1, 2, 3, 4]
>>> lista.clear()
>>> lista
[]

La función copy() devuelve una copia de la lista. Es importante saber que si asignamos una lista a otra variable sin más, ambas son realmente la misma lista y lo que hagamos en una de ellas afecta a la otra. Mira ests código

>>> lista=[1,2,3,4]
>>> lista2=lista
>>> lista2
[1, 2, 3, 4]
>>> lista.clear()
>>> lista2
[]

Hemos creado una lista, la hemos asignado a lista2, hemos borrado lista.clear() y se ha borrado sola lista2. Para no tener este efecto, se usa la función copy()

>>> lista=[1,2,3,4]
>>> lista2=lista.copy()
>>> lista2
[1, 2, 3, 4]
>>> lista.clear()
>>> lista
[]
>>> lista2
[1, 2, 3, 4]

La función count() nos dice cuántas veces está un elemento en la lista

>>> lista = [1,2,3,1,4,5]
>>> lista.count(1)
2
>>> lista.count(6)
0

la función len(), pasándole de parámetro la lista, nos dice cuántos elementos hay en la lista

>>> lista = [1,2,3,1,4,5]
>>> len(lista)
6

Documentación de referencia

Hay bastantes más funciones y posibilidades. En la documentación de referencia puedes verlas.

Tuplas

¿Qué diferencia hay entre una tupla y una lista en python?. Las tuplas son exactamente igual que las listas, con la diferencia que no se pueden modificar una vez creadas. Al crearlas y para distinguirla de una lista, se hace usando paréntesis () en vez de corchetes []. También es posible crearlas sin poner los parénteis, basta poner una lista de valores separados por comas. Si solo hay un valor, basta añadir una coma al final. Vemos los tres casos en el siguiente torzo de código

>>> # tupla vacia
>>> tupla=()
>>> tupla
()
>>> # tupla de un elemento
>>> tupla='pepe',
>>> tupla
('pepe',)

>>> # Ojo, si es de un solo elemento, es importante anadir la coma al final, si no
>>> # no crea una tupla, sino una variable normal de contenido 'pepe'
>>> tupla=("pepe")
>>> tupla
'pepe'

>>> tupla=("pepe",)
>>> tupla
('pepe',)

>>> # tupla de varios elementos
>>> tupla=('pepe','juan','antonio')
>>> tupla
('pepe', 'juan', 'antonio')

Si queremos una tupla vacía, la única forma es usar los paréntesis. Para el resto de los casos, el paréntesis es opcional, basta poner la lista de elementos separadas por comas. Hay un caso especial y es si la tupla es de un solo elemento. Hay que añadir una coma detrás del primer elemento. Si no añadimos la coma, creará una variable normal que contiene el elemento, como vemos en el ejemplo, donde pone "Ojo" en el comentario.

Poco más que contar de las tuplas, podemos acceder a los elementos usando posiciones entre corchetes [] igual que las listas, pero no podemos modificar, añadir o eliminar valores. Tampoco ordenarla ni borrar su contenido.

Diccionarios

Un diccionario en python es una estructura de datos donde cada dato va identificado por una clave. Por ejemplo, una persona puede tener como claves 'nombre', 'edad', 'telefono' y cada clave un valor concreto asociado 'juan', 22, '11223344'. Para crear un diccionario, lo ponemos entre llaves, las claves separadas de su valor por un dos puntos y cada pareja clave:valor separada por una coma con la siguiente pareja

>>> dict = {'nombre':'juan', 'edad':22, 'telefono':'11223344'}
>>> dict
{'nombre': 'juan', 'edad': 22, 'telefono': '11223344'}

Una vez la tenemos, podemos acceder a los elementos bien metiendo entre corchetes la clave, bien llamando al método get() y pasando como parámetro la clave

>>> dict['nombre']
'juan'
>>> dict.get('nombre')
'juan'

get() admite un segundo parámetro que es el valor que queremos que nos devuelva en caso de que no exista la clave que estamos pidiendo

>>> dict={'nombre':'juan','edad':22,'telefono':'11223344'}
>>> dict
{'nombre': 'juan', 'edad': 22, 'telefono': '11223344'}
>>> # No existe 'apellido', nos devolvera 'perez'
>>> dict.get('apellido','perez')
'perez'
>>> # Si existe 'nombre', ignora el parametro 'Pedro' y nos devuelve 'juan'
>>> dict.get('nombre','Pedro')
'juan'
>>> # El diccionario no se altera, no se le anade el apellido
>>> dict
{'nombre': 'juan', 'edad': 22, 'telefono': '11223344'}

Podemos cambiar el valor asignando un nuevo valor a la opción entre corchetes

>>> dict['edad']=23
>>> dict
{'nombre': 'juan', 'edad': 23, 'telefono': '11223344'}

Si ponemos una clave que no existe, la crea sobre la marcha

>>> dict['direccion']='Madrid'
>>> dict
{'nombre': 'juan', 'edad': 23, 'telefono': '11223344', 'direccion': 'Madrid'}

Funciones con diccionarios

Tenemos funciones como las de las listas copy(), clear(), etc, pero tenemos también algunas que son específicas de los diccionarios. Por ejemplo, keys() devuelve las claves presentes en el diccionario, values() devuelve los valores y items() devuelve las parejas clave:valor

>>> dict={'nombre':'juan','edad':22,'telefono':'11223344'}
>>> dict.keys()
dict_keys(['nombre', 'edad', 'telefono'])
>>> dict.values()
dict_values(['juan', 22, '11223344'])
>>> dict.items()
dict_items([('nombre', 'juan'), ('edad', 22), ('telefono', '11223344')])

La función pop(key) devuele el valor de esa key, al igual que get(key), pero elimina el dato del diccionario

>>> dict={'nombre':'juan','edad':22,'telefono':'11223344'}
>>> dict.pop('nombre')
'juan'
>>> dict
{'edad': 22, 'telefono': '11223344'}

La función update() admite un diccionario como parámetro. Actualiza el diccionario con los nuevos valores del diccionario que se pasa como parámetro, o añadiendo las clave:valor que el diccionario original no tenga

>>> dict={'nombre':'juan','edad':22,'telefono':'11223344'}
>>> dict2={'telefono':'99887766','apellido':'perez'}
>>> dict.update(dict2)
>>> # Vemos que cambia el telefono y anade el apellido
>>> dict
{'nombre': 'juan', 'edad': 22, 'telefono': '99887766', 'apellido': 'perez'}

Conjuntos

Un conjunto es una colección de datos, pero sin orden, como en las listas. No se puede acceder a ellos por posición. Tampoco puede estar repetidos. Se crean entre llaves.

# No anade elementos repetidos
>>> conjunto={'a','e','a','e','i','o','u'}
>>> conjunto
{'a', 'u', 'o', 'i', 'e'}

Aquí hay un detalle importante. Si queremos crear un conjunto vacío, la sintaxis es igual que si creamos un diccionario vacío, es decir, {}. Python, por defecto, creará un diccionario. Si queremos crear un conjunto vacío, debemos usar la función set()

>>> # Creacion de un conjunto vacio
>>> conjunto=set()
>>> # Verificamos que efectivamente es un conjunto
>>> type(conjunto)
<class 'set'>
>>> conjunto
set()

>>> # No crea un conjunto vacio, crea un diccionario
>>> conjunto={}
>>> type(conjunto)
<class 'dict'>
>>> conjunto
{}

Otro detalle a tener en cuenta es que un conjunto no admite elementos que se puedan modificar. Por ejemplo, sí admite una tupla, pero no admite una lista

>>> # Creamos una tupla y la anadimos a un conjunto
>>> # Funciona correctamente.
>>> tupla=(1,2,3)
>>> conjunto={1,2,tupla,4}
>>> conjunto
{1, 2, (1, 2, 3), 4}

>>> # Si intentamos lo mismo con una lista
>>> # obtenemos error
>>> lista=[1,2,3]
>>> conjunto={1,2,lista,4}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Podemos añadir elementos con add() y eliminarlos con discard()

>>> conjunto={'a','e','a','e','i','o','u'}
>>> conjunto
{'a', 'u', 'o', 'i', 'e'}
>>> conjunto.add('A')
>>> conjunto
{'a', 'u', 'o', 'i', 'e', 'A'}
>>> conjunto.discard('a')
>>> conjunto
{'u', 'o', 'i', 'e', 'A'}

También se puede usar remove() para eliminar un elemento. La diferencia con discard() es que si el elemento no existe, discard() no da error, mientras que remove() sí lo da.

>>> conjunto={'a','e','a','e','i','o','u'}
>>> conjunto.discard('f')
>>> conjunto
{'a', 'u', 'o', 'i', 'e'}
>>> conjunto.remove('f')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'f'

Operaciones con conjuntos

Podemos unir dos conjuntos con el caracter |. Obtenemos un conjunto con los elementos de los dos conjuntos iniciales. Si hay repetidos, no se repiten, solo se añade uno.

>>> conjunto1={1,2,3,4}
>>> conjunto2={3,4,5,6}
>>> conjunto1 | conjunto2
{1, 2, 3, 4, 5, 6}

La interseccion se hace con &, obteniendo como resultado los elementos comunes

>>> conjunto1={1,2,3,4}
>>> conjunto2={3,4,5,6}
>>> conjunto1 & conjunto2
{3, 4}

y para quedarse con los elementos de un conjunto que no están en el otro se usa el operador -

>>> conjunto1={1,2,3,4}
>>> conjunto2={3,4,5,6}
>>> # Nos quedamos con los elementos de conjunto1 que no estan en conjunto2
>>> conjunto1 - conjunto2
{1, 2}

Con issubset() podemos saber si un conjunto es subconjunto del otro, es decir, si todos los elementos de uno están en el otro

>>> # No es subconjunto
>>> conjunto1={1,2,3,4}
>>> conjunto2={3,4,5,6}
>>> conjunto1.issubset(conjunto2)
False

>>> # conjunto1 es subconjunto de conjunto2, es decir, todos sus elementos están en conjunto2
>>> conjunto1={1,2}
>>> conjunto2={1,2,3,4,5}
>>> conjunto1.issubset(conjunto2)
True

Tenemos los contrario, issuperset(), es decir, todos los elementos del otro conjunto están en el mío. También se puede usar

>>> # Todos los elementos del conjunto1 estan dentro del conjunto2
>>> conjunto1={1,2}
>>> conjunto2={1,2,3,4,5}
>>> conjunto2.issuperset(conjunto1)
True

Tanto issubset() como issuperset pueden reemplazarse por los símbolos < <= > >= ==. Si un conjunto es menor < que otro quiere decir que todos sus elementos están contenidos en el otro. == solo si ambos conjuntos tienen exactamente los mismo elementos.

>>> conjunto1={1,2}
>>> conjunto2={1,2,3,4,5}
>>> conjunto1 <= conjunto2
True
>>> conjunto1 < conjunto2
True
>>> conjunto2 > conjunto1
True
>>> conjunto2 >= conjunto1
True
>>> conjunto1 == conjunto2
False

Con symmetric_difference() obtenemos los elementos de ambos conjuntos que no son comunes a ambos. Tambien se puede usar el operador ^

>>> conjunto1={1,2,3,4}
>>> conjunto2={3,4,5,6}
>>> # Elementos que no estan en los dos conjuntos
>>> conjunto1.symmetric_difference(conjunto2)
{1, 2, 5, 6}

>>> conjunto1 ^ conjunto2
{1, 2, 5, 6}

Con isdisjoint() podemos ver si los conjuntos son disjuntos, es decir, no tienen ningún elemento en común

>>> conjunto1={1,2,3,4}
>>> conjunto2={3,4,5,6}
>>> # No son disjuntos, tienen el 3 y el 4 en comun
>>> conjunto1.isdisjoint(conjunto2)
False

>>> # Ahora si van a ser disjuntos, no tienen elementos comunes.
>>> conjunto2={8,9,10,11}
>>> conjunto1.isdisjoint(conjunto2)
True

Hay más funciones, por supuesto. En la documentación de referencia pudes verlas todas.

Anterior: 02 - Curso de Python - Variables -- Índice: Curso de Python -- Siguiente: 04 - Curso de Python - Condicionales y bucles en Python.