python in - पायथन में सामान्य नुकसान



hindi download (25)

संभावित डुप्लिकेट:
पायथन 2.x गॉचा और लैंडमाइन्स

आज मैं कई वर्षों के बाद mutable डिफ़ॉल्ट तर्कों द्वारा फिर से काटा गया था। जब तक आवश्यक हो, मैं आमतौर पर म्यूटेबल डिफ़ॉल्ट तर्कों का उपयोग नहीं करता, लेकिन मुझे लगता है कि समय के साथ मैं इसके बारे में भूल गया। आज आवेदन में मैंने पीडीएफ पीढ़ी के फ़ंक्शन की तर्क सूची में tocElements = [] जोड़ा और अब "सामग्री की तालिका" "पीडीएफ जेनरेट" के प्रत्येक आमंत्रण के बाद लंबी और अधिक हो जाती है। :)

मुझे अपनी चीज़ों की सूची में और क्या जोड़ना चाहिए ताकि बचने के लिए?

  • हमेशा मॉड्यूल को उसी तरह आयात करें, उदाहरण के लिए from y import x और import x को विभिन्न मॉड्यूल के रूप में माना जाता है

  • सूचियों के स्थान पर रेंज का उपयोग न करें क्योंकि range() वैसे भी एक इटरेटर बन जाएगा, निम्नलिखित विफल हो जाएंगे:

    myIndexList = [0, 1, 3]
    isListSorted = myIndexList == range(3)  # will fail in 3.0
    isListSorted = myIndexList == list(range(3))  # will not
    

    Xrange के साथ गलती से किया जा सकता है :

    myIndexList == xrange(3)
    
  • कई अपवाद प्रकारों को पकड़ने से सावधान रहें:

    try:
        raise KeyError("hmm bug")
    except KeyError, TypeError:
        print TypeError
    

    यह प्रिंट करता है "हम्म बग", हालांकि यह एक बग नहीं है; ऐसा लगता है कि हम दोनों प्रकार के अपवादों को पकड़ रहे हैं, लेकिन इसके बजाय हम केवल KeyError को चर टाइपरर के रूप में पकड़ रहे हैं , इसके बजाय इसका उपयोग करें:

    try:
        raise KeyError("hmm bug")
    except (KeyError, TypeError):
        print TypeError
    

Answers

मुझे नहीं पता कि यह एक आम गलती है, लेकिन जब पाइथन में वृद्धि और कमी ऑपरेटर नहीं हैं, तो डबल संकेतों की अनुमति है, इसलिए

++i

तथा

--i

वाक्य रचनात्मक रूप से सही कोड है, लेकिन कुछ भी "उपयोगी" नहीं करता है या आप उम्मीद कर सकते हैं।


मैंने पाइथन को भी सीखना शुरू कर दिया है और मैंने जो सबसे बड़ी गलतियों को बनाया है, वह लगातार सी ++ / सी # अनुक्रमित "लूप" का उपयोग कर रहा है। पायथन के लिए (i; i <length; i ++) टाइप लूप है और एक अच्छे कारण के लिए - अधिकांश समय वही काम करने के बेहतर तरीके हैं।

उदाहरण: मेरे पास एक विधि थी जो एक सूची में पुनरावृत्त हुई और चयनित वस्तुओं की अनुक्रमणिका लौटा दी:

for i in range(len(myList)):
    if myList[i].selected:
        retVal.append(i)

इसके बजाय पाइथन की सूची समझ है जो एक ही समस्या को एक और अधिक सुरुचिपूर्ण और पढ़ने के लिए आसान तरीके से हल करती है:

retVal = [index for index, item in enumerate(myList) if item.selected]

अनुक्रम पर लूप को इंडेक्स का उपयोग न करें

मत करो:

for i in range(len(tab)) :
    print tab[i]

कर :

for elem in tab :
    print elem

आपके लिए अधिकतर पुनरावृत्ति संचालन को स्वचालित करने के लिए।

यदि आपको वास्तव में इंडेक्स और तत्व दोनों की आवश्यकता है तो enumerate करें।

for i, elem in enumerate(tab):
     print i, elem

सही या गलत के खिलाफ जांचने के लिए "==" का उपयोग करते समय सावधान रहें

if (var == True) :
    # this will execute if var is True or 1, 1.0, 1L

if (var != True) :
    # this will execute if var is neither True nor 1

if (var == False) :
    # this will execute if var is False or 0 (or 0.0, 0L, 0j)

if (var == None) :
    # only execute if var is None

