Una tupla (tuple) es una secuencia de valores. Los valores pueden ser de cualquier tipo y están indexados por enteros, por lo que en ese sentido las tuplas se parecen mucho a las listas. La diferencia importante es que las tuplas son inmutables.
Sintácticamente, una tupla es una secuencia de valores separados por comas:
t = 'a', 'b', 'c', 'd', 'e'
Aunque no es necesario, es común encerrar las tuplas entre paréntesis:
t = ('a', 'b', 'c', 'd', 'e')
Por lo tanto, podemos decir que las tuplas son un tipo de datos que:
tupla = (1,2,3)
tupla2 = 1,2,3 # Se crea una tupla sin paréntesis
vocales = ('a', 'e', 'i', 'o', 'u')
dias = ("lunes", "martes", "miércoles", "jueves", "viernes")
print (tupla)
print (tupla2)
print (vocales)
print (dias)
print (dias[3]) # Se accede por índice al elemento 3
(1, 2, 3)
(1, 2, 3)
('a', 'e', 'i', 'o', 'u')
('lunes', 'martes', 'miércoles', 'jueves', 'viernes')
jueves
tupla = (1, 2, 3)
tupla[0] = 5
# TypeError: object doesn't support item assignment
tupla = 1, 2, ('a', 'b'), 3
print(tupla) #(1, 2, ('a', 'b'), 3)
print(tupla[2][0]) #a
tupla = (1, 2, [88, 99], 3)
tupla[2][0]= 99 # Permite cambiar el valor
t1 = (1, 2, 3)
t2 = (4, 5, 6)
t3 = t1 + t2
print(t3) # (1, 2, 3, 4, 5, 6)
Si bien vimos que las tuplas son inmutables y por lo tanto los elementos no pueden agregarse, borrarse o modificarse. Tenemos algunas opciones para poder simularlo.
Por ejemplo, si queremos agregar un elemento a una tupla, como no podemos modificarla podríamos crear una nueva tupla concatenando el elemento a agregar y ese valor se lo asignamos a la variable ya existente de la tupla.
mi_tupla = (1, 2, 3, 4, 5)
# Si quiesieramos "agregar" un elemento
mi_tupla = mi_tupla + (6,)
En realidad lo que estamos haciendo es concatenar (unir) dos tuplas y de esa manera tenemos el resultado como si fuera agregar un elemento.
El método tuple() permite convertir una lista en una tupla.
lista = [1, 2, 3]
tupla = tuple(lista)
print (lista) # [1, 2, 3]
print (tupla) # (1, 2, 3)
tupla = (1, 2, 3)
for t in tupla:
print(t) #1, 2, 3
El método count(elem) cuenta el número de veces que aparece "elem" en la tupla.
t = (1, 2, 3, 1, 1)
print (t.count(1)) # 3
El método index(elem) busca el objeto que se le pasa como parámetro (elem) y devuelve el índice en el que se ha encontrado.
l = (7, 7, 7, 3, 5)
print(l.index(5)) #4
El método index() también acepta un segundo parámetro opcional, que indica a partir de que índice empezar a buscar el objeto.
l = (7, 7, 7, 3, 5)
print(l.index(7, 2)) #2
ValueError
Los diccionarios son una estructura de datos que permite almacenar su contenido en forma de clave:valor
Son como listas, pero más general. Mientras que en las listas, los índices tienen que ser números enteros, en un diccionario pueden ser (casi) de cualquier tipo.
Algunas propiedades de los diccionarios en Python:
key.value.
diccionario = {} # Se crea diccionario vacío
otro_diccionario = dict() # Se crea diccionario vacío
> traductor = {} # Crear diccionario vacío
> traductor['one']='uno' # Agregar el valor uno a la clave one
> traductor['two']='dos' # Agregar el valor dos a la clave two
> traductor
{'one': 'uno', 'two': 'dos'} # Estructura del diccionario
Si la clave no existe se crea y agrega el valor.
Desde la versión 3.7 de Python los diccionarios están ordenados por lo que los elementos tendrán el orden en el cual fueron agregados. No pasa lo mismo en Python <= 3.6Podemos crear un diccionario nuevo enviándole directamente un diccionario
traductor = {'one': 'uno', 'two': 'dos', 'three': 'tres'}
traductor = {
'one': 'uno',
'two': 'dos',
'three': 'tres'
}
Al igual que las listas y tuplas, los elementos pueden accederse con [] o con la función get()
print(traductor['one']) # Uno
print(traductor.get('one')) # Uno
Para modificar un elemento basta con usar [] con el nombre del key y asignar el valor que queremos.
traductor['one']= 1
print(traductor.get('one')) # 1
Si el key al que accedemos no existe, se añade automáticamente
traductor['four']= 'cuatro'
print(traductor.get('four')) # cuatro
Los diccionarios se iteran igual que una lista. La iteración se realiza sobre su key.
diccionario = {
'nombre': 'Carlos',
'edad': '32',
'e-mail': 'carlitos@gmail.com'
}
for d in diccionario:
print (d)
nombre
edad
e-mail
Si quisiera imprimir el value en vez de la key. ¿Cómo debería modificar el código?
for d in diccionario:
print (diccionario.get(d))
Es posible iterar sobre las keys y values de un diccionario.
diccionario = {
'nombre': 'Carlos',
'edad': '32',
'e-mail': 'carlitos@gmail.com'
}
for k,v in diccionario.items():
print (f"Dato: {k} | Valor: {v}")
Salida:
Dato: nombre | Valor: Carlos
Dato: edad | Valor: 32
Dato: e-mail | Valor: carlitos@gmail.com
Observar que se itera en realidad sobre diccionario.items()
Podemos tener en el value de una key otro diccionario o lista.
anidado1 = {"a": 1, "b": 2}
anidado2 = {"a": 1, "b": 2}
d = {
"anidado1" : anidado1,
"anidado2" : anidado2
}
print(d)
#{'anidado1': {'a': 1, 'b': 2}, 'anidado2': {'a': 1, 'b': 2}}
l1 = [1,2,3,4,5]
l2 = ['a', 'b', 'c']
d = { "numeros" : l1, "letras" : l2 }
print(d)
#{'numeros': [1, 2, 3, 4, 5], 'letras': ['a', 'b', 'c']}
El método clear() elimina todo el contenido del diccionario.
d = {'a': 1, 'b': 2}
d.clear()
print(d) #{}
El método get(key,default) nos permite consultar el value para un key determinado. El segundo parámetro es opcional y es el valor que va a devolver en caso que no encuentre la key.
d = {'a': 1, 'b': 2}
print(d.get('a')) #1
print(d.get('z', 'No encontrado')) #No encontrado
El método items() devuelve una lista con los keys y values del diccionario. Si se convierte en list se puede indexar como si de una lista normal se tratase, siendo los primeros elementos las key y los segundos los value.
d = {'a': 1, 'b': 2}
it = d.items()
print(it) # dict_items([('a', 1), ('b', 2)])
print(list(it)) # [('a', 1), ('b', 2)]
print(list(it)[0][0]) # a
El método keys() devuelve las keys del diccionario. Si se usa en conjunto con list() se puede obtener en forma de lista.
k = d.keys() # dict_keys(['a', 'b'])
lista_keys = list(k) # ['a', 'b']
El método values() devuelve todos los values de un diccionario.
d = {'a': 1, 'b': 2}
print(list(d.values())) #[1, 2] # Se convierte a Lista
El método pop(key) busca y borra la key que se pasa como parámetro y devuelve el value asociado. Si la clave no existe da error.
d = {'a': 1, 'b': 2}
elem = d.pop('a') # elem=1
print(d) #{'b': 2}
El método pop(key,default) es igual que el método get(key) pero en caso de error retorna default pasado por parámetro.
d = {'a': 1, 'b': 2}
elem = d.pop('e', 'no elem') # elem='no elem'
print(d) # {'a': 1, 'b': 2}
El método update(diccionario) recibe como parámetro un diccionario. Los value son actualizados en el diccionario que es llamado. Si alguna key no está es agregada.
d1 = {'a': 1, 'b': 2}
d2 = {'a': 0, 'd': 400}
d1.update(d2)
print(d1)
#{'a': 0, 'b': 2, 'd': 400}
d = {'a': 1, 'b': 2}
if 'a' in d:
print("Encontrado")
else:
d1[a] = 1
Con in se puede buscar si una clave existe. Devolverá True o False.
Puede consultar aquí una lista mas extensa de los métodos mas utilizados
Crea una tupla llamada mi_tupla con los siguientes elementos: 1, 2, 3, 4, 5. E imprima el tercer elemento de la tupla.
mi_diccionario con las siguientes claves y valores
'edad'.'profesion' con el valor 'programador'