otra - llamar funciones dentro de funciones python

Variables de sobrescritura de Python en funciones anidadas

Question

Supongamos que tengo el siguiente código de python:

def outer():
    string = ""
    def inner():
        string = "String was changed by a nested function!"
    inner()
    return string

Quiero una llamada a outer () para devolver "¡La cadena fue cambiada por una función anidada!", Pero aparece "". Concluyo que Python piensa que la línea string = "string was changed by a nested function!" Es una declaración de una nueva variable local a inner (). Mi pregunta es: ¿cómo le digo a Python que debe usar la cadena externa ()? No puedo usar la palabra clave global , porque la cadena no es global, solo vive en un ámbito externo. Ideas?

Answer 1

En Python 3.x, puede usar la palabra clave nonlocal :

def outer():
    string = ""
    def inner():
        nonlocal string
        string = "String was changed by a nested function!"
    inner()
    return string

En Python 2.x, puedes usar una lista con un solo elemento y sobrescribir ese único elemento:

def outer():
    string = [""]
    def inner():
        string[0] = "String was changed by a nested function!"
    inner()
    return string[0]

Answer 2

Esto me sucede con demasiada frecuencia, cuando escribía una función y de repente me doy cuenta de que podría ser una buena idea tener una función auxiliar más pequeña, pero no realmente útil en ningún otro lugar. lo que naturalmente me da ganas de definirlo dentro como una función anidada.

pero tenía experiencia con el objeto anónimo de JAVA (es decir, definir un ejecutable), y la regla era que el objeto anónimo hace una copia impresa de su entorno externo, en este caso, las variables del ámbito externo. Por lo tanto, si la variable externa es un objeto inmutable ( int , char ), no pueden ser modificados por un objeto anónimo ya que se copian por valor, mientras que si es un objeto mutable ( collection , objects ), se pueden cambiar ... ya que se copian por " puntero " (su dirección en memoria)

Si sabe acerca de la programación, piense en ella como paso por valor y pase por referencia.

en python, es muy similar. x=123 es una asignación, le dan a la variable x=123 un nuevo significado (no modifica la anterior x), list[i]/dict[key] son operaciones de acceso a objetos, realmente modifican las cosas

para concluir, necesita un objeto mutable ... para poder modificarlo (aunque puede acceder a una tupla usando [], no puede usarlo aquí porque no es mutable)

Answer 3

Para agregar a la respuesta de Sven :

En Python 2.x, solo puedes leer las variables de alcance externo desde el alcance interno. La asignación solo creará una nueva variable local (es decir, de alcance interno) que oculta la de alcance externo.

Si desea leer y modificar , puede usar un dict para mantener sus variables en el ámbito externo, y luego acceder a ellas a través del dictador en el ámbito interno, también manteniendo su código bastante limpio y legible en presencia de múltiples vars de alcance externo :

def outer():
    # hold some text, plus the number of spaces in the text
    vars = {''text'': ''Some text.'', ''num_spaces'': 1}
    def inner():
        # add some more text
        more_text = '' Then some more text.''
        vars[''text''] += more_text
        # keep track of the number of spaces
        vars[''num_spaces''] += more_text.count('' '')
    inner()
    return vars[''text''], vars[''num_spaces'']

salida:

>>> outer()
(''Some text. Then some more text.'', 5)

Answer 4

También puede evitar esto usando atributos de función:

def outer():
    def inner():
        inner.string = "String was changed by a nested function!"
    inner.string = ""
    inner()
    return inner.string

Aclaración: esto funciona tanto en python 2.xy 3.x.