

In [ ]:

    
"""
IPython Notebook v4.0 para python 2.7
Librerías adicionales: Ninguna.
Contenido bajo licencia CC-BY 4.0. Código bajo licencia MIT. (c) Sebastian Flores.
"""

# Configuracion para recargar módulos y librerías 
%reload_ext autoreload
%autoreload 2

from IPython.core.display import HTML

HTML(open("style/iwi131.css", "r").read())

IWI131

Programación de Computadores

Sebastián Flores

http://progra.usm.cl/

https://www.github.com/usantamaria/iwi131

¿Qué contenido aprenderemos?

Listas
Tuplas

¿Porqué aprenderemos ese contenido?

Listas
Tuplas

Porque utilizar colecciones de elementos resulta natural y permite simplificar operaciones.

Motivación

Calcule el promedio y la desviación estándar de $N$ datos, $x_1$, ..., $x_n$, ingresados por el usuario:

$$ \begin{align} mean &= \frac{1}{n} \sum_{i=1} x_i \\ (std)^2 &= \frac{1}{n} \sum_{i=1} (x_i- mean)^2 \end{align} $$



In [ ]:

    
N = int(raw_input("Ingrese numero de datos:"))
# Calculo del promedio
print "Ingrese numeros (para calcular promedio)"
j = 1
mean = 0.0
while j<=N:
    x_i = float(raw_input("Ingrese numero: "))
    mean += x_i
    j += 1
mean = mean / N
# Calculo de desviacion estandar
print "Ingrese los MISMOS numeros (para calcular desviacion estandar)"
j = 1
var = 0.0
while j<=N:
    x_i = float(raw_input("Ingrese numero: "))
    var += (x_i-mean)**2
    j += 1
std = (var/N)**0.5
# Imprimir resultados
print "promedio", mean
print "desviacion estandar", std

Análisis del problema anterior

El problema anterior resultaba engorroso para el usuario porque necesitabamos realizar 2 ciclos while en los datos:

La primera vez para calcular el promedio.
La segunda vez para calcular la desviación estándar.

Proceso sería más fácil si primero almacenáramos los datos, y luego realizáramos los cálculos necesarios sin molestar al usuario.

Tuplas

Colecciones inmutables de datos.
Tienen un número reducido de operaciones.
Se utilizan cuando el número de elementos y su contenido no varía: por ejemplo, coordenadas de un punto (x,y,z) o número complejo (Real,Imaginario).

Listas

Colecciones mutables de datos.
Tienen un número amplio de operaciones.
Se utilizan cuando el número de elementos es variable.

Tuplas

Colecciones heterogéneas e inmutables de datos.

Se definen con paréntesis redondos y como colección pueden tener datos de distintos tipos:



In [ ]:

    
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.0, 3), (1879, 5, 21))



In [ ]:

    
print personaje[0][0:5]

Tuplas

Desempaquetado de Tuplas

Si una tupla tiene $n$ datos, es posible "desempaquetar" en variables de manera directa:



In [ ]:

    
punto = (6.6, -2.4, 3.7)
x, y, z = punto
print x



In [ ]:

    
personaje = ("Bernardo O'Higgins", (1778, 8, 20), (1842, 10, 24))
nombre, nacimiento, _ = personaje
an, mn, dn = nacimiento
ad, md, dd = defuncion
print ad - an
print personaje

Tuplas

¿Cómo reconocer una tupla?

Utilice type



In [ ]:

    
a = (1,2)
b = (-1,-2)
c1 = a + b
print c1
c2 = (a[0] + b[0], a[1] + b[1])
print c2
print type(a[1])

Tuplas

¿Donde hemos utilizado ya tuplas?

En las funciones de múltiples retornos:



In [ ]:

    
def rectangulo(a,b):
    peri = 2*(a+b)
    area = a*b
    return peri, area

s = rectangulo(1,2)
print type(s)
print s

p, a = rectangulo(2,3)  # Esto de clase anterior era una desempaquetado!
print type(p)
print p
print type(s)
print s

