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

ฉันมีหลายชั้นเรียนซึ่งจะกลายเป็น singletons (กรณีใช้งานของฉันสำหรับคนตัดไม้ แต่นี่ไม่ใช่สิ่งสำคัญ) ฉันไม่ต้องการที่จะถ่วงเวลาเรียนหลายครั้งพร้อมกับเพิ่มชัยชนะเมื่อฉันสามารถสืบทอดหรือตกแต่ง

วิธีการที่ดีที่สุด:

วิธีที่ 1: มัณฑนากร

def singleton(class_):
    instances = {}
    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]
    return getinstance

@singleton
class MyClass(BaseClass):
    pass

ข้อดี

• มัณฑนากรเป็นสารเติมแต่งในลักษณะที่มักใช้งานง่ายกว่าการสืบทอดหลายแบบ

จุดด้อย

• ในขณะที่วัตถุที่สร้างขึ้นโดยใช้ MyClass () จะเป็นวัตถุซิงเกิลจริง MyClass เองนั้นเป็นฟังก์ชั่น aa ไม่ใช่คลาสดังนั้นคุณจึงไม่สามารถเรียกเมธอดคลาสได้ นอกจากนี้สำหรับm = MyClass(); n = MyClass(); o = type(n)();ตอนนั้นm == n && m != o && n != o

วิธีที่ 2: คลาสพื้นฐาน

class Singleton(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):
    pass

ข้อดี

• มันเป็นคลาสที่แท้จริง

จุดด้อย

• มรดกที่หลากหลาย - เอ๊ะ! __new__สามารถเขียนทับในระหว่างการสืบทอดจากชั้นฐานที่สอง? เราต้องคิดมากกว่าที่จำเป็น

วิธีที่ 3: metaclass

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

#Python2
class MyClass(BaseClass):
    __metaclass__ = Singleton

#Python3
class MyClass(BaseClass, metaclass=Singleton):
    pass

ข้อดี

• มันเป็นคลาสที่แท้จริง
• อัตโนมัติครอบคลุมมรดกอย่างน่าอัศจรรย์
• ใช้__metaclass__เพื่อจุดประสงค์ที่เหมาะสม (และทำให้ฉันตระหนักถึง)

จุดด้อย

• ยังมี .... บ้าง?

วิธีที่ 4: มัณฑนากรส่งคืนคลาสที่มีชื่อเดียวกัน

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class_, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w,
                                    class_).__new__(class_,
                                                    *args,
                                                    **kwargs)
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(BaseClass):
    pass

ข้อดี

• มันเป็นคลาสที่แท้จริง
• อัตโนมัติครอบคลุมมรดกอย่างน่าอัศจรรย์

จุดด้อย

• ไม่มีค่าใช้จ่ายสำหรับการสร้างคลาสใหม่แต่ละรายการหรือไม่ ที่นี่เรากำลังสร้างสองคลาสสำหรับแต่ละชั้นเรียนที่เราต้องการสร้างซิงเกิลตัน ในขณะนี้ใช้ได้ในกรณีของฉันฉันกังวลว่านี่อาจไม่ขยาย แน่นอนว่ามีเรื่องที่ถกเถียงกันอยู่ว่ามันง่ายเกินไปที่จะปรับขนาดรูปแบบนี้หรือไม่ ...
• ประเด็นของ_sealedคุณลักษณะคืออะไร
• ไม่สามารถเรียกวิธีการที่มีชื่อเดียวกันกับคลาสพื้นฐานที่ใช้super()เพราะจะเรียกคืน ซึ่งหมายความว่าคุณไม่สามารถปรับแต่งและไม่สามารถซับคลาสคลาสที่ตอบสนองความต้องการให้คุณโทรได้ถึง__new____init__

วิธีที่ 5: โมดูล

ไฟล์โมดูล singleton.py

ข้อดี

• เรียบง่ายดีกว่าซับซ้อน

จุดด้อย

ใช้ Metaclass

ฉันอยากจะแนะนำวิธีที่ # 2แต่คุณควรใช้metaclassดีกว่าคลาสพื้นฐาน นี่คือตัวอย่างการใช้งาน:

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Logger(object):
    __metaclass__ = Singleton

หรือใน Python3

class Logger(metaclass=Singleton):
    pass

ถ้าคุณต้องการเรียกใช้__init__ทุกครั้งที่เรียกคลาสเพิ่ม

        else:
            cls._instances[cls].__init__(*args, **kwargs)

กับคำสั่งในifSingleton.__call__

