अजगर का परिचय

इस लेख में, हम पायथन की मूल बातें कवर करेंगे। हम लक्ष्य के करीब और करीब आ रहे हैं, सामान्य तौर पर, हम जल्द ही डेटा विज्ञान के लिए मुख्य पुस्तकालयों के साथ काम करना शुरू करेंगे और TensorFlow (तंत्रिका नेटवर्क लिखने और तैनात करने के लिए, आप डीप लर्निंग को समझेंगे) का उपयोग करेंगे।

स्थापना

अजगर को python.org से डाउनलोड किया जा सकता है। हालांकि, अगर यह पहले से ही स्थापित नहीं है, तो इसके बजाय
मैं एनाकोंडा वितरण पैकेज की सिफारिश करता हूं, जिसमें पहले से ही डेटा विज्ञान के क्षेत्र में काम करने के लिए आवश्यक अधिकांश पुस्तकालय शामिल हैं।

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

खाली स्थान के

कई प्रोग्रामिंग भाषाएं विभेदित कोड ब्लॉक का उपयोग करती हैं।
ब्रेसिज़। पायथन में इंडेंटेशन का उपयोग किया जाता है:

#      for for i in [ 1, 2, 3, 4, 5] : print (i) #     for i for j in (1, 2, , 4, 5 ] : print ( j ) #     for j print (i + j) #     for j print (i) #     for i print ( "  ") 

इससे कोड को पढ़ना आसान हो जाता है, लेकिन साथ ही यह प्रारूपण का अनुसरण करता है। कोष्ठक और चौकोर कोष्ठक के अंदर के स्थान को नजरअंदाज कर दिया जाता है, जिससे क्रिया के भाव लिखने में आसानी होती है:

 #    long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20) 

और कोड पढ़ने में आसान:

 #   list_of_lists = [ [ 1 , 2, 3 ) , [4, 5, 6 ] , [ 7 , 8, 9 ] ] #      easy_to_read_list_of_lists = [1, 2, 3 ) , [4, 5, 6 ) , [7, 8, 9 ) ] 

बयान जारी रखने के लिए, अगली पंक्ति में बैकस्लैश का उपयोग किया जाता है, हालांकि, ऐसा रिकॉर्ड शायद ही कभी इस्तेमाल किया जाएगा:

 two_plus_three = 2 + \ 3 

व्हॉट्सएप के साथ कोड को प्रारूपित करने से पायथन शेल में कोड को कॉपी और पेस्ट करना मुश्किल हो जाता है। उदाहरण के लिए, निम्नलिखित कोड को कॉपी करने की कोशिश कर रहा है:

 for i in [ 1, 2, 3, 4, 5] : #      print (1) 

मानक पायथन शेल में एक त्रुटि होगी:

 #    :     IndentationError : expected an indented blk 

क्योंकि दुभाषिया के लिए, एक खाली स्ट्रिंग लूप के लिए कोड ब्लॉक के अंत को इंगित करता है।

IPython में एक "% पेस्ट" मैजिक फंक्शन है जो व्हाट्सएप सहित क्लिपबोर्ड पर सब कुछ सही ढंग से पेस्ट करता है।

मॉड्यूल (पुस्तकालय आयात करना)

कुछ पायथन-आधारित प्रोग्रामिंग वातावरण लाइब्रेरी डिफ़ॉल्ट रूप से लोड नहीं होती हैं। इन उपकरणों का उपयोग करने के लिए, आपको उन मॉड्यूल को आयात करना होगा जो उनके पास हैं।

एक दृष्टिकोण केवल मॉड्यूल को स्वयं आयात करना है:

 import re my_regex = re.compile ("[0-9]+",re.I) 

यहां रेगुलर एक्सप्रेशंस के साथ काम करने के लिए फ़ंक्शंस और कॉन्स्टेंट्स वाले मॉड्यूल का नाम है। इस तरह से पूरे मॉड्यूल को आयात करके, आप उन्हें फिर से जोड़कर कार्यों को एक्सेस कर सकते हैं।

यदि कोड में नाम के साथ एक चर पहले से ही है, तो आप मॉड्यूल उपनाम का उपयोग कर सकते हैं:

 import re as regex my_regex = regex.compile("[0-9)+",regex.I) 

उपनाम का उपयोग उन मामलों में भी किया जाता है जहां आयातित मॉड्यूल का बोझिल नाम होता है या जब मॉड्यूल अक्सर मॉड्यूल तक पहुंचता है।

