Вы можете изучить понятие пространства имен. В Python модуль - естественное место для данных Глобальный:

Each module has its own private symbol table, which is used as the global symbol table by all functions defined in the module. Thus, the author of a module can use global variables in the module without worrying about accidental clashes with a user’s global variables. On the other hand, if you know what you are doing you can touch a module’s global variables with the same notation used to refer to its functions, modname.itemname.

Здесь описано конкретное использование global-in-a-module - Как поделиться глобальными переменными между модулями?, и для полноты его содержимое доступно здесь:

The canonical way to share information across modules within a single program is to create a special configuration module (often called config or cfg). Just import the configuration module in all modules of your application; the module then becomes available as a global name. Because there is only one instance of each module, any changes made to the module object get reflected everywhere. For example:

File: config.py

x = 0   # Default value of the 'x' configuration setting

File: mod.py

import config
config.x = 1

File: main.py

import config
import mod
print config.x

Вы можете использовать глобальную переменную в других функциях, объявив ее как global в каждой функции, которая присваивает ей значение:

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar

set_globvar_to_one()
print_globvar()       # Prints 1

Я предполагаю, что причина этого в том, что, поскольку глобальные переменные настолько опасны, Python хочет убедиться, что вы действительно знаете, с чем играете, явно запрашивая ключевое слово global.

См. Другие ответы, если вы хотите использовать глобальную переменную в разных модулях.

Если вы хотите обратиться к глобальной переменной в функции, вы можете использовать ключевое слово Глобальный, чтобы объявить, какие переменные являются глобальными. Вам не нужно использовать его во всех случаях (как кто-то здесь неправильно утверждает) - если имя, указанное в выражении, не может быть найдено в локальной области или областях в функциях, в которых эта функция определена, оно ищется среди глобальных переменные.

Однако, если вы назначаете новую переменную, не объявленную в функции как глобальную, она неявно объявляется как локальная и может затмить любую существующую глобальную переменную с тем же именем.

Кроме того, глобальные переменные полезны, в отличие от некоторых фанатиков ООП, которые утверждают обратное - особенно для небольших скриптов, где ООП является излишним.

Если я правильно понимаю вашу ситуацию, то, что вы видите, является результатом того, как Python обрабатывает локальные (функции) и глобальные (модули) пространства имен.

Допустим, у вас есть такой модуль:

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

Вы могли ожидать, что это напечатает 42, но вместо этого будет напечатано 5. Как уже упоминалось, если вы добавите объявление «global» к func1(), то func2() напечатает 42.

def func1():
    global myGlobal
    myGlobal = 42

Здесь происходит то, что Python предполагает, что любое имя назначен в любом месте функции является локальным для этой функции, если явно не указано иное. Если это только чтение от имени, и имя не существует локально, он попытается найти имя во всех содержащих его областях (например, в глобальной области видимости модуля).

Поэтому, когда вы назначаете 42 имени myGlobal, Python создает локальную переменную, которая затеняет глобальную переменную с тем же именем. Этот локальный объект выходит за пределы области видимости и является сборщик мусора, когда возвращается func1(); Между тем, func2() никогда не видит ничего, кроме (неизмененного) глобального имени. Обратите внимание, что это решение о пространстве имен происходит во время компиляции, а не во время выполнения - если бы вы прочитали значение myGlobal внутри func1(), прежде чем назначать ему, вы бы получили UnboundLocalError, потому что Python уже решил, что он должен быть локальным. переменная, но с ней еще не было связано никакого значения. Но с помощью оператора «global» вы говорите Python, что он должен искать имя в другом месте, а не назначать ему локально.

(Я считаю, что это поведение возникло в основном из-за оптимизации локальных пространств имен - без этого поведения виртуальной машине Python необходимо было бы выполнять как минимум три поиска имени каждый раз, когда новое имя назначается внутри функции (чтобы гарантировать, что имя не t уже существует на уровне модуля / встроенного модуля), что значительно замедлит очень распространенную операцию.)