Tuplas

¿Qué métodos puedo aplicar a tuplas?

len: cuantos elementos hay en la tupla
sum: sacar elementos de la tupla



In [ ]:

    
s_mixto = (1, 1.0, True, "1")
print len(s_mixto)
#print sum(s_mixto)
print sum(s_mixto[:3])

s = (1, 1.0, 2., 2, 3.)
print len(s)
print s[1:-1]
print sum(s)
print sum(s[1:-1])

Listas

Otros métodos

Testear pertenencia en tupla

dato in tupla

regresará siempre un booleano: True si dato está en la tupla, False si no está en la tupla.



In [ ]:

    
mi_tupla = ("sebastian", "carlos", "jose")

print "sebastian" in mi_tupla

print "seba" in mi_tupla

print "carlos" in mi_tupla

print "pepe" in mi_tupla

Tuplas

Acceder valores vs Cambiar valores

Los valores de una tupla pueden accederse mediante índices: [i], [i:], [:j], [i:j].
```
  mi_tupla[mi_indice]
```
Los valores de una tupla no pueden cambiarse. La tupla es completamente inmutable.



In [ ]:

    
# Posicion original
punto = (0, 0, 0)
print punto

# Acceso a valores
v = (1,2,3)
dt = 2.0
print punto[0] + v[0]*dt
print punto[1] + v[1]*dt
print punto[2] + v[2]*dt

# Actualización de valores
#punto[0] = 1

s = (1, 1.0, 2., 2, 3.)
print s[1:-1]
print len(s)
print sum(s)
print sum(s[1:-1])

Tuplas

Ejemplo: Fibonacci con tuplas

Imprima los primeros $n$ numeros de fibonacci



In [ ]:

    
n = int(raw_input("Ingrese n: "))
j = 1
a, b = 0, 1
while j<=n:
    print b, 
    a, b = b, a+b # Mira Ma, sin variables auxiliares
    j+= 1

Listas

Colecciones heterogéneas y mutables de datos.

Se definen con paréntesis cuadrados: [ ]



In [ ]:

    
mi_lista_1 = [1, 1., "1", True]
mi_lista_2 = [1, 2, 4, 10, 55]

print mi_lista_1
print mi_lista_2

# Convertir de tupla a lista
mi_tupla = tuple(mi_lista_1)
print mi_tupla, type(mi_tupla)
mi_nueva_lista = list(mi_tupla)
print mi_nueva_lista, type(mi_nueva_lista)

Listas

Creando listas

Las listas se dicen mutables porque se pueden crear dinámicamente utilizando el método append.

El método append agrega un dato al final de la lista.



In [ ]:

    
valores = []
print valores

valores.append(5)
print valores

valores.append(1)
print valores

valores.append(6)
print valores

valores.append(-4)
print valores

Listas

Creando listas con datos del usuario



In [ ]:

    
# Terminamos de pedir datos cuando se ingresa "fin".
mi_lista = [] # Lista vacia
while True:
    mi_dato = raw_input("Ingrese dato: ")
    if mi_dato=="fin":
        break
    else:
        if mi_dato in ("True", "False"):
            mi_lista.append(bool(mi_dato))
        else:
            mi_lista.append(mi_dato)
        
# Imprimamos la lista
print mi_lista

print bool("True")
print bool("False")
print bool("")

Listas

Accesando listas

Los elementos de la lista se accesan utilizando [i:j] de la misma forma que strings y tuplas.



In [ ]:

    
a = [0, 10, 20, 30]
print a[0]
print a[-1]
print a

a.append(2)
a.append(-3)
print a[0]
print a[-1]
print a

Listas

Otros métodos

len(lista): regresa la cantidad de objetos de la lista
sum(lista): regresa la suma de los elementos de la lista (si se puede).
lista.pop(): regresa el ultimo elemento de la lista y lo saca de la lista.
lista.sort(): ordena los elementos de la lista de menor a mayor.
lista.reverse(): ordena los elementos de la lista en el orden reverso al original.



