दिलचस्प पोस्ट
यह देखने के लिए सबसे अच्छा तरीका है कि डेटा तालिका में एक रिक्त मान है या नहीं पंजीकरण-मुक्त COM के लिए मैनिफ़ेस्ट फ़ाइल जनरेट करें Express.js पर HTTPS को सक्षम करना VB.NET में यादृच्छिक पूर्णांक क्रिप्टिक "स्क्रिप्ट त्रुटि।" क्रोम और फ़ायरफ़ॉक्स में जावास्क्रिप्ट में सूचना दी लम्बाई की सूची में आदिम लम्बे की एक सरणी परिवर्तित करें क्या समानता के लिए फ्लोटिंग पॉइंट वैल्यू 0 से जांचना सुरक्षित है? एक समारोह में कस्टम गुण जोड़ना CodeIgniter में विचारों के भीतर विचारों को शामिल करने का सर्वोत्तम तरीका जीएसएएन का उपयोग करते हुए बेतरतीब ढंग से जेनरेट किए गए और असंगत JSON फ़ील्ड / कुंजी नामों से निपटना जावा में एक सूची पर पुनरावृति करने के तरीके? अनुक्रमणिका त्रुटि: सीमा से बाहर सूची असाइनमेंट सूची सामग्री को फिट करने के लिए मैं एक UIScrollView को कैसे आकार देता हूं JQuery का उपयोग कर अक्षम विशेषता हटाएं? सिद्धांत 2.0 संस्थाओं के अंदर EntityManager का उपयोग करना

पायथन में सी-जैसे संरचनाएं

पायथन में सी-जैसी संरचना को आसानी से परिभाषित करने का कोई तरीका है? मैं सामान की तरह लिखने से थक गया हूँ:

class MyStruct(): def __init__(self, field1, field2, field3): self.field1 = field1 self.field2 = field2 self.field3 = field3 

वेब के समाधान से एकत्रित समाधान "पायथन में सी-जैसे संरचनाएं"

नामांकित ट्यूपल का उपयोग करें, जो पायथन 2.6 में मानक लाइब्रेरी में संग्रह मॉड्यूल में जोड़ा गया था। यदि आपको पायथन 2.4 का समर्थन करने की आवश्यकता है तो रेमंड हेटिंगर के नामित टपल व्यंजन का उपयोग करना भी संभव है।

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

 from collections import namedtuple MyStruct = namedtuple("MyStruct", "field1 field2 field3") 

नव निर्मित प्रकार इस तरह इस्तेमाल किया जा सकता है:

 m = MyStruct("foo", "bar", "baz") 

आप नामांकित तर्कों का उपयोग भी कर सकते हैं:

 m = MyStruct(field1="foo", field2="bar", field3="baz") 

आप कई चीजों के लिए एक ट्यूपल का उपयोग कर सकते हैं जहां आप सी में एक स्ट्रेट का उपयोग करेंगे (उदाहरण के लिए एक्स, वाई निर्देशांक या आरजीबी रंग जैसी कुछ)

बाकी सब के लिए आप डिक्शनरी, या इस तरह एक उपयोगिता वर्ग का उपयोग कर सकते हैं:

 >>> class Bunch: ... def __init__(self, **kwds): ... self.__dict__.update(kwds) ... >>> mystruct = Bunch(field1=value1, field2=value2) 

मुझे लगता है कि "निश्चित" चर्चा यहां है , पायथन कुकबुक के प्रकाशित संस्करण में

शायद आप कंस्ट्रक्टर्स के बिना स्ट्रोक्ट्स की तलाश कर रहे हैं:

 class Sample: name = '' average = 0.0 values = None # list cannot be initialized here! s1 = Sample() s1.name = "sample 1" s1.values = [] s1.values.append(1) s1.values.append(2) s1.values.append(3) s2 = Sample() s2.name = "sample 2" s2.values = [] s2.values.append(4) for v in s1.values: # prints 1,2,3 --> OK. print v print "***" for v in s2.values: # prints 4 --> OK. print v 

कैसे एक शब्दकोश के बारे में?

कुछ इस तरह:

 myStruct = {'field1': 'some val', 'field2': 'some val'} 

फिर आप इसका उपयोग मूल्यों में हेरफेर करने के लिए कर सकते हैं:

 print myStruct['field1'] myStruct['field2'] = 'some other values' 

और मूल्यों को स्ट्रिंग होने की ज़रूरत नहीं है वे बहुत ज्यादा किसी भी अन्य वस्तु हो सकते हैं