Фактически вы не сохраняете глобальное значение в локальной переменной, а просто создаете локальную ссылку на тот же объект, на который ссылается ваша исходная глобальная ссылка. Помните, что почти все в Python - это имя, относящееся к объекту, и при обычной работе ничего не копируется.

Если вам не нужно было явно указывать, когда идентификатор должен ссылаться на предопределенную глобальную переменную, тогда вам, вероятно, придется явно указать, когда идентификатор является новой локальной переменной (например, с помощью чего-то вроде команды 'var' видно в JavaScript). Поскольку локальные переменные встречаются чаще, чем глобальные, в любой серьезной и нетривиальной системе, система Python в большинстве случаев имеет больше смысла.

У вас мог есть язык, который пытается угадать, используя глобальную переменную, если она существует, или создавая локальную переменную, если нет. Однако это было бы очень чревато ошибками. Например, импорт другого модуля может непреднамеренно ввести глобальную переменную с этим именем, изменив поведение вашей программы.

Python использует простую эвристику, чтобы решить, из какой области следует загружать переменную, между локальной и глобальной. Если имя переменной появляется слева от присвоения, но не объявлено глобальным, предполагается, что оно является локальным. Если он не отображается в левой части присвоения, предполагается, что он является глобальным.

>>> import dis
>>> def foo():
...     global bar
...     baz = 5
...     print bar
...     print baz
...     print quux
... 
>>> dis.disassemble(foo.func_code)
  3           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (baz)

  4           6 LOAD_GLOBAL              0 (bar)
              9 PRINT_ITEM          
             10 PRINT_NEWLINE       

  5          11 LOAD_FAST                0 (baz)
             14 PRINT_ITEM          
             15 PRINT_NEWLINE       

  6          16 LOAD_GLOBAL              1 (quux)
             19 PRINT_ITEM          
             20 PRINT_NEWLINE       
             21 LOAD_CONST               0 (None)
             24 RETURN_VALUE        
>>> 

Посмотрите, как baz, который появляется слева от присваивания в foo(), является единственной переменной LOAD_FAST.

При параллельном выполнении глобальные переменные могут привести к неожиданным результатам, если вы не понимаете, что происходит. Вот пример использования глобальной переменной в многопроцессорной обработке. Мы ясно видим, что каждый процесс работает со своей собственной копией переменной:

import multiprocessing
import os
import random
import sys
import time

def worker(new_value):
    old_value = get_value()
    set_value(random.randint(1, 99))
    print('pid=[{pid}] '
          'old_value=[{old_value:2}] '
          'new_value=[{new_value:2}] '
          'get_value=[{get_value:2}]'.format(
          pid=str(os.getpid()),
          old_value=old_value,
          new_value=new_value,
          get_value=get_value()))

def get_value():
    global global_variable
    return global_variable

def set_value(new_value):
    global global_variable
    global_variable = new_value

global_variable = -1

print('before set_value(), get_value() = [%s]' % get_value())
set_value(new_value=-2)
print('after  set_value(), get_value() = [%s]' % get_value())

processPool = multiprocessing.Pool(processes=5)
processPool.map(func=worker, iterable=range(15))

Выход:

before set_value(), get_value() = [-1]
after  set_value(), get_value() = [-2]
pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23]
pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42]
pid=[53970] old_value=[23] new_value=[ 4] get_value=[50]
pid=[53970] old_value=[50] new_value=[ 6] get_value=[14]
pid=[53971] old_value=[42] new_value=[ 5] get_value=[31]
pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44]
pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94]
pid=[53970] old_value=[14] new_value=[ 7] get_value=[21]
pid=[53971] old_value=[31] new_value=[ 8] get_value=[34]
pid=[53972] old_value=[44] new_value=[ 9] get_value=[59]
pid=[53973] old_value=[94] new_value=[10] get_value=[87]
pid=[53970] old_value=[21] new_value=[11] get_value=[21]
pid=[53971] old_value=[34] new_value=[12] get_value=[82]
pid=[53972] old_value=[59] new_value=[13] get_value=[ 4]
pid=[53973] old_value=[87] new_value=[14] get_value=[70]