In [ ]:

    
x = [1,3,5,7,9,0,2,4,6,8]
print len(x)

print sum(x)

x.reverse() # Revierte orden de la lista (y no regresa nada)
print x

x.sort()  # Ordena la lista (y no regresa nada)
print x

x.reverse() # Revierte orden de la lista (y no regresa nada)
print x

xi = x.pop()
print xi
print x

Listas

Otros métodos

Testear pertenencia en lista

dato in lista

regresará siempre un booleano: True si dato está en la lista, False si no está en la lista.



In [ ]:

    
mi_lista = ["sebastian", "carlos", "jose"]

print "sebastian" in mi_lista

print "seba" in mi_lista

print "carlos" in mi_lista

print "pepe" in mi_lista

Listas

Otros métodos: range

El método range es práctico para generar listas de números enteros:

range(m) regresa la lista [0,1,2,..,m-1]
range(n,m) regresa la lista [n,n+1,n+2,...,m-1]
range(n,m,k) regresa la lista [n,n+k, n+2 k,...,x] donde x es el mayor numero n+j k < m



In [ ]:

    
print range(5)
print range(10)

print range(2, 5)
print range(2, 10)

print range(2, 5, 3)
print range(2, 11, 3)

Listas

Ejemplo

Calcula la suma de los recíprocos de los primeros n numeros naturales:

$$ \frac{1}{1}+\frac{1}{2}+\frac{1}{3}+\frac{1}{4}+..\frac{1}{n}$$



In [ ]:

    
n = 10
l = []
j = 1
while j<=n:
    l.append(1./j)
    j+= 1
print sum(l)

Listas

Copiando listas: CUIDADO

Cuando las listas se asignan, en realidad hacen referencia a una lista común. Esto se hace para ahorrar memoria RAM y está implementado así en python.



In [ ]:

    
a = [5, 1, 4]
b = list(a) #  a
b.append(10)
# Modifiquemos b
b[0] = 1000
print b
print a
# la lista a tambien se vio modificada

Para evitar este comportamiento, debemos utilizar

b = list(a)

Listas

Aplicación al ejemplo

Calcule el promedio y la desviación estándar de $N$ datos, $x_1$, ..., $x_n$, ingresados por el usuario:

$$ \begin{align} mean &= \frac{1}{n} \sum_{i=1} x_i \\ (std)^2 &= \frac{1}{n} \sum_{i=1} (x_i- mean)^2 \end{align} $$



In [ ]:

    
###################################################################
# Cambiar para utilizar listas
###################################################################
N = int(raw_input("Ingrese numero de datos:"))
# Calculo del promedio
print "Ingrese numeros (para calcular promedio)"
j = 1
mean = 0.0
while j<=N:
    x_i = float(raw_input("Ingrese numero: "))
    mean += x_i
    j += 1
mean = mean / N
# Calculo de desviacion estandar
print "Ingrese los MISMOS numeros (para calcular desviacion estandar)"
j = 1
var = 0.0
while j<=N:
    x_i = float(raw_input("Ingrese numero: "))
    var += (x_i-mean)**2
    j += 1
std = (var/N)**0.5
# Imprimir resultados
print "promedio", mean
print "desviacion estandar", std

Listas

Solución v1

Calcule el promedio y la desviación estándar de $N$ datos, $x_1$, ..., $x_n$, ingresados por el usuario.



In [ ]:

    
N = int(raw_input("Ingrese numero de datos:"))
lista_datos = []
# Crear la lista
j = 1
while j<=N:
    x_i = float(raw_input("Ingrese numero: "))
    lista_datos.append(x_i)
    j += 1
# Calcular el promedio
i = 0
mean = 0.0
while i<N:
    x_i = lista_datos[i]
    mean += x_i
    i += 1
mean = mean / N
# Calculo de desviacion estandar
k = 0
var = 0.0
while k<N:
    x_k = lista_datos[k]
    var += (x_k-mean)**2
    k += 1
