अजगर अज्ञात

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

तो चलिए चलते हैं।

चेनिंग तुलना ऑपरेटरों:

>>> 1 < 5 < 10 True >>> 1 < 11 < 10 False >>> 1 < 11 > 10 True 

सच्चाई यह है कि यदि आप कोष्ठक जोड़ते हैं तो सभी जादू टूट जाते हैं:

 >>> (1 < 11) > 10 False 

डॉक्टर

iter और दो मापदंडों

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

 with open('mydata.txt') as fp: for line in iter(fp.readline, ''): process_line(line) 

डॉक्टर

contextlib

आप आसानी से और खूबसूरती से अपनी खुद की वस्तुओं, कार्यों, आदि के लिए VAR के रूप में एक्सप्रेस के साथ वाक्यविन्यास का उपयोग करने की अनुमति देता है। प्रलेखन से उदाहरण:

 from contextlib import contextmanager @contextmanager def tag(name): print "[%s]" % name yield print "[/%s]" % name >>> with tag("h1"): ... print "foo" ... [h1] foo [/h1] 

डोका , पीईपी 343

डिफ़ॉल्ट तर्क

कई "हैक" हैं। सबसे पहले, डिफ़ॉल्ट तर्कों के रूप में उत्परिवर्तित वस्तुओं का उपयोग करना लगभग हमेशा एक बुरा विचार है:

 >>> def foo(a=list()): ... a.append(1) ... print a ... >>> foo() [1] >>> foo() [1, 1] >>> foo() [1, 1, 1] 

ऐसा क्यों? तर्कों का डिफ़ॉल्ट मान केवल एक बार निर्धारित किया जाता है जब फ़ंक्शन बनाया जाता है और func_defaults संपत्ति में संग्रहीत किया जाता है:

 >>> foo.func_defaults ([1, 1, 1],) 

लेकिन उपांग और एक उपयोगी नुस्खा में है। निम्न कोड अपेक्षित रूप से काम नहीं करता है:

 >>> l = [] >>> for i in range(3): ... l.append(lambda: i * 2) ... >>> for x in l: ... x() ... 4 4 4 

आप इसे केवल और सुरुचिपूर्ण ढंग से ठीक कर सकते हैं - बस लैम्ब्डा को बदलें : i * 2 को लैम्ब्डा के साथ i = i: i * 2 :

 >>> l = [] >>> for i in range(3): ... l.append(lambda i=i: i * 2) ... >>> for x in l: ... x() ... 0 2 4 

आप निष्पादन मॉडल में नाम और उनके लिए बाध्यकारी के बारे में पढ़ सकते हैं।

अंडाकार

संदर्भ के आधार पर ... (तीन अंक) एक मान्य वाक्यविन्यास हो सकता है। तो, सूची [...] ipsgetitem__ फ़ंक्शन के प्रकार एलिप्सिस के एक ऑब्जेक्ट को पास करता है - एक और अपनी तरह का केवल एक। प्रदर्शन:

 >>> class L(list): ... def __getitem__(self, *args): ... print args ... return list.__getitem__(self, *args) ... >>> l[...] (Ellipsis,) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in __getitem__ TypeError: list indices must be integers, not ellipsis 

Numpy में इस आकर्षण का इस्तेमाल किया।

परिवर्तनशील मूल्यों का आदान-प्रदान

10 वीं कक्षा में, हमें एक सूचनात्मक पाठ में एक कार्य की पेशकश की गई थी - एक तिहाई का उपयोग किए बिना दो चर के मूल्यों को स्वैप करने के लिए। पायथन में, यह एक सवाल भी नहीं है:

 >>> a = 10 >>> b = 5 >>> a, b (10, 5) >>> a, b = b, a >>> a, b (5, 10) 

नेस्टेड सूची की समझ

सूची समझ में, आप के लिए कई का उपयोग कर सकते हैं:

 >>> l = [[1,2,3], [4,5,6]] >>> [lll * 2 for ll in l for lll in ll] [2, 4, 6, 8, 10, 12] 