if var :
    # execute if var is a non-empty string/list/dictionary/tuple, non-0, etc

if not var :
    # execute if var is "", {}, [], (), 0, None, etc.

if var is True :
    # only execute if var is boolean True, not 1

if var is False :
    # only execute if var is boolean False, not 0

if var is None :
    # same as var == None

जांचें कि आप क्या कर सकते हैं, बस इसे करें और त्रुटि को संभालें

पाइथोनिस्टस आमतौर पर कहते हैं "अनुमति से माफी मांगना आसान है"।

मत करो:

if os.path.isfile(file_path) :
    file = open(file_path)
else :
    # do something

कर :

try :
    file =  open(file_path)
except OSError as e:
    # do something

या अजगर 2.6 / 3 के साथ भी बेहतर:

with open(file_path) as file :

यह बहुत बेहतर है क्योंकि यह बहुत अधिक सामान्य है। आप लगभग किसी भी चीज़ को "कोशिश / छोड़कर" लागू कर सकते हैं। आपको इस बात की परवाह करने की आवश्यकता नहीं है कि इसे रोकने के लिए क्या करना है, केवल उस त्रुटि के बारे में जो आप जोखिम ले रहे हैं।

प्रकार के खिलाफ जांच मत करो

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

मत करो:

def foo(name) :
    if isinstance(name, str) :
        print name.lower()

def bar(listing) :
    if isinstance(listing, list) :
        listing.extend((1, 2, 3))
        return ", ".join(listing)

कर :

def foo(name) :
    print str(name).lower()

def bar(listing) :
    l = list(listing)
    l.extend((1, 2, 3))
    return ", ".join(l)

आखिरी तरीके से, foo किसी ऑब्जेक्ट को स्वीकार करेगा। बार तार, tuples, सेट, सूचियों और बहुत कुछ स्वीकार करेंगे। सस्ता ड्रवाई :-)

रिक्त स्थान और टैब मिश्रण न करें

बस मत करो तुम रोओगे

वस्तु को पहले माता-पिता के रूप में उपयोग करें

यह मुश्किल है, लेकिन यह आपके कार्यक्रम के रूप में आपको काट देगा। पाइथन 2.x में पुराने और नए वर्ग हैं। बूढ़े लोग, ठीक है, बूढ़े हैं। उनमें कुछ विशेषताओं की कमी है, और विरासत के साथ अजीब व्यवहार हो सकता है। उपयोग करने योग्य होने के लिए, आपकी कोई भी कक्षा "नई शैली" का होना चाहिए। ऐसा करने के लिए, इसे "ऑब्जेक्ट" से प्राप्त करें:

मत करो:

class Father :
    pass

class Child(Father) :
    pass

कर :

class Father(object) :
    pass


class Child(Father) :
    pass

पायथन 3.x में सभी वर्ग नई शैली हैं ताकि आप class Father: घोषित कर सकें class Father: ठीक है।

__init__ विधि के बाहर वर्ग विशेषताओं को प्रारंभ न करें

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

ऐसा करने से क्लास एट्रिब्यूट (स्थिर विशेषताएँ) सेट हो जाएंगे, फिर जब आप ऑब्जेक्ट विशेषता प्राप्त करने का प्रयास करेंगे, तो यह आपको तब तक मान देगा जब तक कि यह खाली न हो। उस स्थिति में यह कक्षा विशेषताओं को वापस कर देगा।

यह दो बड़े खतरों का तात्पर्य है:

  • यदि वर्ग विशेषता बदल दी गई है, तो प्रारंभिक मान बदल दिया गया है।
  • यदि आप एक परिवर्तनीय ऑब्जेक्ट को डिफ़ॉल्ट मान के रूप में सेट करते हैं, तो आपको उसी ऑब्जेक्ट को उदाहरणों में साझा किया जाएगा।

मत करो (जब तक आप स्थैतिक नहीं चाहते):

class Car(object):
    color = "red"
    wheels = [wheel(), Wheel(), Wheel(), Wheel()]

कर :

class Car(object):
    def __init__(self):
        self.color = "red"
        self.wheels = [wheel(), Wheel(), Wheel(), Wheel()]

सामान्य pitfall: डिफ़ॉल्ट तर्क का मूल्यांकन एक बार किया जाता है :

def x(a, l=[]):
    l.append(a)
    return l

print x(1)
print x(2)

प्रिंट:

[1]
[1, 2]

यानी आप हमेशा एक ही सूची प्राप्त करते हैं।


