<jupyter_start><jupyter_text>4.6. Defining Functions<jupyter_code>#Estructura:
# def nombre_función(<variables>):
#     Cuerpo de la función
#     return valor_a_retornar
def f_suma(n1,n2,n3):
    return n1+n2+n3
f_suma(4,5,6)
#El print usado de forma adecuada hace lo mismo que el return
def f_prod(num1,num2):
    print(num1*num2)
f_prod(4,9)
#También podemos definir funciones sin variables
#Por ejemplo un función que imprima un mensaje conocido
def mensaje():
    print('''\
    +++++++++++
    +         +
    + WARNING +
    +         +
    +++++++++++
    ''')
mensaje()<jupyter_output>+++++++++++
    +         +
    + WARNING +
    +         +
    +++++++++++<jupyter_text>EjercicioVamos a crear un código que imprima la serie de Fibonacci hasta el número n, el cual será ingresado por el usuario.0,1,1,2,3,5,8,13,21,....Y también tendremos que imprimir un mensaje de error si el número ingresado es negativo.<jupyter_code>m=int(input('Ingresa un valor entero: '))

def fibo(n):
    if n<0:
        print('ERROR-404-weona')
    else:
        i,j=0,1
        while i<=n:
            print(i)
            i,j=j,i+j
        print('Fin')

fibo(m)
m=int(input('Ingresa un valor entero: '))
l_fibo=[]

def fibo(n):
    if n<0:
        print('ERROR-404-weona')
    else:
        i,j=0,1
        while i<=n:
            l_fibo.append(i)
            i,j=j,i+j
    return l_fibo

fibo(m)
#Cuando nosotros no usamos 'return' en nuestra función
#no pasa nada mientras usemos un print para reemplazarlo
#de forma efectiva, es decir, para obtener el valor deseado.
#Sin embargo, cuando usamos 'print' para imprimir la función
#, ésta buscará el 'return', y al no encontrarlo interpretará
#que estamos devolviendo nada, I mean, NONE.

def f_prueba(n,m):
    print(n**2+m**2+2*m*n)
f_prueba(3,4)
print(f_prueba(3,4))<jupyter_output>49
None<jupyter_text>4.7. More on Defining Functions 4.7.1. Default Argument Values Problemita para colegio$2x=10$<jupyter_code>#Podemos incluir variables ya definidas en nuestra función
#res=int(input('Ingresa el valor de x: '))

res=int(input('ingresa el valor de x: '))
def valor_x(ans,veces=2,mensaje='Intenta una vez más'):
    while veces > 0:
        if ans==5:
            print('Bien perrx')
            break
        else:
            print(mensaje)
            ans=int(input('ingresa el valor de x: '))
        veces=veces-1
    else:
        print('Muere perrx')

valor_x(res)
def f(a,L=[]):
    L.append(a)
    return L

f(3)
f(5)
f(12)
#En Python 'None' es usado para definir un valor nulo
def f(a,L=None):
    if L is None:
        L=[]
    L.append(a)
    return L

f(3)
f(5)<jupyter_output><empty_output><jupyter_text>4.7.2. Keyword Arguments<jupyter_code>#El gusano número (ID) se convirtió
#en una (bella/fea) (mariposa/polilla) en el día (20/30)

def meta(num,tipo='bella',final='mariposa',dia='20'):
    print("El gusano número",num,"se convirtió en una",end=" ")
    print(tipo,final,"en el día",dia)
meta(5)
meta(38)
meta(num=46)
meta(5,tipo='fea')
meta(4,dia='15')
#def meta(num,tipo='bella',final='mariposa',dia='20'):
meta(14,'horrible','polilla','32')
meta(tipo='fea',num=6)
meta(5.6)
#Usando strings para la variable 'num'
meta('DESCONOCIDO')
#Ejemplo de Python
#Debemos recoerdar que primero van '*' y luego '**', no al revés

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    for kw in keywords:
        print(kw, ":", keywords[kw])
cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="<NAME>",
           client="<NAME>",
           sketch="Cheese Shop Sketch")
