फास्ट ENUM

टीएल, डॉ

github.com/QratorLabs/fastenum

pip install fast-enum 

गणना की आवश्यकता क्यों है

(यदि आप सब कुछ जानते हैं - "मानक पुस्तकालय में गणना" अनुभाग पर जाएं)

कल्पना कीजिए कि आपको अपने स्वयं के डेटाबेस मॉडल में सभी संभावित राज्यों के सेट का वर्णन करने की आवश्यकता है। सबसे अधिक संभावना है, आप सीधे मॉड्यूल नेमस्पेस में परिभाषित स्थिरांक का एक गुच्छा लेंगे:

 # /path/to/package/static.py: INITIAL = 0 PROCESSING = 1 PROCESSED = 2 DECLINED = 3 RETURNED = 4 ... 

... या स्थिर वर्ग विशेषताओं के रूप में:

 class MyModelStates: INITIAL = 0 PROCESSING = 1 PROCESSED = 2 DECLINED = 3 RETURNED = 4 

यह दृष्टिकोण इन राज्यों को mnemonic नामों से संदर्भित करने में मदद करेगा, जबकि आपके भंडार में वे साधारण पूर्णांक होंगे। इस प्रकार, आप एक साथ कोड के विभिन्न भागों में बिखरे हुए जादू की संख्या से छुटकारा पा लेते हैं, साथ ही इसे अधिक पठनीय और सूचनात्मक बनाते हैं।

हालांकि, मॉड्यूल स्थिर और स्थिर विशेषताओं वाले वर्ग दोनों पायथन ऑब्जेक्ट्स की आंतरिक प्रकृति से पीड़ित हैं: वे सभी उत्परिवर्तनीय (उत्परिवर्ती) हैं। आप गलती से रन टाइम पर अपने कंटीन्यू को वैल्यू असाइन कर सकते हैं, और टूटी हुई वस्तुओं को डिबगिंग और रोलिंग करना एक अलग साहसिक कार्य है। तो आप इस अर्थ में अपरिवर्तित स्थिरांक का बंडल बनाना चाह सकते हैं कि घोषित स्थिरांक की संख्या और उनके मान जिस पर वे मैप किए गए हैं, कार्यक्रम निष्पादन के दौरान नहीं बदलेगा।

ऐसा करने के लिए, आप उदाहरण के रूप में नामित namedtuple() का उपयोग करके उन्हें namedtuple() में व्यवस्थित करने का प्रयास कर सकते हैं:

 MyModelStates = namedtuple('MyModelStates', ('INITIAL', 'PROCESSING', 'PROCESSED', 'DECLINED', 'RETURNED')) EntityStates = MyModelStates(0, 1, 2, 3, 4) 

लेकिन यह बहुत साफ-सुथरा और पठनीय नहीं दिखता है, और namedtuple वस्तुएं, बदले में, बहुत ही एक्स्टेंसिबल नहीं हैं। मान लीजिए कि आपके पास एक UI है जो इन सभी राज्यों को प्रदर्शित करता है। आप मॉड्यूल में अपने स्थिरांक का उपयोग कर सकते हैं, विशेषताओं के साथ एक वर्ग, या उन्हें प्रस्तुत करने के लिए ट्यूपल्स नामित (अंतिम दो को प्रस्तुत करना आसान है क्योंकि हम इस बारे में बात कर रहे हैं)। लेकिन ऐसा कोड उपयोगकर्ता को आपके द्वारा परिभाषित प्रत्येक राज्य के लिए पर्याप्त विवरण के साथ प्रदान करना संभव नहीं बनाता है। इसके अलावा, यदि आप अपने यूआई में बहुभाषीवाद और i18n समर्थन को लागू करने की योजना बनाते हैं, तो आपको एहसास होगा कि इन विवरणों के लिए सभी अनुवादों को जल्दी से पूरा करना एक अविश्वसनीय रूप से कठिन काम बन जाता है। आवश्यक रूप से विवरण से मेल खाने का मतलब राज्य के नामों का मिलान नहीं होगा, जिसका अर्थ है कि आप अपने सभी INITIAL राज्यों को gettext में एक ही विवरण में मैप नहीं कर सकते हैं। इसके बजाय, आपका स्थिरांक निम्नलिखित रूप लेता है:

 INITIAL = (0, 'My_MODEL_INITIAL_STATE') 

