blocks|key|698870|text|为此，需要将变量声明为全局变量。但是，也可以通过使用module_name.var_name从模块外部访问全局变量。将此添加为模块的第一行：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|698871|global+__DBNAME__|code-block|syntax|javascript|698872|entityMap^0|Q|K|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

For this, you need to declare the variable as global. However, a global variable is also accessible from outside the module by using <code>module_name.var_name</code>. Add this as the first line of your module:

<pre><code>global __DBNAME__
</code></pre>

blocks|key|1447540|text|下面是正在发生的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447541|首先，Python真正拥有的唯一全局变量是模块作用域变量。您不能创建一个真正全局的变量；您所能做的就是在特定范围内创建一个变量。(如果在Python解释器中创建一个变量，然后导入其他模块，则变量位于最外层的范围内，因此是Python会话中的全局变量。)|1447542|要创建一个模块-全局变量，您所要做的就是给一个名称赋值。|1447543|假设有一个名为foo.py的文件，其中包含以下一行：|1447544|X+=+1|code-block|syntax|javascript|1447545|现在假设您导入了它。|1447546|import+foo
print(foo.X)++#+prints+1|1447547|但是，让我们假设您希望在函数中使用一个模块作用域变量作为全局变量，如您的示例所示。Python的默认假设是假设函数变量是本地的。在尝试使用全局之前，只需在函数中添加一个global声明即可。|offset|length|style|CODE|1447548|def+initDB(name):
++++global+__DBNAME__++#+add+this+line!
++++if+__DBNAME__+is+None:+#+see+notes+below;+explicit+test+for+None
++++++++__DBNAME__+=+name
++++else:
++++++++raise+RuntimeError("Database+name+has+already+been+set.")|1447549|顺便说一句，对于这个例子，简单的if+not+__DBNAME__测试就足够了，因为除空字符串之外的任何字符串值都将计算true，因此任何实际的数据库名称都将计算true。但是对于可能包含可能为0的数字值的变量，不能只说if+not+variablename；在这种情况下，应该使用is运算符显式地测试None。我修改了这个示例以添加一个显式的None测试。None的显式测试从未出错，因此我默认使用它。|1447550|最后，正如其他人在本页面中所指出的，两条前导强调了Python的信号，您希望该变量对模块是“私有”的。如果您执行import+*+from+mymodule，Python将不会将带有两个前导下划线的名称导入到您的名称空间中。但是，如果您只执行一个简单的import+mymodule，然后说dir(mymodule)，您将在列表中看到“私有”变量，如果您显式地引用mymodule.__DBNAME__，Python不会在意，它只会让您引用它。双前导下划线是模块用户的一个主要线索，您不希望他们将该名称重新绑定到他们自己的某个值。|1447551|它被认为是Python中的最佳实践，不执行import+*，而是通过使用mymodule.something或显式地执行from+mymodule+import+something之类的导入来最小化耦合和最大化解释性。|1447552|编辑:如果由于某种原因，您需要在没有global关键字的非常旧版本的Python中执行类似的操作，那么有一个简单的解决方法。不要直接设置模块全局变量，而是在模块全局级别使用可变类型，并将值存储在其中。|1447553|在您的函数中，全局变量名将是只读的；您将无法重新绑定实际的全局变量名。(如果将函数内的变量名分配给该变量名，则只会影响函数中的局部变量名称。)但是您可以使用这个局部变量名来访问实际的全局对象，并在其中存储数据。|1447554|您可以使用list，但是代码会很难看：|1447555|__DBNAME__+=+[None]+#+use+length-1+list+as+a+mutable

#+later,+in+code:++
if+__DBNAME__[0]+is+None:
++++__DBNAME__[0]+=+name|1447556|一个dict更好。但是最方便的是一个类实例，您可以只使用一个简单的类：|1447557|class+Box:
++++pass

__m+=+Box()++#+m+will+contain+all+module-level+values
__m.dbname+=+None++#+database+name+global+in+module

