modify - global variables in python

Python-Visibilidad de variables globales en módulos importados

Question

Me encontré con un poco de una pared importando módulos en una secuencia de comandos de Python. Haré todo lo posible para describir el error, por qué me encuentro con él, y por qué estoy atando este enfoque particular para resolver mi problema (que describiré en un segundo):

Supongamos que tengo un módulo en el que he definido algunas funciones / clases de utilidad, que se refieren a las entidades definidas en el espacio de nombres en el que se importará este módulo auxiliar (deje que "a" sea una entidad de este tipo):

módulo 1:

def f():
    print a

Y luego tengo el programa principal, donde se define "a", en el que quiero importar esas utilidades:

import module1
a=3
module1.f()

La ejecución del programa provocará el siguiente error:

Traceback (most recent call last):
  File "Z:/Python/main.py", line 10, in <module>
    module1.f()
  File "Z:/Python/module1.py", line 3, in f
    print a
NameError: global name ''a'' is not defined

Se han hecho preguntas similares en el pasado (hace dos días, d''uh) y se han sugerido varias soluciones, sin embargo, realmente no creo que se ajusten a mis requisitos. Aquí está mi contexto particular:

Estoy intentando hacer un programa de Python que se conecte a un servidor de base de datos MySQL y muestre / modifique datos con una GUI. Para la limpieza, he definido el conjunto de funciones auxiliares / relacionadas con MySQL en un archivo separado. Sin embargo, todos tienen una variable común, que originalmente había definido dentro del módulo de utilidades, y que es el objeto del cursor del módulo MySQLdb. Más tarde me di cuenta de que el objeto del cursor (que se usa para comunicarse con el servidor db) debe definirse en el módulo principal, de modo que tanto el módulo principal como cualquier cosa que se importe puedan acceder a ese objeto.

El resultado final sería algo como esto:

utilities_module.py:

def utility_1(args):
    code which references a variable named "cur"
def utility_n(args):
    etcetera

Y mi módulo principal:

program.py:

import MySQLdb, Tkinter
db=MySQLdb.connect(#blahblah) ; cur=db.cursor()  #cur is defined!
from utilities_module import *

Y luego, tan pronto como intento llamar a cualquiera de las funciones de utilidades, desencadena el error "nombre global no definido" mencionado anteriormente.

Una sugerencia particular fue tener una declaración "from program import cur" en el archivo de utilidades, como esta:

utilities_module.py:

from program import cur
#rest of function definitions

program.py:

import Tkinter, MySQLdb
db=MySQLdb.connect(#blahblah) ; cur=db.cursor()  #cur is defined!
from utilities_module import *

Pero eso es importación cíclica o algo así y, en definitiva, también se cuelga. Entonces mi pregunta es:

¿Cómo demonios puedo hacer que el objeto "cur", definido en el módulo principal, sea visible para esas funciones auxiliares que se importan en él?

Gracias por su tiempo y mis más sinceras disculpas si la solución se ha publicado en otro lugar. Simplemente no puedo encontrar la respuesta y no tengo más trucos en mi libro.

Answer 1

Como los globales son específicos del módulo, puede agregar la siguiente función a todos los módulos importados y luego usarla para:

• Agregue variables singulares (en formato de diccionario) como globales para aquellas
• Transfiere tu módulo principal global a él.

addglobals = lambda x: globals (). update (x)

Entonces, todo lo que necesitas para transmitir los valores globales actuales es:

módulo de importación

module.addglobals (globals ())

Answer 2

Como solución, podría considerar establecer variables de entorno en la capa externa, así.

main.py:

import os
os.environ[''MYVAL''] = str(myintvariable)

mymodule.py:

import os
print os.environ[''MYVAL'']

Como precaución adicional, maneje el caso cuando MYVAL no está definido dentro del módulo.

Answer 3

Esta publicación es solo una observación del comportamiento de Python que encontré. Quizás los consejos que leas arriba no te sirvan si hiciste lo mismo que hice a continuación.

A saber, tengo un módulo que contiene variables globales / compartidas (como se sugirió anteriormente):

#sharedstuff.py

globaltimes_randomnode=[]
globalist_randomnode=[]

Luego tuve el módulo principal que importa las cosas compartidas con:

import sharedstuff as shared

y algunos otros módulos que realmente poblaron estas matrices. Estos son llamados por el módulo principal. Al salir de estos otros módulos, puedo ver claramente que las matrices están ocupadas. Pero al leerlos en el módulo principal, estaban vacíos. Esto fue bastante extraño para mí (bueno, soy nuevo en Python). Sin embargo, cuando cambio la forma en que importo el sharedstuff.py en el módulo principal a:

from globals import *

funcionó (las matrices estaban pobladas).

Sólo digo''

Answer 4

La solución más fácil a este problema en particular habría sido agregar otra función dentro del módulo que habría almacenado el cursor en una variable global al módulo. Entonces todas las otras funciones podrían usarlo también.

módulo 1:

cursor = None

def setCursor(cur):
    global cursor
    cursor = cur

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

programa principal:

import module1

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

Answer 5

Los Globals en Python son globales para un módulo , no para todos los módulos. (Muchas personas se confunden con esto, porque, por ejemplo, en C, un elemento global es el mismo en todos los archivos de implementación, a menos que explícitamente se convierta en static ).

Hay diferentes maneras de resolver esto, dependiendo de su caso de uso real.

Antes incluso de ir por este camino, pregúntate si esto realmente necesita ser global. ¿Tal vez realmente quieres una clase, con f como método de instancia, en lugar de solo una función gratuita? Entonces podrías hacer algo como esto:

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

Si realmente desea un global, pero está allí para ser utilizado por el module1 , module1 en ese módulo.

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

Por otro lado, si se comparte una gran cantidad de módulos, colóquelo en otro lugar y haga que todos lo importen:

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

... y, en module1.py:

import shared_stuff
def f():
    print shared_stuff.a

No use a from import a menos que la variable sea una constante. from shared_stuff import a se crearía una nueva variable inicializada a lo que shared_stuff.a referido en el momento de la importación, y esta nueva variable no se vería afectada por las asignaciones a shared_stuff.a .

O, en el caso poco frecuente de que realmente necesite que sea verdaderamente global en todas partes, como un built-in, agréguelo al módulo integrado. Los detalles exactos difieren entre Python 2.xy 3.x. En 3.x, funciona así:

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

Answer 6

Una función utiliza los valores globales del módulo en el que está definida . En lugar de establecer a = 3 , por ejemplo, debe establecer module1.a = 3 . Por lo tanto, si desea que cur esté disponible como global en utilities_module , configure utilities_module.cur .

Una mejor solución: no uses globales. Pase las variables que necesita a las funciones que lo necesitan, o cree una clase para agrupar todos los datos, y páselos al inicializar la instancia.