<jupyter_start><jupyter_text>**Continuacion de funciones**<jupyter_code>##Recordemos el ejercicio de la clase pasada
def suma(*number):
  print(type(number))
  total=0
  for i in number:
    total+=i
    return total
    suma(2,3,5,4)
suma(1,2,5,6,7,9) #Al realizar el cambio y/o edicion de la funcion suma que veniamos usando, se puede añadir n elementos para iterar la funcion<jupyter_output><class 'tuple'><jupyter_text>El uso de **:El uso de doble * nos permite tener como parametro de entrada una lista de elementos en forma de clave y valor. La forma de iterar sera usando el comando * item()<jupyter_code>def suma(**dado):
  suma=0;
  for i,j in dado.items():
    suma +=j
  return suma

suma(a=3, b=30, c=7)<jupyter_output><empty_output><jupyter_text>**Ampliemos la definicion del comando return**---1. Devolver parametros.<jupyter_code>def w():
  return "Hi"
w()<jupyter_output><empty_output><jupyter_text>2. Devolver varias variables<jupyter_code>def sd(a,b,c):
  q=a+b+c #Declaracion de variable con una suma de argumentos
  z=q/3   #Declaracion de variable con el promedio
  return q,z
q,z=sd(2,4,6)  
print(q)
print(z)<jupyter_output>12
4.0<jupyter_text>**Formas de hacer documentacion en programacion y por bloques de codigo o linea---<jupyter_code>def paula(a,b):
  """
  Descripcion de la funcion, los parametros que se van a usar, explicar como se usa y que operaciones devuelve esta funcion
  """
  return a+b
paula(2,3)  

help(paula)
print(paula.__doc__) #Otra forma de llamar al comentario es print del # funcion segudo de .__doc__<jupyter_output>Descripcion de la funcion, los parametros que se van a usar, explicar como se usa y que operaciones devuelve esta funcion<jupyter_text>**Diferencias entre valores y referencias**---Existen dos conceptos de paso por *valor* u p*r *referencia* que se aplican a la hora de tratar a los parametros de entrada de una funcion:1. Si se usa un parametro que pasa por valor, se crea una copia locar de la variable, lo cual implica que cualquier modificacion sobre esta no tendra repercusiones sobre la basa original.2. Si la variable pasa como referencia, si actuara directamente sobre la base original.<jupyter_code>#Ejemplo de paso por**valor**

x=3
def funcion(w):
  w=0
funcion(x)
print(x)<jupyter_output>3<jupyter_text>1. inicio con x=32. Se lo pasamos a la funcion()3. Dentro de esta funcion hacemos que la variable valga cero4. Dado que pasa como valor dentro de la funcion se crea una copia locar de x.por lo cual la variable original no se modifica<jupyter_code>##Caso que pasa por **Referencia**
x=[3,6,9,12]
def sw(tipo):
  tipo.append(50)
sw(x)
print(x)<jupyter_output>[3, 6, 9, 12, 50]<jupyter_text>**Tipos de Funciones**---1. Funcion Lambda---Son funciones que normalmente se usan para definir el codigo en una sola linea.<jupyter_code>#Lo que normalmente seria la definicion de la funcion de este estilo:
#def suma(a,b,c,d):
#  return a+b+c+d

#,# se puede escribir de la siguiente forma:
(lambda a,b,c,d: a+b+c+d)(1,2,3,4)

(lambda *number:sum(number))(1,4,5,6,7,8,9)
(lambda **number:sum(number.values()))(a=1,b=4,c=10)
luisa=lambda a,b,c,d:(a,b,c,d)
print(luisa(2,5,7,9))
luisa=lambda a,b,c,d:a+b+c+d
print(luisa(4,6,1,1))<jupyter_output>12<jupyter_text>**RECURSIVIDAD**---Las caracteristicas de una funcion recursiva son las siguientes:1. Seccion en que se llama a si misma.2. seccion del bloque de codigo donde este la condicion que implique retornar sin volver a llamarse.(IMPORTANTE).Los ejemplos tradicionales de recursividad son **calculo factorial** y la serie **fibonacci**.**1. Calculo factorial**En matematicas definimos factorial(n!) como la multiplicacion de todos los numeros predecesores hasta llegar a 1.Ejemplo:5!= 5*4*3*2*1100!= 100*99*98*98*97*96....*1<jupyter_code>#Apliquemos un enfoque no recursivo de calculo factorial:

def factorial(n):
  w=1
  i=2
  while i<=n:
    w *=i
    i +=1
  return w 
factorial(5)  

#Definamos factorial recursivo:

def recursivofac(n):
 if n==1:
   return 1
 else:
   return n*recursivofac(n-1)
recursivofac(10)<jupyter_output><empty_output><jupyter_text>A continuacion complementamos los tipos de generadores:1. Return2. Yield<jupyter_code>def s():
  return 4 
s()  
def s():
  yield 4
s()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11294117647058824, 'fraction_numerical': 0.02776470588235294, 'mean_word_length': 5.411764705882353, 'pattern_counts': {'":': 0, '<': 37, '<?xml version=': 0, '>': 36, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '506550', 'license': 'MIT', 'n_tokens_mistral': 1710, 'n_tokens_neox': 1642, 'n_words': 503, 'path': 'clase7.ipynb', 'repo_name': 'CarolinaGarcia19/Clase1', 'size': '4250'}