คำสองสามคำเกี่ยวกับ metaclasses metaclass เป็นชั้นของชั้น ; นั่นคือชั้นเรียนเป็นตัวอย่างของ metaclass คุณจะพบ metaclass type(obj)ของวัตถุในหลามกับ typeปกติการเรียนแบบใหม่เป็นประเภท Loggerในรหัสข้างต้นจะเป็นชนิดclass 'your_module.Singleton'เช่นเดียวกับ (เท่านั้น) ตัวอย่างของการจะเป็นประเภทLogger class 'your_module.Logger'เมื่อคุณเรียกคนตัดไม้กับLogger()งูใหญ่ครั้งแรกถาม metaclass ของLogger, Singletonสิ่งที่ต้องทำทำให้การสร้างอินสแตนซ์ที่จะจองไว้แล้ว กระบวนการนี้จะเป็นเช่นเดียวกับงูหลามถามชั้นว่าจะทำอย่างไรโทรเมื่อคุณอ้างอิงหนึ่งของคุณลักษณะของมันโดยการทำ__getattr__myclass.attribute

เมตาคลาสจะเป็นตัวตัดสินความหมายของคลาสและวิธีการใช้นิยามนั้น ดูตัวอย่างhttp://code.activestate.com/recipes/498149/ซึ่งสร้าง C-style structใน Python โดยใช้ metaclasses เป็นหลัก เธรดอะไรบ้าง (คอนกรีต) ใช้กรณีสำหรับ metaclasses? ยังมีตัวอย่างบางอย่างโดยทั่วไปดูเหมือนว่าจะเกี่ยวข้องกับการเขียนโปรแกรมเชิงประกาศโดยเฉพาะอย่างยิ่งที่ใช้ใน ORM

ในสถานการณ์เช่นนี้หากคุณใช้วิธีที่ # 2และคลาสย่อยกำหนด__new__วิธีการนั้นจะถูกดำเนินการทุกครั้งที่คุณโทรSubClassOfSingleton()- เพราะมีหน้าที่รับผิดชอบในการเรียกวิธีการที่ส่งกลับอินสแตนซ์ที่เก็บไว้ ด้วย metaclass มันจะถูกเรียกเพียงครั้งเดียวเมื่อมีการสร้างอินสแตนซ์เท่านั้น คุณต้องการปรับแต่งความหมายในการเรียกชั้นเรียนซึ่งกำหนดโดยประเภทของมัน

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

ซิงเกิลตันของคุณไม่จำเป็นต้องมีการสืบทอดหลายอัน (เนื่องจาก metaclass ไม่ใช่คลาสพื้นฐาน) แต่สำหรับคลาสย่อยของคลาสที่สร้างขึ้นซึ่งใช้การสืบทอดหลายคลาสคุณจำเป็นต้องตรวจสอบให้แน่ใจว่าคลาส singleton เป็นคลาสแรก / ซ้ายสุดที่มี metaclass ที่กำหนดใหม่__call__สิ่งนี้ไม่น่าจะเป็นปัญหา อินสแตนซ์ของ dict ไม่อยู่ในเนมสเปซของอินสแตนซ์ดังนั้นจะไม่เขียนทับมันโดยไม่ตั้งใจ

นอกจากนี้คุณยังจะได้ทราบว่ารูปแบบเดี่ยวละเมิด "Single รับผิดชอบหลักการ" - แต่ละชั้นควรทำเพียงสิ่งเดียว ด้วยวิธีนี้คุณไม่ต้องกังวลกับการเลอะสิ่งใดสิ่งหนึ่งรหัสทำถ้าคุณต้องการเปลี่ยนอีกเพราะพวกเขาแยกและห่อหุ้ม การใช้งาน metaclass ผ่านการทดสอบนี้ metaclass เป็นผู้รับผิดชอบในการบังคับใช้รูปแบบและชั้นที่สร้างขึ้นและ subclasses ไม่จำเป็นต้องตระหนักว่าพวกเขาจะ singletons วิธี # 1ล้มเหลวในการทดสอบนี้ตามที่คุณบันทึกไว้ด้วย "MyClass เองเป็นฟังก์ชัน aa ไม่ใช่คลาสดังนั้นคุณจึงไม่สามารถเรียกเมธอดคลาสได้

Python 2 และ 3 รองรับเวอร์ชั่น

การเขียนสิ่งที่ใช้ได้ทั้ง Python2 และ 3 จำเป็นต้องใช้โครงร่างที่ซับซ้อนกว่าเล็กน้อย ตั้งแต่ metaclasses มักจะ subclasses ชนิดtypeก็เป็นไปได้ที่จะใช้อย่างใดอย่างหนึ่งแบบไดนามิกสร้างชั้นฐานตัวกลางในเวลาทำงานกับมันเป็น metaclass และจากนั้นใช้ที่เป็น BaseClass ของประชาชนSingletonชั้นฐาน เป็นการยากที่จะอธิบายมากกว่าที่จะทำดังที่แสดงไว้ถัดไป:

# works in Python 2 & 3
class _Singleton(type):
    """ A metaclass that creates a Singleton base class when called. """
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(_Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(_Singleton('SingletonMeta', (object,), {})): pass

class Logger(Singleton):
    pass

ด้านประชดของวิธีนี้คือมันใช้ subclassing เพื่อใช้ metaclass ข้อดีอย่างหนึ่งที่เป็นไปได้ว่าแตกต่างกับ metaclass บริสุทธิ์จะกลับมาisinstance(inst, Singleton)True

ราชทัณฑ์

ในหัวข้ออื่นคุณอาจสังเกตเห็นแล้ว แต่การใช้งานคลาสพื้นฐานในโพสต์ต้นฉบับของคุณผิด _instancesจำเป็นต้องมีการอ้างอิงในชั้นเรียนคุณจำเป็นต้องใช้super()หรือคุณกำลังเรียกซ้ำและ__new__จริงๆแล้วเป็นวิธีแบบคงที่คุณต้องผ่านชั้นเรียนไปยังไม่ใช่วิธีชั้นเรียนเนื่องจากชั้นจริงยังไม่ได้สร้างขึ้นเมื่อมัน ถูกเรียก. สิ่งเหล่านี้ทั้งหมดจะเป็นจริงสำหรับการใช้งาน metaclass เช่นกัน

class Singleton(object):
  _instances = {}
  def __new__(class_, *args, **kwargs):
    if class_ not in class_._instances:
        class_._instances[class_] = super(Singleton, class_).__new__(class_, *args, **kwargs)
    return class_._instances[class_]

class MyClass(Singleton):
  pass

c = MyClass()

มัณฑนากรคืน Class A

ตอนแรกฉันเขียนความคิดเห็น แต่มันยาวเกินไปฉันจะเพิ่มที่นี่ วิธีที่ # 4ดีกว่ารุ่นมัณฑนากรอื่น ๆ แต่มันเป็นโค้ดมากกว่าที่จำเป็นสำหรับซิงเกิลตันและไม่ชัดเจนว่ามันทำอะไร

ปัญหาหลักเกิดจากคลาสเนื่องจากเป็นคลาสพื้นฐานของตัวเอง อันดับแรกมันไม่แปลกที่การมีคลาสเป็นคลาสย่อยของคลาสที่เกือบเหมือนกันโดยมีชื่อเดียวกันที่มีอยู่ใน__class__แอตทริบิวต์เท่านั้น นอกจากนี้ยังหมายความว่าคุณไม่สามารถกำหนดวิธีการใด ๆ ที่เรียกใช้วิธีการที่มีชื่อเดียวกันในคลาสพื้นฐานของพวกเขาด้วยsuper()เพราะพวกเขาจะเรียกคืน นี่หมายความว่าคลาสของคุณไม่สามารถปรับแต่งได้__new__และไม่สามารถสืบทอดมาจากคลาสใด ๆ ที่จำเป็นต้อง__init__เรียกใช้

ควรใช้รูปแบบซิงเกิลเมื่อใด

กรณีการใช้งานของคุณเป็นหนึ่งในตัวอย่างที่ดีกว่าของความต้องการใช้ซิงเกิล คุณพูดในความคิดเห็นอย่างใดอย่างหนึ่งว่า "สำหรับฉันการบันทึกเป็นเรื่องปกติสำหรับ Singletons" คุณอย่างถูกต้อง

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

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

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

นี่คือคำพูดจากhttp://googletesting.blogspot.com/2008/08/root-cause-cause-of-singletons.html :

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

Singletons ชนิดอื่นซึ่งเป็นแบบกึ่งยอมรับได้คือแบบที่ไม่มีผลต่อการเรียกใช้โค้ดของคุณพวกเขาไม่มี "ผลข้างเคียง" การบันทึกเป็นตัวอย่างที่สมบูรณ์แบบ มันเต็มไปด้วย Singletons และ global state เป็นที่ยอมรับได้ (เพราะจะไม่ทำให้คุณเจ็บ) เนื่องจากแอปพลิเคชันของคุณไม่ทำงานแตกต่างกันไม่ว่าจะเปิดใช้งานตัวบันทึกที่กำหนดหรือไม่ก็ตาม ข้อมูลในที่นี้จะไหลทางเดียว: จากใบสมัครของคุณไปยังตัวบันทึก แม้ว่าผู้บันทึกคิดว่าเป็นสถานะทั่วโลกเนื่องจากไม่มีข้อมูลไหลจากตัวบันทึกลงในแอปพลิเคชันของคุณตัวบันทึกสามารถยอมรับได้ คุณควรฉีด logger ของคุณถ้าคุณต้องการให้การทดสอบยืนยันว่ามีบางสิ่งที่ถูกบันทึก แต่โดยทั่วไปแล้ว Loggers จะไม่เป็นอันตรายแม้จะเต็มไปด้วยสถานะ

class Foo(object):
     pass

some_global_variable = Foo()

โมดูลจะถูกนำเข้าเพียงครั้งเดียวทุกอย่างอื่นจะคิด อย่าใช้ซิงเกิลตันและพยายามอย่าใช้กลม

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

คุณอาจไม่จำเป็นต้องใช้ซิงเกิลตันใน Python เพียงแค่กำหนดข้อมูลและฟังก์ชั่นทั้งหมดของคุณในโมดูลและคุณมีเดือยเดี่ยว

ถ้าคุณต้องมีชั้นเรียนเดี่ยวจริงๆแล้วฉันจะไปกับ:

class My_Singleton(object):
    def foo(self):
        pass

my_singleton = My_Singleton()

ใช้:

from mysingleton import my_singleton
my_singleton.foo()

โดยที่ mysingleton.py เป็นชื่อไฟล์ของคุณที่ My_Singleton กำหนดไว้ใช้งานได้เพราะหลังจากนำเข้าไฟล์ครั้งแรก Python จะไม่เรียกใช้รหัสอีกครั้ง

นี่คือหนึ่งซับสำหรับคุณ:

singleton = lambda c: c()

นี่คือวิธีที่คุณใช้:

@singleton
class wat(object):
    def __init__(self): self.x = 1
    def get_x(self): return self.x

assert wat.get_x() == 1

วัตถุของคุณได้รับการยกตัวอย่างอย่างกระตือรือร้น นี่อาจเป็นหรือไม่ใช่สิ่งที่คุณต้องการ

ตรวจสอบคำถาม Stack Overflow มีวิธีที่ง่ายและสง่างามในการกำหนดซิงเกิลตันใน Python หรือไม่? ด้วยโซลูชั่นที่หลากหลาย

ผมขออยากแนะนำให้ไปดูการเจรจาอเล็กซ์เทลในรูปแบบการออกแบบในหลาม: ส่วนที่ 1และส่วนที่ 2 โดยเฉพาะอย่างยิ่งในตอนที่ 1 เขาพูดถึงวัตถุเดี่ยว / รัฐที่ใช้ร่วมกัน

นี่คือการใช้งานซิงเกิลตันของฉันเอง สิ่งที่คุณต้องทำคือตกแต่งชั้นเรียน เพื่อให้ได้ซิงเกิลคุณต้องใช้Instanceวิธีนี้ นี่คือตัวอย่าง:

   @Singleton
   class Foo:
       def __init__(self):
           print 'Foo created'

   f = Foo() # Error, this isn't how you get the instance of a singleton

   f = Foo.Instance() # Good. Being explicit is in line with the Python Zen
   g = Foo.Instance() # Returns already created instance

   print f is g # True

และนี่คือรหัส:

class Singleton:
    """
    A non-thread-safe helper class to ease implementing singletons.
    This should be used as a decorator -- not a metaclass -- to the
    class that should be a singleton.

    The decorated class can define one `__init__` function that
    takes only the `self` argument. Other than that, there are
    no restrictions that apply to the decorated class.

    To get the singleton instance, use the `Instance` method. Trying
    to use `__call__` will result in a `TypeError` being raised.

    Limitations: The decorated class cannot be inherited from.

    """

    def __init__(self, decorated):
        self._decorated = decorated

    def Instance(self):
        """
        Returns the singleton instance. Upon its first call, it creates a
        new instance of the decorated class and calls its `__init__` method.
        On all subsequent calls, the already created instance is returned.

        """
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance

    def __call__(self):
        raise TypeError('Singletons must be accessed through `Instance()`.')

    def __instancecheck__(self, inst):
        return isinstance(inst, self._decorated)

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

ขอบคุณไมค์วัตคินส์: http://mikewatkins.ca/2008/11/29/python-2-and-3-metaclasses/ หากคุณต้องการให้โปรแกรมทำงานได้ทั้ง Python 2 และ Python 3 คุณต้องทำสิ่งต่อไปนี้

class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

MC = Singleton('MC', (object), {})

class MyClass(MC):
    pass    # Code for the class implementation

ฉันคิดว่า 'object' ในการกำหนดจะต้องถูกแทนที่ด้วย 'BaseClass' แต่ฉันไม่ได้ลองเลย (ฉันได้ลองใช้โค้ดดังที่แสดง)

นอกเหนือจากการเห็นด้วยกับข้อเสนอแนะ Pythonic ทั่วไปเกี่ยวกับการมีโมดูลระดับโลกวิธีการเกี่ยวกับเรื่องนี้:

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class2, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w, class2).__new__(class2, *args, **kwargs)
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(object):
    def __init__(self, text):
        print text
    @classmethod
    def name(class_):
        print class_.__name__

