การมองเห็นตัวแปรส่วนกลางในโมดูลที่นำเข้า

ฉันได้พบกับโมดูลการนำเข้ากำแพงในสคริปต์ Python ฉันจะพยายามอย่างดีที่สุดเพื่ออธิบายข้อผิดพลาดเหตุใดฉันจึงพบปัญหาและเหตุใดฉันจึงผูกแนวทางเฉพาะนี้เพื่อแก้ปัญหาของฉัน (ซึ่งฉันจะอธิบายในไม่กี่วินาที):

สมมติว่าฉันมีโมดูลที่ฉันได้กำหนดฟังก์ชัน / คลาสยูทิลิตี้บางอย่างซึ่งอ้างถึงเอนทิตีที่กำหนดไว้ในเนมสเปซที่จะนำเข้าโมดูลเสริมนี้ (ให้ "a" เป็นเอนทิตีดังกล่าว):

โมดูล 1:

def f():
    print a

จากนั้นฉันก็มีโปรแกรมหลักโดยที่ "a" ถูกกำหนดซึ่งฉันต้องการนำเข้ายูทิลิตี้เหล่านั้น:

import module1
a=3
module1.f()

การดำเนินการโปรแกรมจะทำให้เกิดข้อผิดพลาดต่อไปนี้:

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

