Итак, у меня есть два разных файла, несколько похожий на это:
file1.py
from file2 import *
foo = "bar";
test = SomeClass();
file2.py
class SomeClass :
def __init__ (self):
global foo;
print foo;
Однако я не могу заставить file2 распознавать переменные из файла1, даже если он уже импортирован в файл1. Было бы очень полезно, если это возможно в некотором роде.
Импортирование file2 в file1.py делает глобальные (то есть уровни модуля) именами, привязанными к file2 доступными для следующего кода в file1 - единственное такое имя SomeClass. Он не делает обратное: имена, определенные в file1, не доступны для кода в file2, когда file1 импортирует file2. Это было бы так, даже если вы импортировали правильный путь (import file2, как правильно рекомендует @nate), а не ужасным, ужасным способом, которым вы это делаете (если все под солнцем забывают о существовании конструкции from ... import *, жизнь была бы намного лучше для всех).
По-видимому, вы хотите сделать глобальные имена, определенные в file1 доступными для кода в file2 и наоборот. Это называется "циклической зависимостью" и является ужасной идеей (в Python или где-то еще в этом отношении).
Таким образом, вместо того, чтобы показывать вам невероятно хрупкие, часто недостижимые хаки для достижения (некоторого подобия) циклической зависимости в Python, я бы скорее обсудил много отличных способов, которыми вы можете избегать такая страшная структура.
Например, вы можете поместить глобальные имена, которые должны быть доступны для обоих модулей в третьем модуле (например, file3.py, чтобы продолжить последовательность имен;-) и импортировать этот третий модуль в каждый из двух других (import file3 в file1 и file2, а затем используйте file3.foo и т.д., то есть квалифицированные имена, для доступа или установки этих глобальных имен из одного или обоих других модулей, не barenames).
Конечно, все больше и больше конкретной помощи можно было бы предложить, если бы вы разъяснили (отредактировав свой Q) именно то, почему вы считаете, что вам нужна циклическая зависимость (просто одно простое предсказание: независимо от того, что заставляет вас думать, что вам нужна циклическая зависимость, вы ошибаетесь, -).
from file2 import * создает копии. Вы хотите сделать это:
import file2
print file2.foo
print file2.SomeClass()
Когда вы пишете
from file2 import *
он фактически копирует имена, определенные в file2, в пространство имен file1. Поэтому, если вы переназначите эти имена в file1, написав
foo = "bar"
например, это сделает только это изменение в file1, а не file2. Обратите внимание, что если вы должны были изменить атрибут foo, скажем, сделав
foo.blah = "bar"
то это изменение будет отражено в file2, потому что вы изменяете существующий объект, на который ссылается имя foo, не заменяя его новым объектом.
Вы можете получить необходимый эффект, выполнив это в file1.py:
import file2
file2.foo = "bar"
test = SomeClass()
(обратите внимание, что вы должны удалить from foo import *), хотя я бы предложил тщательно подумать о том, действительно ли вам нужно это делать. Не очень распространено то, что изменение одной переменной модуля изнутри другого модуля действительно оправдано.
global является немного неправильным в Python, module_namespace будет более описательным.
Полноценное имя foo равно file1.foo, и глобальное утверждение лучше избегать, поскольку обычно есть лучшие способы выполнить то, что вы хотите сделать. (Я не могу сказать, что вы хотите сделать из своего примера игрушек.)
Просто поместите свои глобальные переменные в файл, который вы импортируете.
Все приведенные ответы неверны. Невозможно глобализовать переменную внутри функции в отдельном файле.