x = MyClass(111)
x.name()
y = MyClass(222)
print id(x) == id(y)

ผลลัพธ์คือ:

111     # the __init__ is called only on the 1st time
MyClass # the __name__ is preserved
True    # this is actually the same instance

เกี่ยวกับสิ่งนี้:

def singleton(cls):
    instance=cls()
    cls.__new__ = cls.__call__= lambda cls: instance
    cls.__init__ = lambda self: None
    return instance

ใช้เป็นมัณฑนากรในคลาสที่ควรเป็นซิงเกิล แบบนี้:

@singleton
class MySingleton:
    #....

นี่คล้ายกับsingleton = lambda c: c()มัณฑนากรในคำตอบอื่น เช่นเดียวกับโซลูชันอื่นอินสแตนซ์เดียวเท่านั้นที่มีชื่อคลาส ( MySingleton) แต่ด้วยวิธีนี้คุณยังสามารถ "สร้าง" อินสแตนซ์ (ได้รับจริงเพียงตัวอย่าง) MySingleton()จากชั้นเรียนโดยการทำ นอกจากนี้ยังป้องกันไม่ให้คุณสร้างอินสแตนซ์เพิ่มเติมโดยทำtype(MySingleton)()(ซึ่งจะส่งคืนอินสแตนซ์เดียวกัน)

