5 आम शुरुआत पायथन गलतियाँ

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

1. शब्दकोशों या सूचियों की प्रतिलिपि बनाएँ

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

गलत:

>>> dict_a = {"name": "John", "address":"221B Baker street"} >>> dict_b = dict_a 

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

 >>> dict_b["age"] = 26 >>> dict_b {'address': '221B Baker street', 'name': 'John', 'age': 26} >>> dict_a {'address': '221B Baker street', 'name': 'John', 'age': 26} >>> 

सही: कॉपी () या डीपकोपी () विधियों का उपयोग करें।

 >>> dict_c = dict_b.copy() >>> dict_c["location"] = "somewhere" >>> dict_c {'address': '221B Baker street', 'name': 'John', 'age': 26, 'location': 'somewhere'} >>> dict_b {'address': '221B Baker street', 'name': 'John', 'age': 26} >>> dict_a {'address': '221B Baker street', 'name': 'John', 'age': 26} >>> 

कॉपी और डीपकोपी के बीच अंतर देखें।

2. शब्दकोश कुंजी

आइए शब्दकोश में मूल्यों को जोड़ने का प्रयास करें:

 >>> dict_a = dict() >>> dict_a {} >>> dict_a[1] = "apple" >>> dict_a[True] = "mango" >>> dict_a[2] = "melon" 

यदि हम स्क्रीन पर शब्दकोश प्रदर्शित करने की कोशिश करते हैं, तो हम क्या देखेंगे?

 >>> dict_a {1: 'mango', 2: 'melon'} 

क्या हुआ, ट्रू की कहाँ है?

यह याद रखना चाहिए कि बुलियन वर्ग इंटेगर (पूर्णांक) से विरासत में मिला है। और ट्रू के बराबर एक पूर्णांक 1 है; गलत समतुल्य 0. है, इसलिए, कुंजी 1 के लिए मान केवल अधिलेखित है।

 >>> isinstance(True, int) True >>> isinstance(False, int) True >>> True == 1 True >>> False == 0 True 

3. सूचियों या शब्दकोशों को अद्यतन करना

मान लीजिए आप किसी सूची में एक आइटम जोड़ना चाहते हैं।

 >>> list_a = [1,2,3,4,5] >>> list_a = list_a.append(6) >>> list_a >>> # prints nothing 

या शब्दकोश को अपडेट करने की कोशिश कर रहा है।

 >>> dict_a = {"a" : "b"} >>> dict_a = dict_a.update({"c" : "d"}) >>> dict_a >>> # prints nothing 

अब सूची को व्यवस्थित करने का प्रयास करते हैं।

 >>> list_b = [2,5,3,1,7] >>> list_b = list_b.sort() >>> list_b >>> # prints nothing 

कुछ भी क्यों नहीं निकलता, हम क्या गलत कर रहे हैं?

अधिकांश कंटेनर विधियां (जैसे सॉर्ट, अपडेट, एपेंड, ऐड, आदि) प्रदर्शन उद्देश्यों के लिए अनुकूलित हैं - और अनावश्यक रूप से अलग प्रतियां बनाने से बचें।

ऐसे तरीकों के रिटर्न वैल्यू को वैरिएबल में असाइन करने की कोशिश न करें।

सही:

 >>> list_a = [1,2,3,4,5] >>> list_a.append(6) >>> dict_a = {"a" : "b"} >>> dict_a.update({"c" : "d"}) >>> dict_a {'c': 'd', 'a': 'b'} >>> list_a.sort() >>> list_a [1, 2, 3, 4, 5, 6] 

4. इंटर्नल स्ट्रिंग्स

कुछ मामलों में, पायथन मौजूदा अपरिवर्तनीय वस्तुओं का पुन: उपयोग करने की कोशिश करता है। स्ट्रिंग इंटर्निंग ऐसा ही एक मामला है।

 >>> a = "gmail" >>> b = "gmail" >>> a is b True 

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

 >>> a = "@gmail" >>> b = "@gmail" >>> a is b False 

यह भी याद रखें कि == संचालक से भिन्न है। == ऑपरेटर जाँच करता है कि मान समतुल्य हैं या नहीं, जबकि ऑपरेटर यह जाँचता है कि क्या दोनों चर एक ही वस्तु को संदर्भित करते हैं।

 >>> a = "@gmail" >>> b = "@gmail" >>> a is b False >>> a == b True 

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

5. डिफ़ॉल्ट तर्कों का मूल्यांकन एक बार किया जाता है।

एक उदाहरण पर विचार करें:

 def func(a, lst=[]): lst.append(a) return lst print(func(1)) print(func(2)) 

आपको क्या लगता है कि दो प्रिंट के बाद प्रदर्शित किया जाएगा?

कोड चलाते हैं।

 >>> def func(a, lst=[]): ... lst.append(a) ... return lst ... >>> print(func(1)) [1] >>> print(func(2)) [1, 2] 

दूसरा केस आउटपुट [1, 2] क्यों है? क्या यह सिर्फ [2] नहीं होना चाहिए?

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

बोनस: रिक्त स्थान और टैब को मिलाने की आवश्यकता नहीं है। बस नहीं है।