पायथन की छिपी विशेषताएं [बंद]

1419

पायथन प्रोग्रामिंग भाषा की कम-ज्ञात लेकिन उपयोगी विशेषताएं क्या हैं?

  • पायथन कोर के उत्तरों को सीमित करने का प्रयास करें।
  • प्रति उत्तर एक विशेषता।
  • एक उदाहरण और सुविधा का संक्षिप्त विवरण दें, न कि केवल प्रलेखन का एक लिंक।
  • पहली पंक्ति के रूप में शीर्षक का उपयोग करके सुविधा को लेबल करें।

उत्तरों के त्वरित लिंक:

python  hidden-features 
— कंपी
स्रोत

जवाबों:

740

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

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

मामले में आप सोच रहे हैं कि यह क्या कर रहा है 1 < xजो के रूप में बाहर आता है, Trueहै, और फिर की तुलना True < 10है, जो भी है True, तो कोई क्या होता है, नहीं है कि वास्तव में (पिछले उदाहरण देखें।) यह वास्तव में में अनुवाद है 1 < x and x < 10, और x < 10 and 10 < x * 10 and x*10 < 100है, लेकिन कम लिख कर और प्रत्येक के साथ शब्द का केवल एक बार मूल्यांकन किया जाता है।

— थॉमस वाउटर्स
स्रोत
121
यह बहुत मददगार है। यह सभी भाषाओं के लिए मानक होना चाहिए। अफसोस की बात है, यह नहीं है।
— स्टैलिपेटेज़ेल
8
आपको कुछ उदाहरण जोड़ने चाहिए जो झूठी अस्वस्थता लौटाते हैं। जैसे >>> 10 <x <20 असत्य
— जूती
19
यह अन्य तुलना ऑपरेटरों के लिए भी लागू होता है, यही वजह है कि लोग कभी-कभी आश्चर्यचकित होते हैं कि क्यों कोड (जैसे [5] में सच है) गलत है (लेकिन यह इस तरह से शुरू करने के लिए बूलियन के खिलाफ स्पष्ट रूप से परीक्षण करने के लिए अस्वाभाविक है)।
— मील्स
19
अच्छा है, लेकिन समान समानता के लिए देखें, जैसे 'में' और '='। 'ए' बी == सी में डी 'का मतलब है' (ए बी में) और (बी == सी) और (डी में सी) 'जो अप्रत्याशित हो सकता है।
— चार्ल्स मेरियम
15
अज़फे: लिस्प की तुलना स्वाभाविक रूप से इस तरह से काम करती है। यह एक विशेष मामला नहीं है क्योंकि व्याख्या करने के लिए कोई अन्य (उचित) तरीका नहीं है (< 1 x 10)। आप उन्हें एकल तर्कों पर भी लागू कर सकते हैं, जैसे (= 10): cs.cmu.edu/Groups/AI/html/hyperspec/HyperSpec/Body/…
— Ken
512

अपने रेगेक्स को डीबग करने के लिए अजगर रेगेक्स पार्स ट्री प्राप्त करें।

नियमित अभिव्यक्ति अजगर की एक बड़ी विशेषता है, लेकिन उन्हें डीबग करना एक दर्द हो सकता है, और यह सब बहुत आसान है कि एक rexx गलत हो।

सौभाग्य से, अजगर रेगेक्स पार्स ट्री को अविवादित, प्रायोगिक, छिपे हुए ध्वज re.DEBUG(वास्तव में, 128) से पारित करके प्रिंट कर सकता है re.compile।

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

एक बार जब आप वाक्यविन्यास को समझ जाते हैं, तो आप अपनी त्रुटियों को देख सकते हैं। हम वहाँ देख सकते हैं कि मैं बचने के लिए भूल गया []में [/font]।

निश्चित रूप से आप इसे जो चाहे झंडे के साथ जोड़ सकते हैं, जैसे टिप्पणी regexes:

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)
— बैचैक्स
स्रोत
3
नियमित अभिव्यक्ति का उपयोग करते हुए HTML को छोड़कर धीमा और दर्दनाक है। यहां तक ​​कि अंतर्निहित 'html' पार्सर मॉड्यूल काम पूरा करने के लिए regexes का उपयोग नहीं करता है। और अगर html मॉड्यूल आपको खुश नहीं करता है, तो XML / HTML पार्सर मॉड्यूल के बहुत सारे हैं जो पहिया को सुदृढ़ किए बिना काम करता है।
— बैचिएक्स
आउटपुट सिंटैक्स पर प्रलेखन के लिए एक लिंक बहुत अच्छा होगा।
— कार्मिक
1
यह पायथन का एक आधिकारिक हिस्सा होना चाहिए, प्रयोगात्मक नहीं ... RegEx हमेशा मुश्किल है और जो कुछ भी हो रहा है उसका पता लगाने में सक्षम होना वास्तव में उपयोगी है।
— काहिट
460

की गणना

एन्यूमरेट के साथ एक पुनरावृत्ति लपेटें और यह अपने सूचकांक के साथ आइटम का उत्पादन करेगा।

उदाहरण के लिए:


>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

संदर्भ:

— डेव
स्रोत
56
मुझे आश्चर्य है कि यह अजगर सूचियों के बारे में बात करने वाले ट्यूटोरियल में नियमित रूप से शामिल नहीं है।
— ड्रेमन नोव 27'08
45
और यह सब इस समय मैं इस तरह से कोडिंग कर रहा था: i for रेंज (len (a)): ... और फिर वर्तमान आइटम प्राप्त करने के लिए [i] का उपयोग कर रहा हूं।
— फर्नांडो मार्टिन
4
@ जीरी सकलाला: मेरी जानकारी के लिए, इसे पदावनत नहीं किया गया है।
— JAB
23
पवित्र बकवास यह भयानक है। i in xrange (len (a)) के लिए: हमेशा से मेरा सबसे कम पसंदीदा अजगर मुहावरा रहा है।
— कार्मिक
15
गणना करना मनमाने ढंग से सूचकांक से शुरू हो सकता है, आवश्यक नहीं 0. उदाहरण: 'i के लिए, enumerate में आइटम ( सूची , प्रारंभ = 1): प्रिंट i, आइटम' 1 से गणना शुरू करेगा, न कि 0.
— dmitry_romanov
419

जनरेटर वस्तुओं का निर्माण

अगर आप लिखेंगे 

x=(n for n in foo if bar(n))

आप जनरेटर को बाहर निकाल सकते हैं और इसे एक्स को असाइन कर सकते हैं। अब इसका मतलब है कि आप कर सकते हैं

for n in x:

इसका फायदा यह है कि आपको इंटरमीडिएट स्टोरेज की जरूरत नहीं है, जो आपको चाहिए तो होगा

x = [n for n in foo if bar(n)]

कुछ मामलों में यह महत्वपूर्ण गति बढ़ा सकता है।

जनरेटर के अंत में दिए गए कथनों में आप कई जोड़ सकते हैं, मूल रूप से लूप के लिए नेस्टेड की नकल करना:

>>> n = ((a,b) for a in range(0,2) for b in range(4,6))
>>> for i in n:
...   print i 