या आपकी कक्षा इस तरह हो जाती है:

 class MyModelStates: INITIAL = (0, 'MY_MODEL_INITIAL_STATE') 

अंत में, नामित टपल में बदल जाता है:

 EntityStates = MyModelStates((0, 'MY_MODEL_INITIAL_STATE'), ...) 

पहले से ही बुरा नहीं है - अब यह गारंटी देता है कि यूआई द्वारा समर्थित भाषाओं में स्थिति मूल्य और अनुवाद स्टब दोनों प्रदर्शित किए जाते हैं। लेकिन आप देख सकते हैं कि इन मैपिंग का उपयोग करने वाला कोड गड़बड़ हो गया है। प्रत्येक बार, एक इकाई मान निर्दिष्ट करने का प्रयास करते हुए, आपको उस प्रदर्शन से इंडेक्स 0 के साथ मान निकालना होगा जो आप उपयोग कर रहे हैं:

 my_entity.state = INITIAL[0] 

या

 my_entity.state = MyModelStates.INITIAL[0] 

या

 my_entity.state = EntityStates.INITIAL[0] 

और इसी तरह। याद रखें कि पहले दो दृष्टिकोण जो क्रमशः स्थिरांक और वर्ग विशेषताओं का उपयोग करते हैं, उत्परिवर्तन से पीड़ित हैं।

और स्थानान्तरण हमारी सहायता के लिए आते हैं

 class MyEntityStates(Enum): def __init__(self, val, description): self.val = val self.description = description INITIAL = (0, 'MY_MODEL_INITIAL_STATE') PROCESSING = (1, 'MY_MODEL_BEING_PROCESSED_STATE') PROCESSED = (2, 'MY_MODEL_PROCESSED_STATE') DECLINED = (3, 'MY_MODEL_DECLINED_STATE') RETURNED = (4, 'MY_MODEL_RETURNED_STATE') 

वह सब है। अब आप आसानी से अपने रेंडर (जिंजा 2 सिंटैक्स) में लिस्टिंग पर पुनरावृति कर सकते हैं:

 {% for state in MyEntityState %} <option value=”{{ state.val }}”>{{ _(state.description) }}</option> {% endfor %} 

एक गणना दोनों तत्वों के एक सेट के लिए अपरिवर्तनीय है - आप रनटाइम पर एक एन्यूमरेशन के नए सदस्य को परिभाषित नहीं कर सकते हैं और आप पहले से परिभाषित सदस्य को नहीं हटा सकते हैं, और उन तत्वों के उन मूल्यों के लिए जिन्हें यह संग्रहीत करता है - आप किसी विशेषता विशेषताओं को असाइन नहीं कर सकते हैं या किसी विशेषता को हटा सकते हैं।

आपके कोड में, आप बस अपनी संस्थाओं को मान प्रदान करते हैं, जैसे:

 my_entity.state = MyEntityStates.INITIAL.val 

सब कुछ पर्याप्त स्पष्ट, जानकारीपूर्ण और एक्स्टेंसिबल है। यह वह है जिसके लिए हम एन्यूमरेशन का उपयोग करते हैं।

हम इसे और तेज़ कैसे बना सकते हैं?

मानक पुस्तकालय से गणना धीमी है, इसलिए हमने खुद से पूछा - क्या हम इसे गति दे सकते हैं? जैसा कि यह पता चला है, हम, अर्थात्, हमारी गणना का कार्यान्वयन कर सकते हैं:

• सदस्य गणन तक पहुंच पर तीन गुना तेज;
• ~ 8.5 किसी सदस्य की विशेषता ( name , value ) तक पहुँचने पर तेज़;
• मूल्य से किसी सदस्य तक MyEnum(value)) समय 3 गुना तेजी से (एन्यूमरेशन MyEnum(value)) के निर्माता को कॉल करें MyEnum(value)) ;
• नाम से किसी सदस्य तक पहुँचने पर 1.5 गुना तेज़ (जैसा कि MyEnum[name] शब्दकोश) में है।

पायथन में प्रकार और वस्तुएं गतिशील हैं। लेकिन वस्तुओं की गतिशील प्रकृति को सीमित करने के लिए उपकरण हैं। आपको __slots__ साथ एक महत्वपूर्ण प्रदर्शन को बढ़ावा मिल सकता है। यदि आप संभव हो तो डेटा डिस्क्रिप्टर का उपयोग करने से बचें, लेकिन गति में वृद्धि की भी संभावना है - लेकिन आपको आवेदन जटिलता में उल्लेखनीय वृद्धि की संभावना पर विचार करना चाहिए।

स्लॉट्स

उदाहरण के लिए, आप __slots__ का उपयोग करके एक वर्ग घोषणा का उपयोग कर सकते हैं - इस मामले में, कक्षाओं के सभी उदाहरणों में केवल __slots__ में घोषित संपत्तियों का एक सीमित सेट __slots__ और माता-पिता वर्गों के सभी __slots__ ।

वर्णनकर्ता

डिफ़ॉल्ट रूप से, पायथन दुभाषिया सीधे वस्तु की विशेषता का मान लौटाता है (एक ही समय में, हम यह निर्धारित करते हैं कि इस मामले में मान भी एक पायथन ऑब्जेक्ट है, और उदाहरण के लिए, C भाषा के संदर्भ में लंबे समय तक अहस्ताक्षरित):
value = my_obj.attribute # , .

पायथन डेटा मॉडल के अनुसार, यदि विशेषता मान एक ऐसी वस्तु है, जो कि डिस्क्रिप्टर प्रोटोकॉल को लागू करता है, तो इस विशेषता के मूल्य को प्राप्त करने की कोशिश करते समय, दुभाषिया सबसे पहले उस ऑब्जेक्ट का लिंक __get__ , जिसे संपत्ति संदर्भित करती है और फिर विशेष __get__ विधि को कॉल करती __get__ , जो कि हमारे मूल ऑब्जेक्ट के रूप में पास होगी। तर्क:

 obj_attribute = my_obj.attribute obj_attribute_value = obj_attribute.__get__(my_obj) 

मानक पुस्तकालय में गणना

मानक गणन कार्यान्वयन के सदस्यों के कम से कम name और value गुण types.DynamicClassAttribute रूप में घोषित किए जाते हैं। इसका मतलब यह है कि जब आप name और value के मूल्यों को प्राप्त करने की कोशिश करते हैं, तो निम्न होगा:

 one_value = StdEnum.ONE.value #        #   ,      one_value_attribute = StdEnum.ONE.value one_value = one_value_attribute.__get__(StdEnum.ONE) 

 #   ,  __get__     (  python3.7): def __get__(self, instance, ownerclass=None): if instance is None: if self.__isabstractmethod__: return self raise AttributeError() elif self.fget is None: raise AttributeError("unreadable attribute") return self.fget(instance) 

 #   DynamicClassAttribute     `name`  `value`   __get__()  : @DynamicClassAttribute def name(self): """The name of the Enum member.""" return self._name_ @DynamicClassAttribute def value(self): """The value of the Enum member.""" return self._value_ 

इस प्रकार, कॉल के पूरे अनुक्रम को निम्नलिखित छद्म कोड द्वारा दर्शाया जा सकता है:

 def get_func(enum_member, attrname): #        __dict__,        -     return getattr(enum_member, f'_{attrnme}_') def get_name_value(enum_member): name_descriptor = get_descriptor(enum_member, 'name') if enum_member is None: if name_descriptor.__isabstractmethod__: return name_descriptor raise AttributeError() elif name_descriptor.fget is None: raise AttributeError("unreadable attribute") return get_func(enum_member, 'name') 

