Hay diversos tipos de objetos en Python, que a su vez se agrupan en diversas categorías:
| categoría de tipo | nombre |
descripción |
| None | type(None) |
el objeto nulo None |
| Números |
int float complex bool |
entero (precisión arbitraria) |
| Secuencias |
str list tuple range |
cadena de caracteres |
| Mapeo | dict |
diccionario |
| Sets |
set frozenset |
set mutable 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.
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])
print(9 in mi_tuple)
print(6 in mi_tuple)
print(max(mi_tuple), min(mi_tuple))
print(len(mi_tuple))
print([x**3 for x in 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.
lista = list(zip("cadena larga", "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')
Los sets son colecciones no ordenadas de elementos únicos. A diferencia de las secuencias, sus elementos no pueden accederse por indexado ni particionado.
Hay dos typos de sets: set, que es mutable, y frozenset, que es inmutable.
Ambos tipos de sets pueden crearse con las respectivas funciones set() y frozenset().
Estas funciones pueblan el set iterando sobre el argumento dado.
a = set([1, 2, 3, 2, 1, 4, 5, 3])
print(a, type(a))
a = frozenset([1, 2, 3, 2, 1, 4, 5, 3])
print(a, type(a))
Los elementos de un set son únicos (sin repeticiones dentro del set), y deben ser objetos inmutables: números, cadenas de caracteres, tuples y sets inmutables, pero no listas ni sets mutables.
a = set(["foo", (2, 1, 4), 5, 3])
print(a)
a = set(["foo", frozenset([2, 1, 4]), 5, 3])
print(a)
a = set(["foo", [2, 1, 4], 5, 3])
print(a)
a = set(["foo", set([2, 1, 4]), 5, 3])
print(a)
Crear una función que determine el pitch-class set de una secuencia de alturas dada como argumento. Utilizar para ello la función que devuelve el pitch-class de una altura.
def pitch_a_pc(pitch):
'''convierte una altura en número de nota MIDI a pitch-class'''
pc = pitch % 12
return pc
def pcset(alturas):
'''devuelve el pitch-class set de una secuencia de alturas'''
pc_set = set([pitch_a_pc(i) for i in alturas])
return pc_set
# listas con las alturas en nota MIDI
alturas1 = [72, 62, 59, 56, 67, 70, 66, 57, 63, 76, 73, 65]
# imprimir el set
print(pcset(alturas1))
Devuelve la longitud de un set.
Hace una copia del set.
Devuelve la diferencia entre dos sets: todos los elementos que están en el primero, pero no en el argumento.
set1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set2 = set([11, 5, 9, 2, 4, 8])
print(set1)
print(set2)
print(set1.difference(set2))
print(set2.difference(set1))
Devuelve la intersección entre los sets: todos los elementos que están en ambos.
set1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set2 = set([11, 5, 9, 2, 4, 8])
print(set1)
print(set2)
print(set1.intersection(set2))
print(set2.intersection(set1))
Devuelve True si no hay elementos comunes entre los sets.
set1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set2 = set([11, 5, 9, 2, 4, 8])
print(set1)
print(set2)
print(set1.isdisjoint(set2))
Devuelve True si el set es un subconjunto del set argumento.
set1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set2 = set([11, 5, 9, 2, 4, 8])
set3 = set([11, 5, 2, 4])
print(set1)
print(set2)
print(set3)
print(set2.issubset(set1))
print(set3.issubset(set1))
Devuelve True si el set es un superset del set argumento.
set1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set2 = set([11, 5, 9, 2, 4, 8])
set3 = set([11, 5, 2, 4])
print(set1)
print(set2)
print(set3)
print(set1.issuperset(set2))
print(set1.issuperset(set3))
Devuelve todos los elementos que están en un set u otro, pero no en ambos.
set1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set2 = set([11, 5, 9, 2, 4, 8])
print(set1)
print(set2)
print(set1.symmetric_difference(set2))
Devuelve un set con todos los elementos que están en alguno de los sets.
set1 = set([4, 3, 11, 7, 5, 2, 1, 4])
set2 = set([11, 5, 9, 2, 4, 8])
print(set1)
print(set2)
print(set1.union(set2))
Generar una melodía de características isorrítmicas.