(0, 4)
(0, 5)
(1, 4)
(1, 5)
— फ्रीस्पेस
स्रोत
तुम भी उस के लिए एक नेस्टेड सूची समझ का उपयोग कर सकते हैं, हाँ?
— मई'09
54
विशेष रूप से नोट मेमोरी ओवरहेड बचत है। मानों की गणना ऑन-डिमांड होती है, इसलिए आपके पास स्मृति में सूची की समझ का संपूर्ण परिणाम कभी नहीं होता है। यह विशेष रूप से वांछनीय है यदि आप बाद में सूची समझ के केवल भाग पर पुनरावृति करते हैं।
— दोपहर
19
यह विशेष रूप से "छिपी" इमो नहीं है, लेकिन यह भी ध्यान देने योग्य है कि आप एक जनरेटर ऑब्जेक्ट को रिवाइंड नहीं कर सकते हैं, जबकि आप किसी भी समय किसी भी सूची को दोहरा सकते हैं।
— susmits
13
जनरेटर का "नो रिवाइंड" फीचर कुछ भ्रम पैदा कर सकता है। विशेष रूप से, यदि आप डिबगिंग के लिए जनरेटर की सामग्री को प्रिंट करते हैं, तो डेटा को संसाधित करने के लिए बाद में इसका उपयोग करें, यह काम नहीं करता है। डेटा का उत्पादन किया जाता है, प्रिंट द्वारा उपभोग किया जाता है (), फिर सामान्य प्रसंस्करण के लिए उपलब्ध नहीं होता है। यह सूची समझ पर लागू नहीं होता है, क्योंकि वे पूरी तरह से मेमोरी में संग्रहीत हैं।
— जॉनटेल्सल
4
इसी तरह (डुबकी?) उत्तर: stackoverflow.com/questions/101268/hidden-features-of-python/… ध्यान दें, हालांकि, मैंने जो उत्तर यहां दिया है, वह जनरेटर की शक्ति के बारे में एक बहुत अच्छी प्रस्तुति का उल्लेख करता है। आपको वास्तव में इसकी जांच करनी चाहिए।
— डेनिलसन से माया
353

iter () एक कॉल करने योग्य तर्क ले सकता है

उदाहरण के लिए:

def seek_next_line(f):
    for c in iter(lambda: f.read(1),'\n'):
        pass

iter(callable, until_value)समारोह को बार-बार कहता है callableऔर उसके परिणाम पैदावार तक until_valueदिया जाता है।

— mbac32768
स्रोत
अजगर के लिए एक नौसिखिया के रूप में, क्या आप कृपया समझा सकते हैं lambdaकि यहां कीवर्ड क्यों आवश्यक है?
— सेजएक्स
@ लैम्ब्डा के बिना SiegeX, f.read (1) का मूल्यांकन किया जाएगा। इसके बजाय, लैम्ब्डा एक गुमनाम फ़ंक्शन बनाता है और इसे पुनरावृत्ति करता है।
— jmilloy
339

परिवर्तनशील डिफ़ॉल्ट तर्कों के साथ सावधान रहें

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

इसके बजाय, आपको "नहीं दिया गया" बताकर एक प्रहरी मूल्य का उपयोग करना चाहिए और उस परिवर्तनशील को बदलना होगा जिसे आप डिफ़ॉल्ट रूप से पसंद करेंगे:

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]
— जेसन बेकर
स्रोत
39
यह निश्चित रूप से अधिक छिपी हुई विशेषताओं में से एक है। मैंने समय-समय पर इसमें भाग लिया है।
— टॉर्स्टन मारेक
77
मुझे यह समझने में बहुत आसान लगा जब मैंने सीखा कि डिफ़ॉल्ट तर्क एक टपल में रहते हैं जो फ़ंक्शन की विशेषता है, उदाहरण के लिए foo.func_defaults। जो, एक टपल है, अपरिवर्तनीय है।
— रॉबर्ट रॉसनी
2
@grayger: जैसे ही कथन को निष्पादित किया जाता है, उसके तर्क का मूल्यांकन दुभाषिया द्वारा किया जाता है। यह एक कोड ऑब्जेक्ट (फ़ंक्शन का सूट) के लिए एक नाम (या रिबंड) बनाता है। हालाँकि, परिभाषा के समय डिफ़ॉल्ट तर्कों को ऑब्जेक्ट के रूप में त्वरित किया जाता है। यह डिफ़ॉल्ट ऑब्जेक्ट के किसी भी समय का सच है, लेकिन केवल महत्वपूर्ण (दृश्यमान शब्दार्थ को उजागर करना) जब ऑब्जेक्ट उत्परिवर्तित होता है। पुन: बाइंड करने का कोई तरीका नहीं है जो फ़ंक्शन के बंद होने में डिफ़ॉल्ट तर्क नाम है, हालांकि यह स्पष्ट रूप से किसी भी कॉल के लिए ओवर-राइड किया जा सकता है या पूरे फ़ंक्शन को फिर से परिभाषित किया जा सकता है)।
— जिम डेनिस
3
@Robert बेशक तर्क तुच्छ हो सकता है, लेकिन यह जिन वस्तुओं को इंगित करता है, वे अपरिवर्तनीय नहीं हैं।
— पूलि
16
एक त्वरित हैक आपके आरंभीकरण को थोड़ा छोटा करने के लिए: x = x या []। यदि आप 2 लाइन के बजाए स्टेटमेंट का उपयोग कर सकते हैं।
— mankoff
317

जनरेटर कार्यों में मूल्यों को भेजना । इस समारोह में होने वाले उदाहरण के लिए:

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

आप ऐसा कर सकते हैं:

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7
— राफेल डाउगर्ड
स्रोत
माना। आइए इसे पाइथन की एक छिपी विशेषता का एक बुरा उदाहरण के रूप में मानते हैं :)
— राफेल डोवगर्ड
89
अन्य भाषाओं में, मेरा मानना ​​है कि इस जादुई उपकरण को "चर" कहा जाता है।
— finnw
5
कॉरटॉयन्स को कॉरटाइन होना चाहिए और जेनराइटर खुद भी होना चाहिए, बिना मिक्स किए। मेगा-ग्रेट लिंक और बात और इस बारे में उदाहरण यहां हैं: dabeaz.com/coroutines
— u0b34a0f6ae
31
@finnw: उदाहरण एक चर के समान कुछ लागू करता है। हालाँकि, सुविधा का उपयोग कई अन्य तरीकों से किया जा सकता है ... एक चर के विपरीत। यह भी स्पष्ट होना चाहिए कि वस्तुओं के उपयोग से समान शब्दार्थ को लागू किया जा सकता है ( विशेष रूप से पायथन की कॉल विधि को लागू करने वाला एक वर्ग )।
— जिम डेनिस
4
यह उन लोगों के लिए बहुत तुच्छ उदाहरण है, जिन्होंने सह-दिनचर्या कभी नहीं देखी (और शायद समझ नहीं पाएंगे)। उदाहरण जो चर चर ओवरफ्लो के जोखिम के बिना चल रहे औसत को लागू करता है वह एक अच्छा है।
— प्रशांत कुमार
313

यदि आप स्कोप को निरूपित करने के लिए व्हाट्सएप का उपयोग करना पसंद नहीं करते हैं, तो आप जारी करके C- शैली {} का उपयोग कर सकते हैं:

from __future__ import braces
— eduffy
स्रोत
122
वह दुष्ट है। :)
— जेसन बेकर
37
>>> __future__ से इंपोर्ट ब्रेसेस फ़ाइल "<stdin>", लाइन 1 सिंटैक्सएयर: मौका नहीं: पी
— बेंजामिन डब्ल्यू। स्मिथ
40
वह निन्दा है!
— बर्क डी। डेमिर
335
मुझे लगता है कि हमारे यहाँ एक वाक्य रचना में गलती हो सकती है, क्या यह " __past__ आयात ब्रेसिज़" से नहीं होना चाहिए ?
— बिल के
47
से __cruft__ आयात ब्रेसिज़
— फिलिप बी ओल्डम
305

स्लाइस ऑपरेटरों में कदम तर्क। उदाहरण के लिए:

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

विशेष मामला x[::-1]'एक्स उलट' के लिए एक उपयोगी मुहावरा है।

>>> a[::-1]
[5,4,3,2,1]
— राफेल डाउगर्ड
स्रोत
31
बहुत स्पष्ट, मेरी राय में, उलटा () फ़ंक्शन है। >>> सूची (प्रत्यावर्तित (श्रेणी (4))) [3, 2, 1, 0]
— क्रिश्चियन औडार्ड
3
फिर कैसे "इस ia string" [:: - 1] को बेहतर तरीके से लिखना है? उलटा नहीं लगता है मदद करने के लिए
— बेरी Tsakala
24
उलट () के साथ समस्या यह है कि यह एक पुनरावृत्ति देता है, इसलिए यदि आप उलटे अनुक्रम के प्रकार (टपल, स्ट्रिंग, सूची, यूनिकोड, उपयोगकर्ता प्रकार ...) को संरक्षित करना चाहते हैं, तो आपको इसे वापस बदलने के लिए एक अतिरिक्त कदम की आवश्यकता है। ।
— राफेल डाउगर्ड
6
def रिवर्स_स्ट्रिंग (स्ट्रिंग): वापसी स्ट्रिंग [:: - 1]
— पी।
4
@ मुझे लगता है कि अगर कोई आपके पास रिवर्स_स्ट्रिंग को परिभाषित करने के लिए पर्याप्त जानता है, तो आप अपने कोड में [:: - 1] छोड़ सकते हैं और इसके अर्थ के साथ सहज हो सकते हैं और यह उचित है।
— भौतिक विज्ञान
289

सज्जाकार

डेकोरेटर किसी अन्य फ़ंक्शन में एक फ़ंक्शन या विधि को लपेटने की अनुमति देते हैं जो कार्यक्षमता जोड़ सकते हैं, तर्कों या परिणामों को संशोधित कर सकते हैं, आदि आप डेकोरेटर को फ़ंक्शन परिभाषा के ऊपर एक पंक्ति लिख सकते हैं, जो कि "at" साइन (@) के साथ शुरू होता है।

उदाहरण एक print_argsडेकोरेटर को दिखाता है जो कॉल करने से पहले सजाए गए फ़ंक्शन के तर्कों को प्रिंट करता है:

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo
— DzinX
स्रोत
54
जब डेकोरेटर्स को परिभाषित करते हैं, तो मैं @ डेकोरेटर के साथ डेकोरेटर को सजाने की सलाह दूंगा। यह एक डेकोरेटर बनाता है जो उस पर आत्मनिरीक्षण करते समय फ़ंक्शंस सिग्नेचर को संरक्षित करता है। अधिक यहाँ जानकारी: phyast.pitt.edu/~micheles/python/documentation.html
— sirwart
45
यह एक छिपी हुई विशेषता कैसे है?
— वेटल
50
खैर, यह सबसे सरल पायथन ट्यूटोरियल में मौजूद नहीं है, और मैंने पायथन का उपयोग शुरू करने के काफी समय बाद इस पर ठोकर खाई। यही कारण है कि मैं एक छिपी हुई सुविधा को कॉल करूंगा, बस यहां अन्य शीर्ष पदों के समान ही।
— DzinX
16
vetler, प्रश्न "पायथन प्रोग्रामिंग भाषा की कम-ज्ञात लेकिन उपयोगी विशेषताओं" के लिए पूछता है। आप 'कम-ज्ञात लेकिन उपयोगी सुविधाओं' को कैसे मापते हैं? मेरा मतलब है कि इन प्रतिक्रियाओं में से कोई भी छिपी हुई विशेषताएं कैसे हैं?
— जोहड़
4
@vetler यहाँ ज्यादातर बात शायद ही "छिपी" हो।
— हम्फ्रे बोगार्ट
288

