एक स्वस्थ व्यक्ति का स्पर्श

यह लेख पायथन के सर्वश्रेष्ठ आविष्कारों में से एक के बारे में है: नामित हम इसकी सुखद विशेषताओं पर विचार करेंगे, अच्छी तरह से ज्ञात से गैर-स्पष्ट तक। विषय में विसर्जन का स्तर धीरे-धीरे बढ़ेगा, इसलिए मुझे उम्मीद है कि हर कोई अपने लिए कुछ दिलचस्प पाएगा। चलो चलते हैं!

परिचय

निश्चित रूप से आप एक ऐसी स्थिति से सामना कर रहे हैं जहां आपको एक टुकड़े में ऑब्जेक्ट के कई गुणों को स्थानांतरित करने की आवश्यकता होती है। उदाहरण के लिए, एक पालतू जानवर के बारे में जानकारी: प्रकार, उपनाम और उम्र।

अक्सर इस चीज़ के लिए एक अलग वर्ग बनाने के लिए बहुत आलसी होता है, और ट्यूपल्स का उपयोग किया जाता है:

("pigeon", "", 3) ("fox", "", 7) ("parrot", "", 1) 

अधिक स्पष्टता के लिए, एक नामित टपल - संग्रह.नामताल उपयुक्त है:

 from collections import namedtuple Pet = namedtuple("Pet", "type name age") frank = Pet(type="pigeon", name="", age=3) >>> frank.age 3 

हर कोई यह जानता है are और यहाँ कुछ कम ज्ञात विशेषताएं हैं:

त्वरित परिवर्तन फ़ील्ड

क्या होगा यदि गुणों में से एक को बदलना होगा? फ्रैंक उम्र बढ़ने है, और मोटरसाइकिल अपरिवर्तनीय है। इसे पूरी तरह से _replace() न बनाने के लिए, हम _replace() विधि के साथ आए:

 >>> frank._replace(age=4) Pet(type='pigeon', name='', age=4) 

और अगर आप पूरी संरचना को परिवर्तनशील बनाना चाहते हैं - _asdict() :

 >>> frank._asdict() OrderedDict([('type', 'pigeon'), ('name', ''), ('age', 3)]) 

स्वचालित शीर्षक परिवर्तन

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

 # headers = ("name", "age", "with") >>> Pet = namedtuple("Pet", headers) ValueError: Type names and field names cannot be a keyword: 'with' # headers = ("name", "age", "name") >>> Pet = namedtuple("Pet", headers) ValueError: Encountered duplicate field name: 'name' 

समाधान का rename=True तर्क:

 # headers = ("name", "age", "with", "color", "name", "food") Pet = namedtuple("Pet", headers, rename=True) >>> Pet._fields ('name', 'age', '_2', 'color', '_4', 'food') 

"असफल" नामों को क्रम संख्या के अनुसार नाम दिया गया था।

डिफ़ॉल्ट मान

यदि टुपल में वैकल्पिक फ़ील्ड्स का एक गुच्छा है, तो आपको अभी भी हर बार जब आप एक ऑब्जेक्ट बनाते हैं, तो उन्हें सूचीबद्ध करना होगा:

 Pet = namedtuple("Pet", "type name alt_name") >>> Pet("pigeon", "") TypeError: __new__() missing 1 required positional argument: 'alt_name' >>> Pet("pigeon", "", None) Pet(type='pigeon', name='', alt_name=None) 

इससे बचने के लिए, निर्माता में defaults निर्दिष्ट करें:

 Pet = namedtuple("Pet", "type name alt_name", defaults=("",)) >>> Pet("pigeon", "") Pet(type='pigeon', name='', alt_name='') 

defaults पूंछ से डिफ़ॉल्ट मान प्रदान करता है। अजगर 3.7+ में काम करता है

पुराने संस्करणों के लिए, आप प्रोटोटाइप के माध्यम से समान परिणाम प्राप्त कर सकते हैं:

 Pet = namedtuple("Pet", "type name alt_name") default_pet = Pet(None, None, "") >>> default_pet._replace(type="pigeon", name="") Pet(type='pigeon', name='', alt_name='') >>> default_pet._replace(type="fox", name="") Pet(type='fox', name='', alt_name='') 

लेकिन defaults साथ, ज़ाहिर है, बहुत अच्छे।

असाधारण हल्कापन

नामित टपल के लाभों में से एक हल्कापन है। एक लाख कबूतरों की एक सेना को केवल 10 मेगाबाइट लगेंगे:

 from collections import namedtuple import objsize # 3rd party Pet = namedtuple("Pet", "type name age") frank = Pet(type="pigeon", name="", age=None) pigeons = [frank._replace(age=idx) for idx in range(100000)] >>> round(objsize.get_deep_size(pigeons)/(1024**2), 2) 10.3 

तुलना के लिए, यदि आप पेट को एक साधारण वर्ग बनाते हैं, तो एक समान सूची पहले से ही 19 मेगाबाइट पर कब्जा कर लेगी।