हमने ऊपर वर्णित आउटपुट को प्रदर्शित करते हुए एक सरल स्क्रिप्ट लिखी है:

 from enum import Enum class StdEnum(Enum): def __init__(self, value, description): self.v = value self.description = description A = 1, 'One' B = 2, 'Two' def get_name(): return StdEnum.A.name from pycallgraph import PyCallGraph from pycallgraph.output import GraphvizOutput graphviz = GraphvizOutput(output_file='stdenum.png') with PyCallGraph(output=graphviz): v = get_name() 

और निष्पादन के बाद, स्क्रिप्ट ने हमें निम्नलिखित चित्र दिया:


यह दिखाता है कि हर बार जब आप मानक पुस्तकालय से गणना सदस्यों के name और value विशेषताओं तक पहुंचते हैं, तो एक हैंडल कहा जाता है। यह डिस्क्रिप्टर, बदले में, Enum def name(self) विधि के मानक पुस्तकालय से Enum वर्ग के एक कॉल के साथ समाप्त होता है, जो डिस्क्रिप्टर से सजाया गया है।

हमारे FastEnum के साथ तुलना करें:

 from fast_enum import FastEnum class MyNewEnum(metaclass=FastEnum): A = 1 B = 2 def get_name(): return MyNewEnum.A.name from pycallgraph import PyCallGraph from pycallgraph.output import GraphvizOutput graphviz = GraphvizOutput(output_file='fastenum.png') with PyCallGraph(output=graphviz): v = get_name() 

निम्नलिखित छवि में क्या देखा जा सकता है:


यह सब वास्तव में मानक गणन कार्यान्वयन के अंदर होता है जब आप हर बार अपने सदस्यों के name और value गुणों तक पहुंचते हैं। यही कारण है कि हमारा कार्यान्वयन तेज है।

पायथन मानक पुस्तकालय में गणना को लागू करने से डेटा डिस्क्रिप्टर प्रोटोकॉल को लागू करने वाली वस्तुओं के लिए बहुत सारे कॉल का उपयोग किया जाता है। जब हमने अपनी परियोजनाओं में मानक गणना कार्यान्वयन का उपयोग करने की कोशिश की, तो हमने तुरंत देखा कि कितने डेटा विवरणकों को name और value लिए बुलाया गया था।
और चूंकि पूरे कोड में गणना का काफी उपयोग किया गया था, जिसके परिणामस्वरूप प्रदर्शन कम था।

इसके अलावा, मानक Enum वर्ग में कई सहायक "संरक्षित" विशेषताएँ शामिल हैं:

• _member_names_ - गणन के सदस्यों के सभी नामों वाली एक सूची;
• _member_map_ - OrderedDict , जो अपने मूल्य के लिए एक गणना सदस्य के नाम को मैप करता है;
• _value2member_map_ - विपरीत दिशा में मिलान वाला एक शब्दकोश: गणना के सदस्यों के लिए गणन के सदस्यों के मूल्यों।

शब्दकोश खोज धीमी है, क्योंकि प्रत्येक कॉल हैश फ़ंक्शन की गणना की ओर जाता है (जब तक, निश्चित रूप से, परिणाम अलग से कैश किया जाता है, जो कि अप्रबंधित कोड के लिए हमेशा संभव नहीं होता है) और हैश तालिका में खोज, जो इन शब्दकोशों को गणना के लिए एक इष्टतम आधार नहीं बनाता है। यहां तक ​​कि गणना सदस्यों ( StdEnum.MEMBER ) के लिए खोज एक शब्दकोश खोज है।

हमारा दृष्टिकोण