के लिए ... और सिंटैक्स ( http://docs.python.org/ref/for.html देखें )

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

"और" ब्लॉक सामान्य रूप से लूप के अंत में निष्पादित किया जाएगा, जब तक कि ब्रेक को नहीं कहा जाता है।

उपरोक्त कोड निम्नानुसार अनुकरण किया जा सकता है:

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")
— rlerallut
स्रोत
218
मुझे लगता है कि इसके लिए / अन्यथा सिंटैक्स अजीब है। यह "लगता है" के रूप में अगर लूप के शरीर को कभी निष्पादित नहीं किया जाता है तो दूसरे खंड को निष्पादित किया जाना चाहिए।
— कोडपे
14
आह। कभी नहीं देखा कि एक! लेकिन मुझे कहना होगा कि यह एक मिथ्या नाम है। और कौन उम्मीद करेगा कि ब्लॉक तभी क्रियान्वित करेगा जब ब्रेक कभी नहीं होगा? मैं कोडी के साथ सहमत हूं: ऐसा लगता है कि खाली फॉस के लिए प्रवेश किया गया है।
— डैरन थॉमस
52
ऐसा लगता है कि कीवर्ड अंततः होना चाहिए, और नहीं
— जियारो
21
अंत में छोड़कर पहले से ही एक तरह से उपयोग किया जाता है जहां उस सूट को हमेशा निष्पादित किया जाता है।
7
निश्चित रूप से 'और ’नहीं होना चाहिए। शायद 'तब' या कुछ और, और फिर 'और' के लिए जब लूप को कभी निष्पादित नहीं किया गया था।
— टॉर वालोमा
258

2.5 के बाद से dicts के पास एक विशेष विधि है __missing__जो कि लापता वस्तुओं के लिए मंगाई जाती है:

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

वहाँ भी collectionsकहा जाता है defaultdictकि बहुत ज्यादा एक ही है, लेकिन मौजूदा आइटम नहीं के लिए तर्क के बिना एक समारोह कहता है में एक तानाशाह उपवर्ग है :

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

मैं ऐसे डक्ट्स को ऐसे कार्यों के लिए पास करने से पहले नियमित डाइट में परिवर्तित करने की सलाह देता हूं जो ऐसे उपवर्गों की अपेक्षा नहीं करते हैं। d[a_key]यदि कोई आइटम मौजूद है जो एक नए आइटम को तानाशाही में जोड़ देगा, तो यह देखने के लिए कि कोडर का बहुत सारे कोड उपयोग और कैच करते हैं।

— अरमिन रोनाचेर
स्रोत
10
मैं सेटडेफॉल्ट का उपयोग करना पसंद करता हूं। m = {}; m.setdefault ('फू', 1)
— ग्रेगर
22
@grayger का मतलब यही था m={}; m.setdefault('foo', []).append(1)।
— क्रिस्टियन सियुपिटु
1
हालांकि ऐसे मामले हैं जहां डिफ़ॉल्ट को पारित करना बहुत आसान है। फ़ंक्शन उदाहरण के लिए मान से अधिक पुनरावृत्ति कर सकता है और यह अतिरिक्त कोड के बिना अपरिभाषित कुंजी के लिए काम करता है, क्योंकि डिफ़ॉल्ट एक खाली सूची है।
— मैरिएन
3
डिफ़ॉल्ट स्थिति सेटडिफ़ॉल्ट की तुलना में कुछ परिस्थितियों में बेहतर है, क्योंकि यह डिफ़ॉल्ट ऑब्जेक्ट तब तक नहीं बनाता है जब तक कि कुंजी गायब न हो। सेटडेफ़ॉल्ट यह बनाता है कि यह गायब है या नहीं। यदि आपका डिफ़ॉल्ट ऑब्जेक्ट बनाना महंगा है, तो यह एक प्रदर्शन हिट हो सकता है - मुझे सभी सेटडेफ़ॉल्ट कॉल को बदलकर एक प्रोग्राम से एक अच्छा स्पीडअप मिला।
— 17
2
defaultdictsetdefaultअन्य मामलों में विधि की तुलना में अधिक शक्तिशाली है । उदाहरण के लिए, एक काउंटर के लिए- dd = collections.defaultdict(int) ... dd[k] += 1बनाम d.setdefault(k, 0) += 1।
— माइक ग्राहम
247

इन-प्लेस मान स्वैपिंग

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

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

असाइनमेंट का राइट-हैंड साइड एक अभिव्यक्ति है जो एक नया टपल बनाता है। असाइनमेंट का बायाँ हाथ तुरंत अनपैक कर देता है जो (अप्रतिबंधित) नामों पर टैप करता है aऔर b।

काम के बाद, नए टपल unreferenced जाता है और कचरा संग्रहण के लिए चिह्नित किया है, और मूल्यों के लिए बाध्य aऔर bबदली की है।

जैसा कि डेटा संरचनाओं पर पायथन ट्यूटोरियल अनुभाग में उल्लेख किया गया है ,

ध्यान दें कि एकाधिक असाइनमेंट वास्तव में टपल पैकिंग और सीक्वेंस अनपैकिंग का संयोजन है।

— लुकास एस।
स्रोत
1
क्या यह पारंपरिक तरीके से अधिक वास्तविक मेमोरी का उपयोग करता है? मुझे लगता है कि आप केवल एक स्वैप चर के बजाय एक टपल बना रहे हैं
— नाथन
75
यह अधिक मेमोरी का उपयोग नहीं करता है। यह कम उपयोग करता है .. मैंने इसे बस दोनों तरीके से लिखा है, और बाय -कोड को डी-संकलित किया है .. कंपाइलर अनुकूलन करता है, जैसा कि आप यह उम्मीद करेंगे। डिस परिणाम से पता चला कि यह var सेट कर रहा है, और फिर ROT_TWOing। ROT_TWO का अर्थ है 'दो सबसे ऊपर वाले स्टैक वेरिएंट की अदला-बदली' ... वास्तव में बहुत सुंदर है।
— शाही
5
आप अनजाने में पायथन की एक और अच्छी विशेषता को भी इंगित करते हैं, जो यह है कि आप केवल अल्पविराम द्वारा अलग करके आइटमों की एक टुकड़ी बना सकते हैं।
— asmeurer
3
दाना द साने: पायथन में असाइनमेंट एक कथन है, एक अभिव्यक्ति नहीं है, इसलिए यह अभिव्यक्ति अमान्य होगी यदि उच्च प्राथमिकता (= यह एक के रूप में व्याख्या की गई थी, (बी = बी), ए)।
— एचबीएन २३'११
5
यह सबसे कम छिपी हुई विशेषता है जिसे मैंने यहां पढ़ा है। अच्छा है, लेकिन स्पष्ट रूप से हर पायथन ट्यूटोरियल में वर्णित है।
— थियागो ने
235

पठनीय नियमित अभिव्यक्ति

पायथन में आप कई लाइनों पर एक नियमित अभिव्यक्ति को विभाजित कर सकते हैं, अपने मैचों को नाम दे सकते हैं और टिप्पणियां डाल सकते हैं।

उदाहरण वाक्य विन्यास ( पाइथन में गोता से ):

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

उदाहरण नामकरण मिलान ( नियमित अभिव्यक्ति HOWTO से )

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'

आप re.VERBOSEस्ट्रिंग शाब्दिक संयोजन के लिए धन्यवाद का उपयोग किए बिना एक रेगेक्स भी मौखिक रूप से लिख सकते हैं ।

>>> pattern = (
...     "^"                 # beginning of string
...     "M{0,4}"            # thousands - 0 to 4 M's
...     "(CM|CD|D?C{0,3})"  # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                         #            or 500-800 (D, followed by 0 to 3 C's)
...     "(XC|XL|L?X{0,3})"  # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                         #        or 50-80 (L, followed by 0 to 3 X's)
...     "(IX|IV|V?I{0,3})"  # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                         #        or 5-8 (V, followed by 0 to 3 I's)
...     "$"                 # end of string
... )
>>> print pattern
"^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$"
— user18044
स्रोत
7
मुझे नहीं पता कि क्या मैं वास्तव में इस बात पर विचार करूंगा कि पायथन फीचर, अधिकांश आरईआर इंजनों में एक क्रिया विकल्प है।
— जेरेमी बैंक्स
18
हां, लेकिन क्योंकि आप इसे grep या अधिकांश संपादकों में नहीं कर सकते हैं, बहुत सारे लोग नहीं जानते कि यह वहां है। तथ्य यह है कि अन्य भाषाओं में एक समान विशेषता है, यह अजगर की एक उपयोगी और अल्पज्ञात विशेषता नहीं है
— मार्क बेकर
7
बहुत सारी अनुकूलित नियमित अभिव्यक्तियों के साथ एक बड़ी परियोजना में (पढ़ें: मशीन के लिए अनुकूलित लेकिन मनुष्य नहीं), मैंने थोड़ी सी गोली की और उनमें से सभी को वाक्यविन्यास क्रिया में बदल दिया। अब, परियोजनाओं के लिए नए डेवलपर्स को पेश करना बहुत आसान है। अब से हम हर प्रोजेक्ट पर वर्बोज़ आरईएस लागू करते हैं।
— बर्क डी। डेमिर
मैं सिर्फ इतना कहना चाहूंगा: सैकड़ों = "(मुख्यमंत्री | सीडी | डी। सी? 0,3})" # 900 (सीएम), 400 (सीडी), आदि भाषा में पहले से ही चीजों को नाम देने का एक तरीका है, एक टिप्पणी जोड़ने का तरीका और तार जोड़ने का तरीका। भाषा के लिए पहले से ही पूरी तरह से अच्छी तरह से काम करने के लिए यहां विशेष लाइब्रेरी सिंटैक्स का उपयोग क्यों करें? यह सीधे पर्लिस एपिग्राम 9 के खिलाफ जाना प्रतीत होता है
— केन
3
@ जेन: एक रेगेक्स हमेशा सीधे स्रोत में नहीं हो सकता है, इसे सेटिंग्स या एक कॉन्फ़िगर फ़ाइल से पढ़ा जा सकता है। टिप्पणी या केवल अतिरिक्त व्हाट्सएप (पठनीयता के लिए) की सहायता से बहुत मदद मिल सकती है।
222

फंक्शन तर्क अनपैकिंग

आप सूची या का उपयोग करते हुए समारोह तर्क के रूप में एक शब्दकोश खोल सकते हैं *और **।

उदाहरण के लिए:

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

सूचियों के बाद से बहुत उपयोगी शॉर्टकट, टुपल्स और डाइक को व्यापक रूप से कंटेनर के रूप में उपयोग किया जाता है।

— ई-सिटिस
स्रोत
27
* को स्पैट ऑपरेटर के रूप में भी जाना जाता है
— गेब्रियल
3
मुझे यह सुविधा पसंद है, लेकिन pylint दुख की बात नहीं है।
— स्टीफन पॉलगर
5
pylint की सलाह कोई कानून नहीं है। दूसरा तरीका, लागू करें (कॉल करने योग्य, arg_seq, arg_map), 2.3 के बाद से हटा दिया गया है।
— यन वर्निअर
1
pylint की सलाह कानून नहीं हो सकती है, लेकिन यह अच्छी सलाह है। डिबगिंग कोड है कि इस तरह से सामान में अति भोग शुद्ध नरक है। मूल पोस्टर नोट्स के रूप में, यह एक उपयोगी शॉर्टकट है ।
— एंड्रयू
2
मैंने इसे एक बार कोड में इस्तेमाल होते देखा और सोचा कि यह क्या करता है। दुर्भाग्य से "पाइथन **" के लिए Google पर मुश्किल है
— फ्रेजर ग्राहम
205

ROT13 स्रोत कोड के लिए एक मान्य एन्कोडिंग है, जब आप कोड फ़ाइल के शीर्ष पर सही कोडिंग घोषणा का उपयोग करते हैं:

#!/usr/bin/env python
# -*- coding: rot13 -*-

cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")
— आंद्रे
स्रोत
10
महान! ध्यान दें कि बाइट स्ट्रिंग्स को शाब्दिक रूप से कैसे लिया जाता है, लेकिन यूनिकोड स्ट्रिंग्स को डिकोड किया जाता है: कोशिश करेंcevag h"Uryyb fgnpxbiresybj!"
— u0b34a0f6ae
12
दुर्भाग्य से यह py3k से हटा दिया जाता है
— mykhal
9
एंटीवायरस को दरकिनार करने के लिए यह अच्छा है।
— L̲̳̳o̲̳̳n̲̳̳g̲̳̳p̲̳o̲̳̳k̲̳̳e
96
इसका एन्कोडिंग से कोई लेना-देना नहीं है, यह सिर्फ वेल्श में लिखा गया पायथन है। :
— ओलिवियर वर्डियर
33
Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn!
— मैनुअल फेरेरिया
183

पूरी तरह से गतिशील तरीके से नए प्रकार बनाना

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

जो बिल्कुल वैसा ही है

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

शायद सबसे उपयोगी चीज नहीं, लेकिन जानकर अच्छा लगा।

संपादित करें : नए प्रकार का निश्चित नाम, कथन के NewTypeसमान सटीक होना चाहिए class।

संपादित करें : शीर्षक को सुविधा का अधिक सटीक वर्णन करने के लिए समायोजित किया गया।

— टॉर्स्टन मारेक
स्रोत
8
यह उपयोगिता के लिए बहुत अधिक संभावना है, उदाहरण के लिए, JIT ORMs
— मार्क सिडेड
8
मैं इसका उपयोग डायनामिक इनपुट के आधार पर HTML-Form कक्षाएं उत्पन्न करने के लिए करता हूं। बहुत अच्छा!
— पी।
15
नोट: सभी कक्षाएं रनटाइम पर बनाई गई हैं। तो आप सशर्त या किसी फ़ंक्शन के भीतर 'क्लास' स्टेटमेंट का उपयोग कर सकते हैं (वर्गों या वर्गों के परिवारों को बनाने के लिए बहुत उपयोगी है जो क्लोजर के रूप में कार्य करते हैं)। सुधार जो 'प्रकार' लाता है, वह गुणों की एक गतिशील रूप से उत्पन्न सेट (या आधार) को बड़े पैमाने पर परिभाषित करने की क्षमता है।
— स्पूकीलुकेई
1
आप एक रिक्त स्ट्रिंग के साथ अनाम प्रकार भी बना सकते हैं जैसे: टाइप ('', (ऑब्जेक्ट), {'x': 'blah'})
— ब्लूव्हना
3
कोड इंजेक्शन के लिए बहुत उपयोगी हो सकता है।
— अवीहू तुरज़ियन
179

प्रसंग प्रबंधक और "with " कथन

पीईपी 343 में पेश किया गया , ए संदर्भ प्रबंधक एक वस्तु है जो बयानों के एक सूट के लिए रन-टाइम संदर्भ के रूप में कार्य करता है।

चूंकि फीचर नए कीवर्ड का उपयोग करता है, इसलिए इसे धीरे-धीरे पेश किया जाता है: यह पायथन 2.5 के माध्यम से उपलब्ध है __future__ निर्देशन के । पायथन 2.6 और इसके बाद के संस्करण (पायथन 3 सहित) में डिफ़ॉल्ट रूप से उपलब्ध है।

मैंने "के साथ" कथन का बहुत उपयोग किया है क्योंकि मुझे लगता है कि यह एक बहुत ही उपयोगी निर्माण है, यहाँ एक त्वरित डेमो है:

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

यहां पर्दे के पीछे क्या हो रहा है, वह यह है कि "के साथ" बयान विशेष __enter__और कहता है__exit__ फ़ाइल ऑब्जेक्ट पर विधियों को । अपवाद विवरण भी पास किया जाता है __exit__यदि कोई अपवाद स्टेटमेंट बॉडी से उठाया गया था, तो अपवाद हैंडलिंग को वहां होने की अनुमति देता है।

इस विशेष मामले में आपके लिए यह क्या है कि यह गारंटी देता है कि निष्पादन के दायरे से बाहर होने पर फ़ाइल बंद हो जाती है with सामान्य रूप से होता है या कोई अपवाद फेंका गया । यह मूल रूप से सामान्य अपवाद-हैंडलिंग कोड को दूर करने का एक तरीका है।

इसके लिए अन्य सामान्य उपयोग के मामलों में थ्रेड और डेटाबेस लेनदेन के साथ लॉकिंग शामिल हैं।

— Ycros
स्रोत
3
मैं एक कोड समीक्षा को मंजूरी नहीं दूंगा जो भविष्य से कुछ भी आयात करता है । सुविधाएँ उपयोगी से अधिक प्यारी हैं, और आमतौर पर वे केवल पायथन नए लोगों को भ्रमित करते हैं।
— एक पेड nerd
6
हां, नेस्टेड स्कोप और जनरेटर के रूप में इस तरह के "क्यूट" फीचर उन लोगों के लिए बेहतर हैं जो जानते हैं कि वे क्या कर रहे हैं। और जो कोई भी पायथन के भविष्य के संस्करणों के साथ संगत होना चाहता है। नेस्टेड स्कोप और जनरेटर के लिए, पायथन के "भविष्य के संस्करणों" का अर्थ क्रमशः 2.2 और 2.5 है। बयान के साथ, पायथन के "भविष्य के संस्करण" का अर्थ है 2.6।
— क्रिस बी।
10
यह कहने के बिना जा सकता है, लेकिन अजगर v2.6 + के साथ, आपको अब भविष्य से आयात करने की आवश्यकता नहीं है । अब एक प्रथम श्रेणी का कीवर्ड है।
— fitzgeraldsteele
25
2.7 में आपके पास कई हो सकते हैं withs:) with open('filea') as filea and open('fileb') as fileb: ...
— ऑस्टिन रिचर्डसन
5
@ ऑस्टिन मुझे 2.7 पर काम करने के लिए उस वाक्यविन्यास को नहीं मिला। इस तथापि किया काम: with open('filea') as filea, open('fileb') as fileb: ...
— विम
168