ฉันจะขว้างระเบิดเข้าไปในวงแหวน มันเป็นมัณฑนากรที่เรียบง่าย

from abc import ABC

def singleton(real_cls):

    class SingletonFactory(ABC):

        instance = None

        def __new__(cls, *args, **kwargs):
            if not cls.instance:
                cls.instance = real_cls(*args, **kwargs)
            return cls.instance

    SingletonFactory.register(real_cls)
    return SingletonFactory

# Usage
@singleton
class YourClass:
    ...  # Your normal implementation, no special requirements.

ประโยชน์ฉันคิดว่ามันมีโซลูชันอื่น ๆ :

• ชัดเจนและรัดกุม (ตาของฉัน; D)
• การกระทำของมันถูกห่อหุ้มอย่างสมบูรณ์ YourClassคุณไม่จำเป็นต้องมีการเปลี่ยนแปลงเป็นสิ่งเดียวกับการดำเนินงานของ ซึ่งรวมถึงไม่จำเป็นต้องใช้ metaclass สำหรับคลาสของคุณ (โปรดทราบว่า metaclass ด้านบนอยู่ในโรงงานไม่ใช่คลาส "ของจริง")
• มันไม่ได้พึ่งพาการทำแพทช์ลิงเลย
• มันโปร่งใสสำหรับผู้โทร:
  • ผู้โทรยังคงนำเข้าYourClassได้ดูเหมือนเป็นคลาส (เพราะเป็น) และพวกเขาใช้งานได้ตามปกติ ไม่จำเป็นต้องปรับผู้โทรเข้ากับฟังก์ชั่นจากโรงงาน
  • สิ่งที่YourClass()อินสแตนซ์ยังคงเป็นอินสแตนซ์ที่แท้จริงของYourClassคุณที่ใช้งานไม่ใช่พร็อกซีใด ๆ ดังนั้นจึงไม่มีโอกาสเกิดผลข้างเคียงจากสิ่งนั้น
  • isinstance(instance, YourClass) และการดำเนินการที่คล้ายกันยังคงทำงานได้ตามที่คาดไว้ (แม้ว่าบิตนี้จะต้องใช้ abc ดังนั้นอย่ารวม Python <2.6)

ข้อเสียอย่างหนึ่งเกิดขึ้นกับฉัน: classmethods และ staticmethods ของคลาสจริงไม่สามารถเรียกได้อย่างโปร่งใสผ่านคลาสโรงงานที่ซ่อนไว้ ฉันใช้มันไม่ค่อยพอที่จะไม่เกิดขึ้นกับความต้องการนั้น แต่มันจะได้รับการแก้ไขอย่างง่ายดายโดยการใช้ metaclass แบบกำหนดเองบนโรงงานที่ใช้__getattr__()ในการมอบหมายการเข้าถึงคุณลักษณะทั้งหมดของ ish ให้กับคลาสจริง

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