#+later,+in+code:
if+__m.dbname+is+None:
++++__m.dbname+=+name|1447558|(您实际上不需要大写数据库名变量。)|1447559|我喜欢只使用__m.dbname而不是__m["DBNAME"]的语法；在我看来，这似乎是最方便的解决方案。但是dict解决方案也很好。|1447560|对于dict，您可以使用任何可访问的值作为键，但是当您满意地使用有效标识符的名称时，您可以使用上面提到的类似于Box的简单类。|1447561|entityMap^0|0|0|0|0|0|0|0|2C|6|0|0|G|H|32|J|3X|2|47|4|4S|4|4Z|4|0|1K|M|3I|F|41|D|52|J|0|L|8|10|I|1O|U|0|I|6|0|0|5|4|0|0|2|4|0|0|0|6|A|J|D|1K|4|0|2|4|1J|3|0^^$0|@$1|2|3|4|5|6|7|1O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1S|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1T|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1U|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1V|8|@$S|1W|T|1X|U|V]]|9|@]|A|$]]|$1|W|3|X|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|1Z|8|@$S|20|T|21|U|V]|$S|22|T|23|U|V]|$S|24|T|25|U|V]|$S|26|T|27|U|V]|$S|28|T|29|U|V]|$S|2A|T|2B|U|V]]|9|@]|A|$]]|$1|10|3|11|5|6|7|2C|8|@$S|2D|T|2E|U|V]|$S|2F|T|2G|U|V]|$S|2H|T|2I|U|V]|$S|2J|T|2K|U|V]]|9|@]|A|$]]|$1|12|3|13|5|6|7|2L|8|@$S|2M|T|2N|U|V]|$S|2O|T|2P|U|V]|$S|2Q|T|2R|U|V]]|9|@]|A|$]]|$1|14|3|15|5|6|7|2S|8|@$S|2T|T|2U|U|V]]|9|@]|A|$]]|$1|16|3|17|5|6|7|2V|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2W|8|@$S|2X|T|2Y|U|V]]|9|@]|A|$]]|$1|1A|3|1B|5|J|7|2Z|8|@]|9|@]|A|$K|L]]|$1|1C|3|1D|5|6|7|30|8|@$S|31|T|32|U|V]]|9|@]|A|$]]|$1|1E|3|1F|5|J|7|33|8|@]|9|@]|A|$K|L]]|$1|1G|3|1H|5|6|7|34|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|35|8|@$S|36|T|37|U|V]|$S|38|T|39|U|V]|$S|3A|T|3B|U|V]]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|3C|8|@$S|3D|T|3E|U|V]|$S|3F|T|3G|U|V]]|9|@]|A|$]]|$1|1M|3|-4|5|6|7|3H|8|@]|9|@]|A|$]]]|1N|$]]

Here is what is going on.

First, the only global variables Python really has are module-scoped variables. You cannot make a variable that is truly global; all you can do is make a variable in a particular scope. (If you make a variable inside the Python interpreter, and then import other modules, your variable is in the outermost scope and thus global within your Python session.)

All you have to do to make a module-global variable is just assign to a name.

Imagine a file called foo.py, containing this single line:

<pre><code>X = 1
</code></pre>

Now imagine you import it.

<pre><code>import foo
print(foo.X) # prints 1
</code></pre>

However, let's suppose you want to use one of your module-scope variables as a global inside a function, as in your example. Python's default is to assume that function variables are local. You simply add a <code>global</code> declaration in your function, before you try to use the global.

<pre><code>def initDB(name):
 global __DBNAME__ # add this line!
 if __DBNAME__ is None: # see notes below; explicit test for None
 __DBNAME__ = name
 else:
 raise RuntimeError("Database name has already been set.")
</code></pre>

By the way, for this example, the simple <code>if not __DBNAME__</code> test is adequate, because any string value other than an empty string will evaluate true, so any actual database name will evaluate true. But for variables that might contain a number value that might be 0, you can't just say <code>if not variablename</code>; in that case, you should explicitly test for <code>None</code> using the <code>is</code> operator. I modified the example to add an explicit <code>None</code> test. The explicit test for <code>None</code> is never wrong, so I default to using it.