उदाहरण के लिए, जब मैटलपोटलिब मॉड्यूल पर आधारित डेटा की कल्पना करते हैं, तो यह आमतौर पर होता है
निम्नलिखित मानक उपनाम का उपयोग करें:

 import matplotlib.pyplot as plt 

यदि आपको मॉड्यूल से कई विशिष्ट मूल्य प्राप्त करने की आवश्यकता है, तो आप उन्हें स्पष्ट रूप से आयात कर सकते हैं और प्रतिबंधों के बिना उपयोग कर सकते हैं:

 from collections import defaultdict , Counter lookup = defaultdict(int) my_counter = Counter() 

कार्यों

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

 def double() : """,  ,     docstring,  ,    . ,       2""" return  * 2 

पायथन में कार्य को प्रथम श्रेणी की वस्तुओं के रूप में माना जाता है। इसका मतलब यह है कि उन्हें चर के लिए सौंपा जा सकता है और अन्य कार्यों के लिए उसी तरह पारित किया जा सकता है जैसे कोई अन्य तर्क:

 #   f   def apply_to_one(f): '""'  f      """ return f(1) my _ double = double #       = apply_to_one(my_double) # = 2 

इसके अलावा, आप आसानी से छोटे अनाम फ़ंक्शंस या लैम्बडा एक्सप्रेशन बना सकते हैं:

  = apply_to_one(lambda :  + 4) # = 5 

लैम्ब्डा एक्सप्रेशन को वेरिएबल्स में सौंपा जा सकता है। हालाँकि, डीफ़ ऑपरेटर का उपयोग करने की अनुशंसा की जाती है:

 another double = lmbd : 2 *  #    def another_double (x) : return 2 *  #   

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

 def my_print (message="oe   " ): print (message ) my_print ( "pe") #  '' my_print () #  '   ' 

नाम से तर्क निर्दिष्ट करना कभी-कभी उचित होता है:

 #   def subtract ( a=0, =0 ) : return  - b subtract (10, 5)#  5 subtract (0, 5)#  -5 subtract (b=5 )#  ,      

भविष्य में, कार्यों का उपयोग अक्सर किया जाएगा।

पंक्तियां

चरित्र के तार (या वर्णों के अनुक्रम) दोनों तरफ एकल या दोहरे उद्धरण (वे मेल खाने चाहिए) तक सीमित हैं:

 single_quoted_string = '    ' #  double_quoted_string = "  " #  

बैकस्लैश का उपयोग विशेष वर्णों को एनकोड करने के लिए किया जाता है। उदाहरण के लिए:

 tab_string = "\t" #    len (tab_string)# = 1 

यदि आपको बैकस्लैश की आवश्यकता है, जो सीधे होता है
विंडोज ऑपरेटिंग सिस्टम में डायरेक्टरी नामों में, फिर r "" का उपयोग करके आप एक अनफ़ॉर्मेटेड स्ट्रिंग बना सकते हैं:

 not_tab_string = r"\t" #   ' \ '  ' t ' len (not_tab_string) # = 2 

टेक्स्ट के मल्टी-लाइन ब्लॉक ट्रिपल सिंगल (या) का उपयोग करके बनाए गए हैं
डबल) उद्धरण:

 multi_line_string = """   .        """ 

अपवाद

जब कुछ गलत होता है, तो पायथन अपवाद छोड़ देता है। अनचाही अपवादों के कारण कार्यक्रम अप्रत्याशित रूप से बंद हो जाता है। अपवादों को कोशिश और बयानों को छोड़कर इस्तेमाल किया जाता है:

 try: print (0 / 0) except ZeroDivisionError : rint ( "    ") 

हालांकि कई प्रोग्रामिंग भाषाओं में अपवादों का उपयोग एक खराब प्रोग्रामिंग शैली माना जाता है, पायथन में इस बारे में चिंता करने की कोई बात नहीं है कि इसका उपयोग कोड क्लीनर बनाने के लिए किया जाता है, और कभी-कभी हम बस यही करेंगे।

सूचियों

संभवतः पायथन में सबसे महत्वपूर्ण डेटा संरचना एक सूची है। यह अन्य प्रोग्रामिंग भाषाओं में एक सरणी के समान, केवल एक ऑर्डर किया गया संग्रह (या संग्रह) है, लेकिन अतिरिक्त कार्यक्षमता के साथ।

 integer_list = [1, 2, ] #    heterogeneous_list = ["", 0.1 , True] #   list_of_lists = [integer_list, heterogeneous_list, [] ] #   list_length = len(integer_list) #  = 3 list_sum = sum(integer_list)#    = 6 

