क्या मुझे कक्षा या शब्दकोश का उपयोग करना चाहिए?

Question 1

मेरे पास एक ऐसा वर्ग है जिसमें केवल फ़ील्ड और कोई विधियाँ नहीं हैं, जैसे:

class Request(object):

    def __init__(self, environ):
        self.environ = environ
        self.request_method = environ.get('REQUEST_METHOD', None)
        self.url_scheme = environ.get('wsgi.url_scheme', None)
        self.request_uri = wsgiref.util.request_uri(environ)
        self.path = environ.get('PATH_INFO', None)
        # ...

इसे आसानी से एक डिक्टेट में अनुवाद किया जा सकता था। भविष्य के अतिरिक्त के लिए वर्ग अधिक लचीला है और इसके साथ तेज हो सकता है __slots__। तो क्या इसके बजाय एक हुकुम का उपयोग करने का कोई लाभ होगा? क्या एक तानाशाह किसी वर्ग से तेज होगा? और स्लॉट के साथ एक वर्ग की तुलना में तेजी से?

Question 2

आप इसे शब्दकोश क्यों बनायेंगे? फायदा क्या है? यदि आप बाद में कुछ कोड जोड़ना चाहते हैं तो क्या होता है? आपका __init__कोड कहां जाएगा ?

कक्षाएं संबंधित डेटा (और आमतौर पर कोड) को बंडल करने के लिए होती हैं।

डिक्शनरी कुंजी-मूल्य संबंधों को संग्रहीत करने के लिए है, जहां आमतौर पर कुंजियाँ सभी एक ही प्रकार की होती हैं, और सभी मान एक प्रकार के होते हैं। कभी-कभी वे डेटा को बंडल करने के लिए उपयोगी हो सकते हैं जब कुंजी / विशेषता नाम सभी सामने नहीं जानते हैं, लेकिन अक्सर यह संकेत है कि आपके डिज़ाइन के साथ कुछ गलत है।

इसे एक क्लास रखें।

Question 3

जब तक आपको किसी वर्ग के अतिरिक्त तंत्र की आवश्यकता न हो तब शब्दकोश का उपयोग करें। आप namedtupleहाइब्रिड दृष्टिकोण के लिए भी उपयोग कर सकते हैं :

>>> from collections import namedtuple
>>> request = namedtuple("Request", "environ request_method url_scheme")
>>> request
<class '__main__.Request'>
>>> request.environ = "foo"
>>> request.environ
'foo'

यहां प्रदर्शन का अंतर कम से कम होगा, हालांकि मुझे आश्चर्य होगा कि अगर शब्दकोश तेज नहीं था।

Question 4

अजगर में एक वर्ग है एक dict नीचे। आपको क्लास के व्यवहार के साथ कुछ ओवरहेड मिलता है, लेकिन आप इसे बिना प्रोफाइलर के नोटिस नहीं कर पाएंगे। इस मामले में, मेरा मानना है कि आप वर्ग से लाभान्वित होंगे क्योंकि:

आपके सभी तर्क एक ही फ़ंक्शन में रहते हैं
अद्यतन करना आसान है और रुक जाता है
यदि आप बाद में कुछ भी बदलते हैं, तो आप इंटरफ़ेस को आसानी से रख सकते हैं

Question 5

मुझे लगता है कि हर एक का उपयोग मेरे लिए उस पर प्राप्त करने के लिए बहुत व्यक्तिपरक है, इसलिए मैं सिर्फ संख्याओं पर टिकूंगा।

मैंने उस समय की तुलना की, जिसमें एक परिवर्तन करने के लिए समय लगता है, और एक परिवर्तनशील, एक new_style वर्ग और स्लॉट्स के साथ एक new_style वर्ग।

यहां वह कोड है जिसका मैं इसे परीक्षण करता था (यह थोड़ा गड़बड़ है लेकिन यह काम करता है।)

import timeit

class Foo(object):

    def __init__(self):

        self.foo1 = 'test'
        self.foo2 = 'test'
        self.foo3 = 'test'

def create_dict():

    foo_dict = {}
    foo_dict['foo1'] = 'test'
    foo_dict['foo2'] = 'test'
    foo_dict['foo3'] = 'test'

    return foo_dict

