從模塊B讀取和寫入模塊A中的變量

Question

需要一個解決方案或解決方法來從moduleB讀取和寫入moduleA中的變量。下面是代碼：

moduleA

import moduleB 

variable = 10 

def changeVariable(): 
    global variable 
    variable = 20 

def main(): 
    print("From moduleA, variable =", variable, " before change.") 
    moduleB.main() 
    print("From moduleA, variable =", variable, " after change.") 

if __name__ == "__main__": 
    main() 

moduleB

import moduleA 

def main(): 
    print("From moduleB, variable =", moduleA.variable, " before change.") 
    moduleA.variable = 20 # Try 1 
    moduleA.changeVariable() # Try 2 
    print("From moduleB, variable =", moduleA.variable, " after change.") 

if __name__ == "__main__": 
    main() 

當運行moduleA我們得到：

• 從moduleA，改變之前變量= 10。
• 從moduleB開始，變化前的變量= 10。
• 從moduleB，變量後變量= 20。
• 來自moduleA，變化後變量= 10。

---

下面是使用靜態變量另一個例子：

moduleAA

import moduleBB 

class AA: 
    variable = 0 

    @staticmethod 
    def changeVariable(): 
     AA.variable = 20 

def main(): 
    AA.variable = 10 
    print("From moduleAA, variable =", AA.variable, " before change.") 
    moduleBB.main() 
    print("From moduleAA, variable =", AA.variable, " after change.") 

if __name__ == "__main__": 
    main() 

moduleBB

import moduleAA 

def main(): 
    print("From moduleB, variable =", moduleAA.AA.variable, " before change.") 
    moduleAA.AA.variable = 20 # Try 1 
    moduleAA.AA.changeVariable() # Try 2 
    print("From moduleB, variable =", moduleAA.AA.variable, " after change.") 

if __name__ == "__main__": 
    main() 

當運行moduleAA時，我們得到：

• 從moduleAA，變量= 10之前改變。
• 從moduleBB開始，變化前的變量= 0。
• 從moduleBB，變量後變量= 20。
• 從moduleAA，變化後的變量= 10。

Answer 1

當您執行moduleA你運行它作爲一個腳本 - 基本上是一個與__main__名稱模塊，而不是一個「正常」的模塊，這就是它如何被加載。如果你一開始就看sys.modules（在你導入moduleB之前），你不會在那裏找到你的moduleA，但是你會發現模塊__main__（它很快就會擁有variable的值爲10）。

然後當您導入moduleB，它進口moduleA - Python中試圖找到加載moduleA但沒有任何，所以它會嘗試從磁盤，瞧加載它！它會被加載，但這次是moduleA。 Python然後查找從moduleA導入的moduleB，並且由於它已經存在，所以儘管存在循環依賴關係（如果在代碼中有類似的東西 - 你做錯了），它也不會對此產生任何大驚小怪。

無論如何，因爲它現在加載爲moduleA，其if __name__ == "__main__":塊的計算結果爲false，因此不會引起任何額外的大驚小怪。moduleB繼續其執行，但它也不匹配它的if __name__ == "__main__":塊，因此它只是被加載並坐在那裏。

現在我們回到我們的moduleA__main__代表 - 其if __name__ == "__main__":塊計算結果爲真，那麼它所謂的main()功能，進而調用moduleB的main()功能，然後改變variable價值，但在moduleA，不在__main__。所以，現在當它回到__main__並且它試圖讀取它自己的variable值時，它得到10的不變版本。但是，如果您打印出：print(getattr(sys.modules["moduleA"], "variable"))，您會看到您的moduleB確實更改了moduleA的變量。

如果你真的想迫使main的變化，儘量讓你的moduleB，如：

import sys 

def main(): 
    moduleA = sys.modules["__main__"] # this is the executing `moduleA` in your case 
    print("From moduleB, variable =", moduleA.variable, " before change.") 
    moduleA.variable = 20 
    print("From moduleB, variable =", moduleA.variable, " after change.") 

if __name__ == "__main__": 
    main() 

這將，從moduleA運行測試的情況下，打印出：

('From moduleA, variable =', 10, ' before change.') 
('From moduleB, variable =', 10, ' before change.') 
('From moduleB, variable =', 20, ' after change.') 
('From moduleA, variable =', 20, ' after change.') 

那是什麼繼續這裏，而你的靜態變量示例也會發生同樣的情況 - 你始終將目標鎖定在你的moduleB的「錯誤」模塊中。無論哪種方式，請不要在任何生產代碼或其他開發人員最終不得不篡改您的代碼的情況下執行此操作 - 循環冗餘是所有事情都很好的禍根。