Universidad

Nacional de Asunción
Facultad Politécnica

Paradigmas de la Programación

Licenciatura en Ciencias Informáticas

Prof. Carlos Zayas Guggiari

carlos@zayas.org
def ordenar(lista):
menor = []
igual = []
mayor = []
if lista == []:
return lista
else:
pivote = lista[0]
for item in lista:
if item < pivote:
menor.append(item)
if item == pivote:
igual.append(item)
if item > pivote:
mayor.append(item)
return ordenar(menor) + igual + ordenar(mayor)
def ordenar(lista):
return [] if lista == [] else \
ordenar([item for item in lista[1:] if item < lista[0]]) \
+ lista[0:1] + \
ordenar([item for item in lista[1:] if item >= lista[0]])
Pasarlas como parámetros de otras funciones
Asignarlas a variables
Almacenarlas en estructuras de datos
Retornarlas como resultado de otras funciones
# Funciones de primera clase
def a(): return 'A'
def b(): return 'B'
def c(): return 'C'

# Pasar una función como parámetro

def hacer(x): return x()
print hacer(a)

# Asignar una función a una variable

y = b
print y()

# Almacenar funciones en estructuras de datos

l = [a, b, c]
d = {'a': a, 'b': b, 'c': c}
print l[input('0, 1, 2 ? ')]()
print d[raw_input('a, b, c ? ')]()

# Retornar una función como resultado

def f(x): return l[x]
print f(2)()
Acepta una o más funciones como parámetro
Devuelve una función como resultado
def saludar(idioma):

def saludar_es(): return "Hola"

def saludar_en(): return "Hello"

def saludar_fr(): return "Bonjour"

saludo = { "es": saludar_es,

"en": saludar_en,
"fr": saludar_fr }

return saludo[idioma]

f = saludar("es")

print f()
>>> cuadrado = lambda x: x**2
>>> cuadrado(2)
4
>>> cuadrado(3)
9
>>> lambda x: x**2
<function <lambda> at 0xb74469cc>
>>>
>>> (lambda x: x**2)(3)
9
>>> a = lambda x, y, z: x*y*z
>>> a(2,3,4)
24
Valores Explícitos
Constantes, Variables
Operadores (Aritméticos, Lógicos)
Funciones
Identificadores (Nombres)
Literales (Cadenas, Números)
Formas entre paréntesis (Tuplas)
Formas entre corchetes (Listas)
Formas entre llaves (Diccionarios)
3 + 5
"Hola, Mundo"
a == 1
int("4")
(2, 4, 6)
[3, 6, 9]
{'a': 1, 'b': 2}
Simple (Expresión)
Compuesto (Bloque)
print 42
if x: hacer(y)
return
a = 7
for item in lista: print item
while 1: print 'Hola'
>>> 4%2
0
>>> 5%2
1
>>> bool(4%2)
False
>>> bool(5%2)
True
def iif1(condicion, verdadero, falso):
'Imperativo (sentencia)'
if condicion:
return verdadero
else:
return falso

def iif2(condicion, verdadero, falso):

'Funcional (expresión)'
return verdadero if condicion else falso

def iif3(condicion, verdadero, falso):

'Funcional (corto circuito)'
return condicion and verdadero or falso

# f = lambda a, b, c: (a and b or c)
iif4 = lambda condicion, verdadero, falso: condicion and verdadero or falso

# f = lambda a, b, c: (b, c)[not a]

iif5 = lambda condicion, verdadero, falso: (verdadero, falso)[not condicion]
var1 = 3
var2 = 4

def fun():
print "Dentro de la función"
var1 = 5
var2 = 6
print "var1 es {} y var2 es {}".format(var1, var2)
print "var1 (glo): {}".format(globals()['var1'])
print "var2 (glo): {}".format(globals()['var2'])
print "var1 (loc): {}".format(locals()['var1'])
print "var2 (loc): {}".format(locals()['var2'])

print "Inicio del programa"

print "var1 es {} y var2 es {}".format(var1, var2)
fun()
print "Fuera de la función"
print "var1 es {} y var2 es {}".format(var1, var2)
Inicio del programa
var1 es 3 y var2 es 4
Dentro de la función
var1 es 5 y var2 es 6
var1 (glo): 3
var2 (glo): 4
var1 (loc): 5
var2 (loc): 6
Fuera de la función
var1 es 3 y var2 es 4
def hacerInc(x):
def inc(y):
# x está "cerrada" en la definición de inc
return x + y
return inc

inc5 = hacerInc(5)
inc7 = hacerInc(7)

print inc5(3) # imprime 8

print inc7(2) # imprime 9
def hacerPot(n):
print "id(n): %X" % id(n)
def pot(x):
return x**n
print "id(pot): %X" % id(pot)
return pot

cuad = hacerPot(2)
cubo = hacerPot(3)

del hacerPot # Borra funcion

print cuad(3), repr(cuad) # imprime 9

print cuad.__closure__
print cuad.__closure__[0].cell_contents

print cubo(3), repr(cubo) # imprime 27