class Bar(object):
    __slots__ = ['foo1', 'foo2', 'foo3']

    def __init__(self):

        self.foo1 = 'test'
        self.foo2 = 'test'
        self.foo3 = 'test'

tmit = timeit.timeit

print 'Creating...\n'
print 'Dict: ' + str(tmit('create_dict()', 'from __main__ import create_dict'))
print 'Class: ' + str(tmit('Foo()', 'from __main__ import Foo'))
print 'Class with slots: ' + str(tmit('Bar()', 'from __main__ import Bar'))

print '\nChanging a variable...\n'

print 'Dict: ' + str((tmit('create_dict()[\'foo3\'] = "Changed"', 'from __main__ import create_dict') - tmit('create_dict()', 'from __main__ import create_dict')))
print 'Class: ' + str((tmit('Foo().foo3 = "Changed"', 'from __main__ import Foo') - tmit('Foo()', 'from __main__ import Foo')))
print 'Class with slots: ' + str((tmit('Bar().foo3 = "Changed"', 'from __main__ import Bar') - tmit('Bar()', 'from __main__ import Bar')))

और यहाँ उत्पादन है ...

बनाना...

Dict: 0.817466186345
Class: 1.60829183597
Class_with_slots: 1.28776730003

परिवर्तनशील ...

Dict: 0.0735140918748
Class: 0.111714198313
Class_with_slots: 0.10618612142

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

ध्यान दें:

मैंने 'क्लास' का परीक्षण new_style और old_style दोनों वर्गों के साथ किया। यह पता चला है कि Old_style कक्षाएं बनाने के लिए तेज़ हैं, लेकिन संशोधित करने के लिए धीमी (बहुत अधिक लेकिन महत्वपूर्ण नहीं हैं यदि आप एक तंग लूप में बहुत सारी कक्षाएं बना रहे हैं (टिप: आप इसे गलत कर रहे हैं)।

चरों के बनाने और बदलने का समय भी आपके कंप्यूटर पर हो सकता है क्योंकि मेरा पुराना और धीमा है। सुनिश्चित करें कि आप 'वास्तविक' परिणाम देखने के लिए इसे स्वयं परखें।

संपादित करें:

मैंने बाद में नामित नाम का परीक्षण किया: मैं इसे संशोधित नहीं कर सकता लेकिन 10000 नमूने (या ऐसा कुछ) बनाने में 1.4 सेकंड का समय लगा, इसलिए शब्दकोश वास्तव में सबसे तेज़ है।

यदि मैं चाबियाँ और मूल्यों को शामिल करने के लिए तानाशाही फ़ंक्शन को बदल देता हूं और जब मैं इसे बनाता हूं, तो यह वेरिएबल युक्त वेरिएबल के बजाय वापस लौटा देता है। यह 0.8 सेकंड के बजाय मुझे 0.65 देता है ।

class Foo(dict):
    pass

बनाना स्लॉट्स वाली एक क्लास की तरह है और वेरिएबल को बदलना सबसे धीमा (0.17 सेकंड) है, इसलिए इन क्लास का इस्तेमाल न करें । एक तानाशाही (गति) के लिए या ऑब्जेक्ट से व्युत्पन्न वर्ग के लिए जाएं ('सिंटैक्स कैंडी')

Question 6

मैं @adw से सहमत हूं। मैं कभी भी एक शब्दकोश के साथ एक "वस्तु" (एक ओ ओ अर्थ में) का प्रतिनिधित्व नहीं करूंगा। शब्दकोश सकल नाम / मूल्य जोड़े। कक्षाएं वस्तुओं का प्रतिनिधित्व करती हैं। मैंने कोड देखा है जहां वस्तुओं को शब्दकोशों के साथ दर्शाया गया है और यह स्पष्ट नहीं है कि चीज़ का वास्तविक आकार क्या है। क्या होता है जब कुछ नाम / मान नहीं होते हैं? क्या ग्राहक को कुछ भी डालने से रोकता है या बाहर कुछ भी प्राप्त करने की कोशिश कर रहा है। चीज़ के आकार को हमेशा स्पष्ट रूप से परिभाषित किया जाना चाहिए।

पायथन का उपयोग करते समय अनुशासन के साथ निर्माण करना महत्वपूर्ण है क्योंकि भाषा लेखक को पैर में उसे / खुद को गोली मारने के कई तरीके देती है।

Question 7

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

इसलिए, कक्षा के साथ रहें।

Question 8

यदि आप जो हासिल करना चाहते हैं वह सब सिंटेक्स कैंडी की तरह obj.bla = 5है obj['bla'] = 5, खासकर यदि आपको यह दोहराना है कि बहुत कुछ, आप शायद कुछ सादे कंटेनर वर्ग का उपयोग करना चाहते हैं जैसे कि मार्टिनेस सुझाव। फिर भी, वहाँ कोड काफी फूला हुआ और अनावश्यक रूप से धीमा है। आप इसे इस तरह सरल रख सकते हैं:

class AttrDict(dict):
    """ Syntax candy """
    __getattr__ = dict.__getitem__
    __setattr__ = dict.__setitem__
    __delattr__ = dict.__delitem__

स्मृति उपयोग के namedtupleसाथ s या कक्षा में स्विच करने का एक और कारण __slots__हो सकता है। डायट को सूची प्रकारों की तुलना में बहुत अधिक मेमोरी की आवश्यकता होती है, इसलिए यह सोचने का बिंदु हो सकता है।

वैसे भी, आपके विशिष्ट मामले में, आपके वर्तमान कार्यान्वयन से दूर जाने के लिए कोई प्रेरणा प्रतीत नहीं होती है। आप इनमें से लाखों वस्तुओं को बनाए रखने के लिए प्रतीत नहीं होते हैं, इसलिए किसी भी सूची-व्युत्पन्न प्रकार की आवश्यकता नहीं है। और यह वास्तव में कुछ कार्यात्मक तर्क से युक्त है __init__, इसलिए आपको भी नहीं मिलना चाहिए AttrDict।

Question 9

यह संभव है कि आपका केक हो और इसे खाएं। दूसरे शब्दों में आप कुछ ऐसा बना सकते हैं जो एक वर्ग और शब्दकोश उदाहरण दोनों की कार्यक्षमता प्रदान करता है। ActiveState का Dɪᴄᴛɪᴏɴᴀʀʏ ᴡɪᴛʜ Active-sᴀᴄᴄᴇ .ss देखें नुस्खा देखें और करने के तरीकों पर टिप्पणी करें।

यदि आप उपवर्ग के बजाय एक नियमित कक्षा का उपयोग करने का निर्णय लेते हैं, तो मैंने पाया है कि Tɪᴍᴘʟᴇ sʙᴜᴛ ʙᴜᴛ ʜᴀɴᴅʏ "ᴀ a a a ᴛᴜғғ sᴛᴜғғ" recipess नुस्खा (एलेक्स मार्टेली द्वारा) बहुत ही लचीला और उपयोगी है। ऐसा लगता है कि आप कर रहे हैं (यानी जानकारी के सापेक्ष सरल एग्रीगेटर बनाएं)। चूंकि यह एक वर्ग है आप आसानी से तरीकों को जोड़कर इसकी कार्यक्षमता को और बढ़ा सकते हैं।

अंत में यह ध्यान दिया जाना चाहिए कि कक्षा के सदस्यों के नाम कानूनी पायथन पहचानकर्ता होने चाहिए, लेकिन शब्दकोष कुंजी नहीं है - इसलिए एक शब्दकोश उस संबंध में अधिक स्वतंत्रता प्रदान करेगा क्योंकि चाबियाँ कुछ भी हो सकती हैं (यहां तक कि एक स्ट्रिंग नहीं है)।

अपडेट करें

मॉड्यूल पायथन 3.3 में एक वर्ग object(जिसका कोई नहीं है __dict__) का नाम SimpleNamespace(जिसमें एक है) को जोड़ा गया था types, और अभी तक कोई अन्य विकल्प नहीं है।

Question 10

class ClassWithSlotBase:
    __slots__ = ('a', 'b',)

def __init__(self):
    self.a: str = "test"
    self.b: float = 0.0


def test_type_hint(_b: float) -> None:
    print(_b)


class_tmp = ClassWithSlotBase()

test_type_hint(class_tmp.a)

मैं एक वर्ग की सिफारिश करता हूं। यदि आप एक वर्ग का उपयोग करते हैं, तो आप दिखाए गए अनुसार प्रकार संकेत प्राप्त कर सकते हैं। और क्लास सपोर्ट ऑटो तब पूरा होता है जब क्लास फंक्शन का तर्क हो।