हमने सी में सुरुचिपूर्ण एन्यूमरेशन्स और जावा में सुंदर एक्स्टेंसिबल एन्यूमरेशन्स के लिए एक आँख के साथ एन्यूमरेशंस के हमारे कार्यान्वयन का निर्माण किया। मुख्य कार्य जो हम घर पर लागू करना चाहते थे, वे इस प्रकार थे:

• गणन संभव के रूप में स्थिर होना चाहिए; यहाँ "स्थिर" का अर्थ निम्न है - यदि किसी चीज़ की घोषणा के दौरान केवल एक बार और उसके बाद गणना की जा सकती है, तो इस पर (और केवल इस समय) गणना की जानी चाहिए;
• यदि किसी श्रेणी में एन्युमरेशन के नए सदस्यों को परिभाषित किया जाता है, तो एन्यूमरेशन (यह "अंतिम" क्लास होना चाहिए) - यह मानक लाइब्रेरी में लागू होने के लिए सही है, इस अपवाद के साथ कि विरासत निषिद्ध है, भले ही विरासत वर्ग नए सदस्यों को परिभाषित न करे;
• गणना में विस्तार के लिए पर्याप्त गुंजाइश होनी चाहिए (अतिरिक्त विशेषताओं, विधियों, आदि)

हम केवल मामले में डिक्शनरी खोज का उपयोग करते हैं - यह किसी मानार्थ सदस्य के लिए मान value का व्युत्क्रम मानचित्रण है। अन्य सभी गणना केवल कक्षा घोषणा के दौरान एक बार की जाती हैं (जहां टाइप निर्माण को कॉन्फ़िगर करने के लिए मेटाक्लस का उपयोग किया जाता है)।
मानक पुस्तकालय के विपरीत, हम केवल सदस्य मूल्य के रूप में वर्ग घोषणा में = साइन के बाद पहला मान संसाधित करते हैं:
मानक पुस्तकालय में A = 1, 'One' संपूर्ण टुपल 1, "One" मान value ;
A: 'MyEnum' = 1, 'One' हमारे कार्यान्वयन में, केवल 1 मान value रूप 1 माना जाता है।

आगे त्वरण __slots__ के उपयोग के माध्यम से प्राप्त किया जाता है जहां संभव हो। __slots__ का उपयोग करके घोषित पायथन कक्षाओं में, __slots__ के लिए __dict__ विशेषता नहीं बनाई जाती है, जिसमें उनके मूल्यों के लिए विशेषता नामों की मैपिंग होती है (इसलिए, आप __slots__ में उल्लिखित उदाहरण की किसी भी संपत्ति की घोषणा नहीं कर सकते हैं)। इसके अलावा, __slots__ में परिभाषित विशेषताओं के मूल्यों को ऑब्जेक्ट उदाहरण पॉइंटर में एक निरंतर ऑफसेट पर एक्सेस किया जाता है। यह गुणों की उच्च गति है क्योंकि यह हैश गणना और हैश टेबल स्कैन से बचा जाता है।

अतिरिक्त चिप्स क्या हैं?

FastEnum 3.6 से पहले पायथन के किसी भी संस्करण के साथ संगत नहीं है क्योंकि यह पायथन 3.6 में लागू सार्वभौमिक एनोटेशन का उपयोग करता है। यह माना जा सकता है कि PyPi से typing मॉड्यूल स्थापित करने में मदद मिलेगी। संक्षिप्त उत्तर नहीं है। कार्यान्वयन PEP-484 का उपयोग कुछ कार्यों, विधियों, और संकेत के प्रकारों के तर्क के लिए करता है, इसलिए वाक्य रचना असंगतता के कारण Python 3.5 से पहले किसी भी संस्करण का समर्थन नहीं किया जाता है। लेकिन, फिर से, __new__ में कोड की बहुत पहली पंक्ति चर के प्रकार को इंगित करने के लिए PEP-526 सिंटैक्स का उपयोग करती है। तो पायथन 3.5 या तो काम नहीं करेगा। आप कार्यान्वयन को पुराने संस्करणों में पोर्ट कर सकते हैं, हालांकि हम जब भी संभव हो, क्यूरेटर लैब्स में टाइप एनोटेशन का उपयोग करते हैं, क्योंकि यह जटिल परियोजनाओं को विकसित करने में बहुत मदद करता है। खैर, अंत में! आप संस्करण 3.6 से पहले पायथन में फंस जाना नहीं चाहते हैं, क्योंकि नए संस्करणों में आपके मौजूदा कोड के साथ कोई पिछड़ी असंगतता नहीं है (बशर्ते कि आप पायथन 2 का उपयोग नहीं कर रहे हैं), और 3.5 की तुलना में asyncio के कार्यान्वयन में बहुत काम किया गया है। हमारा विचार, तत्काल अद्यतन के लायक है।