Finally, as others have noted on this page, two leading underscores signals to Python that you want the variable to be "private" to the module. If you ever do an <code>import * from mymodule</code>, Python will not import names with two leading underscores into your name space. But if you just do a simple <code>import mymodule</code> and then say <code>dir(mymodule)</code> you will see the "private" variables in the list, and if you explicitly refer to <code>mymodule.__DBNAME__</code> Python won't care, it will just let you refer to it. The double leading underscores are a major clue to users of your module that you don't want them rebinding that name to some value of their own.

It is considered best practice in Python not to do <code>import *</code>, but to minimize the coupling and maximize explicitness by either using <code>mymodule.something</code> or by explicitly doing an import like <code>from mymodule import something</code>.

EDIT: If, for some reason, you need to do something like this in a very old version of Python that doesn't have the <code>global</code> keyword, there is an easy workaround. Instead of setting a module global variable directly, use a mutable type at the module global level, and store your values inside it.

In your functions, the global variable name will be read-only; you won't be able to rebind the actual global variable name. (If you assign to that variable name inside your function it will only affect the local variable name inside the function.) But you can use that local variable name to access the actual global object, and store data inside it.

You can use a <code>list</code> but your code will be ugly:

<pre><code>__DBNAME__ = [None] # use length-1 list as a mutable

# later, in code: 
if __DBNAME__[0] is None:
 __DBNAME__[0] = name
</code></pre>

A <code>dict</code> is better. But the most convenient is a class instance, and you can just use a trivial class:

<pre><code>class Box:
 pass

__m = Box() # m will contain all module-level values
__m.dbname = None # database name global in module

# later, in code:
if __m.dbname is None:
 __m.dbname = name
</code></pre>

(You don't really need to capitalize the database name variable.)

I like the syntactic sugar of just using <code>__m.dbname</code> rather than <code>__m["DBNAME"]</code>; it seems the most convenient solution in my opinion. But the <code>dict</code> solution works fine also.

With a <code>dict</code> you can use any hashable value as a key, but when you are happy with names that are valid identifiers, you can use a trivial class like <code>Box</code> in the above.

blocks|key|1447569|text|你正在陷入一种微妙的怪癖。您不能在python函数中重新分配模块级变量。我认为这是为了阻止人们偶然地在一个函数中重新分配东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447570|您可以访问模块名称空间，只是不应该尝试重新分配。如果您的函数指定了什么，它就会自动成为一个函数变量--+python将不会查看模块名称空间。|1447571|你可以：|1447572|__DB_NAME__+=+None

def+func():
++++if+__DB_NAME__:
++++++++connect(__DB_NAME__)
++++else:
++++++++connect(Default_value)|code-block|syntax|javascript|1447573|但是不能在函数中重新分配__DB_NAME__。|offset|length|style|CODE|1447574|一个解决办法是：|1447575|__DB_NAME__+=+[None]

def+func():
++++if+__DB_NAME__[0]:
++++++++connect(__DB_NAME__[0])
++++else:
++++++++__DB_NAME__[0]+=+Default_value|1447576|注意，我没有重新分配__DB_NAME__，我只是修改它的内容。|1447577|entityMap^0|0|0|0|0|C|B|0|0|0|A|B|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|12|8|@$M|13|N|14|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|17|8|@$M|18|N|19|O|P]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|X|$]]

You are falling for a subtle quirk. You cannot re-assign module-level variables inside a python function. I think this is there to stop people re-assigning stuff inside a function by accident. 

You can access the module namespace, you just shouldn't try to re-assign. If your function assigns something, it automatically becomes a function variable - and python won't look in the module namespace.

You can do:

<pre><code>__DB_NAME__ = None

def func():
 if __DB_NAME__:
 connect(__DB_NAME__)
 else:
 connect(Default_value)
</code></pre>

but you cannot re-assign <code>__DB_NAME__</code> inside a function. 

One workaround:

<pre><code>__DB_NAME__ = [None]

def func():
 if __DB_NAME__[0]:
 connect(__DB_NAME__[0])
 else:
 __DB_NAME__[0] = Default_value
</code></pre>

Note, I'm not re-assigning <code>__DB_NAME__</code>, I'm just modifying its contents.