def unique(real_cls):

    class UniqueFactory(ABC):

        @functools.lru_cache(None)  # Handy for 3.2+, but use any memoization decorator you like
        def __new__(cls, *args, **kwargs):
            return real_cls(*args, **kwargs)

    UniqueFactory.register(real_cls)
    return UniqueFactory

จากทั้งหมดที่กล่าวมาฉันเห็นด้วยกับคำแนะนำทั่วไปว่าหากคุณคิดว่าคุณต้องการสิ่งใดสิ่งหนึ่งคุณควรหยุดสักครู่แล้วถามตัวเองว่าคุณทำจริงหรือไม่ 99% ของเวลา, YAGNI

• หากต้องการมีหลายอินสแตนซ์ของคลาสเดียวกัน แต่หาก args หรือ kwargs แตกต่างกันสามารถใช้สิ่งนี้
• อดีต
  1. หากคุณมีการserialสื่อสารในระดับการจัดการและเพื่อสร้างอินสแตนซ์ที่คุณต้องการส่งพอร์ตอนุกรมเป็นอาร์กิวเมนต์แล้วด้วยวิธีการแบบดั้งเดิมจะไม่ทำงาน
  2. ด้วยการใช้ decorators ที่กล่าวถึงข้างต้นเราสามารถสร้างคลาสได้หลายอินสแตนซ์ถ้า args นั้นแตกต่างกัน
  3. สำหรับ args เดียวกัน decorator จะส่งคืนอินสแตนซ์เดียวกันซึ่งถูกสร้างขึ้นแล้ว

>>> from decorators import singleton
>>>
>>> @singleton
... class A:
...     def __init__(self, *args, **kwargs):
...         pass
...
>>>
>>> a = A(name='Siddhesh')
>>> b = A(name='Siddhesh', lname='Sathe')
>>> c = A(name='Siddhesh', lname='Sathe')
>>> a is b  # has to be different
False
>>> b is c  # has to be same
True
>>>

รหัสขึ้นอยู่กับคำตอบของ Tolli

#decorator, modyfies new_cls
def _singleton(new_cls):
    instance = new_cls()                                              #2
    def new(cls):
        if isinstance(instance, cls):                                 #4
            return instance
        else:
            raise TypeError("I can only return instance of {}, caller wanted {}".format(new_cls, cls))
    new_cls.__new__  = new                                            #3
    new_cls.__init__ = lambda self: None                              #5
    return new_cls


#decorator, creates new class
def singleton(cls):
    new_cls = type('singleton({})'.format(cls.__name__), (cls,), {} ) #1
    return _singleton(new_cls)


#metaclass
def meta_singleton(name, bases, attrs):
    new_cls = type(name, bases, attrs)                                #1
    return _singleton(new_cls)

คำอธิบาย:

1. สร้างคลาสใหม่สืบทอดจากที่กำหนดcls
   (จะไม่แก้ไขclsในกรณีที่มีคนต้องการตัวอย่างsingleton(list))

2. สร้างตัวอย่าง ก่อนที่จะเอาชนะ__new__มันง่ายมาก

3. ตอนนี้เมื่อเราสร้างอินสแตนซ์ได้ง่าย ๆ การแทนที่__new__โดยใช้ช่วงเวลาที่กำหนดวิธีการที่ผ่านมา

4. ฟังก์ชันจะส่งกลับเฉพาะเมื่อมันเป็นสิ่งที่คาดว่าจะโทรมิฉะนั้นยกinstance เงื่อนไขจะไม่พบเมื่อมีคนพยายามที่จะสืบทอดจากชั้นตกแต่งTypeError
   

5. หาก__new__()ผลตอบแทนที่เป็นตัวอย่างของclsแล้วตัวอย่างใหม่ของ__init__()วิธีการที่จะถูกเรียกเช่นที่ตัวเองเป็นตัวอย่างใหม่และข้อโต้แย้งที่เหลือเป็นเช่นเดียวกับที่ถูกส่งผ่านไปยัง__init__(self[, ...])__new__()

   instanceเริ่มต้นแล้วดังนั้นฟังก์ชันแทนที่__init__ด้วยฟังก์ชันที่ไม่ทำอะไรเลย

ดูการทำงานออนไลน์

มันคล้ายกับคำตอบโดย fab เล็กน้อย แต่ไม่เหมือนกันทุกประการ