आप मान को सेट कर सकते हैं और वर्ग कोष्ठक का उपयोग करके सूची के nth तत्व तक पहुँच सकते हैं:

  = list(range (10)) #   {0, 1 , . . . , 9] zero =  [0] # = 0 ,  -, .  .  1-  = 0 one = x [1] # = 1 nine =  [-1] # = 9, -    eight =  [-2] # = 8, -     [0] = -1 #   = { - 1 , 1 , 2, 3, . . . , 9] 

इसके अलावा, वर्ग कोष्ठक का उपयोग "कट" सूचियों के लिए किया जाता है:

 first_three = [:] #   = [-1 , 1, 2] three_to_end = [3:] #    = {3, 4, ... , 9] one_to_four = [1:5] #     = {1 , 2, 3, 4] last_three = [-3:] #   = { 7, 8, 9] without_first_and_last = x[1:-1] #     = {1 , 2, ... , 8] _ of _ = [:] #   = [ -1, 1, 2, ... , 91 

पायथन का एक एलएन स्टेटमेंट है जो यह जांचता है कि कोई तत्व किसी सूची से संबंधित है:

 1 ln [1, 2, 3] #True 0 ln [1, 2, 3] #False 

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

सूचियाँ एक साथ श्रृंखला के लिए आसान हैं:

  = [1, 2, 3] . extend ( [ 4, 5, 6] ) #   = {1, 2, 3, 4, 5, 6} 

यदि आप सूची को अपरिवर्तित छोड़ना चाहते हैं, तो आप सूचियों को जोड़ सकते हैं:

  = [1, 2, 3]  =  + [4, 5, 6] #= (1, 2, 3, 4, 5, 6] ;    

आमतौर पर, एक ऑपरेशन में सूचियों में एक तत्व जोड़ा जाता है:

  = [1, 2, 3] x.append (0)#   = [1,2,3,0] =  [-1] # = 0 z = len (x)# = 4 

यदि आप जानते हैं कि इसमें कितने तत्व हैं, तो किसी सूची को खोलना अक्सर सुविधाजनक होता है:

 ,  = [1, 2] #   = 1,  = 2 

यदि अभिव्यक्ति के दोनों किनारों पर तत्वों की संख्या समान नहीं है, तो एक ValueError त्रुटि संदेश प्रदर्शित किया जाएगा।

त्याग किए गए मूल्यों के लिए, अंडरस्कोर आमतौर पर उपयोग किया जाता है:

 _,  = [1, 2] #   == 2,     

tuples

ट्यूप्स सूचियों के अपरिवर्तनीय (या अपरिवर्तनीय) चचेरे भाई हैं।

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

 my_list = [1, 2] #   my_tuple = (1, 2) #   other_tuple = 3, 4 #    my_list [1] = 3 #  my_list = [1 , 3] try: my_tuple [1] = 3 except ypeError : print ( "   " ) 

कार्य से कई मान वापस करने के लिए एक सुविधाजनक तरीका प्रदान करता है:

 #        def sum_and_product (x,  ) : return ( + ) , ( * ) sp = sum_and_product (2, 3) # = (5, 6) s,  = sum_and_product (S, 10) # s = 15,  = 50 

Tuples (और सूचियाँ) कई असाइनमेंट में उपयोग किए जाते हैं:

 ,  = 1, 2 #   = 1,  = 2 ,  = ,  #   -;   = 2,  = 1 

शब्दकोशों

एक शब्दकोश या साहचर्य सूची एक और बुनियादी डेटा संरचना है।

इसमें, मान कुंजियों से जुड़े होते हैं, जो आपको विशिष्ट कुंजी के अनुरूप मूल्य को जल्दी से प्राप्त करने की अनुमति देता है:

 empty_dict = {} #   - empty_dict2 = dict () #   - grades = { "Grigoriy" : 80, "Tim" : 95 } #   (  ) 

वर्गाकार कोष्ठकों का उपयोग करके मुख्य मूल्य तक पहुँचा जा सकता है:

 rigory_aleksee = grades[ "Grigoriy"] # = 80 

यदि आप ऐसे मान का अनुरोध करने का प्रयास करते हैं जो डिक्शनरी में नहीं है, तो आपको KeyError त्रुटि संदेश प्राप्त होगा:

 try: kates_grade = grades [ "Kate "] except eyError: rint ( "    ! " ) 