डीएफ: यह बहुत अच्छा है … मुझे नहीं पता था कि मैं डिक्ट का उपयोग कर एक कक्षा में खेतों तक पहुंच सकता था।

निशान: ऐसी परिस्थितियों का जो मैं चाहता हूं कि यह ठीक हो, जब मैं एक ट्यूपल चाहता हूं, लेकिन किसी शब्दकोष के रूप में "भारी"

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

… कौन सा आपकी दूसरी टिप्पणी पर ले जाता है पाइथन डिक्ट्स को मानना ​​है कि "भारी" एक अत्यंत गैर-अजवायनिक अवधारणा है और ऐसी टिप्पणियों को पढ़ने से मेरे पायथन ज़ेन को मारता है। यह अच्छा नहीं है।

आप देखते हैं, जब आप एक क्लास घोषित करते हैं तो आप वास्तव में एक शब्दकोश के आसपास एक बहुत ही जटिल आवरण बना रहे हैं – तो, ​​यदि कुछ भी हो, तो आप एक सरल शब्दकोश का उपयोग करके अधिक ऊपरी जोड़ रहे हैं एक ओवरहेड जो, वैसे, किसी भी मामले में अर्थहीन है। यदि आप प्रदर्शन महत्वपूर्ण अनुप्रयोगों पर काम कर रहे हैं, तो सी या कुछ का उपयोग करें

आप इनट पैरामीटर को स्थिति के आधार पर उदाहरण चर में भी दे सकते हैं

 # Abstract struct class class Struct: def __init__ (self, *argv, **argd): if len(argd): # Update by dictionary self.__dict__.update (argd) else: # Update by position attrs = filter (lambda x: x[0:2] != "__", dir(self)) for n in range(len(argv)): setattr(self, attrs[n], argv[n]) # Specific class class Point3dStruct (Struct): x = 0 y = 0 z = 0 pt1 = Point3dStruct() pt1.x = 10 print pt1.x print "-"*10 pt2 = Point3dStruct(5, 6) print pt2.x, pt2.y print "-"*10 pt3 = Point3dStruct (x=1, y=2, z=3) print pt3.x, pt3.y, pt3.z print "-"*10 

आप मानक संरचना में उपलब्ध सी संरचना को subclass कर सकते हैं। Ctypes मॉड्यूल एक संरचना वर्ग प्रदान करता है। डॉक्स से उदाहरण:

 >>> from ctypes import * >>> class POINT(Structure): ... _fields_ = [("x", c_int), ... ("y", c_int)] ... >>> point = POINT(10, 20) >>> print point.x, point.y 10 20 >>> point = POINT(y=5) >>> print point.x, point.y 0 5 >>> POINT(1, 2, 3) Traceback (most recent call last): File "<stdin>", line 1, in ? ValueError: too many initializers >>> >>> class RECT(Structure): ... _fields_ = [("upperleft", POINT), ... ("lowerright", POINT)] ... >>> rc = RECT(point) >>> print rc.upperleft.x, rc.upperleft.y 0 5 >>> print rc.lowerright.x, rc.lowerright.y 0 0 >>> 

जब भी मुझे "तत्काल डेटा ऑब्जेक्ट की ज़रूरत होती है जो भी एक शब्दकोश की तरह व्यवहार करता है" (मैं सी स्ट्रैक्ट्स के बारे में नहीं सोचता!), मैं इस प्यारा हैक के बारे में सोचता हूं:

 class Map(dict): def __init__(self, **kwargs): super(Map, self).__init__(**kwargs) self.__dict__ = self 

अब आप बस कह सकते हैं:

 struct = Map(field1='foo', field2='bar', field3=42) self.assertEquals('bar', struct.field2) self.assertEquals(42, struct['field3']) 

उन समय के लिए पूरी तरह से आसान होता है जब आपको "डेटा बैग जो कि एक वर्ग नहीं है" की आवश्यकता होती है, और जब नामित किया जाता है तो नाम के लिए समझ से बाहर हो …

आप निम्न प्रकार से अजगर में सी-स्टाइल संरचना का उपयोग कर सकते हैं।

 class cstruct: var_i = 0 var_f = 0.0 var_str = "" 

अगर आप बस cstruct के उद्देश्य का उपयोग करना चाहते हैं

 obj = cstruct() obj.var_i = 50 obj.var_f = 50.00 obj.var_str = "fifty" print "cstruct: obj i=%df=%fs=%s" %(obj.var_i, obj.var_f, obj.var_str) 

