PyObject के साथ सवालों के जवाब

सभी को नमस्कार। इस लेख में मैं अजगर से pyobject.ru साइट पर प्रश्नों और कार्यों के उत्तर देने की कोशिश करूंगा, और यह भी बताऊंगा कि मैंने ऐसा क्यों किया। प्रश्न स्वयं यहाँ उपलब्ध हैं ।

अस्वीकरण :

मैं आपको तुरंत चेतावनी देता हूं: पोस्ट को सामान्य रूप से अजगर और प्रोग्रामिंग में नॉब लिखा गया है। यदि आपके पास स्पष्टीकरण और टिप्पणियां हैं (और वे, मुझे आशा है, होगा), कृपया लिखें।

सवालों के जवाबों को उसी श्रेणी में बांटा जाएगा।
पीएस पायथन I का संस्करण 2.6.6 है

तो चलिए शुरू करते हैं।

डेटा प्रकार, बुनियादी निर्माण

सुविधा के लिए, हम एक छोटा परीक्षण वर्ग बनाएंगे:

class Foo(object): """docstring for Foo""" arg1 = None _arg2 = None __arg3 = None def __init__(self): super(Foo, self).__init__() def bar(self): pass 

1. किसी वस्तु की सभी विशेषताओं की सूची कैसे प्राप्त करें

  print dir(Foo) 

2. किसी वस्तु की सभी सार्वजनिक विशेषताओं की सूची कैसे प्राप्त करें
पायथन में, "_" का उपयोग संरक्षित विशेषताओं को इंगित करने के लिए किया जाता है, और निजी के लिए, चर नाम से पहले "__"। इसलिए, केवल सार्वजनिक विशेषताओं की सूची प्राप्त करने के लिए, सभी विशेषताओं की सूची को फ़िल्टर किया जाना चाहिए। यह सूची अभिव्यक्तियों (सूची की समझ) की सहायता से किया जा सकता है:

  print [arg for arg in dir(Foo) if not arg.startswith('_')] 

या फ़िल्टर फ़ंक्शन का उपयोग करें:

  print filter(lambda x: not x.startswith('_'), dir(Foo)) 

मेरे लिए, पहला विकल्प बेहतर पठनीयता के कारण बेहतर है।

3. वस्तु विधियों की सूची कैसे प्राप्त करें
चूंकि पायथन में फ़ंक्शंस और तरीके पहली तरह की वस्तुएं हैं (जैसे कि सही ढंग से लिखा गया है?), फिर सत्यापन के लिए हम गेटअटर फ़ंक्शन का उपयोग करेंगे, जो ऑब्जेक्ट की विशेषता और कॉल करने योग्य फ़ंक्शन को लौटाता है, जो सत्यापन करता है।

  print [arg for arg in dir(Foo) if callable(getattr(Foo, arg))] #  print filter(lambda arg: callable(getattr(Foo, arg)), dir(Foo)) 

4. किस "मैजिक" चर में मदद की सामग्री संग्रहीत की जाती है?
__Doc__ विशेषता में। इस चर के तुरंत बाद एक टिप्पणी दर्ज की जाती है
क्लास / मेथड / फंक्शन डिक्लेरेशन (देखें टेस्ट क्लास)।

  print Foo.__doc__ 

आप अंतःक्रियात्मक रूप से सहायता फ़ंक्शन का उपयोग कर सकते हैं:

  >>> help(int) 

5. दो ट्यूपल हैं, पहले दो के संयोजन के रूप में तीसरा प्राप्त करें

  print (2, 5) + (4, 6) 

6. दो टुपल्स हैं, पहले दो टुपल्स के अनूठे तत्वों के मिलन के रूप में तीसरा प्राप्त करें
इस कार्य में, मैंने 2 दृष्टिकोण देखे:
1. ट्यूपल्स में एक तत्व की जांच के लिए लूप लिखें
2. अंतर्निहित सेट प्रकार (अनिवार्य रूप से एक हैश) का उपयोग करें, जिस पर तार्किक संचालन लागू किया जा सकता है।
दूसरे दृष्टिकोण का उपयोग कर समाधान (XOR का उपयोग करके):

  print tuple(set((2, 3, 4)) ^ set((4, 5))) 

7. क्यों, यदि सूची लूप में बदल जाती है, तो x के लिए lst [:] का उपयोग किया जाता है, जिसका अर्थ है: [:]?
[:] - एक अजगर में कटौती का पदनाम। आप उनके बारे में पढ़ सकते हैं, उदाहरण के लिए, यहाँ । संक्षेप में: [:] lst की एक प्रति बनाता है और पहले में परिवर्तन मूल मूल्यों पर चलना को प्रभावित नहीं करते हैं।