std = (var/N)**0.5
# Imprimir resultados
print "promedio", mean
print "desviacion estandar", std

Listas

Solución v2

Calcule el promedio y la desviación estándar de $N$ datos, $x_1$, ..., $x_n$, ingresados por el usuario.



In [ ]:

    
N = int(raw_input("Ingrese numero de datos:"))
lista_datos = []
# Crear la lista
j = 1
while j<=N:
    x_i = float(raw_input("Ingrese numero: "))
    lista_datos.append(x_i)
    j += 1
    
# Calcular el promedio
mean = sum(lista_datos) / N

# Calculo de desviacion estandar
k = 0
var = 0.0
while k<N:
    x_k = lista_datos[k]
    var += (x_k-mean)**2
    k += 1
std = (var/N)**0.5

# Imprimir resultados
print "promedio", mean
print "desviacion estandar", std

Ejercicio Tipo Certamen: C2 1S 2014

Cineton, una nueva cadena de cines creada por emprendedores de la USM, est ́a ingresando al mercado cinematogr ́afico. Por eso necesita de su ayuda para implementar ciertas funciones ́ de la cartelera en Phyton y con ellas manejar la cartelera. Para ello se cuenta con la informaci on de cine en una lista de tuplas como cartelera. A modo de ejemplo, en cartelera la pel ́ıcula ’Gloria’ (Chilena), creada en 2013, se exhibir ́a el mes de ’enero’ en las ’sala1’ y ’sala2’.

Cada elemento de la lista tiene la siguiente estructura:

(mes, pais, nombre_pelicula, año_filmacion, [sala1, sala2, ...])



In [ ]:

    
cartelera = [
('febrero', 'FRANCIA', 'El muelle', 1962, ['sala1', 'sala3']),
('febrero', 'FRANCIA', 'La dama de honor', 2004, ['sala1', 'sala4']),
('abril', 'RUSIA', 'Padre del soldado', 1964, ['sala3', 'sala2', 'sala4']),
('enero', 'CHILE', 'Gloria', 2013, ['sala1', 'sala2']),
('mayo', 'MEXICO', 'Cumbres', 2013, ['sala3', 'sala2']),
('julio', 'FRANCIA', 'Melo', 1986, ['sala3', 'sala1']),
('junio', 'BELGICA', 'Rondo', 2012, ['sala4', 'sala2']),
('marzo', 'ALEMANIA', 'Tiempo de Canibales', 2014, ['sala1', 'sala2']),
('marzo', 'ALEMANIA', 'Soul Kitchen', 2009, ['sala3', 'sala4']),
]

Ejercicio Tipo Certamen: C2 1S 2014

Pregunta 1

Desarrolle la función pelicula_por_pais(cartelera, pais) que recibe la lista de la cartelera y el nombre de un país, y que retorne la lista con las películas realizadas en dicho país. Cada elemento de esta lista resultante es una tupla con el nombre de la película y el año de filmación.

>>> pelicula_por_pais(cartelera, 'FRANCIA')
[('El muelle', 1962), ('La dama de honor', 2004), ('Melo', 1986)]



In [ ]:

    
# Solucion estudiantes

Ejercicio Tipo Certamen: C2 1S 2014

Solución pregunta 1

>>> pelicula_por_pais(cartelera, 'FRANCIA')
[('El muelle', 1962), ('La dama de honor', 2004), ('Melo', 1986)]



In [ ]:

    
# Solucion

def pelicula_por_pais(cartelera, pais):
    n = len(cartelera)
    j = 0
    peliculas_pais = []
    while j<n:
        mes_j, pais_j, nombre_pelicula_j, anno_j, salas_j = cartelera[j]
        if pais_j==pais:
            peliculas_pais.append( (nombre_pelicula_j, anno_j) )
        j += 1

    return peliculas_pais

print pelicula_por_pais(cartelera, 'FRANCIA')

Minitareas

Próximo lunes Actividad 3: listas y tuplas. ¡Practiquen!

Enviar minitareas.