यदि आप cstruct की वस्तुओं की एक सरणी बनाना चाहते हैं

 obj_array = [cstruct() for i in range(10)] obj_array[0].var_i = 10 obj_array[0].var_f = 10.00 obj_array[0].var_str = "ten" #go ahead and fill rest of array instaces of struct #print all the value for i in range(10): print "cstruct: obj_array i=%df=%fs=%s" %(obj_array[i].var_i, obj_array[i].var_f, obj_array[i].var_str) 

नोट: 'cstruct' नाम के बजाय, कृपया var_i, var_f, var_str के बजाय अपने स्ट्रक्चर नाम का उपयोग करें, कृपया अपने संरचना के सदस्य चर को परिभाषित करें

मैंने एक डेकोरेटर लिखा था जिसे आप किसी भी तरीके से उपयोग करने के लिए इसका उपयोग कर सकते हैं ताकि सभी तर्कों को पारित किया जाए, या किसी भी चूक, उदाहरण के लिए आवंटित किए गए हैं

 def argumentsToAttributes(method): argumentNames = method.func_code.co_varnames[1:] # Generate a dictionary of default values: defaultsDict = {} defaults = method.func_defaults if method.func_defaults else () for i, default in enumerate(defaults, start = len(argumentNames) - len(defaults)): defaultsDict[argumentNames[i]] = default def newMethod(self, *args, **kwargs): # Use the positional arguments. for name, value in zip(argumentNames, args): setattr(self, name, value) # Add the key word arguments. If anything is missing, use the default. for name in argumentNames[len(args):]: setattr(self, name, kwargs.get(name, defaultsDict[name])) # Run whatever else the method needs to do. method(self, *args, **kwargs) return newMethod 

एक त्वरित प्रदर्शन ध्यान दें कि मैं एक स्थितीय तर्क का उपयोग करता हूं, b लिए डिफ़ॉल्ट मान का उपयोग करें, और एक नामांकित तर्क c । मैं तब सभी 3 संदर्भित self प्रिंट करने के लिए दिखाता हूं कि विधि दर्ज होने से पहले उन्हें ठीक से सौंपा गया है।

 class A(object): @argumentsToAttributes def __init__(self, a, b = 'Invisible', c = 'Hello'): print(self.a) print(self.b) print(self.c) A('Why', c = 'Nothing') 

ध्यान दें कि मेरे डेकोरेटर को किसी भी विधि के साथ काम करना चाहिए, न सिर्फ __init__

यह थोड़ी देर हो सकती है लेकिन मैंने पायथन मेटा-क्लासेस (डेकोरेटर संस्करण के नीचे भी) का उपयोग कर एक समाधान बनाया है।

जब __init__ को समय के दौरान कहा जाता है, यह प्रत्येक तर्क और उनके मूल्य को पकड़ लेता है और उन्हें अपने वर्ग के उदाहरण चर के रूप में निर्दिष्ट करता है। इस तरह से आप मैन्युअल रूप से प्रत्येक मूल्य को निर्दिष्ट किए बिना एक संरचना-जैसे वर्ग बना सकते हैं

मेरे उदाहरण में कोई त्रुटि जाँच नहीं है, इसलिए इसे पालन करना आसान है

 class MyStruct(type): def __call__(cls, *args, **kwargs): names = cls.__init__.func_code.co_varnames[1:] self = type.__call__(cls, *args, **kwargs) for name, value in zip(names, args): setattr(self , name, value) for name, value in kwargs.iteritems(): setattr(self , name, value) return self 

यहां यह कार्रवाई में है

 >>> class MyClass(object): __metaclass__ = MyStruct def __init__(self, a, b, c): pass >>> my_instance = MyClass(1, 2, 3) >>> my_instance.a 1 >>> 

मैंने इसे reddit पर पोस्ट किया और / u / matchu ने एक डेकोरेटर संस्करण पोस्ट किया जो क्लीनर है। मैं आपको इसे उपयोग करने के लिए प्रोत्साहित करता हूं जब तक कि आप मेटैक्लास संस्करण का विस्तार नहीं करना चाहते।

 >>> def init_all_args(fn): @wraps(fn) def wrapped_init(self, *args, **kwargs): names = fn.func_code.co_varnames[1:] for name, value in zip(names, args): setattr(self, name, value) for name, value in kwargs.iteritems(): setattr(self, name, value) return wrapped_init >>> class Test(object): @init_all_args def __init__(self, a, b): pass >>> a = Test(1, 2) >>> aa 1 >>> 

