
# Function call
print("Daniel")


# Function call with annotation
resultado : int = round(88.5)
resultado


dir(round)


round.__call__(10.5)


## Veamos un ejemplo del segundo tipo
from random import randint

roll: int = randint(1, 6)
print(roll)


lista_de_nombres = ['Alejandra', 'Manuela', 'Pedro', 'manuel', 'Jose']


# Mirar el primer nombre
print(lista_de_nombres[0])
# Ver si la primera letra 
print(lista_de_nombres[0][0])
# Ver si la primera letra es la que me interesa
print(ord(lista_de_nombres[0][0]) == ord("M"))
# Repetir
lista_nombres_M = []
for nombre in lista_de_nombres:
    if nombre[0] == "M":
        lista_nombres_M.append(nombre)
print(lista_nombres_M)

# Ver que hay un problema: no da manuel, con minsucula. Posible solución: 
# usar alguna función que normalize la mayuscula/minuscula: str.upper()


def nombres_primera_letra(lista, letra):
    """Obtener nombres de una lista que empiezan por una letra"""
    lista_nombres = []
    for nombre in lista:
        if nombre[0].upper() == letra.upper():
            lista_nombres.append(nombre)
    return lista_nombres


nombres_primera_letra.__doc__


# Veamos si funciona
nombres_primera_letra(lista_de_nombres, "M")


# La ventaja de una función es que podemos generalizar su uso
nombres_primera_letra(lista_de_nombres, "A")


# Posible solución
def mi_maximo(a: float, b:int) -> float:
    """Obtengo el máximo de dos números"""
    if a > b:
        return print(f"El número a: {a} es mayor que b: {b}")
    elif a < b:
        return print(f"El número a: {a} es menor que el número b: {b}")
    else:
        return print(f"Los números a: {a} y b: {b} son iguales")


# Descomentar
mi_maximo(5,4)
#mi_maximo(5,4.3)


mi_maximo.__doc__


def punto_en_recta(x: float) -> float:
    """Ecuacion de la recta"""
    return 2 * x + 1


print(punto_en_recta(5.5))


5(1)


def rendimiento(saldo, tipo_i, meses):
    rend = saldo *((1+ tipo_i/meses)**meses)
    return rend


def abs_function(x):
    if x < 0:
        abs_value = -x
    else:
        abs_value = x
    return abs_value


abs_function(-4)


def f(x):
    if x < 0:
        return 'negativo'
    return 'nonegativo'


def f(x):
    a = 2*x


a = f(2)
type(a)


import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure(figsize=(10,4))
ax = fig.add_subplot()

n = 100
e_values = []   # empty list

for i in range(n):
    e = np.random.normal(0,1,1)
    e_values.append(e)

plt.plot(e_values)
plt.show()


def graf(n,m,v):

    fig = plt.figure(figsize=(10,4))
    ax = fig.add_subplot()


    e_values = []   # empty list

    for i in range(n):
        e = np.random.normal(m,v,1)
        e_values.append(e)

    plt.plot(e_values)
    plt.show()


graf(1000, 1,1)


def st(n,a,m,v,x0):

    fig = plt.figure(figsize=(10,4))
    ax = fig.add_subplot()
    
    x = np.empty([n,len(a)])
    x[0] = x0
    m, v = 0, 1


    for c, alfa in enumerate(a):
        for i in range(1,n):
            x[i,c] = alfa * x[i-1,c] + np.random.normal(m,v,1)
        ax.plot(x[:,c], label = f"$\\alpha$={alfa}")
        ax.set_xlabel("Tiempo")
        ax.set_ylabel("Tasa de inflación")

    plt.legend()
    plt.title("Evolución de $x_t = \\alpha \\times x_{t-1} + \epsilon_t$")
    plt.show()


st(n = 100,a = [0, 0.5, 1],m = 0,v = 1,x0 = 0.1)


def add_arg(a,b):
    c = a + b
    return c


add_arg(5,4)


# Otra forma de llamar a la función con argumentos
x = (5,4)
add_arg(*x)


a = (1,2,3)
print(a)
print(*a)


a = {"a":1, "b": 2}
print(*a)


# Unpacking
a, *b = [1,2,3,4,5]
#a, *_, b = [1,2,3,4,5]
print(*b)