Оказывается, ответ всегда прост.

Вот небольшой пример модуля с простым способом показать его в определении main:

def five(enterAnumber,sumation):
    global helper
    helper  = enterAnumber + sumation

def isTheNumber():
    return helper

Вот как это показать в определении main:

import TestPy

def main():
    atest  = TestPy
    atest.five(5,8)
    print(atest.isTheNumber())

if __name__ == '__main__':
    main()

Этот простой код работает именно так, и он будет выполняться. Я надеюсь, что это помогает.

В дополнение к уже существующим ответам и, чтобы сделать это более запутанным:

In Python, variables that are only referenced inside a function are implicitly global. If a variable is assigned a new value anywhere within the function’s body, it’s assumed to be a local. If a variable is ever assigned a new value inside the function, the variable is implicitly local, and you need to explicitly declare it as ‘global’.

Though a bit surprising at first, a moment’s consideration explains this. On one hand, requiring global for assigned variables provides a bar against unintended side-effects. On the other hand, if global was required for all global references, you’d be using global all the time. You’d have to declare as global every reference to a built-in function or to a component of an imported module. This clutter would defeat the usefulness of the global declaration for identifying side-effects.

Источник: Каковы правила для локальных и глобальных переменных в Python?.

Вы говорите, что нужно использовать такой метод:

globvar = 5

def f():
    var = globvar
    print(var)

f()  # Prints 5

Но лучше использовать глобальную переменную следующим образом:

globvar = 5
def f():
    global globvar
    print(globvar)
f()   #prints 5

Оба дают одинаковый результат.

Вам нужно ссылаться на глобальную переменную в каждой функции, которую вы хотите использовать.

Следующим образом:

var = "test"

def printGlobalText():
    global var #wWe are telling to explicitly use the global version
    var = "global from printGlobalText fun."
    print "var from printGlobalText: " + var

def printLocalText():
    #We are NOT telling to explicitly use the global version, so we are creating a local variable
    var = "local version from printLocalText fun"
    print "var from printLocalText: " + var

printGlobalText()
printLocalText()
"""
Output Result:
var from printGlobalText: global from printGlobalText fun.
var from printLocalText: local version from printLocalText
[Finished in 0.1s]
"""

Попробуй это:

def x1():
    global x
    x += 1
    print('x1: ', x)

def x2():
    global x
    x = x+1
    print('x2: ', x)

x = 5
print('x:  ', x)
x1()
x2()

# Output:
# x:   5
# x1:  6
# x2:  7

После и в качестве дополнения используйте файл, содержащий все глобальные переменные, все объявленные локально, а затем import as:

Файл initval.py:

Stocksin = 300
Prices = []

Файл getstocks.py:

import initval as iv

def getmystocks(): 
    iv.Stocksin = getstockcount()


def getmycharts():
    for ic in range(iv.Stocksin):

If I create a global variable in one function, how can I use that variable in another function?

Мы можем создать глобал с помощью следующей функции:

def create_global_variable():
    global global_variable # must declare it to be a global first
    # modifications are thus reflected on the module's global scope
    global_variable = 'Foo' 

Написание функции фактически не запускает ее код. Итак, мы вызываем функцию create_global_variable:

>>> create_global_variable()

Использование глобалов без изменений

Вы можете просто использовать его, если не ожидаете изменить объект, на который он указывает:

Например,

def use_global_variable():
    return global_variable + '!!!'

и теперь мы можем использовать глобальную переменную:

>>> use_global_variable()
'Foo!!!'

Модификация глобальной переменной изнутри функции

Чтобы указать глобальную переменную на другой объект, вам необходимо снова использовать ключевое слово global:

def change_global_variable():
    global global_variable
    global_variable = 'Bar'

Обратите внимание, что после написания этой функции код, фактически меняющий ее, все еще не запускается:

>>> use_global_variable()
'Foo!!!'

Итак, после вызова функции:

>>> change_global_variable()

мы видим, что глобальная переменная была изменена. Имя global_variable теперь указывает на 'Bar':

>>> use_global_variable()
'Bar!!!'

Обратите внимание, что «глобальный» в Python не является по-настоящему глобальным - он глобален только на уровне модуля. Таким образом, он доступен только функциям, написанным в модулях, в которых он является глобальным. Функции запоминают модуль, в котором они написаны, поэтому при экспорте в другие модули они по-прежнему ищут глобальные переменные в модуле, в котором они были созданы.

Локальные переменные с таким же именем

Если вы создадите локальную переменную с тем же именем, она затмит глобальную переменную:

def use_local_with_same_name_as_global():
    # bad name for a local variable, though.
    global_variable = 'Baz' 
    return global_variable + '!!!'

>>> use_local_with_same_name_as_global()
'Baz!!!'

Но использование этой неверно названной локальной переменной не меняет глобальную переменную:

>>> use_global_variable()
'Bar!!!'

Обратите внимание, что вам следует избегать использования локальных переменных с теми же именами, что и глобальные, если вы точно не знаете, что делаете, и у вас есть очень веская причина для этого. С такой причиной еще не сталкивался.

Мы получаем такое же поведение в классах

Следующий за комментарием спрашивает:

what to do if I want to create a global variable inside a function inside a class and want to use that variable inside another function inside another class?

Здесь я демонстрирую, что мы получаем то же поведение в методах, что и в обычных функциях:

class Foo:
    def foo(self):
        global global_variable
        global_variable = 'Foo'

class Bar:
    def bar(self):
        return global_variable + '!!!'

Foo().foo()

И сейчас:

>>> Bar().bar()
'Foo!!!'

Но я бы посоветовал вместо использования глобальных переменных использовать атрибуты класса, чтобы не загромождать пространство имен модуля. Также обратите внимание, что мы не используем здесь аргументы self - это могут быть методы класса (удобно, если изменить атрибут класса из обычного аргумента cls) или статические методы (без self или cls).

Запись в явные элементы глобального массива, по-видимому, не требует глобального объявления, хотя запись в него «оптом» имеет это требование:

import numpy as np

hostValue = 3.14159
hostArray = np.array([2., 3.])
hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]])

def func1():
    global hostValue    # mandatory, else local.
    hostValue = 2.0

def func2():
    global hostValue    # mandatory, else UnboundLocalError.
    hostValue += 1.0

def func3():
    global hostArray    # mandatory, else local.
    hostArray = np.array([14., 15.])

def func4():            # no need for globals
    hostArray[0] = 123.4

def func5():            # no need for globals
    hostArray[1] += 1.0

def func6():            # no need for globals
    hostMatrix[1][1] = 12.

def func7():            # no need for globals
    hostMatrix[0][0] += 0.33

func1()
print "After func1(), hostValue = ", hostValue
func2()
print "After func2(), hostValue = ", hostValue
func3()
print "After func3(), hostArray = ", hostArray
func4()
print "After func4(), hostArray = ", hostArray
func5()
print "After func5(), hostArray = ", hostArray
func6()
print "After func6(), hostMatrix = \n", hostMatrix
func7()
print "After func7(), hostMatrix = \n", hostMatrix

Если у вас есть локальная переменная с тем же именем, вы можете использовать globals() функция.

globals()['your_global_var'] = 42

Ссылка на пространство имен класса, в котором вы хотите, чтобы изменение отображалось.

В этом примере бегун использует Максимум из файла config. Я хочу, чтобы мой тест изменил значение Максимум, когда его использует бегун.

основной / config.py

max = 15000

основной / runner.py

from main import config
def check_threads():
    return max < thread_count 

тесты / runner_test.py

from main import runner                # <----- 1. add file
from main.runner import check_threads
class RunnerTest(unittest):
   def test_threads(self):
       runner.max = 0                  # <----- 2. set global 
       check_threads()