आप ऑपरेटर का उपयोग करके एक कुंजी की जांच कर सकते हैं:

 grigoriy_has_grade = "Grigoriy" in grades #true kate_has_grade = "Kate" in grades #false 

शब्दकोशों में एक () विधि है, जो अपवाद को फेंकने के बजाय एक लापता कुंजी की खोज करते समय डिफ़ॉल्ट मान लौटाता है:

 grigoriy_grade = grades. get ( "Grigoriy ", 0) # =80 kates_grade = grades.get ("Kate" , 0) # = 0 no_ones_grade = grades.get ( "No One" ) #    = None 

एक ही वर्ग कोष्ठक का उपयोग करके मुख्य मूल्य असाइनमेंट किया जाता है:

 grades [ "Tim" ] = 99 #    grades [ "Kate"] = 100 #    num_students = len(grades) # = 3 

शब्दकोशों को अक्सर संरचनात्मक का प्रतिनिधित्व करने के लिए एक आसान तरीके के रूप में उपयोग किया जाता है
जानकारी:

 tweet = { "user" : " grinaleks", "text" : "   -  ", " retweet_count" : 100, "hashtags " : [ "# data", " #science", " #datascience " , " #awesome", "#yolo" ] } 

व्यक्तिगत कुंजी खोजने के अलावा, आप एक ही बार में सभी से संपर्क कर सकते हैं:

 tweet_keys = tweet.keys() #   tweet_values = tweet.values() #   tweet_items = tweet.items() #   (, ) "user" in tweet_keys # True,    in  "user" in tweet # -,   in  "grinaleks" in tweet_values # True 

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

डिफ़ॉल्ट डिक्शनरी

दस्तावेज़ को शब्दों को गिनने की आवश्यकता है। समस्या का स्पष्ट समाधान एक शब्दकोश बनाना है जिसमें कुंजियाँ शब्द हैं, और मूल्य शब्दों की आवृत्ति (या पाठ में शब्दों की घटनाओं की संख्या) हैं। शब्द जांच के दौरान, यदि वर्तमान शब्द पहले से ही शब्दकोश में है, तो इसकी आवृत्ति बढ़ जाती है, और यदि यह अनुपस्थित है, तो इसे शब्दकोश में जोड़ा जाता है:

 #   word_ counts = { } document = { } #  ;    for word in document : if word in word counts: word_counts [word] += 1 else : word_counts [word] = 1 

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

 word_ counts = { } for word in document : try: word_counts [word] += 1 except eyError : word_counts [word] = 1 

तीसरी ट्रिक है गेट () पद्धति का उपयोग करना, जो कि गुम हो चुकी चाबियों के साथ स्थिति पर गर्व करती है:

 word_counts = { } for word in document : previous_count = word_counts.get (word, 0) word_counts [word] = previous_count + 1 

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

 from collections import defaultdict word_counts = defaultdict(int) # int ()  0 for word in document : word_counts[word] += 1 

इसके अलावा, डिफॉल्ट डिक्शनरी का उपयोग सूची, शब्दकोश और यहां तक ​​कि उपयोगकर्ता द्वारा परिभाषित कार्यों के साथ काम करते समय व्यावहारिक उपयोग का है:

 dd_list = defaultdict (list)# list ()    dd_list [2].append (l) #  dd_list  (2: {1] } dd_dict = defaultdict (dict ) # dict ()    dict dd_dict ["Grigoriy"] [ "City" ] = "Seattle" # { "Grigoriy" : { "City" : Seattle"} dd_pair = defaultdict (lambda: [0,0] ) dd_pair [2][1] = 1 #  dd_pair  (2 : {0,1] } 

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

काउंटर शब्दकोश

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

यह मुख्य रूप से हिस्टोग्राम बनाते समय उपयोग किया जाएगा:

 from collections import Counter  = Counter([0,1,2,0]) #    = { 0 : 2, 1 : 1, 2 : 1 } 

इसकी कार्यक्षमता शब्द आवृत्तियों की गणना की समस्या को हल करने के लिए पर्याप्त आसान बनाती है:

 #      word_counts = Counter (document) 

काउंटर डिक्शनरी में most_common () विधि है, जो अक्सर उपयोगी होती है:

 #  10       () for word, count in word_counts.most_common(10) : print (word, count ) 

सेट