blocks|key|1447579|text|Steveha的回答对我很有帮助，但忽略了一个重要的观点(我认为wisty是这么说的)。如果只访问函数中的变量，但不赋值，则不需要全局关键字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1447580|如果不使用全局关键字分配变量，那么Python将创建一个新的本地变量--模块变量的值现在将隐藏在函数中。使用全局关键字在函数中分配模块var。|1447581|Pylint1.3.1在Python2.7下，如果不分配var，则强制不使用全局。|1447582|module_var+=+'/dev/hello'

def+readonly_access():
++++connect(module_var)

def+readwrite_access():
++++global+module_var
++++module_var+=+'/dev/hello2'
++++connect(module_var)|code-block|syntax|javascript|1447583|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Steveha's answer was helpful to me, but omits an important point (one that I think wisty was getting at). The global keyword is not necessary if you only access but do not assign the variable in the function.

If you assign the variable without the global keyword then Python creates a new local var -- the module variable's value will now be hidden inside the function. Use the global keyword to assign the module var inside a function.

Pylint 1.3.1 under Python 2.7 enforces NOT using global if you don't assign the var.

<pre><code>module_var = '/dev/hello'

def readonly_access():
 connect(module_var)

def readwrite_access():
 global module_var
 module_var = '/dev/hello2'
 connect(module_var)
</code></pre>

blocks|key|1482456|text|通过在模块上访问模块级变量的显式访问|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1482457|1482458|简而言之：：这里描述的技术与steveha's+answer、(除了)中描述的技术相同，即没有创建人工助手对象来显式地对变量进行作用范围。相反，模块对象本身被赋予一个变量指针，因此在从任何地方访问时都提供了显式的作用域。(类似于本地函数作用域中的赋值)。|1482459|把它想象成self用于当前模块，而不是当前实例！|1482460|#+db.py
import+sys

#+this+is+a+pointer+to+the+module+object+instance+itself.
this+=+sys.modules[__name__]

#+we+can+explicitly+make+assignments+on+it+
this.db_name+=+None

def+initialize_db(name):
++++if+(this.db_name+is+None):
++++++++#+also+in+local+function+scope.+no+scope+specifier+like+global+is+needed
++++++++this.db_name+=+name
++++++++#+also+the+name+remains+free+for+local+use
++++++++db_name+=+"Locally+scoped+db_name+variable.+Doesn't+do+anything+here."
++++else:
++++++++msg+=+"Database+is+already+initialized+to+{0}."
++++++++raise+RuntimeError(msg.format(this.db_name))|code-block|syntax|javascript|1482461|As+modules+are+cached+and+therefore+import+only+once，您可以随时在任意数量的客户机上导入db.py，操作相同的通用状态：|CODE|1482462|#+client_a.py
import+db

db.initialize_db('mongo')|1482463|#+client_b.py
import+db

if+(db.db_name+==+'mongo'):
++++db.db_name+=+None++#+this+is+the+preferred+way+of+usage,+as+it+updates+the+value+for+all+clients,+because+they+access+the+same+reference+from+the+same+module+object|1482464|#+client_c.py
from+db+import+db_name
#+be+careful+when+importing+like+this,+as+a+new+reference+"db_name"+will
#+be+created+in+the+module+namespace+of+client_c,+which+points+to+the+value+
#+that+"db.db_name"+has+at+import+time+of+"client_c".

if+(db_name+==+'mongo'):++#+checking+is+fine+if+"db.db_name"+doesn't+change
++++db_name+=+None++#+be+careful,+because+this+only+assigns+the+reference+client_c.db_name+to+a+new+value,+but+leaves+db.db_name+pointing+to+its+current+value.|1482465|1482466|作为一项额外的奖励，我发现它总体上相当是pythonic的，因为它非常适合Pythons的显式策略，而不是隐式策略。|1482467|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/1978076/2889970|1|https://stackoverflow.com/a/2029528/2889970^0|0|5|0|0|5|1|V|3|E|G|0|0|5|4|B|4|0|0|1Y|5|0|1G|1|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|G|3|H|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@$9|1K|A|1L|1|1M]]|E|$]]|$1|I|3|J|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|K|3|L|5|M|7|1S|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|1T|8|@$9|1U|A|1V|B|R]]|D|@$9|1W|A|1X|1|1Y]]|E|$]]|$1|S|3|T|5|M|7|1Z|8|@]|D|@]|E|$N|O]]|$1|U|3|V|5|M|7|20|8|@]|D|@]|E|$N|O]]|$1|W|3|X|5|M|7|21|8|@]|D|@]|E|$N|O]]|$1|Y|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|Z|3|10|5|6|7|23|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|24|8|@]|D|@]|E|$]]]|12|$13|$5|14|15|16|E|$17|18]]|19|$5|14|15|16|E|$17|1A]]]]