यह बदले में, मानक पुस्तकालय के विपरीत auto के विशेष आयात को अनावश्यक बनाता है। आप बस संकेत करते हैं कि गणना का सदस्य इस मान का उदाहरण होगा बिना मूल्य प्रदान किए - और मूल्य आपके लिए स्वतः उत्पन्न हो जाएगा। यद्यपि फास्टनम के साथ काम करने के लिए पाइथन 3.6 पर्याप्त है, लेकिन ध्यान रखें कि शब्दकोशों में कुंजियों के क्रम को संरक्षित करना केवल पाइथन 3.7 में शुरू किया गया था (और हमने केस 3.6 के लिए अलग से OrderedDict उपयोग नहीं किया था)। हम किसी भी उदाहरण को नहीं जानते हैं जहां मूल्यों का स्वचालित रूप से उत्पन्न आदेश महत्वपूर्ण है, क्योंकि हम मानते हैं कि अगर डेवलपर ने पर्यावरण को एक गणना सदस्य को मान देने और असाइन करने का कार्य प्रदान किया है, तो मूल्य स्वयं इसके लिए इतना महत्वपूर्ण नहीं है। हालाँकि, यदि आपने अभी भी पायथन 3.7 पर स्विच नहीं किया है, तो हमने आपको चेतावनी दी है।

जिन्हें डिफ़ॉल्ट मान (1) के बजाय 0 (शून्य) से प्रारंभ करने के लिए अपने _ZERO_VALUED की _ZERO_VALUED , वे _ZERO_VALUED एन्यूमरेशन की घोषणा करते समय एक विशेष विशेषता का उपयोग करके ऐसा कर सकते हैं, जो परिणामी कक्षा में संग्रहीत नहीं किया जाएगा।

हालांकि, कुछ प्रतिबंध हैं: गणना के सदस्यों के सभी नाम कैपिटल पत्रों में लिखे जाने चाहिए, अन्यथा वे मेटाक्लस द्वारा संसाधित नहीं किए जाएंगे।

अंत में, आप अपने एन्यूमरेशन्स के लिए एक बेस क्लास की घोषणा कर सकते हैं (ध्यान रखें कि बेस क्लास खुद मेटाक्लास का उपयोग कर सकता है, इसलिए आपको सभी उपवर्गों को मेटाक्लस प्रदान करने की आवश्यकता नहीं है) - बस इस वर्ग में सामान्य तर्क (विशेषताओं और विधियों) को परिभाषित करें और एन्यूमरेशन के सदस्यों को परिभाषित न करें। (इसलिए कक्षा को "अंतिम रूप नहीं दिया जाएगा")। जब आप चाहें तो इस वर्ग के कई विरासत वाले वर्गों की घोषणा कर सकते हैं, और वारिसों के पास स्वयं एक ही तर्क होगा।

उपनाम और वे कैसे मदद कर सकते हैं

मान लें कि आपके पास कोड का उपयोग है:

 package_a.some_lib_enum.MyEnum 

और यह है कि MyEnum वर्ग निम्नानुसार घोषित किया गया है:

 class MyEnum(metaclass=FastEnum): ONE: 'MyEnum' TWO: 'MyEnum' 