8. एक ही लंबाई की दो सूचियाँ हैं, एक कुंजी में, दूसरी मान में। एक शब्दकोश बनाओ।
हम जिप फ़ंक्शन का उपयोग करेंगे, जो मूल्यों की एक जोड़ी के ट्यूपल्स बनाता है, और तानाशाही, जो पारित तर्कों का एक शब्दकोश बनाता है।

  a = ('John', 'Peter') b = (1, 2) print dict(zip(a, b)) 

9. अलग-अलग लंबाई की दो सूचियाँ हैं, एक कुंजी में, दूसरी मानों में। एक शब्दकोश बनाओ। उन कुंजियों के लिए जिनके लिए कोई मूल्य नहीं हैं, मान के रूप में कोई भी उपयोग न करें मान जिसके लिए अनदेखी करने की कोई कुंजी नहीं है।

  a = ('John', 'Peter', 'Daniel') b = (1, 2) print dict((len(a) > len(b)) and map(None, a, b) or zip(a, b)) #    if/else,   Python 2.5 print dict(map(None, a, b) if (len(a) > len(b)) else zip(a, b)) 

इस मामले में, हम ज़िप, मानचित्र कार्यों का उपयोग करेंगे। ज़िप की एक विशेषता यह है कि वापसी का परिणाम सबसे कम चलने योग्य तक सीमित है। यही है, यह हमारे लिए एकदम सही है जब चाबियाँ से अधिक मूल्य हैं। दूसरी अजगर शाखा में, नक्शे में एक दस्तावेजित विशेषता होती है, अर्थात्, यदि कोई भी चलने योग्य मान दूसरों की तुलना में कम है, तो यह किसी के साथ पूरक नहीं है। यदि फ़ंक्शन के बजाय किसी को भी पारित नहीं किया जाता है, तो संघ का प्रदर्शन किया जाता है और आउटपुट पर हमें समान ट्यूपल्स मिलते हैं।
वैकल्पिक रूप से, itertools.izip_longest फ़ंक्शन का उपयोग करने पर विचार करें, जिसे 2.6 में जोड़ा गया था।

10. एक शब्दकोश है। इसे उल्टा कर दो। यानी जोड़े कुंजी: मूल्य स्वैप - मूल्य: कुंजी।

  a = {'John': 1, 'Peter': 2} print dict((val, key) for (key, val) in a.iteritems()) 

वैकल्पिक रूप से, ज़िप फ़ंक्शन का फिर से उपयोग करें।

  a = {'John': 1, 'Peter': 2} print dict(zip(a.itervalues(), a.iterkeys())) 

पीएस मैं गुरु से सुझाव देता हूं कि इस मामले में उपयोग करने के लिए क्या अधिक उपयुक्त है - ज़िप या इटर्टोलेसिसिप। यही मान मूल्यों / सिद्धांतों के लिए जाता है।

11. यूनिकोड में एक स्ट्रिंग है, utf-8 और cp1251 में एन्कोडेड 8-बिट स्ट्रिंग प्राप्त करें
मैंने लेख लिखने के समय सही लिखा था, लेकिन अगर मैंने कार्य को सही तरीके से समझा, तो:

  greeting = u'' print greeting.encode('utf-8') print greeting.encode('cp1251') 

12. एक cp1251 एन्कोडेड स्ट्रिंग है, एक यूनिकोड स्ट्रिंग प्राप्त करें
इसी तरह:

  greeting = '' print greeting.decode('cp1251') 

कार्यों

1. एक समारोह लिखें जिसमें आप एक सूची के रूप में या एक समय में एक या एक तर्कों को पारित कर सकते हैं। समारोह में सभी तर्क दिए गए हैं।
मैं निम्नानुसार समाधान देखता हूं: हस्तांतरित सूची पर पुनरावृत्ति। यदि सूची आइटम में __len__ विशेषता है, जिसका अर्थ है कि यह चलने योग्य है, तो इसे विस्तारित करें और इसे हमारे फ़ंक्शन में पास करें।

  def sum(*args): """ Returns sum of the args. >>> sum(1) 1 >>> sum(2, 2) 4 >>> sum(1, 2, (3, 4)) 10 >>> sum(1, ()) 1 >>> sum(-1, 1.0) 0.0 """ result = 0 for arg in args: if hasattr(arg, '__len__'): result += sum(*arg) else: result += arg return result 

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

  def addition_inner(val): """ >>> add5 = addition_inner(5) >>> add5(3) 8 >>> add1 = addition_inner(-1) >>> add1(3) 2 >>> add_str = addition_inner('s') >>> add_str(3) Traceback (most recent call last): ... TypeError: unsupported operand type(s) for +: 'int' and 'str' """ def func(arg): return arg + val return func def addition_lambda(val): """ >>> add5 = addition_lambda(5) >>> add5(3) 8 >>> add1 = addition_lambda(-1) >>> add1(3) 2 >>> add_str = addition_lambda('s') >>> add_str(3) Traceback (most recent call last): ... TypeError: unsupported operand type(s) for +: 'int' and 'str' """ return lambda x: x + val 