सेट या सेट डेटा संरचना दोहराए बिना अनियंत्रित तत्वों का एक संग्रह है:

 s = set ()#    s.add (1) #  s = { 1 } s.add (2) #  s = { 1, 2 } s.add (2) # s    = { 1, 2 }  = len (s) # = 2  = 2 in s # = True z = 3 in s # = False 

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

 #  - stopwords_list = [ "a", "an" , "at "] + hundreds_of_other_words + [ "yet ", " you"] " zip" in stopwords_list # False,     #  - stopwords_set = set(stopwords_list) " zip" in stopwords_set #    

दूसरा कारण डेटा सेट में अद्वितीय तत्व प्राप्त करना है:

 item_list = [1, 2, 3, 1, 2, 3] #  num_items = len( item_list) #  = 6 item_set = set(item_list) #   (1, 2, 3} num_distinct_items = len(item_set) #   = 3 distinct_item_list = list(item_set) #    = [1,2,3] 

कई का उपयोग शब्दकोशों और सूचियों की तुलना में बहुत कम किया जाएगा।

नियंत्रण संरचनाओं

अधिकांश अन्य प्रोग्रामिंग भाषाओं में, यदि कथन का उपयोग करके स्थिति के अनुसार कार्य किए जा सकते हैं:

 if 1 > 2: message " 1    2 . . . " elif 1 > 3: message "elif  'else if '" else: message = "      ,  else " 

इसके अलावा, आप सिंगल-लाइन ट्रिपल इफ़-तत्कालीन ऑपरेटर का उपयोग कर सकते हैं, जिसे कभी-कभी बाद में उपयोग किया जाएगा:

 parity = "" if  % 2 ===  else " " 

पायथन में एक व्हेल लूप है:

  = 0 while  < 10: print (x, " 10")  += 1 

हालांकि, ऑपरेटर के लिए लूप का उपयोग अधिक बार किया जाएगा:

 for  in range (lO) : print (x, " 10" ) 51 

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

 continue  break: for  1n range (10) : 1f  == 3: continue #      if  == 5: break print (x) #    

परिणामस्वरूप, 0, 1, 2 और 4 प्रिंट किए जाएंगे।

सचाई

पाइथन में बूलियन चर अधिकांश अन्य प्रोग्रामिंग भाषाओं की तरह ही काम करते हैं, केवल एक अपवाद के साथ - वे पूंजीकृत हैं:

 one_is_less_than_two = 1 < 2 #True true_equals_false = True == False #False 

कोई नहीं के बराबर मूल्य का संकेत करने के लिए, एक विशेष कोई भी वस्तु का उपयोग नहीं किया जाता है, जो अन्य भाषाओं में शून्य से मेल खाती है:

  = None print (x == None )#  True,    - print (  is None ) #  True - 

पाइथन किसी भी मूल्य का उपयोग कर सकता है जहां बूलियन बूलियन प्रकार की उम्मीद की जाती है। निम्नलिखित तत्वों में से सभी में बूलियन का मूल्य गलत है:

• झूठी; ।
• कोई नहीं;
• सेट () (सेट):
• [] (खाली सूची);
• {} (खाली शब्दकोश);

बहुत कुछ बाकी सब सच माना जाता है। यदि खाली सूचियों की जांच के लिए कथन का उपयोग करना आसान हो जाता है। खाली लाइनें, खाली शब्दकोष, आदि। कभी-कभी, हालांकि, यह कठिन-से-पहचान त्रुटियों की ओर जाता है, यदि आप निम्नलिखित को ध्यान में नहीं रखते हैं:

 s = some_function_that_returns_a_string () #    if s: first_char = s [0] #     else: first char = "" 

यहाँ एक ही करने के लिए एक आसान तरीका है:

 first_char = s and s [0] 

क्योंकि तार्किक ऑपरेटर और दूसरा मान लौटाता है, यदि पहला सत्य है, और पहला मूल्य, यदि यह गलत है। इसी तरह, यदि निम्नलिखित अभिव्यक्ति में x या तो एक संख्या है, या संभवतः कोई भी नहीं है, तो परिणाम किसी भी तरह एक संख्या होगी:

 safe  =  or 0 #   

पाइथन बिल्ट-इन ऑल फंक्शन में एक लिस्ट लेता है और तभी रिटर्न करता है जब प्रत्येक लिस्ट आइटम सही हो, और कोई भी बिल्ट-इन फंक्शन तब सही हो, जब कम से कम एक एलिमेंट सही हो:

 all ( [True, 1, { 3 }]) # True all ( [True, 1, {}] ) # False, {} =  any ( [ True, 1, {}]) # True, True =  all ( [] ) # True,      any ( [ ] ) # False,