शब्दकोशों में एक () विधि है

शब्दकोशों में एक 'प्राप्त' () विधि है। यदि आप d ['key'] करते हैं और कुंजी नहीं है, तो आपको एक अपवाद मिलता है। यदि आप d.get ('कुंजी') करते हैं, तो आपको कोई नहीं मिलता है यदि 'कुंजी' नहीं है। आप उस आइटम को वापस लाने के लिए दूसरा तर्क जोड़ सकते हैं, जैसे कि कोई नहीं, उदाहरण के लिए: d.get ('कुंजी', 0)।

यह नंबर जोड़ने जैसी चीजों के लिए बहुत अच्छा है:

sum[value] = sum.get(value, 0) + 1

— रोरी
स्रोत
39
इसके अलावा, सेटडेफॉल्ट विधि की जांच करें।
— डैरन थॉमस
27
इसके अलावा, चेकआउट संग्रह।
— jfs
8
यदि आप पायथन 2.7 या बाद के संस्करण का उपयोग कर रहे हैं, या 3.1 या बाद में, संग्रह मॉड्यूल में काउंटर क्लास की जाँच करें। docs.python.org/library/collections.html#collections.Counter
— एलियास ज़मरिया
ओह यार, इस पूरे समय मैं कर रहा हूँ get(key, None)। कोई विचार नहीं था जो Noneडिफ़ॉल्ट रूप से प्रदान किया गया था।
— जॉर्डन रीटर
152

