__getattr__ บนโมดูล

จะใช้การเทียบเท่า__getattr__กับคลาสบนโมดูลได้อย่างไร?

ตัวอย่าง

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

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

# note this function is intentionally on the module, and not the class above
def __getattr__(mod, name):
    return getattr(A(), name)

if __name__ == "__main__":
    # i hope here to have my __getattr__ function above invoked, since
    # salutation does not exist in the current namespace
    salutation("world")

ซึ่งจะช่วยให้:

matt@stanley:~/Desktop$ python getattrmod.py 
Traceback (most recent call last):
  File "getattrmod.py", line 9, in <module>
    salutation("world")
NameError: name 'salutation' is not defined

เมื่อไม่นานมานี้ Guido ได้ประกาศว่าการค้นหาวิธีการพิเศษทั้งหมดในคลาสสไตล์ใหม่ข้าม__getattr__และ__getattribute__ . วิธีการ Dunder เคยทำงานร่วมกับโมดูล - คุณสามารถยกตัวอย่างเช่นการใช้โมดูลเป็นผู้จัดการบริบทโดยเพียงแค่การกำหนด__enter__และ__exit__ก่อนเทคนิคผู้ยากจน

เมื่อเร็ว ๆ นี้คุณลักษณะทางประวัติศาสตร์บางอย่างได้กลับมาอีกครั้งโมดูล__getattr__ในหมู่พวกเขาและดังนั้นการแฮ็กที่มีอยู่ (โมดูลที่แทนที่ตัวเองด้วยคลาสในsys.modulesเวลานำเข้า) จึงไม่จำเป็นอีกต่อไป

ใน Python 3.7+ คุณใช้วิธีเดียวที่ชัดเจน ในการปรับแต่งการเข้าถึงแอตทริบิวต์บนโมดูลให้กำหนด__getattr__ฟังก์ชันที่ระดับโมดูลซึ่งควรยอมรับหนึ่งอาร์กิวเมนต์ (ชื่อของแอตทริบิวต์) และส่งคืนค่าที่คำนวณหรือเพิ่มAttributeError:

# my_module.py

def __getattr__(name: str) -> Any:
    ...

นอกจากนี้ยังจะช่วยให้ตะขอเข้า "จาก" from my_module import whateverการนำเข้าเช่นคุณสามารถกลับมาสร้างแบบไดนามิกวัตถุสำหรับงบเช่น

ในบันทึกที่เกี่ยวข้องพร้อมกับ getattr โมดูลคุณอาจกำหนดฟังก์ชั่นในระดับโมดูลเพื่อตอบสนองต่อ__dir__ dir(my_module)ดูPEP 562สำหรับรายละเอียด

มีปัญหาพื้นฐานสองประการที่คุณพบที่นี่:

1. __xxx__ วิธีการจะถูกค้นหาในชั้นเรียนเท่านั้น
2. TypeError: can't set attributes of built-in/extension type 'module'

(1) หมายถึงวิธีการแก้ปัญหาใด ๆ ที่จะต้องติดตามด้วยว่าโมดูลใดถูกตรวจสอบมิฉะนั้นทุกโมดูลจะมีพฤติกรรมการแทนที่อินสแตนซ์ และ (2) หมายความว่า (1) เป็นไปไม่ได้ด้วยซ้ำ ... อย่างน้อยก็ไม่ใช่โดยตรง