def mamarre(cosa,*reclamo,**protagonistas):
    print('Profesor, ¿ya tiene mi',cosa,'?')
    print('No, joven, aún no tengo su',cosa)
    for i in reclamo:
        print(i)
    print("+" * 32)
    for i in protagonistas:
        print(i,':',protagonistas[i])
mamarre('nota','Putamare oe, weon eres no','Profe pavo rctmr',
        'Vete a la mierda',alumno='Ricardo',profesor='Chachi')<jupyter_output>Profesor, ¿ya tiene mi nota ?
No, joven, aún no tengo su nota
Putamare oe, weon eres no
Profe pavo rctmr
Vete a la mierda
++++++++++++++++++++++++++++++++
alumno : Ricardo
profesor : Chachi<jupyter_text>4.7.3. Special parametersEs importante tener en cuenta la estructura del tipo de variable al elaborar la función. Como podemos notar primero van las variables de tipo posicional, es decir, aquellas que son llamadas ingresando directamente el valor a asignar a la variable, y luego se colocarán los 'keyword arguments'.```def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):      -----------    ----------     ----------        |             |                  |        |        Positional or keyword   |        |                                - Keyword only         -- Positional only```         El uso del slash y el asterisco es opcional, por ejemplo, nosotros no lo usamos arrriba.  4.7.4. Arbitrary Argument Lists<jupyter_code>#Poniendo '*' delante de mi variable le estamos diciendo a Python
#que voy a usar un número arbitrario de argumentos, los cuales
#se van a agrupar formando una tupla, la cual se almacenará en
#la variable antes mencionada.

def prueba(*num):
    print(num)
    return sum(num)

prueba(5,7,13.5)
#Podemos usar la función 'join()' la cual sirve para 
#concatenar strings dentro de un iterable con la finalidad de 
#formar un nuevo string.
#Para ello usamos un separador el cual será también un string.
#Su sintaxis es de la siguiente forma:

# string_separador.join(iterable)

def nombres(*name,sepa=' '):
    print(name)
    return sepa.join(name)

print(nombres('Alexis','Tremolada'))<jupyter_output>('Alexis', 'Tremolada')
<NAME><jupyter_text>4.7.5. Unpacking Argument Lists<jupyter_code>list(range(3,6))
arg=[2,20,3]
list(range(*arg))
def meta(num,tipo='bella',final='mariposa',dia='20'):
    print("El gusano número",num,"se convirtió en una",end=" ")
    print(tipo,final,"en el día",dia)
    
d={'num':50,'tipo':'fea','final':'polilla','dia':56}
meta(**d)<jupyter_output>El gusano número 50 se convirtió en una fea polilla en el día 56<jupyter_text>4.7.6. Lambda Expressions<jupyter_code>r=lambda x,y,z: (x*y)**z
r(2,3,2)
def inc(n):
    return lambda x:x+n

f=inc(5) #f=x+5---> Se define f como f=f(x)
f(3) #f(3)=3+5
#Aprendamos a ordenar listas de forma ascendente o descendente

#Ascendente
ani=['perro','conejo','pangolín','gato']
ani.sort()
ani
#Descendente
ani.sort(reverse=True)
ani
vocal=['a','á','e','é','i','í','o','ó','u','ú','ü']

def v_cont(e):
    n=0
    for j in e:
        for i in vocal:
            if j==i:
                n=n+1
    return n
v_cont('lgtbi')
test=[1,2,5,2]
test.sort()
test
ani.sort(key=v_cont)
ani
ani_2=['murciélago','ñandú','camello']
ani_2.sort(reverse=True,key=v_cont)
ani_2<jupyter_output><empty_output><jupyter_text>4.7.7. Documentation Strings<jupyter_code>m1=float(input('Ingresa un número: '))
m2=float(input('Ingresa un otro número: '))

def d_cua(n1,n2):
    """Documentación:
    
    A continuación calcularemos la diferencia de cuadrados"""
    return n1**2-n2**2

print(d_cua.__doc__)
d_cua(m1,m2)<jupyter_output>Ingresa un número: 4
Ingresa un otro número: 5
Documentación:
    
    A continuación calcularemos la diferencia de cuadrados
StarcoderdataJupyterStructuredCleanDedup