มีการถามคำถามที่คล้ายกันในอดีต (เมื่อสองวันก่อน d'uh) และมีการแนะนำวิธีแก้ปัญหาหลายวิธี แต่ฉันไม่คิดว่าสิ่งเหล่านี้ตรงกับความต้องการของฉัน นี่คือบริบทเฉพาะของฉัน:

ฉันกำลังพยายามสร้างโปรแกรม Python ที่เชื่อมต่อกับเซิร์ฟเวอร์ฐานข้อมูล MySQL และแสดง / แก้ไขข้อมูลด้วย GUI เพื่อความสะอาดฉันได้กำหนดฟังก์ชันที่เกี่ยวข้องกับ MySQL เสริม / ยูทิลิตี้ไว้ในไฟล์แยกต่างหาก อย่างไรก็ตามพวกเขาทั้งหมดมีตัวแปรทั่วไปซึ่งฉันเคยกำหนดไว้ในโมดูลยูทิลิตี้และเป็นเคอร์เซอร์วัตถุจากโมดูล MySQLdb ฉันรู้ในภายหลังว่าวัตถุเคอร์เซอร์ (ซึ่งใช้สื่อสารกับเซิร์ฟเวอร์ db) ควรถูกกำหนดไว้ในโมดูลหลักเพื่อให้ทั้งโมดูลหลักและสิ่งใดก็ตามที่นำเข้ามาในนั้นสามารถเข้าถึงวัตถุนั้นได้

ผลลัพธ์สุดท้ายจะเป็นดังนี้:

utilities_module.py:

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

และโมดูลหลักของฉัน:

program.py:

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

จากนั้นทันทีที่ฉันพยายามเรียกใช้ฟังก์ชันยูทิลิตี้ใด ๆ มันจะทำให้เกิดข้อผิดพลาด "global name not defined" ดังกล่าวข้างต้น

ข้อเสนอแนะเฉพาะคือให้มีคำสั่ง "from program import cur" ในไฟล์ยูทิลิตี้เช่นนี้:

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 *

แต่นั่นคือการนำเข้าแบบวนรอบหรืออะไรทำนองนั้นและบรรทัดล่างสุดก็ขัดข้องเช่นกัน ดังนั้นคำถามของฉันคือ:

ฉันจะทำให้วัตถุ "cur" ที่กำหนดไว้ในโมดูลหลักปรากฏแก่ฟังก์ชันเสริมที่นำเข้ามาในนรกได้อย่างไร

ขอขอบคุณที่สละเวลาและขออภัยอย่างสุดซึ้งหากมีการโพสต์วิธีแก้ปัญหาไว้ที่อื่น ฉันไม่สามารถหาคำตอบได้ด้วยตัวเองและฉันไม่มีกลเม็ดอื่น ๆ ในหนังสือของฉัน

Globals ใน Python เป็นโมดูลทั่วโลกไม่ใช่ในทุกโมดูล (หลายคนสับสนในเรื่องนี้เพราะใน C พูดว่า global เหมือนกันในทุกไฟล์การนำไปใช้งานเว้นแต่คุณจะระบุไว้อย่างชัดเจนstatic)

มีหลายวิธีในการแก้ปัญหานี้ขึ้นอยู่กับกรณีการใช้งานจริงของคุณ

ก่อนที่จะไปตามเส้นทางนี้ให้ถามตัวเองก่อนว่าสิ่งนี้จำเป็นต้องเกิดขึ้นทั่วโลกจริงๆหรือไม่ บางทีคุณอาจต้องการคลาสโดยใช้fเป็นวิธีอินสแตนซ์มากกว่าแค่ฟังก์ชั่นฟรี? จากนั้นคุณสามารถทำสิ่งนี้:

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

หากคุณต้องการ global จริงๆ แต่มีไว้เพื่อใช้โดยmodule1ตั้งค่าในโมดูลนั้น

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

ในทางกลับกันหากaมีการแชร์โดยโมดูลจำนวนมากให้วางไว้ที่อื่นและให้ทุกคนนำเข้า:

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

…และใน module1.py:

import shared_stuff
def f():
    print shared_stuff.a

อย่าใช้fromการนำเข้าเว้นแต่ว่าตัวแปรจะเป็นค่าคงที่ from shared_stuff import aจะสร้างใหม่aตัวแปรเริ่มต้นกับสิ่งที่shared_stuff.aเรียกว่าในช่วงเวลาของการนำเข้าและใหม่นี้ตัวแปรจะไม่ได้รับผลกระทบจากการที่ได้รับมอบหมายไปashared_stuff.a

หรือในกรณีที่เกิดขึ้นได้ยากที่คุณจำเป็นต้องใช้งานได้ทั่วโลกอย่างแท้จริงเช่นในตัวให้เพิ่มลงในโมดูลในตัว รายละเอียดที่แน่นอนแตกต่างกันระหว่าง Python 2.x และ 3.x ใน 3.x มันทำงานดังนี้:

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

ในการแก้ปัญหาชั่วคราวคุณสามารถพิจารณาการตั้งค่าตัวแปรสภาพแวดล้อมในเลเยอร์ภายนอกเช่นนี้

main.py:

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

mymodule.py:

import os

myval = None
if 'MYVAL' in os.environ:
    myval = os.environ['MYVAL']

เพื่อความระมัดระวังเป็นพิเศษให้จัดการกรณีที่ไม่ได้กำหนด MYVAL ไว้ในโมดูล

ฟังก์ชั่นใช้ Globals ของโมดูลมันเป็นที่กำหนดไว้ใน. แทนการตั้งค่าตัวอย่างเช่นคุณควรจะตั้งค่าa = 3 module1.a = 3ดังนั้นถ้าคุณต้องการcurใช้ได้เป็นในระดับโลกชุดutilities_moduleutilities_module.cur

ทางออกที่ดีกว่า: อย่าใช้ globals ส่งผ่านตัวแปรที่คุณต้องการไปยังฟังก์ชันที่ต้องการหรือสร้างคลาสเพื่อรวมข้อมูลทั้งหมดเข้าด้วยกันและส่งผ่านไปเมื่อเริ่มต้นอินสแตนซ์

โพสต์นี้เป็นเพียงการสังเกตพฤติกรรม Python ที่ฉันพบ บางทีคำแนะนำที่คุณอ่านด้านบนอาจไม่ได้ผลสำหรับคุณหากคุณทำสิ่งเดียวกับที่ฉันทำด้านล่าง

กล่าวคือฉันมีโมดูลที่มีตัวแปรส่วนกลาง / ที่ใช้ร่วมกัน (ตามที่แนะนำข้างต้น):

#sharedstuff.py

globaltimes_randomnode=[]
globalist_randomnode=[]

จากนั้นฉันมีโมดูลหลักที่นำเข้าสิ่งที่แชร์ด้วย:

import sharedstuff as shared

และโมดูลอื่น ๆ ที่เติมอาร์เรย์เหล่านี้จริง สิ่งเหล่านี้เรียกโดยโมดูลหลัก เมื่อออกจากโมดูลอื่น ๆ เหล่านี้ฉันสามารถเห็นได้อย่างชัดเจนว่ามีการเติมอาร์เรย์ แต่เมื่ออ่านย้อนกลับไปในโมดูลหลักกลับว่างเปล่า สิ่งนี้ค่อนข้างแปลกสำหรับฉัน (ฉันยังใหม่กับ Python) อย่างไรก็ตามเมื่อฉันเปลี่ยนวิธีนำเข้า sharedstuff.py ในโมดูลหลักเป็น:

from globals import *

มันใช้งานได้ (อาร์เรย์ถูกเติม)

แค่บอกว่า

วิธีแก้ปัญหาที่ง่ายที่สุดสำหรับปัญหานี้คือการเพิ่มฟังก์ชันอื่นภายในโมดูลที่จะเก็บเคอร์เซอร์ไว้ในตัวแปร global ไปยังโมดูล จากนั้นฟังก์ชันอื่น ๆ ทั้งหมดก็สามารถใช้งานได้เช่นกัน

โมดูล 1:

cursor = None

def setCursor(cur):
    global cursor
    cursor = cur

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

โปรแกรมหลัก:

import module1

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

เนื่องจาก globals เป็นโมดูลเฉพาะคุณสามารถเพิ่มฟังก์ชันต่อไปนี้ให้กับโมดูลที่นำเข้าทั้งหมดจากนั้นใช้เพื่อ:

• เพิ่มตัวแปรเอกพจน์ (ในรูปแบบพจนานุกรม) เป็นลูกโลกสำหรับตัวแปรเหล่านั้น
• โอนย้ายโมดูลหลักของคุณไปที่มัน

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

จากนั้นสิ่งที่คุณต้องส่งต่อไปยังลูกโลกปัจจุบันคือ:

โมดูลนำเข้า

module.addglobals (ลูกโลก ())

เนื่องจากฉันไม่เห็นมันในคำตอบข้างต้นฉันคิดว่าฉันจะเพิ่มวิธีแก้ปัญหาง่ายๆของฉันซึ่งเป็นเพียงการเพิ่มglobal_dictอาร์กิวเมนต์ให้กับฟังก์ชันที่ต้องใช้ globals ของโมดูลการโทรจากนั้นส่งคำสั่งไปยังฟังก์ชันเมื่อเรียก เช่น:

# external_module
def imported_function(global_dict=None):
    print(global_dict["a"])


# calling_module
a = 12
from external_module import imported_function
imported_function(global_dict=globals())

>>> 12

วิธี OOP ในการทำเช่นนี้คือทำให้โมดูลของคุณเป็นคลาสแทนที่จะเป็นชุดของวิธีการที่ไม่ถูกผูกไว้ จากนั้นคุณสามารถใช้__init__หรือวิธีการ setter เพื่อตั้งค่าตัวแปรจากผู้เรียกเพื่อใช้ในวิธีการของโมดูล