โชคดีที่ sys.modules ไม่จู้จี้จุกจิกเกี่ยวกับสิ่งที่ไปที่นั่นดังนั้น wrapper จะใช้งานได้ แต่สำหรับการเข้าถึงโมดูลเท่านั้น (เช่นimport somemodule; somemodule.salutation('world')สำหรับการเข้าถึงโมดูลเดียวกันคุณต้องดึงวิธีการจากคลาสการทดแทนและเพิ่มลงในglobals()eiher ด้วย a วิธีการที่กำหนดเองในคลาส (ฉันชอบใช้.export()) หรือกับฟังก์ชันทั่วไป (เช่นที่ระบุไว้แล้วเป็นคำตอบ) สิ่งหนึ่งที่ควรคำนึงถึง: หาก Wrapper กำลังสร้างอินสแตนซ์ใหม่ทุกครั้งและโซลูชัน globals ไม่ใช่ คุณจบลงด้วยพฤติกรรมที่แตกต่างกันอย่างละเอียดโอ้และคุณไม่ได้ใช้ทั้งสองอย่างพร้อมกันไม่ว่าจะเป็นอย่างใดอย่างหนึ่ง

ปรับปรุง

จากGuido van Rossum :

มีการแฮ็กที่ใช้และแนะนำเป็นครั้งคราว: โมดูลสามารถกำหนดคลาสที่มีฟังก์ชันการทำงานที่ต้องการจากนั้นในตอนท้ายให้แทนที่ตัวเองใน sys.modules ด้วยอินสแตนซ์ของคลาสนั้น (หรือด้วยคลาสหากคุณยืนยัน แต่โดยทั่วไปมีประโยชน์น้อยกว่า) เช่น:

# module foo.py

import sys

class Foo:
    def funct1(self, <args>): <code>
    def funct2(self, <args>): <code>

sys.modules[__name__] = Foo()

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

ดังนั้นวิธีที่กำหนดไว้ในการบรรลุสิ่งที่คุณต้องการคือการสร้างคลาสเดียวในโมดูลของคุณและเมื่อการกระทำสุดท้ายของโมดูลแทนที่sys.modules[__name__]ด้วยอินสแตนซ์ของคลาสของคุณ - และตอนนี้คุณสามารถเล่นกับ__getattr__/ __setattr__/ ได้__getattribute__ตามต้องการ

หมายเหตุ 1 : หากคุณใช้ฟังก์ชันนี้สิ่งอื่นใดในโมดูลเช่นลูกโลกฟังก์ชันอื่น ๆ ฯลฯ จะสูญหายไปเมื่อทำการsys.modulesมอบหมายงานดังนั้นโปรดตรวจสอบให้แน่ใจว่าทุกสิ่งที่จำเป็นอยู่ในคลาสทดแทน

หมายเหตุ 2 : เพื่อสนับสนุนfrom module import *คุณต้อง__all__กำหนดไว้ในคลาส ตัวอย่างเช่น:

class Foo:
    def funct1(self, <args>): <code>
    def funct2(self, <args>): <code>
    __all__ = list(set(vars().keys()) - {'__module__', '__qualname__'})

ทั้งนี้ขึ้นอยู่กับรุ่นหลามของคุณอาจจะมีชื่ออื่น ๆ __all__ที่จะละเว้นจาก set()สามารถละเว้นถ้างูหลาม 2 เข้ากันได้ไม่จำเป็นต้อง

นี่เป็นการแฮ็ก แต่คุณสามารถรวมโมดูลด้วยคลาสได้:

class Wrapper(object):
  def __init__(self, wrapped):
    self.wrapped = wrapped
  def __getattr__(self, name):
    # Perform custom logic here
    try:
      return getattr(self.wrapped, name)
    except AttributeError:
      return 'default' # Some sensible default

sys.modules[__name__] = Wrapper(sys.modules[__name__])

เรามักจะไม่ทำแบบนั้น

สิ่งที่เราทำคือสิ่งนี้

class A(object):
....

# The implicit global instance
a= A()

def salutation( *arg, **kw ):
    a.salutation( *arg, **kw )

ทำไม? เพื่อให้สามารถมองเห็นอินสแตนซ์ส่วนกลางโดยนัยได้

ตัวอย่างเช่นดูที่randomโมดูลซึ่งสร้างอินสแตนซ์ส่วนกลางโดยปริยายเพื่อลดความซับซ้อนของกรณีการใช้งานที่คุณต้องการตัวสร้างตัวเลขสุ่มแบบ "ธรรมดา"

คล้ายกับสิ่งที่ @ Håvard S เสนอในกรณีที่ฉันต้องการใช้เวทมนตร์บางอย่างในโมดูล (เช่น__getattr__) ฉันจะกำหนดคลาสใหม่ที่สืบทอดมาจากtypes.ModuleTypeและใส่สิ่งนั้นเข้าไปsys.modules(อาจจะแทนที่โมดูลที่กำหนดแบบกำหนดเองของฉันModuleType)

ดู__init__.pyไฟล์หลักของWerkzeugสำหรับการใช้งานที่ค่อนข้างมีประสิทธิภาพ

นี่มันแฮ็ค แต่ ...

import types

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

    def farewell(self, greeting, accusative):
         print greeting, accusative

def AddGlobalAttribute(classname, methodname):
    print "Adding " + classname + "." + methodname + "()"
    def genericFunction(*args):
        return globals()[classname]().__getattribute__(methodname)(*args)
    globals()[methodname] = genericFunction

# set up the global namespace

x = 0   # X and Y are here to add them implicitly to globals, so
y = 0   # globals does not change as we iterate over it.

toAdd = []

def isCallableMethod(classname, methodname):
    someclass = globals()[classname]()
    something = someclass.__getattribute__(methodname)
    return callable(something)


for x in globals():
    print "Looking at", x
    if isinstance(globals()[x], (types.ClassType, type)):
        print "Found Class:", x
        for y in dir(globals()[x]):
            if y.find("__") == -1: # hack to ignore default methods
                if isCallableMethod(x,y):
                    if y not in globals(): # don't override existing global names
                        toAdd.append((x,y))


for x in toAdd:
    AddGlobalAttribute(*x)


if __name__ == "__main__":
    salutation("world")
    farewell("goodbye", "world")

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

จะไม่สนใจแอตทริบิวต์ทั้งหมดที่มี "__"

ฉันจะไม่ใช้สิ่งนี้ในรหัสการผลิต แต่ควรช่วยให้คุณเริ่มต้นได้

นี่คือผลงานที่ต่ำต้อยของฉันเอง - การปรุงแต่งเล็กน้อยของคำตอบที่ได้คะแนนสูงของ @ Håvard S แต่ชัดเจนกว่าเล็กน้อย (ดังนั้นอาจเป็นที่ยอมรับสำหรับ @ S.Lott แม้ว่าอาจจะไม่ดีพอสำหรับ OP):

import sys

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

class Wrapper(object):
    def __init__(self, wrapped):
        self.wrapped = wrapped

    def __getattr__(self, name):
        try:
            return getattr(self.wrapped, name)
        except AttributeError:
            return getattr(A(), name)

_globals = sys.modules[__name__] = Wrapper(sys.modules[__name__])

if __name__ == "__main__":
    _globals.salutation("world")

สร้างไฟล์โมดูลของคุณที่มีคลาสของคุณ นำเข้าโมดูล รันgetattrบนโมดูลที่คุณเพิ่งนำเข้า คุณสามารถนำเข้าแบบไดนามิกโดยใช้__import__และดึงโมดูลจาก sys.modules

นี่คือโมดูลของคุณsome_module.py:

class Foo(object):
    pass

class Bar(object):
    pass

และในโมดูลอื่น:

import some_module

Foo = getattr(some_module, 'Foo')

ทำสิ่งนี้แบบไดนามิก:

import sys

__import__('some_module')
mod = sys.modules['some_module']
Foo = getattr(mod, 'Foo')