สัญญาเดี่ยวไม่จำเป็นต้องที่เราจะสามารถที่จะเรียกตัวสร้างหลายครั้ง ในฐานะที่เป็นโสดควรจะสร้างครั้งเดียวเท่านั้นมันไม่ควรที่จะถูกสร้างขึ้นเพียงครั้งเดียว? "การปลอมแปลง" คอนสตรัคเตอร์ทำให้เนื้อหาบกพร่อง

ดังนั้นข้อเสนอแนะของฉันเป็นเพียงแค่นี้:

class Elvis():
    def __init__(self):
        if hasattr(self.__class__, 'instance'):
            raise Exception()
        self.__class__.instance = self
        # initialisation code...

    @staticmethod
    def the():
        if hasattr(Elvis, 'instance'):
            return Elvis.instance
        return Elvis()

สิ่งนี้ไม่ได้ออกกฎการใช้นวกรรมิกหรือฟิลด์instanceตามรหัสผู้ใช้:

if Elvis() is King.instance:

... หากคุณทราบแน่ชัดว่าElvisยังไม่มีการสร้างและสิ่งนั้นKingมี

แต่มันกระตุ้นให้ผู้ใช้ใช้theวิธีการแบบสากล:

Elvis.the().leave(Building.the())

หากต้องการทำให้สมบูรณ์คุณสามารถแทนที่__delattr__()ยกข้อยกเว้นหากมีความพยายามลบinstanceและแทนที่__del__()เพื่อให้มีข้อยกเว้น (ยกเว้นว่าเรารู้ว่าโปรแกรมกำลังจะสิ้นสุด ... )

การปรับปรุงเพิ่มเติม

ฉันขอขอบคุณผู้ที่ช่วยด้วยความคิดเห็นและการแก้ไขซึ่งยินดีต้อนรับ ขณะที่ฉันใช้ Jython สิ่งนี้ควรใช้งานได้ดีกว่าและปลอดภัยกับเธรด

try:
    # This is jython-specific
    from synchronize import make_synchronized
except ImportError:
    # This should work across different python implementations
    def make_synchronized(func):
        import threading
        func.__lock__ = threading.Lock()

        def synced_func(*args, **kws):
            with func.__lock__:
                return func(*args, **kws)

        return synced_func

class Elvis(object): # NB must be subclass of object to use __new__
    instance = None

    @classmethod
    @make_synchronized
    def __new__(cls, *args, **kwargs):
        if cls.instance is not None:
            raise Exception()
        cls.instance = object.__new__(cls, *args, **kwargs)
        return cls.instance

    def __init__(self):
        pass
        # initialisation code...

    @classmethod
    @make_synchronized
    def the(cls):
        if cls.instance is not None:
            return cls.instance
        return cls()

จุดที่ควรทราบ:

1. หากคุณไม่ได้คลาสย่อยจากวัตถุใน python2.x คุณจะได้รับคลาสแบบเก่าซึ่งไม่ได้ใช้ __new__
2. เมื่อผสม__new__คุณต้องตกแต่งด้วย @classmethod หรือ__new__จะเป็นวิธีการอินสแตนซ์ที่ไม่ถูกผูกไว้
3. สิ่งนี้อาจได้รับการปรับปรุงให้ดีขึ้นโดยการใช้ metaclass เนื่องจากจะทำให้คุณสามารถสร้างtheคลาสระดับคุณสมบัติได้instance

สายการบินหนึ่ง (ฉันไม่ได้ภูมิใจ แต่มันทำงานได้):

class Myclass:
  def __init__(self):
      # do your stuff
      globals()[type(self).__name__] = lambda: self # singletonify

หากคุณไม่ต้องการการเริ่มต้นอย่างขี้เกียจของอินสแตนซ์ของ Singleton ต่อไปนี้ควรเป็นเรื่องง่ายและปลอดภัยสำหรับเธรด:

class A:
    instance = None
    # Methods and variables of the class/object A follow
A.instance = A()

วิธีAนี้เป็นการเริ่มต้นเดี่ยวที่นำเข้าโมดูล

บางทีฉันอาจจะคิดถึงรูปแบบซิงเกิล แต่วิธีแก้ปัญหาของฉันคือแบบเรียบง่ายและใช้งานได้จริง (pythonic?) รหัสนี้เต็มสองเป้าหมาย

1. ทำอินสแตนซ์ของการFooเข้าถึงได้ทุกที่ (ทั่วโลก)
2. Fooสามารถมีอินสแตนซ์เดียวเท่านั้น

นี่คือรหัส

