[Python3] Définir dynamiquement des variables globales dans une fonction

introduction

Motivation: Je souhaite définir dynamiquement des variables globales et affecter des valeurs dans une fonction!

(Vous ne pouvez pas faire ça avec Hoi Hoi ...)

def dainyuu(val_name):
    global val
    val = 123  #Je veux attribuer à une variable avec le nom spécifié ici

dainyuu("val")
print(val)  #Référence en dehors de la fonction

exec()Il est possible de définir et d'affecter des variables dynamiques par, mais je l'ai résumé car il a fallu un certain temps pour les affecter aux variables globales.

La vérification est Python 3.7.3.

--Référence officielle: Fonction intégrée #exec

Modèle 1: définition simple des variables globales

--Pass `globals ()` comme deuxième argument de exec

• Ne passez pas le troisième argument

execÀglobals()En passant uniquement, l'affectation dans la chaîne devient une affectation à une variable globale.

#Sauf indication contraire, ce sera la définition de la variable locale
def define_variable_test1(var_name):
    exec("{0} = 123".format(var_name))
    eval("print('{0}(in) : ' + str({0}))".format(var_name))

# globals()Sera la définition de la variable globale
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

Modèle 2: utiliser des variables locales pour définir des variables globales

--Passez `globals ()` et `locals ()` `àexec --Déclarer les variables globales '' dans la déclaration d'évaluation

execÀlocals()Si vous réussissez, l'affectation dans la chaîne devient une variable locale, mais dans la même chaîneglobalEn le déclarant, vous pouvez l'affecter à une variable globale.

# locals()Si vous le passez également, ce sera une définition d'une variable locale
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))

#La déclaration de variable globale dans exec fait la définition de variable globale
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

En parlant bien sûr, c'est naturel, mais j'étais inquiet car je pouvais passer `` global () '' comme argument ...

Ou plutôt, je parle d'essayer d'arrêter l'acte de marcher d'une manière si mauvaise.

Motif 3: éditez directement la valeur de retour de globals () ''

Ce sont les informations envoyées aux commentaires. C'est de la magie noire ...!

# globals()Il est également possible d'éditer directement le dictionnaire renvoyé par
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

La substitution réussit normalement, mais pour être honnête, je ne pense pas que ce soit une pratique recommandée, alors soyez prudent. Le comportement peut changer à l'avenir.

Notez que globals () '' a réussi, mais local () '' `` a échoué dans la fonction. (Les changements ne sont pas reflétés dans les variables locales réelles)

Fonctions intégrées #locals ()

** Remarque **: Le contenu de ce dictionnaire ne doit pas être modifié; les modifications n'affectent pas les valeurs des variables locales ou libres utilisées par l'interpréteur.

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