आपने डिफ़ॉल्ट तर्कों का उल्लेख किया है ... एक जो लगभग म्यूटेबल डिफ़ॉल्ट तर्क के रूप में खराब है: डिफ़ॉल्ट मान जो कोई None

एक समारोह पर विचार करें जो कुछ खाना पकाएगा:

def cook(breakfast="spam"):
    arrange_ingredients_for(breakfast)
    heat_ingredients_for(breakfast)
    serve(breakfast)

चूंकि यह breakfast लिए डिफ़ॉल्ट मान निर्दिष्ट करता है, इसलिए किसी अन्य फ़ंक्शन के लिए किसी विशेष मामले के बिना "अपना डिफ़ॉल्ट नाश्ता पकाएं" असंभव है:

def order(breakfast=None):
    if breakfast is None:
        cook()
    else:
        cook(breakfast)

हालांकि, अगर cook इस्तेमाल डिफ़ॉल्ट मूल्य के रूप में None किया जाता है तो इससे बचा जा सकता है:

def cook(breakfast=None):
    if breakfast is None:
        breakfast = "spam"

def order(breakfast=None):
    cook(breakfast)

इसका एक अच्छा उदाहरण है Django बग #6988 । डैंजो के कैशिंग मॉड्यूल में "कैश टू सेव" फ़ंक्शन था जो इस तरह दिखता था:

def set(key, value, timeout=0):
    if timeout == 0:
        timeout = settings.DEFAULT_TIMEOUT
    _caching_backend.set(key, value, timeout)

लेकिन, memcached बैकएंड के लिए, 0 का एक टाइमआउट का मतलब है "कभी टाइमआउट नहीं" ... जैसा कि आप देख सकते हैं, निर्दिष्ट करना असंभव होगा।


त्रुटि संदेशों में %s formatter का उपयोग करना। लगभग हर परिस्थिति में, %r का उपयोग किया जाना चाहिए।

उदाहरण के लिए, इस तरह कोड की कल्पना करें:

try:
    get_person(person)
except NoSuchPerson:
    logger.error("Person %s not found." %(person))

इस त्रुटि को मुद्रित किया गया:

ERROR: Person wolever not found.

यह कहना असंभव है कि क्या person चर स्ट्रिंग "wolever" , यूनिकोड स्ट्रिंग u"wolever" या Person क्लास का एक उदाहरण है (जिसे def __str__(self): return self.name परिभाषित किया गया है जिसे def __str__(self): return self.name )। जबकि, अगर %r का उपयोग किया गया था, तो तीन अलग-अलग त्रुटि संदेश होंगे:

...
logger.error("Person %r not found." %(person))

अधिक उपयोगी त्रुटियों का उत्पादन करेंगे:

ERROR: Person 'wolever' not found.
ERROR: Person u'wolever' not found.
ERROR: Person  not found.

इसके लिए एक और अच्छा कारण यह है कि पथ कॉपी / पेस्ट करने के लिए बहुत आसान हैं। कल्पना कीजिए:

try:
    stuff = open(path).read()
except IOError:
    logger.error("Could not open %s" %(path))

यदि path some path/with 'strange' "characters" , तो त्रुटि संदेश होगा:

ERROR: Could not open some path/with 'strange' "characters"

जो एक शेल में कॉपी / पेस्ट करने के लिए दृश्यात्मक पार्स और हार्ड करना मुश्किल है।

जबकि, अगर %r का उपयोग किया जाता है, तो त्रुटि होगी:

ERROR: Could not open 'some path/with \'strange\' "characters"'

दृश्यमान रूप से पार्स करना आसान है, प्रतिलिपि बनाना आसान है, सब कुछ बेहतर है।


++n और --n सी या जावा पृष्ठभूमि से आने वाले लोगों द्वारा अपेक्षित काम नहीं कर सकता है।

++n सकारात्मक संख्या का सकारात्मक है, जो कि बस n

--n ऋणात्मक संख्या का नकारात्मक है, जो कि बस n


इनलाइन तर्क के लिए X and Y or Z का उपयोग करके मुझे खुद को प्रशिक्षित करने की एक बुरी आदत थी।

जब तक आप 100% हमेशा गारंटी नहीं दे सकते कि Y एक वास्तविक मूल्य होगा, भले ही आपका कोड 18 महीने के समय में बदल जाए, फिर भी आप कुछ अप्रत्याशित व्यवहार के लिए स्वयं को सेट अप करते हैं।

शुक्र है, बाद के संस्करणों में आप Y if X else Z उपयोग कर सकते हैं।