3. आइटम 2 के समान एक कारखाना लिखें, लेकिन इस तरह के कार्यों की सूची लौटाएं
इस मामले में, यह उन कार्यों की सूची को वापस करने के लिए समझ में आता है जो हमने ऊपर लिखे थे।
यह कुछ इस तरह दिखेगा:

  def additions(start, end): """ Returns list of addition functions >>> for addition in additions(0, 5): ... print addition(1) 1 2 3 4 5 >>> print additions(5, 0) [] >>> print additions(0, 2) # doctest: +ELLIPSIS [<function func at 0x...>, <function func at 0x...>] """ return [addition_inner(val) for val in range(start, end)] 

4. एक एनालॉग नक्शा लिखें:
- पहला तर्क या तो एक फ़ंक्शन या फ़ंक्शन की सूची है
- दूसरा तर्क - कार्यों को पारित करने के लिए तर्कों की एक सूची
- यह माना जाता है कि ये कार्य एक ही तर्क के कार्य हैं
मैंने इस कार्य को अंतर्निहित मानचित्र (एक विकल्प के रूप में - एक लूप द्वारा प्रतिस्थापित) का उपयोग करके कार्यान्वित किया। मैंने पास-पास मूल्य के प्रकार की जांच करने के लिए हैसट्रैट और __len__ मैजिक विधि के रूप में आइंस्टीन फ़ंक्शन और संग्रह मॉड्यूल का भी उपयोग किया।

  def mymap(func, args): """ Applies list of functions for args. >>> add0 = addition_inner(0) >>> add1 = addition_inner(1) >>> add2 = addition_inner(2) >>> add5 = addition_inner(5) >>> print mymap(add5, [1, 2, 3]) [6, 7, 8] >>> print mymap([add0, add1, add2], [1, 2, 3]) [(1, 2, 3), (2, 3, 4), (3, 4, 5)] >>> print mymap([], []) [] >>> print mymap(sum, [(3, 4, 5, 6, (7,))]) [25] """ if isinstance(func, collections.Iterable): return [tuple(map(f, args)) for f in func] #  #return [tuple(f(arg) for arg in args) for f in func] else: return [func(arg) for arg in args] 

iterators

थोड़ा विषयांतर। मुझे इट्रेटर कोड लिखने में ज्यादा बात नहीं दिखी, जैसा कि उनके कोड को itertools मॉड्यूल के प्रलेखन में वर्णित किया गया है। मुझे बेहतर लिखने की संभावना नहीं है।
Iterators जनरेटर पर आधारित हैं, जिनमें से एक उत्कृष्ट लेख है ।

मॉड्यूल

1. हमारे पास एक आयातित मॉड्यूल फू है, किसी फ़ाइल के भौतिक पथ का पता कैसे करें, यह कहां से आया है?
पथ __file__ मॉड्यूल विशेषता में संग्रहीत है।

2. फू मॉड्यूल से, आप फीडपसर मॉड्यूल को आयात करते हैं। फीडपरसर का एक्स संस्करण साइट-पैकेजों के सिस्टम-वाइड डायरेक्टरी में है, संस्करण वाई फू मॉड्यूल के बगल में है। पर्यावरण चर PYTHONPATH को परिभाषित किया गया है, और इसमें फीडरसर भी है, संस्करण Z. किस संस्करण का उपयोग किया जाएगा?
वर्जन Y आयात किया जाएगा।
प्रलेखन (ट्यूटोरियल के अनुभाग 6) के अनुसार, आयात आदेश निम्नानुसार है:
1. स्क्रिप्ट जो चलाया गया था, उसके आगे निर्देशिका
2. PYTHONPATH
3. सिस्टम कैटलॉग

3. निर्देशिका की सूची को कैसे देखना है जिसमें पायथन मॉड्यूल की खोज करता है?

  >>> import sys >>> sys.path 

4. आपके पास फू मॉड्यूल है, बार मॉड्यूल इसके अंदर आयात किया जाता है। Foo मॉड्यूल के बगल में बारकोड और बार / __ init__.py फाइलें हैं। किस मॉड्यूल का उपयोग किया जाएगा।
दूसरा उपयोग किया जाएगा, अर्थात् पैकेज। जैसा कि मैं इसे समझता हूं, निर्देशिकाओं का पुन: पता लगाया जाता है, और पैकेज पहले आयात किए जाते हैं।

5. __name__ == '__main__' का क्या अर्थ है और क्यों
यह निर्धारित करने के लिए उपयोग किया जाता है कि क्या कोई फ़ाइल आयात या लॉन्च की गई है। यदि हम इसे चलाते हैं, तो मान __main__ होगा, यदि हम इसे आयात करते हैं, तो मॉड्यूल का नाम।

आज सब है, धन्यवाद।
पीएस अगर किसी को दिलचस्पी होगी - मैं आखिरी 2 खंडों के उत्तर के अपने संस्करण लिखूंगा।