Explicit access to module level variables by accessing them explicity on the module

<hr>

In short: The technique described here is the same as in <a href="https://stackoverflow.com/a/1978076/2889970">steveha's answer</a>, except, that no artificial helper object is created to explicitly scope variables. Instead the module object itself is given a variable pointer, and therefore provides explicit scoping upon access from everywhere. (like assignments in local function scope).

Think of it like self for the current module instead of the current instance !

<pre class="lang-python prettyprint-override"><code># db.py
import sys

# this is a pointer to the module object instance itself.
this = sys.modules[__name__]

# we can explicitly make assignments on it 
this.db_name = None

def initialize_db(name):
 if (this.db_name is None):
 # also in local function scope. no scope specifier like global is needed
 this.db_name = name
 # also the name remains free for local use
 db_name = "Locally scoped db_name variable. Doesn't do anything here."
 else:
 msg = "Database is already initialized to {0}."
 raise RuntimeError(msg.format(this.db_name))
</code></pre>

<a href="https://stackoverflow.com/a/2029528/2889970">As modules are cached and therefore import only once</a>, you can import <code>db.py</code> as often on as many clients as you want, manipulating the same, universal state:

<pre class="lang-python prettyprint-override"><code># client_a.py
import db

db.initialize_db('mongo')
</code></pre>

<pre class="lang-python prettyprint-override"><code># client_b.py
import db

if (db.db_name == 'mongo'):
 db.db_name = None # this is the preferred way of usage, as it updates the value for all clients, because they access the same reference from the same module object
</code></pre>

<pre class="lang-python prettyprint-override"><code># client_c.py
from db import db_name
# be careful when importing like this, as a new reference "db_name" will
# be created in the module namespace of client_c, which points to the value 
# that "db.db_name" has at import time of "client_c".

if (db_name == 'mongo'): # checking is fine if "db.db_name" doesn't change
 db_name = None # be careful, because this only assigns the reference client_c.db_name to a new value, but leaves db.db_name pointing to its current value.
</code></pre>

<hr>

As an additional bonus I find it quite pythonic overall as it nicely fits Pythons policy of Explicit is better than implicit.

Is there a way to set up a global variable inside of a module? When I tried to do it the most obvious way as appears below, the Python interpreter said the variable <code>__DBNAME__</code> did not exist.

<pre><code>...
__DBNAME__ = None

def initDB(name):
 if not __DBNAME__:
 __DBNAME__ = name
 else:
 raise RuntimeError("Database name has already been set.")
...
</code></pre>

And after importing the module in a different file

<pre><code>...
import mymodule
mymodule.initDB('mydb.sqlite')
...
</code></pre>

And the traceback was:

<blockquote>
 ...
 UnboundLocalError: local variable 'DBNAME' referenced before assignment
 ...
</blockquote>

Any ideas? I'm trying to set up a singleton by using a module, as per <a href="https://stackoverflow.com/questions/31875/is-there-a-simple-elegant-way-to-define-singletons-in-python/31887#31887">this fellow's</a> recommendation.

How to create module-wide variables in Python?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有办法在模块内设置全局变量吗？当我试图以如下所示的最明显的方式来做它时，Python解释器说变量__DBNAME__不存在。...__DBNAME__ = Nonedef initDB(name):    if not __DBNAME__:        __DBNAME__ = name    else:     ...

问如何在Python中创建模块范围的变量？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Python中创建模块范围的变量？EN