#!/usr/bin/env python3

class Foo:
    me = None

    def __init__(self):
        if Foo.me != None:
            raise Exception('Instance of Foo still exists!')

        Foo.me = self


if __name__ == '__main__':
    Foo()
    Foo()

เอาท์พุต

Traceback (most recent call last):
  File "./x.py", line 15, in <module>
    Foo()
  File "./x.py", line 8, in __init__
    raise Exception('Instance of Foo still exists!')
Exception: Instance of Foo still exists!

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

import builtins

# -----------------------------------------------------------------------------
# So..... you would expect that a class would be "global" in scope, however
#   when different modules use this,
#   EACH ONE effectively has its own class namespace.  
#   In order to get around this, we use a metaclass to intercept
#   "new" and provide the "truly global metaclass instance" if it already exists

class MetaConfig(type):
    def __new__(cls, name, bases, dct):
        try:
            class_inst = builtins.CONFIG_singleton

        except AttributeError:
            class_inst = super().__new__(cls, name, bases, dct)
            builtins.CONFIG_singleton = class_inst
            class_inst.do_load()

        return class_inst

# -----------------------------------------------------------------------------

class Config(metaclass=MetaConfig):

    config_attr = None

    @classmethod
    def do_load(cls):
        ...<load-cfg-from-file>...

ฉันจำไม่ได้ว่าฉันเจอทางแก้ปัญหานี้ที่ไหน แต่ฉันคิดว่ามันเป็น 'หรูหรา' ที่สุดจากมุมมองที่ไม่ใช่ Python-expert ของฉัน:

class SomeSingleton(dict):
    __instance__ = None
    def __new__(cls, *args,**kwargs):
        if SomeSingleton.__instance__ is None:
            SomeSingleton.__instance__ = dict.__new__(cls)
        return SomeSingleton.__instance__

    def __init__(self):
        pass

    def some_func(self,arg):
        pass

ทำไมฉันถึงชอบสิ่งนี้? ไม่มีมัณฑนากรไม่มีคลาสเมต้าไม่มีการสืบทอดหลายอย่าง ... และถ้าคุณตัดสินใจว่าคุณไม่ต้องการให้เป็นซิงเกิลอีกต่อไปเพียงแค่ลบ__new__เมธอด ในขณะที่ฉันยังใหม่กับ Python (และ OOP โดยทั่วไป) ฉันคาดหวังว่าจะมีคนตั้งฉันให้ตรงเกี่ยวกับสาเหตุที่สิ่งนี้เป็นวิธีการที่แย่มาก?

นี่เป็นวิธีที่ฉันต้องการใช้งานซิงเกิลตัน:

class Test(object):
    obj = None

    def __init__(self):
        if Test.obj is not None:
            raise Exception('A Test Singleton instance already exists')
        # Initialization code here

    @classmethod
    def get_instance(cls):
        if cls.obj is None:
            cls.obj = Test()
        return cls.obj

    @classmethod
    def custom_method(cls):
        obj = cls.get_instance()
        # Custom Code here

คำตอบนี้น่าจะไม่ใช่สิ่งที่คุณกำลังมองหา ฉันต้องการซิงเกิลตันในแง่ที่ว่าวัตถุนั้นมีตัวตนของมันเพื่อเปรียบเทียบกับ ในกรณีของฉันมันถูกนำมาใช้เป็นค่า Sentinel คำตอบนั้นง่ายมากทำสิ่งใดก็ตามmything = object()และโดยธรรมชาติของงูเหลือมเพียงสิ่งนั้นเท่านั้นที่จะมีตัวตนของมัน

#!python
MyNone = object()  # The singleton

for item in my_list:
    if item is MyNone:  # An Example identity comparison
        raise StopIteration

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

ฉันต้องการที่จะสามารถเขียนบางสิ่งเช่นนี้ (การกำหนดค่าเริ่มต้นขี้เกียจ) แต่น่าเสียดายที่ชั้นเรียนไม่สามารถใช้ได้ในเนื้อหาของคำจำกัดความของตนเอง

# wouldn't it be nice if we could do this?
class Foo(object):
    instance = None

    def __new__(cls):
        if cls.instance is None:
            cls.instance = object()
            cls.instance.__class__ = Foo
        return cls.instance

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

เริ่มต้นกระตือรือร้น:

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        return foo_instance


foo_instance = FooMaker()
foo_instance.__class__ = Foo

การเริ่มต้น Lazy:

เริ่มต้นกระตือรือร้น:

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        global foo_instance
        if foo_instance is None:
            foo_instance = FooMaker()
        return foo_instance


foo_instance = None