inside - python closure example

Función anidada en Python

Question

¿Qué beneficio o implicaciones podríamos obtener con el código de Python como este?

class some_class(parent_class):
    def doOp(self, x, y):
        def add(x, y):
            return x + y
        return add(x, y)

Encontré esto en un proyecto de código abierto, haciendo algo útil dentro de la función anidada, pero sin hacer absolutamente nada más que llamarlo. (El código actual se puede encontrar here .) ¿Por qué alguien podría codificarlo así? ¿Hay algún beneficio o efecto secundario para escribir el código dentro de la función anidada en lugar de en la función externa normal?

Answer 1

¿Estás seguro de que el código era exactamente así? La razón normal para hacer algo como esto es crear una función parcial, una función con parámetros integrados. Llamar a la función externa devuelve un llamativo que no necesita parámetros, por lo que puede almacenarse y usarse en algún lugar donde es imposible pasar parámetros. Sin embargo, el código que ha publicado no hará eso; llama a la función inmediatamente y devuelve el resultado, en lugar del llamante. Puede ser útil publicar el código real que vio.

Answer 2

Además de los generadores de funciones, donde la creación de funciones internas es casi la definición de un generador de funciones, la razón por la que creo funciones anidadas es para mejorar la legibilidad. Si tengo una pequeña función que solo será invocada por la función externa, entonces alinearé la definición para que no tenga que saltar para determinar qué está haciendo esa función. Siempre puedo mover el método interno fuera del método de encapsulado si encuentro la necesidad de reutilizar la función más adelante.

Ejemplo de juguete:

import sys

def Foo():
    def e(s):
        sys.stderr.write(''ERROR: '')
        sys.stderr.write(s)
        sys.stderr.write(''/n'')
    e(''I regret to inform you'')
    e(''that a shameful thing has happened.'')
    e(''Thus, I must issue this desultory message'')
    e(''across numerous lines.'')
Foo()

Answer 3

La idea detrás de los métodos locales es similar a las variables locales: no contaminar el espacio de nombre más grande. Obviamente, los beneficios son limitados, ya que la mayoría de los idiomas tampoco proporcionan dicha funcionalidad directamente.

Answer 4

No puedo imaginar ninguna buena razón para un código como ese.

Quizás haya una razón para la función interna en las revisiones anteriores, como otras Ops.

Por ejemplo, esto tiene un poco más de sentido:

class some_class(parent_class):
    def doOp(self, op, x, y):
        def add(x, y):
            return x + y
        def sub(x,y):
            return x - y
        return locals()[op](x,y)

some_class().doOp(''add'', 1,2)

pero en su lugar la función interna debería ser métodos de clase ("privados"):

class some_class(object):
    def _add(self, x, y):
        return x + y
    def doOp(self, x, y):
        return self._add(x,y)

Answer 5

Normalmente lo haces para hacer closures :

def make_adder(x):
    def add(y):
        return x + y
    return add

plus5 = make_adder(5)
print(plus5(12))  # prints 17

Las funciones internas pueden acceder a las variables del ámbito adjunto (en este caso, la variable local x ). Si no está accediendo a ninguna variable desde el alcance adjunto, en realidad son solo funciones ordinarias con un alcance diferente.

Answer 6

Un beneficio potencial del uso de métodos internos es que le permite usar variables locales del método externo sin pasarlas como argumentos.

def helper(feature, resultBuffer):
  resultBuffer.print(feature)
  resultBuffer.printLine()
  resultBuffer.flush()

def save(item, resultBuffer):

  helper(item.description, resultBuffer)
  helper(item.size, resultBuffer)
  helper(item.type, resultBuffer)

puede escribirse de la siguiente manera, que podría decirse que es mejor

def save(item, resultBuffer):

  def helper(feature):
    resultBuffer.print(feature)
    resultBuffer.printLine()
    resultBuffer.flush()

  helper(item.description)
  helper(item.size)
  helper(item.type)