वर्गों का क्या मतलब है वस्तुएं हैं?

Question

मैं सिर्फ अजगर वर्ग दस्तावेज के बारे में पढ़ रहा था, यह कहता है, पाइथन में "कक्षाएं स्वयं वस्तुएं हैं"। क्या यह सी # या जावा कक्षाओं से अलग है? इस प्रकार के वर्गों के सी # या जावा के साथ तुलनात्मक लाभ और नुकसान क्या हैं?

Answer 1

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

व्यक्तिगत रूप से मुझे नहीं लगता कि अंतर इतना बड़ा सौदा है, लेकिन मुझे यकीन है कि हम इसके बारे में एक अच्छा धार्मिक युद्ध शुरू कर सकते हैं।

Answer 2

पायथन में, कक्षाएं इस अर्थ में वस्तुएं हैं कि आप उन्हें चर के लिए असाइन कर सकते हैं, उन्हें कार्यों में भेज सकते हैं, आदि किसी भी अन्य वस्तु की तरह। उदाहरण के लिए

>>> t = type(10) 
>>> t 
<type 'int'> 
>>> len(t.__dict__) 
55 
>>> t() # construct an int 
0 
>>> t(10) 
10 

जावा Class वस्तुओं जो एक वर्ग के बारे में कुछ जानकारी प्रदान है, लेकिन आप स्पष्ट वर्ग नाम के स्थान पर उनका उपयोग नहीं कर सकते हैं। वे वास्तव में कक्षाएं नहीं हैं, केवल वर्ग सूचना संरचनाएं हैं।

Class C = x.getClass(); 
new C(); // won't work 

Answer 3

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

पाइथन में एक वर्ग की तरह दिखता है वास्तव में एक वस्तु भी है।

यह here की तुलना में मैं कभी :)

Answer 4

कर सकते हैं की घोषणा एक वर्ग बस एक चर घोषित है ज्यादा बेहतर exlpained है:

class foo(object): 
    def bar(self): pass 
print foo # <class '__main__.foo'> 

वे सौंपा है और किसी भी चर की तरह रखा जा सकता है:

class foo(object): 
    pass 
class bar(object): 
    pass 
baz = bar # simple variable assignment 
items = [foo, bar] 
my_foo = items[0]() # creates a foo 
for x in (foo, bar): # create one of each type 
    print x() 

और एक चर के रूप में चारों ओर पारित किया गया:

class foo(object): 
    def __init__(self): 
     print "created foo" 
def func(f): 
    f() 

func(foo) 

वे आधार वर्ग सूची सहित काम करता है, के द्वारा बनाई जा सकता है:

def func(base_class, var): 
    class cls(base_class): 
     def g(self): 
      print var 
    return cls 

class my_base(object): 
    def f(self): print "hello" 

new_class = func(my_base, 10) 
obj = new_class() 
obj.f() # hello 
obj.g() # 10 

इसके विपरीत, जबकि जावा में कक्षाएं, उन्हें प्रतिनिधित्व करने जैसे वस्तुओं की है। String.class, कक्षा का नाम स्वयं - स्ट्रिंग - कोई ऑब्जेक्ट नहीं है और इसे एक के रूप में नहीं बदला जा सकता है। यह स्थैतिक रूप से टाइप की गई भाषाओं के लिए निहित है।

Answer 5

कक्षाएं ऑब्जेक्ट्स हैं कि वे किसी ऑब्जेक्ट की तरह पाइथन कोड में मैनिपुलेबल हैं। अन्य ने दिखाया है कि आप उन्हें कार्यों के आसपास कैसे पारित कर सकते हैं, जिससे उन्हें किसी ऑब्जेक्ट की तरह संचालित किया जा सकता है। यहां बताया गया है कि आप यह कैसे कर सकते हैं:

class Foo(object): 
    pass 

f = Foo() 

f.a = "a" # assigns attribute on instance f 
Foo.b = "b" # assigns attribute on class Foo, and thus on all instances including f 

print f.a, f.b 

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

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

Answer 6

वर्गों वस्तुओं होने का एक और लाभ यह है कि वस्तुओं कार्यावधि में अपने वर्ग बदल सकते हैं:

>>> class MyClass(object): 
...  def foo(self): 
...   print "Yo There! I'm a MyCLass-Object!" 
... 
>>> class YourClass(object): 
...  def foo(self): 
...   print "Guess what?! I'm a YourClass-Object!" 
... 
>>> o = MyClass() 
>>> o.foo() 
Yo There! I'm a MyCLass-Object! 
>>> o.__class__ = YourClass 
>>> o.foo() 
Guess what?! I'm a YourClass-Object! 

वस्तुओं एक विशेष गुण __class__ उस वर्ग जिनमें से वे एक उदाहरण हैं की ओर इशारा करता है। यह केवल इसलिए संभव है क्योंकि वर्ग स्वयं वस्तुएं हैं, और इसलिए __class__ जैसी विशेषता के लिए बाध्य किया जा सकता है।

Answer 7

चूंकि इस प्रश्न में एक छोटा सा टैग है, यह उत्तर स्मॉलटॉक परिप्रेक्ष्य से है। ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में, संदेश-पासिंग के माध्यम से चीजें होती हैं। यदि आप उस संदेश को समझते हैं, तो आप किसी ऑब्जेक्ट को संदेश भेजते हैं, यह संबंधित विधि निष्पादित करता है और एक मान देता है। लेकिन वस्तु पहली जगह कैसे बनाई गई है? यदि वस्तुओं को बनाने के लिए विशेष वाक्यविन्यास पेश किया गया है जो संदेश पासिंग के आधार पर सरल वाक्यविन्यास तोड़ देगा। यह वही है जावा जैसी भाषाओं में होता है:

p = new Point(10, 20); // Creates a new Point object with the help of a special keyword - new. 
p.draw(); // Sends the message `draw` to the Point object. 

यह ऊपर कोड से स्पष्ट है के रूप में, भाषा के दो तरीके से काम करने में करना पड़ता है - एक जरूरी और उन्मुखी अन्य वस्तु।

p := Point new: 10 y: 20. 
p draw. 

यहाँ new संदेश एक सिंगलटन वस्तु को भेजने Point जो एक Metaclass का एक उदाहरण है कहा जाता है: इसके विपरीत, स्मालटाक एक सुसंगत वाक्य रचना केवल संदेश सेवा के आधार पर है। भाषा को गणना का एक सतत मॉडल देने के अलावा, मेटाक्लास क्लास के गतिशील संशोधन की अनुमति देता है। उदाहरण के लिए, निम्न कथन एक रखता या वी एम पुनः आरंभ करने की आवश्यकता के बिना Point वर्ग के लिए एक नया उदाहरण चर जोड़ देगा:

Point addInstVarName: 'z'. 

इस विषय पर सबसे अच्छा पढ़ने The Art of the Metaobject Protocol है।