अब, आपने फैसला किया है कि आप कुछ रीफैक्टरिंग करना चाहते हैं और लिस्टिंग को दूसरे पैकेज में ट्रांसफर करना चाहते हैं। आप कुछ इस तरह से बनाएं:

 package_b.some_lib_enum.MyMovedEnum 

जहां MyMovedEnum को इस तरह घोषित किया गया है:

 class MyMovedEnum(MyEnum): pass 

अब आप उस चरण के लिए तैयार हैं जिस पर पुराने पते पर स्थित स्थानांतरण अप्रचलित माना जाता है। आप इस गणना के आयात और कॉल को फिर से लिखते हैं ताकि इस गणना का नया नाम (इसका उपनाम) अब उपयोग किया जाए - आप यह सुनिश्चित कर सकते हैं कि इस उपनाम के सभी सदस्य वास्तव में पुराने नाम के साथ वर्ग में घोषित किए गए हैं। अपने प्रोजेक्ट डॉक्यूमेंटेशन में, आप घोषणा करते हैं कि MyEnum हटा दिया गया है और भविष्य में कोड से हटा दिया जाएगा। उदाहरण के लिए, अगली रिलीज़ में। मान लीजिए कि आपका कोड pickle का उपयोग करने वाले गणन सदस्यों के साथ आपकी वस्तुओं को संग्रहीत करता है। इस बिंदु पर, आप अपने कोड में MyMovedEnum का उपयोग करते हैं, लेकिन आंतरिक रूप से, सभी गणन सदस्य अभी भी MyEnum उदाहरण हैं। आपका अगला कदम MyEnum और MyMovedEnum की घोषणाओं की MyEnum - MyMovedEnum ताकि MyMovedEnum उपवर्ग न हो और अपने सभी सदस्यों की MyEnum स्वयं कर सके; दूसरी ओर, MyEnum , अब किसी भी सदस्य की घोषणा नहीं करता है, लेकिन MyMovedEnum का सिर्फ एक उपनाम (उपवर्ग) बन जाता है।

वह सब है। जब आप अपने अनुप्रयोगों को unpickle स्टेज पर पुनः आरंभ करते हैं, तो unpickle सभी सदस्यों को MyMovedEnum उदाहरण के रूप में पुनः घोषित किया MyMovedEnum और इस नए वर्ग के साथ संबद्ध हो जाएगा। जिस क्षण आपको यकीन हो जाता है कि आपके सभी ऑब्जेक्ट संग्रहीत हैं, उदाहरण के लिए, डेटाबेस में, फिर से deserialized किया गया है (और संभवतः फिर से क्रमबद्ध और भंडार में संग्रहीत) - आप एक नई रिलीज़ जारी कर सकते हैं, जिसमें इसे पहले एक अप्रचलित वर्ग के रूप में चिह्नित किया गया था। MyEnum को अधिक अनावश्यक घोषित किया जा सकता है और कोड बेस से हटा दिया जा सकता है।

इसे अपने लिए आज़माएँ: github.com/QratorLabs/fastenum , pypi.org/project/fast-enum ।
कर्म में पेशेवरों लेखक जाना FastEnum - santjagocorkez ।

UPD: संस्करण 1.3.0 में, मौजूदा वर्गों से विरासत में लेना संभव हो गया, उदाहरण के लिए, int , float , str । ऐसे गणन के सदस्य एक समान मूल्य ( IntEnum.MEMBER == int(value_given_to_member) ) और निश्चित रूप से, एक साफ वस्तु के साथ समानता के लिए परीक्षा उत्तीर्ण करते हैं, और निश्चित रूप से, वे इन विरासत वर्गों के उदाहरण हैं। यह बदले में, एनम से विरासत में लिए गए एनम के सदस्य को sys.exit() दुभाषिया वापसी कोड के रूप में sys.exit() लिए एक सीधा तर्क होने की अनुमति देता है।