ऐसा इसलिए होता है क्योंकि अजगर में सामान्य वस्तुएं भारी __dict__ डैंडर ले जाती हैं, जिसमें ऑब्जेक्ट की सभी विशेषताओं के नाम और मूल्य होते हैं:

 class PetObj: def __init__(self, type, name, age): self.type = type self.name = name self.age = age frank_obj = PetObj(type="pigeon", name="", age=3) >>> frank_obj.__dict__ {'type': 'pigeon', 'name': '', 'age': 3} 

नामांकित वस्तुएं इस शब्दकोश से रहित हैं, और इसलिए कम स्मृति लेती हैं:

 frank = Pet(type="pigeon", name="", age=3) >>> frank.__dict__ AttributeError: 'Pet' object has no attribute '__dict__' >>> objsize.get_deep_size(frank_obj) 335 >>> objsize.get_deep_size(frank) 239 

लेकिन नामित टपल को __dict__ कैसे छुटकारा __dict__ ? ツ पर पढ़ें

समृद्ध आंतरिक दुनिया

यदि आप लंबे समय से अजगर के साथ काम कर रहे हैं, तो आप शायद जानते हैं: एक हल्की वस्तु __slots__ के माध्यम से बनाई जा सकती है:

 class PetSlots: __slots__ = ("type", "name", "age") def __init__(self, type, name, age): self.type = type self.name = name self.age = age frank_slots = PetSlots(type="pigeon", name="", age=3) 

"स्लॉट" ऑब्जेक्ट में विशेषताओं के साथ एक शब्दकोश नहीं है, इसलिए वे छोटी मेमोरी लेते हैं। "स्लॉट्स पर फ्रैंक" "मोटरसाइकिल पर फ्रैंक" के रूप में हल्का है, देखें:

 >>> objsize.get_deep_size(frank) 239 >>> objsize.get_deep_size(frank_slots) 231 

यदि आप यह तय करते हैं कि नामपट्ट भी स्लॉट का उपयोग करता है, तो यह सच्चाई से बहुत दूर नहीं है। जैसा कि आप याद करते हैं, विशिष्ट ट्यूपल कक्षाएं गतिशील रूप से घोषित की जाती हैं:

 Pet = namedtuple("Pet", "type name age") 

नामांकित निर्माणकर्ता अलग-अलग काले जादू का उपयोग करता है और इस वर्ग की तरह कुछ बनाता है (बहुत सरलीकृत):

 class Pet(tuple): __slots__ = () type = property(operator.itemgetter(0)) name = property(operator.itemgetter(1)) age = property(operator.itemgetter(2)) def __new__(cls, type, name, age): return tuple.__new__(cls, (type, name, age)) 

अर्थात्, हमारा पालतू एक साधारण tuple , जिसमें तीन संपत्ति विधियों को नाखूनों के साथ पिन किया गया है:

• type टपल के अशक्त तत्व को लौटाता है
• name - टपल का पहला तत्व
• age - टपल का दूसरा तत्व

और __slots__ केवल वस्तुओं को हल्का बनाने के लिए आवश्यक है। नतीजतन, पेट थोड़ी जगह लेता है और इसे नियमित रूप से इस्तेमाल किया जा सकता है:

 >>> frank.index("") 1 >>> type, _, _ = frank >>> type 'pigeon' 

चालाकी से आविष्कार किया, हुह?

डेटा वर्गों से हीन नहीं

चूंकि हम कोड जनरेशन की बात कर रहे हैं। अजगर 3.7 में, एक uber-जनरेटर कोड दिखाई दिया है, जिसमें कोई समान नहीं है - dataclasses।

जब आप पहली बार एक डेटा क्लास देखते हैं, तो आप इसके लिए भाषा के नए संस्करण में स्विच करना चाहते हैं:

 from dataclasses import dataclass @dataclass class PetData: type: str name: str age: int 

चमत्कार तो बहुत अच्छा है! लेकिन एक अति सूक्ष्म अंतर है - यह वसा है:

 frank_data = PetData(type="pigeon", name="", age=3) >>> objsize.get_deep_size(frank_data) 335 >>> objsize.get_deep_size(frank) 239 

डेटा वर्ग एक नियमित अजगर वर्ग उत्पन्न करता है, जिसकी वस्तुएं __dict__ के भार के नीचे समाप्त हो __dict__ । इसलिए यदि आप आधार से लाइनें पढ़ रहे हैं और उन्हें ऑब्जेक्ट में बदल रहे हैं, तो डेटा क्लास सबसे अच्छा विकल्प नहीं हैं।

लेकिन रुकिए, आप टूप्ले की तरह डेटा क्लास को फ्रीज कर सकते हैं। शायद तब यह आसान हो जाएगा?

 @dataclass(frozen=True) class PetFrozen: type: str name: str age: int frank_frozen = PetFrozen(type="pigeon", name="", age=3) >>> objsize.get_deep_size(frank_frozen) 335 

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

⌘ ⌘ ⌘

मुझे वास्तव में नामित टपल पसंद है:

• ईमानदार चलने योग्य,
• गतिशील प्रकार की घोषणा
• नामित विशेषता पहुंच
• हल्के और अपरिवर्तनीय।

और उसी समय यह कोड की 150 लाइनों में लागू किया जाता है। सुख के लिए और क्या चाहिए ツ

यदि आप मानक पायथन लाइब्रेरी के बारे में अधिक जानना चाहते हैं, तो @ohmypy चैनल को सब्सक्राइब करें