कुछ जवाब यहाँ व्यापक रूप से विस्तृत हैं मैंने सबसे आसान विकल्प पाया है (से: http://norvig.com/python-iaq.html ):

 class Struct: "A structure that can have any fields defined." def __init__(self, **entries): self.__dict__.update(entries) 

आरंभ:

 >>> options = Struct(answer=42, linelen=80, font='courier') >>> options.answer 42 

अधिक जोड़ने:

 >>> options.cat = "dog" >>> options.cat dog 

संपादित करें: माफ करना पहले से आगे नीचे यह उदाहरण नहीं देखा था।

पायथन 3.6 के बाद से यह काफी सरल और सुंदर हो गया (आईएमएचओ):

इसे इस तरह घोषित करें: (नोटिस, यह टाइप एनोटेशन के लिए अनुमति देता है)

 from typing import NamedTuple class MyStruct(NamedTuple): my_string: str my_int: int my_list: list my_dict: dict my_foo: Foo 

इसे इस तरह प्रयोग करें:

 my_item = MyStruct( my_string='foo', my_int=0, my_list=['bar'], my_dict={'baz': 'qux'}, my_foo=Foo('bar') ) 

या इस तरह अगर आप वास्तव में चाहते हैं:

 my_item = MyStruct('foo', 0, ['bar'], {'baz': 'qux'}, Foo('bar')) 

मुझे यह जवाब नहीं मिला, इसलिए मुझे लगता है कि मैं इसे जोड़ दूंगा क्योंकि मैं अभी अजगर झुका रहा हूं और बस इसे खोजा है। पायथन ट्यूटोरियल (इस मामले में पायथन 2) निम्नलिखित सरल और प्रभावी उदाहरण देता है:

 class Employee: pass john = Employee() # Create an empty employee record # Fill the fields of the record john.name = 'John Doe' john.dept = 'computer lab' john.salary = 1000 

वह है, एक खाली वर्ग ऑब्जेक्ट बनाया गया है, तत्काल, और फ़ील्ड गतिशील रूप से जोड़ दी गई है

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

 class Employee: def __init__ (self): self.name = None # or whatever self.dept = None self.salary = None 

अब एक नज़र में आप कम से कम यह देख सकते हैं कि कार्यक्रम किस फ़ील्ड की अपेक्षा की जाएगी।

दोनों टाइपो के लिए प्रवण हैं, john.slarly = 1000 सफल होंगे। फिर भी, यह काम करता है

निजी तौर पर, मुझे यह संस्करण बहुत पसंद है I यह @ डीएफ का उत्तर बढ़ाता है।

 class struct: def __init__(self, *sequential, **named): fields = dict(zip(sequential, [None]*len(sequential)), **named) self.__dict__.update(fields) def __repr__(self): return str(self.__dict__) 

यह प्रारंभ के दो तरीकों का समर्थन करता है (जो मिश्रित किया जा सकता है):

 # Struct with field1, field2, field3 that are initialized to None. mystruct1 = struct("field1", "field2", "field3") # Struct with field1, field2, field3 that are initialized according to arguments. mystruct2 = struct(field1=1, field2=2, field3=3) 

इसके अलावा, यह अच्छा प्रिंट करता है:

 print(mystruct2) # Prints: {'field3': 3, 'field1': 1, 'field2': 2} 

मुझे लगता है कि पायथन संरचना शब्दकोश इस आवश्यकता के लिए उपयुक्त है।

 d = dict{} d[field1] = field1 d[field2] = field2 d[field2] = field3 

https://stackoverflow.com/a/32448434/159695 पायथन 3 में काम नहीं करता है

https://stackoverflow.com/a/35993/159695 पायथन 3 में काम करता है

और मैं इसे डिफ़ॉल्ट मान जोड़ने के लिए विस्तारित करता हूं।

 class myStruct: def __init__(self, **kwds): self.x=0 self.__dict__.update(kwds) # Must be last to accept assigned member variable. def __repr__(self): args = ['%s=%s' % (k, repr(v)) for (k,v) in vars(self).items()] return '%s(%s)' % ( self.__class__.__qualname__, ', '.join(args) ) a=myStruct() b=myStruct(x=3,y='test') c=myStruct(x='str') >>> a myStruct(x=0) >>> b myStruct(x=3, y='test') >>> c myStruct(x='str')