वर्णनकर्ता

वे कोर पायथन सुविधाओं के एक पूरे समूह के पीछे का जादू हैं।

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

यहां बताया गया है कि आप अपने स्वयं के (रीड-ओनली) संस्करण को डिस्क्रिप्टर का उपयोग करके कैसे लागू करेंगे:

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

और आप इसे बिल्ट-इन प्रॉपर्टी की तरह ही इस्तेमाल करेंगे ():

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

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

रेमंड हेटिंगर के पास एक उत्कृष्ट ट्यूटोरियल है जो मुझे बताने की तुलना में उनका वर्णन करने का बेहतर काम करता है।

— निक जॉनसन
स्रोत
यह डेकोरेटर्स का डुप्लिकेट है, है ना !? ( stackoverflow.com/questions/101268/… )
— gecco
2
नहीं, डेकोरेटर और डिस्क्रिप्टर पूरी तरह से अलग चीजें हैं, हालांकि उदाहरण कोड में, मैं एक डिस्क्रिप्टर डेकोरेटर बना रहा हूं। :)
— निक जॉनसन
1
ऐसा करने का दूसरा तरीका एक लैम्ब्डा के साथ है:foo = property(lambda self: self.__foo)
— पीट पीटरसन
1
@PetePeterson हां, लेकिन propertyखुद को डिस्क्रिप्टर के साथ लागू किया जाता है, जो मेरे पोस्ट का बिंदु था।
— निक जॉनसन 3
142

सशर्त असाइनमेंट

x = 3 if (y == 1) else 2

यह वास्तव में ऐसा लगता है जैसे: "3 से x असाइन करें यदि y 1 है, अन्यथा 2 से x असाइन करें"। ध्यान दें कि parens आवश्यक नहीं हैं, लेकिन मैं उन्हें पठनीयता के लिए पसंद करता हूं। यदि आपके पास कुछ अधिक जटिल है, तो आप इसे श्रृंखलाबद्ध भी कर सकते हैं:

x = 3 if (y == 1) else 2 if (y == -1) else 1

हालांकि एक निश्चित बिंदु पर, यह बहुत दूर जाता है।

ध्यान दें कि आप उपयोग कर सकते हैं यदि ... किसी भी अभिव्यक्ति में। उदाहरण के लिए:

(func1 if y == 1 else func2)(arg1, arg2)

यहां func1 को बुलाया जाएगा यदि y 1 और func2 है, अन्यथा। दोनों ही मामलों में तर्कों arg1 और arg2 के साथ संबंधित फ़ंक्शन को बुलाया जाएगा।

निम्न रूप से, निम्नलिखित भी मान्य है:

x = (class1 if y == 1 else class2)(arg1, arg2)

जहाँ class1 और class2 दो वर्ग हैं।

— tghw
स्रोत
29
असाइनमेंट विशेष हिस्सा नहीं है। तुम बस के रूप में आसानी से कुछ कर सकता है: वापसी 3 अगर (y == 1) और 2
— ब्रायन
25
यह वैकल्पिक तरीका पहली बार है जब मैंने मोटापे से ग्रस्त अजगर को देखा है।
— क्रेग मैकक्वीन
3
Kylebrooks: यह उस मामले में नहीं है, बूलियन ऑपरेटरों शॉर्ट सर्किट। यह केवल 2 का मूल्यांकन करेगा यदि बूल (3) == गलत।
— रोडीच
15
यह पीछे की शैली वाली कोडिंग मुझे भ्रमित करती है। ऐसा कुछ x = ((y == 1) ? 3 : 2)मेरे लिए और अधिक समझ में आता है
— एमपीएन
13
मुझे लगता है कि @Mark के ठीक विपरीत, C- शैली के टर्नरी ऑपरेटरों ने मुझे हमेशा भ्रमित किया है, क्या सही पक्ष या मध्य है जो झूठी स्थिति पर मूल्यांकन किया जाता है? मैं पायथन के टर्नरी सिंटैक्स को बहुत पसंद करता हूं।
— जेफरी हैरिस
141

सिद्धांत : एक ही समय में प्रलेखन और यूनिट-परीक्षण।

पायथन प्रलेखन से निकाले गए उदाहरण:

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()
— पियरे-जीन कूपर्ट
स्रोत
6
सिद्धांत निश्चित रूप से शांत हैं, लेकिन मैं वास्तव में सभी क्रॉफ्ट को नापसंद करता हूं जो आपको यह परीक्षण करने के लिए टाइप करना होगा कि कुछ को एक अपवाद उठाना चाहिए
— टीएम।
60
सिद्धांत ओवररेटेड हैं और प्रलेखन को प्रदूषित करते हैं। बिना किसी सेटअप () के आप कितनी बार स्टैंडअलोन फ़ंक्शन का परीक्षण करते हैं?
— एक भुगतान nerd
2
कौन कहता है कि आप एक सिद्धांत में सेटअप नहीं कर सकते हैं? एक फ़ंक्शन लिखें जो संदर्भ उत्पन्न करता है और locals()फिर आपके locals().update(setUp())
— सिद्धांत
12
यदि एक स्टैंडअलोन फ़ंक्शन को सेटअप की आवश्यकता होती है, तो संभावना अधिक होती है कि इसे कुछ असंबंधित सामान से हटा दिया जाए या एक कक्षा में डाल दिया जाए। क्लास डोक्टेस्ट नेमस्पेस को फिर से क्लास मेथड डॉक्टेस में फिर से इस्तेमाल किया जा सकता है, इसलिए यह सेटअप, डीआरवाई और रीडेबल की तरह ही है।
— एंडी मिखाइलेंको
4
"आप कितनी बार एक स्टैंडअलोन फ़ंक्शन का परीक्षण करते हैं" - बहुत सारे। मुझे लगता है कि जब मैं facades पर निर्णय ले रहा हूं, तो सिद्धांत अक्सर डिजाइन प्रक्रिया से स्वाभाविक रूप से उभरता है।
— ग्रेग लिंड
138