शुरू करने से पहले पहली गलती: व्हाइटस्पेस से डरो मत

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


कुछ व्यक्तिगत राय, लेकिन मुझे यह सबसे अच्छा नहीं लगता है:

  • बहिष्कृत मॉड्यूल का उपयोग करें (उनके लिए चेतावनियों का उपयोग करें)

  • अधिक कक्षाओं और विरासत का उपयोग (स्थिर भाषाओं की विरासत शायद)

  • स्पष्ट रूप से घोषणात्मक एल्गोरिदम का उपयोग करें (जैसे itertools उपयोग के for पुनरावृत्ति के रूप में)

  • मानक lib से कार्यों को दोबारा कार्यान्वित करें, "क्योंकि मुझे उन सभी सुविधाओं की आवश्यकता नहीं है"

  • इसके लिए सुविधाओं का उपयोग (पुराने पायथन संस्करणों के साथ संगतता को कम करना)

  • मेटाक्लास का उपयोग करते समय जब आपको वास्तव में और अधिक आम तौर पर चीज़ों को "जादू" नहीं बनाना पड़ता है

  • जनरेटर का उपयोग करने से बचें

  • (अधिक व्यक्तिगत) निम्न स्तर के आधार पर सीपीथन कोड को माइक्रो-ऑप्टिमाइज़ करने का प्रयास करें। एल्गोरिदम पर बेहतर समय व्यतीत करें और फिर ctypes द्वारा बुलाए गए एक छोटे सी साझा lib को अनुकूलित करके अनुकूलित करें (आंतरिक लूप पर 5x perf boosts हासिल करना इतना आसान है)

  • जब iterators पर्याप्त होगा तो अनावश्यक सूचियों का उपयोग करें

  • आपको आवश्यक libs से पहले 3.x के लिए सीधे एक प्रोजेक्ट कोड करें, यह सब उपलब्ध है (यह बिंदु अब थोड़ा विवादास्पद हो सकता है!)


उत्परिवर्तनीय डिफ़ॉल्ट तर्कों के समान उत्परिवर्तनीय वर्ग विशेषता है।

>>> class Classy:
...    foo = []
...    def add(self, value):
...        self.foo.append(value)
... 
>>> instance1 = Classy()
>>> instance2 = Classy()
>>> instance1.add("Foo!")
>>> instance2.foo
['Foo!']

आप क्या उम्मीद नहीं करते हैं।


आश्चर्यचकित है कि किसी ने यह नहीं कहा:

इंडेंट करते समय टैब और रिक्त स्थान मिलाएं।

वास्तव में, यह एक हत्यारा है। मुझ पर विश्वास करो। विशेष रूप से , अगर यह चलता है।


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

