Hay diversos tipos de objetos en Python, que a su vez se agrupan en diversas categorías:
| categoría | tipo | descripción |
|---|---|---|
| None | type(None) | el objeto nulo None |
| Números | int | entero (precisión arbitraria) |
| float | coma flotante | |
| complex | complejo | |
| bool | booleano (True o False) | |
| Secuencias | str | cadena de caracteres |
| list | lista | |
| tuple | tuple | |
| range | rango de enteros | |
| Mapeo | dict | diccionario |
| Sets | set | set mutable |
| frozenset | set inmutable |
Como se vio en la clase 2, la función type() devuelve el tipo al que pertenece un objeto:
type(None)
type(3)
type(3.2)
type(True)
type("hola")
type([2, 3, 5])
type(range(10))
Al igual que las listas y las cadenas de caracteres (strings), los tuples son objetos de tipo secuencia.
Son muy similares a las listas y comparten varias de sus funciones y métodos, aunque su principal diferencia es que son inmutables.
Al igual que las listas, los tuples son:
Pero por otra parte, los tuples son:
Un tuple puede crearse simplemente mediante una secuencia de elementos separados por comas.
Opcionalmente pueden delimitarse los elementos mediante paréntesis (en vez de corchetes, como las listas).
En algunos casos, los paréntesis pueden ser necesarios para evitar
ambigüedades. También podemos tomar como criterio siempre usar
paréntesis para definir un tuple.
tuple1 = 1, 2, 3
tuple2 = (4, 5, 6)
print(tuple1, type(tuple1), sep='\t')
print(tuple2, type(tuple2), sep='\t')
Aternativamente, puede crearse un tuple mediante la función tuple(), con cualquier iterable como argumento:
tuple1 = tuple([1, 2, 3])
tuple2 = tuple(range(4, 7))
print(tuple1, type(tuple1), sep='\t')
print(tuple2, type(tuple2), sep='\t')
Un tuple vacío puede crearse con un par de paréntesis vacíos:
tuple1 = ()
print(tuple1, type(tuple1), sep='\t')
Para crear un tuple de un solo elemento es necesario poner una coma después del mismo, de lo contrario se evaluará la expresión.
Esto es independiente del uso de paréntesis.
no_tuple1 = 3*4
no_tuple2 = (3*4)
tuple1 = 3*4,
tuple2 = (3*4,)
print(no_tuple1, type(no_tuple1), sep='\t')
print(no_tuple2, type(no_tuple2), sep='\t')
print(tuple1, type(tuple1), sep='\t')
print(tuple2, type(tuple2), sep='\t')
Los tuples disponen de todas las funciones y los métodos comunes a las secuencias inmutables, vistas anteriormente.
| T1 + T2 | concatenación |
| T * N, N * T | repetición |
| X in T X not in T | pruebas de pertenencia |
| T[i] | acceso por indexado |
| T[i:j], T[i:j:k] | acceso por particionado, con incremento opcional |
| len(T) | longitud |
| min(T), max(T) | ítem mínimo y máximo |
| for item in T: [expr for item in T] | iteración |
También admite dos métodos específicos:
.index()
.count()
Estos métodos funcionan de la misma manera que en las listas, tal como fue visto en la clase pasada.
Se puede repetir la información almacenada en un tuple:
tuple1 = (1, 2)
print(tuple1)
tuple1 *= 3
print(tuple1)
Es posible concatenar dos tuples, conformando un nuevo tuple:
tuple1 = (1, 2)
tuple1 *= 3
tuple2 = (3, 4, 5, 6)
mi_tuple = tuple1 + tuple2
print(mi_tuple)
También se puede acceder a uno o varios elementos por indexado:
tuple1 = (1, 2)
tuple1 *= 3
tuple2 = (3, 4, 5, 6)
mi_tuple = tuple1 + tuple2
print(mi_tuple)
print(mi_tuple[2])
print(mi_tuple[3:6])
Es posible verificar la pertenencia de un determinado dato en un tuple, buscar el valor máximo y mínimo, y también preguntar por su largo total:
tuple1 = (1, 2)
tuple1 *= 3
tuple2 = (3, 4, 5, 6)
mi_tuple = tuple1 + tuple2
print(mi_tuple)
print(9 in mi_tuple)
print(6 in mi_tuple)
print(max(mi_tuple), min(mi_tuple))
print(len(mi_tuple))
Los tuples pueden recorrerse, por ejemplo al definir una lista de comprensión:
tuple1 = (1, 2)
tuple1 *= 3
tuple2 = (3, 4, 5, 6)
mi_tuple = tuple1 + tuple2
print(mi_tuple)
print([x**3 for x in mi_tuple])
Es posible averiguar en qué índice se encuentra determinado elemento, así como contar cuántas veces aparece dentro del tuple:
tuple1 = (1, 2)
tuple1 *= 3
tuple2 = (3, 4, 5, 6)
mi_tuple = tuple1 + tuple2
print(mi_tuple)
print(mi_tuple.index(4))
print(mi_tuple.count(2))
La función zip permite recorrer más de un iterable en paralelo, y devuelve una secuencia de tuples donde cada elemento pertence a cada uno de los iterables.
lista1 = [1, 2, 3, 4]
lista2 = ['a', 'b', 'c', 'd']
# crea una lista por comprensión
lista_zip1 = [(x, y) for x, y in zip(lista1, lista2)]
print(lista_zip1)
# crea una lista mediante la función list()
lista_zip2 = list(zip(lista1, lista2))
print(lista_zip2)
La función zip puede utilizarse en todo tipo de estructuras en las que se recorren iterables.
Los iterables pueden ser de cualquier tipo (listas, tuples, cadenas de caracteres, función range(), etc.).
lista = list(zip('hola', range(1,5)))
print(lista)
for (x, y) in zip('hola', range(1,5)):
print(x*y)
Si los iterables no tienen la misma longitud, la función zip() ajusta la iteración a la longitud del más corto, e ignora los demás.
lista = list(zip([1, 2, 3, 4, 5, 6], "foo"))
print(lista)
Dada una lista de alturas en nota MIDI, y una lista de duraciones en fracciones de tiempo, generar una lista de notas en forma de tuples (altura, duración). Imprimir en columnas.
# listas con las alturas y las duraciones
alturas = [72, 62, 59, 56, 67, 70, 66, 57, 63, 76, 73, 65]
duraciones = [1.5, 1.75, 0.25, 1, 1.5, 1, 0.5, 0.5, 0.75, 0.75, 0.75, 0.75]
# lista con las notas en forma de tuples
notas = list(zip(alturas, duraciones))
# imprimir la lista, y en columnas
print(notas)
for i in notas:
print(i[0], i[1], sep='\t')