नामित स्वरूपण

% -रूपक एक शब्दकोश लेता है (% i /% s आदि सत्यापन भी लागू होता है)।

>>> print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

>>> foo, bar = 'question', 123

>>> print "The %(foo)s is %(bar)i." % locals()
The question is 123.

और चूंकि स्थानीय () भी एक शब्दकोष है, आप बस इसे एक तानाशाह के रूप में पारित कर सकते हैं और आपके स्थानीय चर से% -substitions कर सकते हैं। मुझे लगता है कि यह पर आधारित है, लेकिन चीजों को सरल करता है ..

नई शैली स्वरूपण

>>> print("The {foo} is {bar}".format(foo='answer', bar=42))
— पासी सावोलेन
स्रोत
60
चरणबद्ध किया जाएगा और अंततः स्ट्रिंग के प्रारूप () विधि से प्रतिस्थापित किया जाएगा।
— कांस्टेंटिन
3
नामांकित स्वरूपण अनुवादकों के लिए बहुत उपयोगी है क्योंकि वे केवल संदर्भ के लिए चर नामों के बिना प्रारूप स्ट्रिंग को देखते हैं
— पिक्सेलबीट
2
अजगर 3.0.1 में काम करने की जरूरत है (प्रिंट कॉल के आसपास पेरेंटेस को जोड़ने की जरूरत है)।
— पासी सावोलैनेन जूल
9
एक हैश , है ना? मैं देखता हूं कि तुम कहां से आए हो।
— shylent
11
% s स्वरूपण को चरणबद्ध नहीं किया जाएगा। str.format () निश्चित रूप से अधिक पायथोनिक है, हालांकि वास्तव में सरल स्ट्रिंग प्रतिस्थापन के लिए 10x का धीमा है। मेरा विश्वास% s स्वरूपण अभी भी सबसे अच्छा अभ्यास है।
— केनेथ रेइट्ज
132

अधिक अजगर मॉड्यूल (जासूसी रूप से 3 पार्टी वाले) को जोड़ने के लिए, ज्यादातर लोग PYTHONPATH पर्यावरण चर का उपयोग करते प्रतीत होते हैं या वे अपनी साइट-संकुल निर्देशिकाओं में सहानुभूति या निर्देशिका जोड़ते हैं। एक और तरीका, * .pth फ़ाइलों का उपयोग करना है। यहाँ आधिकारिक अजगर डॉक्टर की व्याख्या है:

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

— dgrant
स्रोत
1
मैंने कभी भी उस .pth फ़ाइल के बीच सेट-अप निर्देशिका से साइट-संकुल निर्देशिका और इस विचार के बीच संबंध नहीं बनाया। बहुत बढ़िया।
— ढोला पाला
122

अपवाद अन्य खंड:

try:
  put_4000000000_volts_through_it(parrot)
except Voom:
  print "'E's pining!"
else:
  print "This parrot is no more!"
finally:
  end_sketch()

अन्य क्लॉज़ का उपयोग अतिरिक्त कोड को कोशिश क्लॉज़ में जोड़ने से बेहतर है क्योंकि यह गलती से एक अपवाद को पकड़ने से बचता है जो कि कोड द्वारा संरक्षित नहीं किया जा रहा था ... बयान को छोड़कर।

Http://docs.python.org/tut/node10.html देखें

— कॉन्स्टेंटिन
स्रोत
8
+1 यह कमाल है। यदि बिना किसी अपवाद के ब्लॉक में प्रवेश करने के लिए प्रयास ब्लॉक निष्पादित होता है, तो दूसरा ब्लॉक दर्ज किया जाता है। और फिर निश्चित रूप से, अंततः ब्लॉक निष्पादित किया जाता है
— इंस्पेक्टरगेटगेट
मैं अंत में क्यों 'बाकी' है! धन्यवाद।
— तायर्नोन
यह जारी रखने के लिए और अधिक समझ में आता है, लेकिन मुझे लगता है कि यह पहले से ही लिया गया है;)
— पावेल प्रोक
ध्यान दें कि Python2 के पुराने संस्करणों पर आपके पास दोनों और नहीं हो सकते हैं: और अंत में: एक ही कोशिश के लिए खंड: ब्लॉक
— केविन हॉर्न
1
@ पवेल प्रोक, जैसा कि केविन हॉर्न ने उल्लेख किया है, इस वाक्यविन्यास को पायथन की प्रारंभिक रिलीज के बाद पेश किया गया था और मौजूदा भाषा में नए आरक्षित कीवर्ड जोड़ना हमेशा समस्याग्रस्त है। यही कारण है कि एक मौजूदा कीवर्ड को आमतौर पर पुन: उपयोग किया जाता है (हाल ही में सी + + मानक में "ऑटो")।
— कांस्टेंटिन
114

अपवादों को फिर से उठाना :

# Python 2 syntax
try:
    some_operation()
except SomeError, e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

# Python 3 syntax
try:
    some_operation()
except SomeError as e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

एक त्रुटि हैंडलर के अंदर कोई तर्क नहीं के साथ 'बढ़ाएँ' बयान पायथन को मूल ट्रेसबैक अक्षुण्ण के साथ अपवाद को फिर से बढ़ाने के लिए कहता है , आपको "ओह, क्षमा करें, क्षमा करें, मुझे यह पकड़ने का मतलब नहीं था, क्षमा करें, क्षमा करें। "

यदि आप मूल ट्रेसबैक के साथ प्रिंट, स्टोर या फिडेल करना चाहते हैं, तो आप इसे sys.exc_info () के साथ प्राप्त कर सकते हैं, और इसे पायथन की तरह प्रिंट करना 'ट्रेसबैक' मॉड्यूल के साथ किया जाएगा।

— थॉमस वाउटर्स
स्रोत
क्षमा करें, लेकिन यह लगभग सभी भाषाओं की एक प्रसिद्ध और सामान्य विशेषता है।
— लुकास एस।
6
इटैलिकाइज़्ड टेक्स्ट पर ध्यान दें। कुछ लोग raise eइसके बजाय करेंगे , जो मूल ट्रेसबैक को संरक्षित नहीं करता है।
— हबनबीत
12
शायद अधिक जादुई है, exc_info = sys.exc_info(); raise exc_info[0], exc_info[1], exc_info[2]यह इसके बराबर है, लेकिन आप उन मूल्यों को बदल सकते हैं (जैसे, अपवाद प्रकार या संदेश को बदल सकते हैं)
— ianb
3
@ लुकास एस। खैर, मुझे यह नहीं पता था, और मुझे खुशी है कि यह यहाँ लिखा गया है।
— ई-सतीस
मैं यहाँ अपनी जवानी दिखा रहा हूँ, लेकिन मैंने हमेशा पायथन 2.7 में पायथन 3 वाक्यविन्यास का उपयोग किया है, जिसमें कोई समस्या नहीं है
— wim
106

