Funciones II

Contenidos

• Funciones: recordando conceptos
• Ejemplos
• Funciones: return y argumentos
• Funciones recursivas

Funciones

---

Recuerda

• Una función es un conjunto de sentencias que se agrupan en una entidad para realizar una tarea.
  • Cada vez que se necesite ejecutar la tarea se llamará a la función.
• Las funciones evitan repetir sentencias y facilitan el desarrollo (divide y vencerás).
• Definir una función implica darle un nombre, especificar sus argumentos y, finalmente, las sentencias que la forman.

Recuerda

• No se pueden omitir nunca los paréntesis de una función, ni al definirla ni al ejecutarla, aunque no haya argumentos.
• Una función no conoce las variables locales de las otras funciones.
• Los argumentos son variables locales, simplemente están inicializados a un valor que se establece en tiempo de ejecución en el momento de llamar a la función.

Ejemplos

---

No recibe argumentos y devuelve dos valores

def entrada_datos():
    """Pide por teclado base y exponente"""
    base = int(input("Introduce la base: "))
    exponente = int(input("Introduce el exponente (>0): "))
    while exponente<=0:
        exponente= int(input("Error en el rango. Introduce el número (>0): "))
    return base, exponente

Función que recibe dos argumentos y devuelve un valor

def calcula_potencia (base,exp):
    """Calcula la potencia"""
    potencia=1 
    n=1
    while n<=exp:
         potencia=potencia*base
         n=n+1
    return potencia

Función que recibe tres argumentos y no devuelve nada

def imprime_salida(base,exponente,potencia):
    """Muestra el resultado por pantalla"""
    print(f"{base} elevado a {exponente} vale {potencia}")

Encapsula el programa principal

Función que encapsula el programa principal y evita el uso de variables globales

def main():
    base, exp = entrada_datos()
    pot = calcula_potencia (base, exp)
    print(f"{base} elevado a {exp} vale {pot}")

Programa completo

def entrada_datos():
    """Pide por teclado base y exponente"""
    base = int(input("Introduce la base: "))
    exponente = int(input("Introduce el exponente (>0): "))
    while exponente<=0:
        exponente= int(input("Error en el rango. Introduce el número (>0): "))
    return base, exponente


def calcula_potencia (base,exp):
    """Calcula la potencia"""
    potencia=1 
    n=1
    while n<=exp:
         potencia=potencia*base
         n=n+1
    return potencia

def imprime_salida(base,exponente,potencia):
    """Muestra el resultado por pantalla"""
    print(f"{base} elevado a {exponente} vale {potencia}")
    
def main():
    base, exp = entrada_datos()
    pot = calcula_potencia (base, exp)
    print(f"{base} elevado a {exp} vale {pot}")
    
if __name__ == "__main__":
    main()

5 elevado a 3 vale 125

Funciones: return y argumentos

---

Return

• En Python, una función puede devolver más de un valor con return.
• Donde se llama a dicha función hay que recoger los valores devueltos en el mismo orden en el que la función los devolvió.

def division_entera(dividendo, divisor):
 return dividendo // divisor, dividendo % divisor

def main():
    n1 = int(input("Dime un número entero: "))
    n2 = int(input("Dime un otro número entero: "))
    cociente, resto = division_entera(n1, n2)
    print(f"El cociente de dividir {n1} entre {n2} es {cociente} y el resto es {resto}.")

if __name__ == "__main__":
    main()

El cociente de dividir 6 entre 4 es 1 y el resto es 2.

Argumentos

• Cuando se llama a una función, los argumentos pueden indicarse mediante una asignación al nombre utilizado en la definición de la función. Implicaciones:
  • Es un poco más tedioso llamar a a la función pero...
  • Facilita utilizar funciones con muchos argumentos porque no es necesario ponerlos todos al llamar a la función y sobre todo...
  • Disminuye la posibilidad de cometer errores al no importar el orden en el que se ponen los argumentos cuando se llama a la función.

def division_entera(dividendo, divisor):
    return dividendo // divisor, dividendo % divisor

def main():
    n1 = int(input("Dime un número entero: "))
    n2 = int(input("Dime un otro número entero: "))
    cociente, resto = division_entera(divisor=n2, dividendo=n1)
    print(f"El cociente de dividir {n1} entre {n2} es {cociente} y el resto es {resto}.")


if __name__ == "__main__":
    main()

El cociente de dividir 7 entre 3 es 2 y el resto es 1.

• Se pueden mezclar argumentos por posición y argumentos por nombre a la hora de llamar a una función pero, en ese caso, primero van los que se especifican por posición y después los que se especifican por nombre.
• Cuando se define una función, los argumentos pueden tomar un valor por defecto de forma que, cuando se llama a la función, si no se especifica ningún valor para ellos, toman dicho valor por defecto.

def potencia(base,exponente=2):
    """Función con un valor por defecto para el segundo argumento"""
    resultado = base
    for i in range(1,exponente):
        resultado *=base
    return resultado

def main():
    n = int(input("Dime un número entero:"))
    cuadrado = potencia(n)
    print(f"{n} al cuadrado vale {cuadrado}")

if __name__ == "__main__":
    main()

6 al cuadrado vale 36

Funciones recursivas

---

• Una función se puede llamar a sí misma (función recursiva). En ese caso:
  • Es necesario que exista al menos un caso en el que la función no se llame a sí misma (caso base), o tendremos un desbordamiento de pila.
  • La recursividad permite implementar algunas definiciones matemáticas / operaciones que por su propia naturaleza son recursivas de forma:
    • Más concisa.
    • Pero menos eficiente.

Ejemplo

def potencia(base,exponente = 2):
    if exponente == 1:
        return base
    return base * potencia(base, exponente - 1)

def main():
    n1 = int(input("Dime la base: "))
    n2 = int(input("Dime el exponente: "))
    print(f"{n1} elevado a {n2} vale {potencia(base=n1, exponente=n2)}")
    
if __name__=="__main__":
    main()

4 elevado a 3 vale 64