[Python3] Definieren Sie globale Variablen in einer Funktion dynamisch

Einführung

Motivation: Ich möchte globale Variablen dynamisch definieren und Werte in einer Funktion zuweisen!

(Mit Hoi Hoi geht das nicht ...)

def dainyuu(val_name):
    global val
    val = 123  #Ich möchte einer Variablen mit dem hier angegebenen Namen zuweisen

dainyuu("val")
print(val)  #Referenz außerhalb der Funktion

exec()Es ist möglich, dynamische Variablen zu definieren und zuzuweisen, aber ich habe es zusammengefasst, da die Zuweisung zu globalen Variablen einige Zeit in Anspruch genommen hat.

Die Überprüfung ist Python 3.7.3.

• Offizielle Referenz: Integrierte Funktion #exec

Muster 1: Einfache Definition globaler Variablen

--Pass `globals ()` als zweites Argument von `` `exec```

• Übergeben Sie das dritte Argument nicht

execZuglobals()Wenn Sie nur übergeben, wird die Zuweisung in der Zeichenfolge zu einer Zuweisung zu einer globalen Variablen.

#Sofern nicht anders angegeben, ist dies die Definition der lokalen Variablen
def define_variable_test1(var_name):
    exec("{0} = 123".format(var_name))
    eval("print('{0}(in) : ' + str({0}))".format(var_name))

# globals()Wird die Definition der globalen Variablen sein
def define_variable_test2(var_name):
    exec("{0} = 345".format(var_name), globals())
    eval("print('{0}(in) : ' + str({0}))".format(var_name))


define_variable_test1("val1")
try:
    print("val1(out): {0}\n".format(val1))
except NameError:
    print("val1(out): not defined\n")

define_variable_test2("val2")
try:
    print("val2(out): {0}\n".format(val2))
except NameError:
    print("val2(out): not defined\n")

out

val1(in) : 123
val1(out): not defined

val2(in) : 345
val2(out): 345

Muster 2: Verwenden Sie lokale Variablen, um globale Variablen zu definieren

--Pass `globals ()` und `local ()` to exec``` --Declare `global `Variablen in der Evaluierungsanweisung

execZulocals()Wenn Sie übergeben, wird die Zuweisung in der Zeichenfolge zu einer lokalen Variablen, jedoch in derselben ZeichenfolgeglobalIndem Sie es deklarieren, können Sie es einer globalen Variablen zuweisen.

# locals()Wenn Sie es auch übergeben, wird es eine Definition einer lokalen Variablen sein
def define_variable_test3(var_name):
    local_val = 12345
    exec("{0} = local_val".format(var_name), globals(), locals())
    eval("print('{0}(in) : ' + str({0}))".format(var_name))

#Die globale Variablendeklaration in exec definiert die globale Variable
def define_variable_test4(var_name):
    local_val = 34567
    exec("global {0}\n{0} = local_val".format(var_name), globals(), locals())
    eval("print('{0}(in) : ' + str({0}))".format(var_name))


define_variable_test3("val3")
try:
    print("val3(out): {0}\n".format(val3))
except NameError:
    print("val3(out): not defined\n")

define_variable_test4("val4")
try:
    print("val4(out): {0}\n".format(val4))
except NameError:
    print("val4(out): not defined\n")

out

val3(in) : 12345
val3(out): not defined

val4(in) : 34567
val4(out): 34567

Apropos natürlich, es ist natürlich, aber ich war besorgt, weil ich "global ()" als Argument übergeben könnte ...

Oder besser gesagt, ich spreche davon, den Akt des Gehens auf solch einem bösen Weg zu stoppen.

Muster 3: Bearbeiten Sie direkt den Rückgabewert von `globals ()`

Dies sind die Informationen, die an die Kommentare gesendet werden. Es ist schwarze Magie ...!

# globals()Es ist auch möglich, das von zurückgegebene Wörterbuch direkt zu bearbeiten
def define_variable_test5(var_name):
    local_val = 1234567
    globals()[var_name] = local_val
    eval("print('{0}(in) : ' + str({0}))".format(var_name))

define_variable_test5("val5")
try:
    print("val5(out): {0}\n".format(val5))
except NameError:
    print("val5(out): not defined\n")

out

val5(in) : 1234567
val5(out): 1234567

Die Substitution ist normalerweise erfolgreich, aber um ehrlich zu sein, halte ich es nicht für eine empfohlene Vorgehensweise. Seien Sie also bitte vorsichtig. Das Verhalten kann sich in Zukunft ändern.

Beachten Sie, dass `globals ()` erfolgreich war, `local ()` jedoch in der Funktion fehlgeschlagen ist. (Änderungen werden in den tatsächlichen lokalen Variablen nicht berücksichtigt.)

Integrierte Funktionen #locals ()

** Hinweis **: Der Inhalt dieses Wörterbuchs darf nicht geändert werden. Änderungen wirken sich nicht auf die Werte der vom Interpreter verwendeten lokalen oder freien Variablen aus.

def changing_local_variable_test():
    var = 123
    print("before: {0}".format(var))
    locals()["var"] = 234
    print("after:  {0}".format(var))

changing_local_variable_test()

out

before: 123
after:  123