Я добавляю это, поскольку не видел этого ни в одном из других ответов, и это может быть полезно для кого-то, кто борется с чем-то похожим. Функция globals() возвращает изменяемый глобальный словарь символов, в котором вы можете «волшебным образом» сделать данные доступными для остальной части вашего кода. Например:

from pickle import load
def loaditem(name):
    with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile:
        globals()[name] = load(openfile)
    return True

а также

from pickle import dump
def dumpfile(name):
    with open(name+".dat", "wb") as outfile:
        dump(globals()[name], outfile)
    return True

Просто позволит вам выгружать / загружать переменные из и в глобальное пространство имен. Супер удобно, без суеты. Уверен, что это только Python 3.

Глобалы в порядке - кроме многопроцессорности

Глобалы в связи с многопроцессорностью на разных платформах / средах поскольку Windows / Mac OS с одной стороны и Linux - с другой, доставляют много хлопот.

Я покажу вам это на простом примере, указав на проблему, с которой я столкнулся некоторое время назад.

Если вы хотите понять, почему в Windows / MacO и Linux все по-другому, вы нужно знать, что механизм по умолчанию для запуска нового процесса на ...

• Windows / MacOs - это `` порождение ''
• Linux - это вилка

Они разные в распределении памяти и инициализации ... (но я не буду вдаваться в подробности. здесь).

Давайте посмотрим на проблему / пример ...

import multiprocessing

counter = 0

def do(task_id):
    global counter
    counter +=1
    print(f'task {task_id}: counter = {counter}')

if __name__ == '__main__':

    pool = multiprocessing.Pool(processes=4)
    task_ids = list(range(4))
    pool.map(do, task_ids)

Окна

Если вы запустите это в Windows (и, я полагаю, в MacOS тоже), вы получите следующий результат ...

task 0: counter = 1
task 1: counter = 2
task 2: counter = 3
task 3: counter = 4

Linux

Если вы запустите это в Linux, вы получите следующее.

task 0: counter = 1
task 1: counter = 1
task 2: counter = 1
task 3: counter = 1

Есть 2 способа объявить переменную глобальной:

1. назначить переменную внутри функций и использовать глобальную строку

def declare_a_global_variable():
    global global_variable_1
    global_variable_1 = 1

# Note to use the function to global variables
declare_a_global_variable() 

2. назначить переменную вне функций:

global_variable_2 = 2

Теперь мы можем использовать эти объявленные глобальные переменные в других функциях:

def declare_a_global_variable():
    global global_variable_1
    global_variable_1 = 1

# Note to use the function to global variables
declare_a_global_variable() 
global_variable_2 = 2

def print_variables():
    print(global_variable_1)
    print(global_variable_2)
print_variables() # prints 1 & 2

Примечание 1:

Если вы хотите изменить глобальную переменную внутри другой функции, такой как update_variables(), вы должны использовать глобальную строку в этой функции перед назначением переменной:

global_variable_1 = 1
global_variable_2 = 2

def update_variables():
    global global_variable_1
    global_variable_1 = 11
    global_variable_2 = 12 # will update just locally for this function

update_variables()
print(global_variable_1) # prints 11
print(global_variable_2) # prints 2

Заметка 2:

Существует исключение для примечания 1 для переменных списка и словаря без использования глобальной строки внутри функции:

# declaring some global variables
variable = 'peter'
list_variable_1 = ['a','b']
list_variable_2 = ['c','d']

def update_global_variables():
    """without using global line"""
    variable = 'PETER' # won't update in global scope
    list_variable_1 = ['A','B'] # won't update in global scope
    list_variable_2[0] = 'C' # updated in global scope surprisingly this way
    list_variable_2[1] = 'D' # updated in global scope surprisingly this way

update_global_variables()

print('variable is: %s'%variable) # prints peter
print('list_variable_1 is: %s'%list_variable_1) # prints ['a', 'b']
print('list_variable_2 is: %s'%list_variable_2) # prints ['C', 'D']