सीपीआई में समवर्ती कोड डालने या रैपर के माध्यम से कई प्रक्रियाओं (थ्रेड के बजाए) का उपयोग करके एसएमपी का लाभ लेने जैसे कुछ कामकाज हैं (उदाहरण के लिए http://www.parallelpython.org पर उपलब्ध एक) लेकिन यदि कोई पाइथन में वास्तविक बहु-थ्रेडिंग की आवश्यकता है, किसी को ज्योथन, आयरनपीथन आदि जैसी चीजों को देखना चाहिए (जीआईएल सीपीथॉन दुभाषिया की एक विशेषता है, इसलिए अन्य कार्यान्वयन प्रभावित नहीं होते हैं)।

पायथन 3000 एफएक्यू (आर्टिमा में उपलब्ध) के मुताबिक उपरोक्त अभी भी नवीनतम पायथन संस्करणों के लिए खड़ा है।


एक डिफ़ॉल्ट तर्क को म्यूट करना:

def foo(bar=[]):
    bar.append('baz')
    return bar

डिफ़ॉल्ट मान का मूल्यांकन केवल एक बार होता है, और हर बार फ़ंक्शन कहलाता नहीं है। foo() को बार-बार कॉल ['baz'] , ['baz', 'baz'] , ['baz', 'baz', 'baz'] , ...

यदि आप बार को म्यूट करना चाहते हैं तो ऐसा कुछ करें:

def foo(bar=None):
    if bar is None:
        bar = []

    bar.append('baz')
    return bar

या, यदि आप अंतिम होने के लिए तर्क पसंद करते हैं:

def foo(bar=[]):
    not_bar = bar[:]

    not_bar.append('baz')
    return not_bar

कार्यात्मक उपकरण का उपयोग नहीं कर रहा है। यह शैली के दृष्टिकोण से सिर्फ एक गलती नहीं है, यह एक गति दृष्टिकोण से एक गलती है क्योंकि बहुत से कार्यात्मक उपकरण सी में अनुकूलित किए जाते हैं।

यह सबसे आम उदाहरण है:

temporary = []
for item in itemlist:
    temporary.append(somefunction(item))
itemlist = temporary

ऐसा करने का सही तरीका:

itemlist = map(somefunction, itemlist)

ऐसा करने के लिए सही तरीका:

itemlist = [somefunction(x) for x in itemlist]

और यदि आपको केवल एक बार में प्रसंस्कृत वस्तुओं की आवश्यकता होती है, एक बार में, एक बार में, आप स्मृति को बचा सकते हैं और पुनरावृत्त समकक्षों का उपयोग कर गति में सुधार कर सकते हैं

# itertools-based iterator
itemiter = itertools.imap(somefunction, itemlist)
# generator expression-based iterator
itemiter = (somefunction(x) for x in itemlist)


Stdlib से एक के रूप में एक ही नाम के साथ एक स्थानीय मॉड्यूल बनाना। यह लगभग हमेशा दुर्घटना से किया जाता है (जैसा कि इस प्रश्न में बताया गया है), लेकिन आमतौर पर क्रिप्टिक त्रुटि संदेशों में परिणाम होता है।


मानक पुस्तकालय में देखने से पहले अपना खुद का कोड रोलिंग। उदाहरण के लिए, इसे लिखना:

def repeat_list(items):
    while True:
        for item in items:
            yield item

जब आप इसका उपयोग कर सकते हैं:

from itertools import cycle

अक्सर अनदेखा मॉड्यूल के उदाहरण ( itertools अलावा) में शामिल हैं:

  • कमांड लाइन पार्सर्स बनाने के लिए optparse
  • कॉन्फ़िगरेशन फ़ाइलों को मानक तरीके से पढ़ने के लिए ConfigParser
  • अस्थायी फ़ाइलों को बनाने और प्रबंधित करने के लिए tempfile
  • पाइथन ऑब्जेक्ट्स को डिस्क पर संग्रहीत करने के लिए shelve , जब एक पूर्ण डेटाबेस डेटाबेस अधिक हो जाता है तो आसान होता है

पाइथन भाषा गॉटचास - चीजें जो बहुत अस्पष्ट तरीकों से विफल होती हैं

  • परिवर्तनीय डिफ़ॉल्ट तर्क का उपयोग करना।

  • अग्रणी शून्य का मतलब ऑक्टल है। 09 पायथन 2.x में एक बहुत अस्पष्ट वाक्यविन्यास त्रुटि है

  • एक superclass या subclass में गलत वर्तनी विधि नाम। सुपरक्लास गलत वर्तनी गलती खराब है, क्योंकि उप-वर्गों में से कोई भी इसे सही ढंग से ओवरराइड नहीं करता है।

पायथन डिजाइन Gotchas

  • आत्मनिरीक्षण पर समय व्यतीत करना (उदाहरण के लिए स्वचालित रूप से प्रकार या सुपरक्लास पहचान या अन्य सामान निर्धारित करने का प्रयास करना)। सबसे पहले, यह स्रोत पढ़ने से स्पष्ट है। सबसे महत्वपूर्ण बात यह है कि अजीब पायथन आत्मनिरीक्षण पर बिताए गए समय आमतौर पर बहुरूपता को समझने में मौलिक विफलता को इंगित करते हैं। एसओ पर पाइथन आत्मनिरीक्षण प्रश्नों का 80% पॉलिमॉर्फिज्म पाने में विफलता है।

  • कोड गोल्फ पर समय व्यतीत करना। सिर्फ इसलिए कि आपके आवेदन का आपका मानसिक मॉडल चार कीवर्ड ("करें", "क्या", "मैं", "माध्य") है, इसका मतलब यह नहीं है कि आपको ऐसा करने के लिए एक हाइपर-जटिल आत्मनिर्भर सजावटी-संचालित ढांचा बनाना चाहिए। पाइथन आपको डीआरवाई को उस स्तर पर ले जाने की अनुमति देता है जो सुस्तता है। एसओ पर शेष पायथन आत्मनिरीक्षण प्रश्न गोल्फ अभ्यास कोड को जटिल समस्याओं को कम करने का प्रयास करते हैं।

  • Monkeypatching।

  • वास्तव में मानक पुस्तकालय के माध्यम से पढ़ने के लिए विफलता, और पहिया reinventing।

  • इंटरैक्टिव प्रकार को कन्फ्लेट करना-जैसा कि आप एक उचित कार्यक्रम के साथ पायथन जाते हैं। जबकि आप अंतःक्रियात्मक रूप से टाइप कर रहे हैं, आप एक चर का ट्रैक खो सकते हैं और globals() का उपयोग करना होगा। साथ ही, जब आप टाइप कर रहे हैं, लगभग सबकुछ वैश्विक है। उचित कार्यक्रमों में, आप एक चर का "ट्रैक" कभी नहीं खोलेंगे, और कुछ भी वैश्विक नहीं होगा।


डिफ़ॉल्ट म्यूटेबल तर्क से कुछ हद तक संबंधित, एक खाली सूची उत्तीर्ण होने पर "अनुपलब्ध" केस परिणामों के लिए कोई कैसे अंतर करता है:

def func1(toc=None):
    if not toc:
        toc = []
    toc.append('bar')

def func2(toc=None):
    if toc is None:
        toc = []
    toc.append('bar')

def demo(toc, func):
    print func.__name__
    print '  before:', toc
    func(toc)
    print '  after:', toc

demo([], func1)
demo([], func2)

आउटपुट यहां है:

func1
  before: []
  after: []
func2
  before: []
  after: ['bar']

जब आपको सरणी की आबादी की आवश्यकता होती है तो आपको ऐसा कुछ लिखने का लुत्फ उठाया जा सकता है:

>>> a=[[1,2,3,4,5]]*4

और यह सुनिश्चित करें कि जब आप इसे देखेंगे तो यह आपको वह देगा जो आप उम्मीद करते हैं

>>> from pprint import pprint
>>> pprint(a)

[[1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5]]

लेकिन उम्मीद नहीं है कि आपकी आबादी के तत्व अलग-अलग वस्तुएं हों:

>>> a[0][0] = 2
>>> pprint(a)

[[2, 2, 3, 4, 5],
 [2, 2, 3, 4, 5],
 [2, 2, 3, 4, 5],
 [2, 2, 3, 4, 5]]

जब तक आपको इसकी आवश्यकता नहीं है ...

एक कामकाज का उल्लेख करने लायक है:

a = [[1,2,3,4,5] for _ in range(4)]

इस पर पुनरावृत्ति करते समय एक सूची को संशोधित न करें।

odd = lambda x : bool(x % 2)
numbers = range(10)
for i in range(len(numbers)):
    if odd(numbers[i]):
        del numbers[i]

इस समस्या के आसपास काम करने के लिए एक आम सुझाव है कि सूची में उल्टा सूची में पुन: प्रयास करना है:

for i in range(len(numbers)-1,0,-1):
    if odd(numbers[i]):
        del numbers[i]

लेकिन पुरानी जगह बदलने के लिए एक नई सूची बनाने के लिए एक सूची समझ का उपयोग करना बेहतर है:

numbers[:] = [n for n in numbers if not odd(n)]

स्ट्रिंग मिलान / परिवर्तन के लिए पूर्ण नियमित अभिव्यक्ति दृष्टिकोण को re आयात करना और उपयोग करना, जब प्रत्येक सामान्य ऑपरेशन (जैसे पूंजीकरण, सरल मिलान / खोज) के लिए पूरी तरह से अच्छी स्ट्रिंग विधियां मौजूद होती हैं।


अंतिम लिंक मूल है, यह SO प्रश्न एक डुप्लिकेट है।


पायथन 2.5 और नए के लिए एक विशिष्ट वाक्यविन्यास है:

[on_true] if [cond] else [on_false]

पुराने पायथन में एक टर्नरी ऑपरेटर लागू नहीं किया जाता है लेकिन इसे अनुकरण करना संभव है।

cond and on_true or on_false

हालांकि, एक संभावित समस्या है, जो यदि on_true मूल्यांकन करता है और on_true मूल्यांकन False तो on_false की बजाय वापस आ जाता है। यदि आप इस व्यवहार को चाहते हैं तो विधि ठीक है, अन्यथा इसका उपयोग करें:

{True: on_true, False: on_false}[cond is True] # is True, not == True

जिसे द्वारा लिपटा जा सकता है:

def q(cond, on_true, on_false)
    return {True: on_true, False: on_false}[cond is True]

और इस तरह इस्तेमाल किया:

q(cond, on_true, on_false)

यह सभी पायथन संस्करणों के साथ संगत है।





python