La visibilité des variables globales dans les modules importés

Globals en Python sont globales à un module, pas à travers tous les modules. (Beaucoup de gens sont confus par cela, parce que, par exemple, en C, un global est le même sur tous les fichiers de mise en œuvre, sauf si vous explicitement faire static.)

Il existe différentes méthodes pour résoudre ce problème, selon votre cas d'utilisation.

Avant même d'entrer dans cette voie, demandez-vous si elle a vraiment besoin d'être global. Peut-être que vous voulez vraiment classe, avec f comme une méthode d'instance, plutôt que de simplement une fonction libre? Ensuite, vous pourriez faire quelque chose comme ceci:

import module1
thingy1 = module1.Thingy(a=3)
thingy1.f()

Si vraiment vous ne voulez mondiale, mais il est juste là pour être utilisé par module1, de le fixer dans ce module.

import module1
module1.a=3
module1.f()

D'autre part, si a est partagée par tout un tas de modules, le mettre quelque part d'autre, et tout le monde l'importer:

import shared_stuff
import module1
shared_stuff.a = 3
module1.f()

... et, dans module1.py:

import shared_stuff
def f():
    print shared_stuff.a

Ne pas utiliser un from l'importation, sauf si la variable est destinée à être une constante. from shared_stuff import a de créer une nouvelle a variable initialisée à ce que shared_stuff.a mentionnés au moment de l'importation, et ce nouveau a variable ne serait pas affecté par des assignations à des shared_stuff.a.

Ou, dans les rares cas où vous avez vraiment besoin pour être véritablement mondiale partout, comme un builtin, l'ajouter à la builtin module. Les détails diffèrent entre Python 2.x et 3.x. En 3.x, il fonctionne comme ceci:

import builtins
import module1
builtins.a = 3
module1.f()

Une fonction utilise les variables globales du module, c'est défini dans. Au lieu de définir a = 3, par exemple, vous devriez être en paramètre module1.a = 3. Donc, si vous voulez cur disponibles en tant que global dans utilities_module, ensemble utilities_module.cur.

Une meilleure solution: ne pas utiliser de variables globales. Passer les variables dont vous avez besoin dans les fonctions qui en ont besoin, ou de créer une classe permettant de regrouper toutes les données ensemble, et de le transmettre lors de l'initialisation de l'instance.

La méthode la plus simple solution de ce problème particulier aurait été d'ajouter une autre fonction dans le module qui aurait stocké le curseur dans une variable globale pour le module. Alors que toutes les autres fonctions pourraient l'utiliser aussi bien.

module1:

cursor = None

def setCursor(cur):
    global cursor
    cursor = cur

def method(some, args):
    global cursor
    do_stuff(cursor, some, args)

programme principal:

import module1

cursor = get_a_cursor()
module1.setCursor(cursor)
module1.method()

Puisque je n'ai pas vu cela dans les réponses ci-dessus, j'ai pensé que je voudrais ajouter ma solution simple qui est juste pour ajouter un global_dict argument à la fonction nécessitant l'appel du module globals, et de passer ensuite le dict dans la fonction lors de l'appel; e.g:

# external_module
def imported_function(global_dict=None):
    print(global_dict["a"])


# calling_module
a = 12
from external_module import imported_function
imported_function(global_dict=globals())

>>> 12