print cubo.__closure__
print cubo.__closure__[0].cell_contents
id(n): 1662C50
id(pot): 7FA071713050
id(n): 1662C38
id(pot): 7FA0717130C8
9 <function pot at 0x7fa071713050>
(<cell at 0x7fa07170fa98: int object at 0x1662c50>,)
2
27 <function pot at 0x7fa0717130c8>
(<cell at 0x7fa07170fb08: int object at 0x1662c38>,)
3
Unir datos con código de manera similar a POO
Reemplazar el uso de constantes ("hard coded")
Eliminar el uso de variables globales
def externa(funcion):
def interna():
print "Antes de", funcion
retorno = funcion() # 1
return retorno + 1
return interna

def f(): return 1

decorada = externa(f) # 2
print decorada()
def externa(funcion):
def interna():
print "Antes de", funcion
retorno = funcion() # 1
return retorno + 1
return interna

@externa
def f(): return 1

print f() # 2
def decorador(funcion):
def nueva(*parametros):
print "Llamada a la función", funcion.__name__, repr(parametros)
return funcion(*parametros)
return nueva

def sumar(a, b): return a + b

print decorador(sumar)(2, 3)

@decorador
def restar(a, b): return a - b

print restar(5, 2)

Llamada a la función sumar (2, 3)

5
Llamada a la función restar (5, 2)
3

>>> i = [x*x for x in range(5)]
>>> for c in i: print c,
...
0 1 4 9 16
>>> for c in i: print c,
...
0 1 4 9 16
>>> g = (x*x for x in range(5))
>>> for c in g: print c,
...
0 1 4 9 16
>>> for c in g: print c,
...
>>>
>>> def migenerador():
... yield 1
... yield 2
... yield 3
...
>>> for valor in migenerador():
... print valor
...
1
2
3
>>> g = migenerador()
>>> next(g)
1
>>> g.next()
2
>>> next(g)
3
>>> next(g)
Traceback (most recent call last):
File "<console>", line 1, in <module>
StopIteration
 def par(numero):

return numero % 2 == 0

def pares(inicio=2):

numero = inicio

while True:
if par(numero):
yield numero
numero += 1

>>> a = pares(100)
>>> for i in range(10):print a.next(),
...
100 102 104 106 108 110 112 114 116 118
Humor informático
def fact1a(f):
'Imperativo con Recursividad'
if f == 0:
return 1
else:
return f * fact1a(f-1)

def fact1b(f):
'Imperativo con Recursividad (compacto)'
return 1 if f == 0 else f * fact1b(f-1)

# Imperativo con Recursividad (lambda)

fact1c = lambda f: 1 if f == 0 else f * fact1c(f-1)
def fact2a(f):
'Imperativo con Iteración'
r = 1
for n in range(1, f+1):
r *= n
return r

def fact2b(f):
'Imperativo con Iteración (convencional)'
i = 1
r = 1
while i <= f:
r = r * i
i = i + 1
return r
def fact3(f):
'Implementación Funcional'
return reduce(lambda x, y: x * y, range(1, f+1))
>>> lista = []
>>> for item in range(1, 20):
... if item % 2 == 0:
... lista.append(item)
...
>>> lista
[2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> lista = [item for item in range(1,20) if item % 2 == 0]
>>> lista
[2, 4, 6, 8, 10, 12, 14, 16, 18]
# Bloque estructurado:

for expresion1 in secuencia1:

if not (condicion1):
continue
for expresion2 in secuencia2:
if not (condicion2):
continue
...
for expresionN in secuenciaN:
if not (condicionN):
continue
expresion

# Comprensión de lista:

[ expresion for expresion1 in secuencia1 if condicion1

for expresion2 in secuencia2 if condicion2
...
for expresionN in secuenciaN if condicionN ]
>>> items = [1, 2, 3, 4, 5]
>>> cuadrado = []
>>> for item in items:
... cuadrado.append(item ** 2)
...
>>> cuadrado
[1, 4, 9, 16, 25]
>>> def cuadrado(n): return n ** 2
...
>>> map(cuadrado, items)
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, items)
[1, 4, 9, 16, 25]
>>> funciones = [lambda x: x ** 2, lambda x: x ** 3]
>>> for i in range(5): map(lambda x: x(i), funciones)
...
[0, 0]
[1, 1]
[4, 8]
[9, 27]
[16, 64]
>>> celsius = [39.2, 36.5, 37.3, 37.8]
>>> fahrenheit = map(lambda x: (float(9)/5)*x + 32, celsius)
>>> fahrenheit
[102.56, 97.7, 99.14, 100.03999999999999]
>>> celsius = map(lambda x: (float(5)/9)*(x-32), fahrenheit)
>>> celsius
[39.2, 36.5, 37.300000000000004, 37.8]
>>> fib = [0,1,1,2,3,5,8,13,21,34,55]
>>> filter(lambda x: x % 2, fib)
[1, 1, 3, 5, 13, 21, 55]
>>> filter(lambda x: x % 2 == 0, fib)
[0, 2, 8, 34]
>>> a = [1, 2, 3, 4, 5]
>>> reduce(lambda x, y: x * y, a)
120
>>> (((1*2)*3)*4)*5
120
>>> reduce(lambda x, y: x + y, range(10))
45
>>> 1+2+3+4+5+6+7+8+9
45