# El orden importa
def add_arg(a,b):
    c = a.upper()
    d = np.log(b)
    print(c)
    return d

x = ("Juan",4)
#x = (4, "Juan")
add_arg(*x)


def add_arg(b,c):
    d = b + c

a = add_arg(1,1)
print(a)


def f(x, a=1, b=1):
    return a + b * x
f(1)


def f(a=1, b=1, x):
    return a + b * x
f(1)


f(2, a=4, b=5)


d = {"a": 4, "b": 5}
f(2, **d)


def suma(numeros):
    total = 0
    for n in numeros:
        total += n
    return total


suma([1,2,3,4]*10)
#print([1,2,3,4]*2)


def media(*args):
  return sum(args) / len(args)

v = (1,2,3,4,5,6,7,8,9,10)
media(*v)


def function(*args, j, g):
    print(args, j, g)

values = [1, 2, 3, 4]

function(j="Hola j", g=" Hola g", *values)
function(j="Hola j", *values, g=" Hola g")
function(*values, j="Hola j", g=" Hola g")


def ciudades(**kwargs):
    for clave, valor in kwargs.items():
        print(f"{clave.capitalize()}: {valor}")

datos_1 = {"ciudad": "Montevideo",
         "coordenadas": "Lat Long",
         "población": 1.5}

ciudades(**datos_1)

datos_2 = {"ciudad": "Vigo",
         "coordenadas": "Lat Long",
         "población": 0.5,
         "ideoma": "gallego"}

ciudades(**datos_2)


def add_arg(*,b,c):
    d = b + c
    return d
add_arg(b = 1,c = 1)


add_arg(1,1)


ts_length = 100
e_values = []   # empty list

for i in range(ts_length):
    e = np.random.randn()
    e_values.append(e)

plt.plot(e_values)
plt.show()


def generate_data(n):
    e_values = []
    for i in range(n):
        e = np.random.randn()
        e_values.append(e)
    return e_values

data = generate_data(100)
plt.plot(data)
plt.show()


def generate_data(n, generator_type):
    e_values = []
    for i in range(n):
        if generator_type == 'U':
            e = np.random.uniform(0, 1)
        else:
            e = np.random.randn()
        e_values.append(e)
    return e_values

data = generate_data(100, 'U')
plt.plot(data)
plt.show()


def generate_data(n, generator_type):
    e_values = []
    for i in range(n):
        e = generator_type()
        e_values.append(e)
    return e_values

data = generate_data(100, np.random.uniform)
plt.plot(data)
plt.show()


max(7, 2, 4)   # max() is a built-in Python function


m = max
m(7, 2, 4)


from numpy.random import uniform

def binomial_rv(n, p):
    count = 0
    for i in range(n):
        U = uniform()
        if U < p:
            count = count + 1    # Or count += 1
    return count

binomial_rv(10, 0.5)


from numpy.random import uniform

def secuencia_para_pago(k, n):  # paga is salen k exitos consecutivos

    pago = 0
    count = 0

    for i in range(n):
        U = uniform()
        count = count + 1 if U < 0.5 else 0
        print(U,count)    # print counts 
        if count == k:
            pago = 1

    return pago
secuencia_para_pago(3, 10)


def secuencia_para_pago(k, n):  # paga si al menos k exitos

    pago = 0
    count = 0

    for i in range(n):
        U = uniform()
        count = count + ( 1 if U < 0.5 else 0 )
        print(count)
        if count == k:
            payoff = 1

    return payoff

secuencia_para_pago(3, 10)

Introduccion a Funciones¶

Visión general¶

Empecemos por un ejemplo sencillo

Aspectos básicos en la definición de funciones¶

Sintaxis básica¶

Ejercicio:¶

Return¶

Ejercicio:¶

Ejercicio:¶

Argumentos de una función¶

Positional arguments¶

Variadic parameters¶

Variadic Keyword Parameters¶

Solo el argumento *¶

Siguientes temas relacionados con funciones¶

La Flexibilidad de las Funciones Python¶

¿Por qué escribir funciones?¶

Ejemplos¶

Extracciones aleatorias¶

Añadir condiciones¶

Ejercicio 1¶

Una posible solución:¶

Ejercicio 2¶

Posible solucion¶