IWI-131 Programación¶
Tuplas¶
Una tupla es una secuencia de elementos agrupados, que por conveniencia nos interesa manipular como una unidad.
Es similar a una lista, pero por lo general contiene pocos elementos y dependiendo del contexto tendrá una longitud constante.
Ejemplos:
- Coordenadas en $\mathbb{R}^n$ ($n$ elementos).
- Fechas (3 elementos).
- Posición de una pieza de ajedrez (2 elementos).
A diferencia de las listas, las tuplas son inmutables, es decir, no pueden modificarse una vez creadas.
Creación de Tuplas¶
- Usando paréntesis
(). - Usando la función
tuple().
Tupla Vacía¶
Aunque no tiene mucha utilidad. ¿Por qué?
a = ()
b = tuple()
print(a)
print(b)
() ()
Tupla con elementos¶
a = (1,2,3,4)
b = tuple(['a', 1, True, [1, 2]])
print(a)
print(b)
(1, 2, 3, 4)
('a', 1, True, [1, 2])
c = tuple([1, 2, 3, 4])
d = tuple((1, 2, 3, 4))
print(c)
print(d)
(1, 2, 3, 4) (1, 2, 3, 4)
tup = tuple("abc")
print(tup)
('a', 'b', 'c')
Desempaquetado de Tuplas¶
Los valores individuales de una tupla pueden ser recuperados asignando la tupla a las variables respectivas. Esto se llama desempaquetar la tupla.
tupla = (1, 2, 3)
a, b, c = tupla
print(tupla)
print(a, b, c)
(1, 2, 3) 1 2 3
Para desempaquetar correctamente debe utilizar tantas variables como elementos posee la tupla.
tupla = (1, 2, 3)
a, b = tupla
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-6-ae12a64c6800> in <module> 1 tupla = (1, 2, 3) ----> 2 a, b = tupla ValueError: too many values to unpack (expected 2)
Además, también es posible extraer los valores usando su índice, al igual que con las listas:
tupla = (1, 2, 3)
print(tupla[1])
2
A diferencia de las listas, los elementos de una tupla no se pueden modificar:
tupla = (1, 2, 3)
tupla[0] = 100
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-8-970d1eb5a3e2> in <module> 1 tupla = (1, 2, 3) ----> 2 tupla[0] = 100 TypeError: 'tuple' object does not support item assignment
Usos recomendados¶
Las tuplas se usan siempre que es necesario agrupar valores. Generalmente, conceptos del mundo real son representados como tuplas que agrupan información sobre ellos.
posicion_alfil = (7, 6)
alumno = ('Fulano', 'De Tal', '201199001-1')
carta = (5, 'corazones')
fecha = (2011, 4, 12)
triangulo = ((5, 1), (2, 4), (-2, 0))
personaje = ('Arturo Prat', (1848, 4, 3), (1879, 5, 21))
punto = (6.6, -2.4, 3.7)
x, y, z = punto
print(x)
6.6
personaje = ("Bernardo O'Higgins", (1778, 8, 20), (1842, 10, 24))
nombre, nacimiento, defuncion = personaje
an, mn, dn = nacimiento
ad, md, dd = defuncion
print(ad - an)
64
Comparación de Tuplas¶
Dos tuplas son iguales cuando tienen el mismo tamaño y cada uno de sus elementos correspondientes tienen el mismo valor:
(1, 2) == (3 // 2, 1 + 1)
True
(6, 1) == (6, 2)
False
(6, 1) == (6, 1, 0)
False
Para determinar si una tupla es menor que otra, se utiliza lo que se denomina orden lexicográfico. Si los elementos en la primera posición de ambas tuplas son distintos, ellos determinan el ordenamiento de las tuplas:
(1, 4, 7) < (2, 0, 0, 1)
True
(1, 9, 10) < (0, 5)
False
La primera comparación es True porque 1 < 2. La segunda comparación es False porque 1 > 0. No importa el valor que tengan los siguientes valores, o si una tupla tiene más elementos que la otra.
Si los elementos en la primera posición son iguales, entonces se usa el valor siguiente para hacer la comparación:
(6, 1, 8) < (6, 2, 8)
True
(6, 1, 8) < (6, 0)
False
La primera comparación es True porque 6 == 6 y 1 < 2. La segunda comparación es False porque 6 == 6 y 1 > 0
.
Si los elementos respectivos siguen siendo iguales, entonces se sigue probando con los siguientes uno por uno, hasta encontrar dos distintos. Si a una tupla se le acaban los elementos para comparar antes que a la otra, entonces es considerada menor que la otra:
(1, 2) < (1, 2, 4)
True
(1, 3) < (1, 2, 4)
False
La primera compación es True porque 1 == 1, 2 == 2, y ahí se acaban los elementos de la primera tupla. La segunda comparación es False porque 1 == 1 y 3 < 2; en este caso sí se alcanza a determinar el resultado antes que se acaben los elementos de la primera tupla.
Algunas operaciones sobre tuplas¶
Verificar si elemento se encuentra en una tupla¶
La instrucción in permite verificar si un elemento está contenido en una tupla.
t = (1, 5, 6)
1 in t
True
3 not in t
True
Funciones que aceptan tuplas como parámetros¶
Longitud de una tupla¶
La función len(tupla) entrega la cantidad de elementos de la tupla ingresada como parámetro.
t = (1,2,3,4,8,10)
print("La cantidad de elementos en la tupla es", len(t))
La cantidad de elementos en la tupla es 6
Suma de los valores de una tupla¶
Usando la función sum(tupla), se puede determinar la suma de los elementos de una tupla.
sum(t)
28
Mínimo y Máximo en una tupla de elementos¶
La función min(tupla) y max(tupla) entrega el valor mínimo y máximo de la tupla ingresada como parámetro.
print(min(t), max(t))
1 10
Ciclo for en tuplas¶
- Un ciclo
forpuede ser usado para iterar sobre tuplas.
tt = tuple(range(10))
for e in tt:
print(e)
0 1 2 3 4 5 6 7 8 9
Mezcla de Estructuras: Lista de Tuplas¶
Algunas veces es necesario integrar varias estructuras para resolver ciertos problemas.
# Opcion 1
ramos = [
('Progra', 'IWI-131', 3),
('Mate', 'MAT-021', 5),
('Física', 'FIS-100', 3),
('Ed.Fisica', 'DEW-100', 1),
('Inmanente', 'HRW-102', 2)
]
# Iterar sobre la lista de tuplas
for ramo in ramos:
nombre, sigla, c = ramo
print(nombre, 'tiene', c, 'creditos')
Progra tiene 3 creditos Mate tiene 5 creditos Física tiene 3 creditos Ed.Fisica tiene 1 creditos Inmanente tiene 2 creditos
# Opcion 2
ramos = [
('Progra', 'IWI-131', 3),
('Mate', 'MAT-021', 5),
('Física', 'FIS-100', 3),
('Ed.Fisica', 'DEW-100', 1),
('Inmanente', 'HRW-102', 2)
]
# Iterar sobre la lista de tuplas
for nombre, sigla, c in ramos:
print(nombre, 'tiene', c, 'creditos')
Progra tiene 3 creditos Mate tiene 5 creditos Física tiene 3 creditos Ed.Fisica tiene 1 creditos Inmanente tiene 2 creditos
Ordenar una lista de tuplas¶
star_wars = [
(4, 'Una nueva Esperanza'),
(5, 'El Imperio Contraataca'),
(6, 'El Retorno del Jedi'),
(1, 'La Amenaza Fantasma'),
(2, 'El Ataque de los Clones'),
(3, 'La Venganza de los Siths'),
(7, 'El Despertar de la Fuerza'),
(8, 'Los Ultimos Jedi')
]
star_wars
[(4, 'Una nueva Esperanza'), (5, 'El Imperio Contraataca'), (6, 'El Retorno del Jedi'), (1, 'La Amenaza Fantasma'), (2, 'El Ataque de los Clones'), (3, 'La Venganza de los Siths'), (7, 'El Despertar de la Fuerza'), (8, 'Los Ultimos Jedi')]
star_wars.sort()
star_wars
[(1, 'La Amenaza Fantasma'), (2, 'El Ataque de los Clones'), (3, 'La Venganza de los Siths'), (4, 'Una nueva Esperanza'), (5, 'El Imperio Contraataca'), (6, 'El Retorno del Jedi'), (7, 'El Despertar de la Fuerza'), (8, 'Los Ultimos Jedi')]
nums = [(1, 4), (1, 2), (1, 1), (1, 10)]
nums
[(1, 4), (1, 2), (1, 1), (1, 10)]
nums.sort()
nums
[(1, 1), (1, 2), (1, 4), (1, 10)]
Para ordenar una lista de tuplas, utiliza el criterio de comparación de tuplas utilizando un orden ascendente.
Ejercicios¶
Ejercicio 1¶
Escriba una función distancia(p1, p2) que retorne la distancia entre los puntos p1 y p2:
>>> a = (5.1, 7.3, 2.4)
>>> b = (1.1, 2.8, 4.9)
>>> distancia(a, b)
6.5192024052026492
def distancia(p1, p2):
x1, y1, z1 = p1
x2, y2, z2 = p2
dx = x2 - x1
dy = y2 - y1
dz = z2 - z1
return (dx ** 2 + dy ** 2 + dz ** 2) ** 0.5
a = (5.1, 7.3, 2.4)
b = (1.1, 2.8, 4.9)
distancia(a, b)
6.519202405202649
Ejercicio 2¶
Un polígono está determinado por la lista de sus vértices. Escriba una función perimetro(vertices) que entregue el perímetro del polígono definido por la lista vertices:
>>> p = [(4, 1), (7, 2), (7, 4), (5, 9)]
>>> perimetro(p)
18.609700215601432
# Distancia para puntos en R^2
def distancia(p1, p2):
(x1, y1), (x2, y2) = p1, p2
dx, dy = x2 - x1, y2 - y1
return (dx ** 2 + dy ** 2) ** .5
# Propuesta 1
def perimetro(vertices):
n = len(vertices)
suma = 0.0
for i in range(n):
a = vertices[i]
b = vertices[(i + 1) % n]
suma += distancia(a, b)
return suma
p = [(4, 1), (7, 2), (7, 4), (5, 9)]
perimetro(p)
18.609700215601432
# Propuesta 2
def perimetro(vertices):
n = len(vertices)
actual = vertices[0:n]
sgte = vertices[1:n] + [vertices[0]]
distancias = []
for i in range(n):
d = distancia(actual[i], sgte[i])
distancias.append(d)
return sum(distancias)
p = [(4, 1), (7, 2), (7, 4), (5, 9)]
perimetro(p)
18.609700215601432