मुख्य संदेश :)

import this
# btw look at this module's source :)

डी-साइफ़र्ड :

टिम पीटर्स द्वारा ज़ेन ऑफ़ पायथन

सुंदर बदसूरत से बेहतर है।
निहितार्थ की तुलना में स्पष्ट है।
सरल जटिल से बेहतर है।
कॉम्प्लेक्स जटिल से बेहतर है।
फ्लैट नेस्टेड से बेहतर है।
विरल घने से बेहतर है।
पठनीयता मायने रखती है।
नियम तोड़ने के लिए विशेष मामले पर्याप्त नहीं हैं।
यद्यपि व्यावहारिकता शुद्धता को हरा देती है।
त्रुटियों को कभी भी चुपचाप नहीं गुजरना चाहिए।
जब तक स्पष्ट रूप से चुप नहीं कराया जाता।
अस्पष्टता के सामने, अनुमान लगाने के प्रलोभन से इनकार करें। वहाँ एक होना चाहिए - और अधिमानतः इसे करने के लिए केवल एक ही - स्पष्ट तरीका।
हालांकि यह तरीका पहली बार में स्पष्ट नहीं हो सकता जब तक कि आप डच न हों।
अब पहले से बेहतर है।
हालांकि कभी-कभी इससे बेहतर नहीं होता हैसही अब।
यदि कार्यान्वयन को समझाना कठिन है, तो यह एक बुरा विचार है।
यदि कार्यान्वयन की व्याख्या करना आसान है, तो यह एक अच्छा विचार हो सकता है।
नाम स्थान एक महान विचार का सम्मान कर रहे हैं - चलो उन में से अधिक करते हैं!

— मार्क
स्रोत
1
किसी भी विचार क्यों स्रोत उस तरह cyphered था? क्या यह सिर्फ मनोरंजन के लिए था, या कोई और कारण था?
— मिनीक्वार
42
जिस तरह से स्रोत लिखा है वह ज़ेन के खिलाफ जाता है!
— hasen
8
— erryprice
2
मैंने अपने /usr/lib/python2.6/this.py को पुराने कोड को इसके साथ बदल दिया है print s.translate("".join(chr(64<i<91 and 65+(i-52)%26 or 96<i<123 and 97+(i-84)%26 or i) for i in range(256)))और यह अब बहुत बेहतर लग रहा है !! :-D
— फोरट्रान
2
@MiniQuark: त्वरित इतिहास का सबक: wefearchange.org/2010/06/import-this-and-zen-of-python.html
105

इंटरएक्टिव दुभाषिया टैब पूर्णता

try:
    import readline
except ImportError:
    print "Unable to load readline module."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")


>>> class myclass:
...    def function(self):
...       print "my function"
... 
>>> class_instance = myclass()
>>> class_instance.<TAB>
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.f<TAB>unction()

आपको PYTHONSTARTUP परिवेश चर भी सेट करना होगा।

— mjard
स्रोत
2
यह एक बहुत ही उपयोगी सुविधा है। इतना तो मैं इसे सक्षम करने के लिए एक सरल स्क्रिप्ट है (प्लस अन्य आत्मनिरीक्षण बढ़ाने के एक जोड़े): pixelbeat.org/scripts/inpy
— Pixelbeat
43
IPython आपको
— akaihola
यह नियमित python प्रॉम्प्ट की तुलना में pdb प्रॉम्प्ट पर अधिक उपयोगी होता (जैसा कि IPython वैसे भी उस उद्देश्य को पूरा करता है)। हालाँकि, यह pdb प्रॉम्प्ट पर काम नहीं करता है, शायद क्योंकि pdb टैब के लिए अपना स्वयं का बाइंड करता है (जो कम उपयोगी है)। मैंने pdb प्रॉम्प्ट पर parse_and_bind () कॉल करने की कोशिश की, लेकिन यह अभी भी काम नहीं किया। IPython के साथ pdb प्रॉम्प्ट प्राप्त करने का विकल्प अधिक काम है, इसलिए मैं इसका उपयोग नहीं करता हूं।
— haridsv
2
@haridsv - easy_install ipdb- तब आप उपयोग कर सकते हैंimport ipdb; ipdb.set_trace()
— डौग हैरिस
1
ओएक्सएक्स पर [और मैं अन्य प्रणालियों की कल्पना करता हूं जो कि libedit का उपयोग करते हैं] आपको करना होगाreadline.parse_and_bind ("bind ^I rl_complete")
— फू बाह
91

नेस्टेड सूची समझ और जनरेटर अभिव्यक्ति:

[(i,j) for i in range(3) for j in range(i) ]    
((i,j) for i in range(4) for j in range(i) )

ये नेस्टेड-लूप कोड के विशाल हिस्से को बदल सकते हैं।

— राफेल डाउगर्ड
स्रोत
"फॉर जे इन रेंज (i)" - क्या यह एक टाइपो है? आम तौर पर आप i और j के लिए निश्चित सीमाएँ चाहते हैं। यदि आप 2d सरणी तक पहुँच रहे हैं, तो आप अपने आधे तत्वों को याद करेंगे।
— पीटर गिब्सन
मैं इस उदाहरण में किसी भी सरणियों तक नहीं पहुँच रहा हूँ। इस कोड का एकमात्र उद्देश्य यह दिखाना है कि आंतरिक पर्वतमाला के भाव बाहरी लोगों से पहुँच सकते हैं। उप-उत्पाद जोड़े की एक सूची है (x, y) जैसे कि 4> x> y> 0।
— राफेल डाउगर्ड
2
कलन या दोहरे योग में दोहरे एकीकरण की तरह।
— यौ
22
यहां याद रखने की प्रमुख बात (जो मुझे महसूस करने में लंबा समय लगा) यह है कि forबयानों के क्रम को उस क्रम में लिखा जाना है, जिसकी अपेक्षा आप उन्हें बाहर से अंदर की ओर से एक मानक-पाश में लिखे जाने के लिए करेंगे।
— sykora
2
Sykora की टिप्पणी में जोड़ने के लिए: कल्पना कीजिए कि आप अंदर से fors और ifs के ढेर से शुरू कर रहे हैं yield x। इसे एक जनरेटर अभिव्यक्ति में बदलने के लिए, xसबसे पहले, सभी कॉलोन (और yield) को हटा दें , और कोष्ठक में पूरी चीज़ को घेर लें। इसके बजाय सूची समझ बनाने के लिए, बाहरी कोनों को वर्ग कोष्ठक से बदलें।
— केन अर्नोल्ड
91

निर्माणकर्ता के लिए ओवरलोडिंग संचालक set:

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

मानक पुस्तकालय संदर्भ से अधिक विवरण: सेट प्रकार

— किव
स्रोत
ट्यूटोरियल में, आंशिक रूप से docs.python.org/tutorial/datastructures.html#sets
— XTL
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.