Si tengo alguna función como esa:

def function(some number, steps):
  if steps == 1: return 1
  result = some calculation + function(some number, steps - 1)
  return round(result, 2)

Que devuelve un número flotante.
Mi pregunta es: ¿Hay alguna manera de devolver el resultado redondeado solo cuando devuelvo el resultado de la función completa pero no de la llamada recursiva (para guardar la precisión en el cálculo).
Espero que entiendas mi pregunta.
Gracias por adelantado.

0
Zarkos 9 may. 2019 a las 13:20

4 respuestas

La mejor respuesta

En términos generales, si desea detectar que está dentro de una llamada recursiva en Python, puede agregar un parámetro predeterminado a la función de esta manera:

def my_func(arg1, arg2, _inside_recursion=False):
   # Default calls will have _inside_recursion as False
   # Make sure that your recursive calls set the parameter
   recursive_result = my_func(arg1, arg2, _inside_recursion=True)
2
Barak Itkin 9 may. 2019 a las 10:24

¡Si! Puede proporcionar una marca que se activará para llamadas consecutivas:

def function(some number, steps, do_rounding=True):
    if steps == 1:
        return 1
    result = some calculation + function(some number, steps - 1, False)
    if do_rounding:
        return round(result, 2)
    else:
        return result
2
Frieder 9 may. 2019 a las 10:25

No hay forma de distinguir si su función actual se invoca como parte de la recursión o como primer paso. Sin embargo, puede introducir una nueva función que llamará a la existente y realizará un redondeo adicional.

def internal_function(some number, steps):
    if steps == 1: return 1
    return some calculation + function(some number, steps - 1)

def function(some_number, steps):
    return round(internal_function(some_number, steps), 2)

Editar: si bien es cierto que el enfoque de agregar un argumento opcional a la función también puede servir, tiene dos desventajas:

  • contamina la interfaz pública de la función: sus usuarios ahora se preguntan si deberían dar un valor al argumento y qué valor deberían dar exactamente
  • hace que la parte computacional sea más larga de leer y también puede potencialmente destruir optimizaciones de llamada de cola.
2
Nikola Dimitroff 9 may. 2019 a las 10:40

Tal vez quieres algo como esto? Esto no es equivalente al código OP, pero tiene sentido. Aplica some_calculation recursivamente steps veces y redondea el valor final.

def function(x, steps):
  if steps == 1: return round(x, 2)
  return function(some_calculation(x), steps - 1)
0
ziggystar 9 may. 2019 a las 10:27