कई उत्परिवर्तनीय वस्तुओं का निर्माण

उदाहरण के लिए, आपको 5 सूचियों की सूची बनाने की आवश्यकता है। मैं यह करना चाहता हूं:

 >>> l = [[]] * 5 >>> l [[], [], [], [], []] 

लेकिन आप नहीं कर सकते:

 >>> l[0].append(1) >>> l [[1], [1], [1], [1], [1]] 

शायद इस तरह बेहतर:

 >>> l = [[] for _ in range(5)] 

रोट 13, string_escape, यूनिकोड_स्केप encodings

सुपर सीक्रेट Rot13 एन्क्रिप्शन विधि :

 >>> 'Hello world!'.encode('rot13') 'Uryyb jbeyq!' >>> 'Uryyb jbeyq!'.decode('rot13') u'Hello world!' 

अगला। उदाहरण के लिए, एक बाहरी स्रोत से एक स्ट्रिंग है, जबकि स्ट्रिंग में शाब्दिक \ n, \ t, \ r , आदि हैं। एक स्वरूपित स्ट्रिंग कैसे प्राप्त करें (वास्तव में, सुरक्षित निकासी करें )?

 >>> s = 'Hello\\n\\rworld!' >>> s 'Hello\\n\\rworld!' >>> repr(s) "'Hello\\\\n\\\\rworld!'" >>> print s.decode('string_escape') Hello world! 

यूनिकोड_स्केप इसी तरह काम करता है, केवल यूनिकोड के साथ, और स्ट्रिंग्स के साथ नहीं। वह यह भी जानता है कि स्ट्रिंग '\ u0457' को ":" अक्षर में कैसे बदलना है :

 >>> print '\u0457'.decode('unicode_escape') ї 

समर्थित एन्कोडिंग की सूची मानक-एनकोडिंग है ।

textwrap

ग्रंथों के साथ काम करने के लिए बहुत उपयोगी है। हम लंबी लाइन के साथ बहुत से छोटे बनाते हैं:

 >>> s = "Python is a programming language that lets you work more quickly and integrate your systems more effectively. You can learn to use Python and see almost immediate gains in productivity and lower maintenance costs." >>> print textwrap.fill(s, 25) Python is a programming language that lets you work more quickly and integrate your systems more effectively. You can learn to use Python and see almost immediate gains in productivity and lower maintenance costs. 

डॉक - अभी भी बहुत स्वादिष्ट है।

itertools

सरासर भावना। पढ़ें-फिर से न पढ़ें, विशेषकर व्यंजनों के साथ अनुभाग । यहाँ मुझे याद रखने वाला है:

 >>> def grouper(n, iterable, fillvalue=None): ... "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx" ... args = [iter(iterable)] * n ... return izip_longest(fillvalue=fillvalue, *args) ... >>> list(grouper(2, [1,2,3,4,5,6])) [(1, 2), (3, 4), (5, 6)] >>> list(grouper(3, [1,2,3,4,5,6])) [(1, 2, 3), (4, 5, 6)] >>> list(grouper(4, [1,2,3,4,5,6], fillvalue=0)) [(1, 2, 3, 4), (5, 6, 0, 0)] 

चाल यह है कि हम एक पुनरावृत्त के साथ काम करते हैं

समापन

अधिकांश जानकारी StackOverFlow पर एक अद्भुत विषय से है, बाकी की अपनी टिप्पणियां हैं। आप इस विषय पर बहुत कुछ लिख सकते हैं, इसलिए मैंने केवल सबसे दिलचस्प और उपयोगी साझा करने का प्रयास किया।
आपका ध्यान के लिए धन्यवाद!
प्रलेखन की शक्ति आपके साथ आ सकती है!

PS अगर कोई टिप्पणी है - मैं पीएम के संदेशों के लिए बहुत आभारी रहूंगा।