डेटा साइंस में Python का सामान्य सिंटैक्स (बुनियादी)

हाल ही में, मैं यह किताब Data Science from Scratch (PDF एड्रेस) पढ़ रहा था, यह डेटा साइंस के लिए एक बेहतरीन और आसानी से समझ आने वाली शुरुआती किताब है। इसके एक अध्याय में Python के बुनियादी सिंटैक्स और डेटा साइंस में अक्सर इस्तेमाल होने वाले एडवांस सिंटैक्स का परिचय दिया गया है। मुझे लगा कि यह परिचय बहुत अच्छा, संक्षिप्त और स्पष्ट है, इसलिए मैंने इसे यहाँ एक संदर्भ के रूप में अनुवाद करके रखा है।
डेटा साइंस में अक्सर इस्तेमाल होने वाले Python सिंटैक्स (बुनियादी)
डेटा साइंस में अक्सर इस्तेमाल होने वाले Python सिंटैक्स (एडवांस)

यह अध्याय डेटा प्रोसेसिंग में बेहद उपयोगी Python के बुनियादी सिंटैक्स और कार्यों पर केंद्रित है (Python 2.7 पर आधारित)।

स्पेसिंग (इंडेंटेशन) का फॉर्मेट

कई प्रोग्रामिंग भाषाएँ कोड ब्लॉक को नियंत्रित करने के लिए कोष्ठकों का उपयोग करती हैं, लेकिन Python इंडेंटेशन (अंदर की ओर जगह) का इस्तेमाल करती है:

for i in [1, 2, 3, 4, 5]:  
    print i          # "for i" लूप की पहली लाइन  
    for j in [1, 2, 3, 4, 5]:  
        print j      # "for j" लूप की पहली लाइन  
        print i + j  # "for j" लूप की आखिरी लाइन  
    print i          # "for i" लूप की आखिरी लाइन  
print "done looping"  

यह Python कोड को पढ़ने में बहुत आसान बनाता है, लेकिन इसका मतलब यह भी है कि आपको हमेशा फॉर्मेटिंग पर ध्यान देना होगा। कोष्ठकों के अंदर के स्पेस को अनदेखा कर दिया जाता है, जो लंबे एक्सप्रेशन लिखते समय बहुत उपयोगी होता है:

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]]  
easier_to_read_list_of_lists = [ [1, 2, 3],  
                                 [4 ,5 ,6 ],  
                                 [7 ,8 ,9 ] ]  

मल्टी-लाइन स्टेटमेंट

आप एक बैकस्लैश का उपयोग करके दो लाइनों को जोड़ सकते हैं (हालांकि यह तरीका कम ही इस्तेमाल होता है):

two_plus_three = 2 + \
                 3  

मॉड्यूल (Modules)

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

1. पूरे मॉड्यूल को सीधे इम्पोर्ट करना:

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

यहाँ इम्पोर्ट किया गया _re_ मॉड्यूल रेगुलर एक्सप्रेशन के लिए इस्तेमाल होता है। मॉड्यूल इम्पोर्ट करने के बाद, आप विशिष्ट कार्यों को कॉल करने के लिए सीधे मॉड्यूल नाम को उपसर्ग (re.) के रूप में उपयोग कर सकते हैं।

2. यदि इम्पोर्ट किए जाने वाले मॉड्यूल का नाम कोड में पहले से उपयोग किया जा चुका है, तो आप मॉड्यूल को इम्पोर्ट करते समय उसे एक अलग नाम पर मैप कर सकते हैं:

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

3. अगर आप ‘शरारती’ बनना चाहते हैं, तो आप पूरे मॉड्यूल को वर्तमान नेमस्पेस में इम्पोर्ट कर सकते हैं, जिससे अनजाने में आपके पहले से परिभाषित वैरिएबल ओवरराइट हो सकते हैं:

match = 10  
from re import *  # re मॉड्यूल में एक match फंक्शन है  
print match       # match फंक्शन को आउटपुट करता है  

चूँकि आप एक अच्छे व्यक्ति हैं, मुझे विश्वास है कि आप ऐसा नहीं करेंगे।

अंकगणितीय संक्रियाएँ (Arithmetic Operations)

Python 2.7 डिफ़ॉल्ट रूप से पूर्णांक भाग (integer division) का उपयोग करता है, इसलिए $ 5 / 2 = 2 $ होता है। लेकिन कई बार हमें पूर्णांक भाग नहीं चाहिए होता, इसलिए हम इस मॉड्यूल को इम्पोर्ट कर सकते हैं:

from __future__ import division  

इसे इम्पोर्ट करने के बाद, $5 / 2 = 2.5$ हो जाएगा।
पूर्णांक भाग (Integer division): $5 // 2 = 2$.

फंक्शन (Functions)

फंक्शन की परिभाषा

फंक्शन एक ऐसा नियम है जो 0 या अधिक इनपुट ले सकता है और एक निश्चित आउटपुट देता है। Python में, हम def फंक्शन_नाम(पैरामीटर) का उपयोग करके एक फंक्शन को परिभाषित करते हैं:

def double(x):  
    """आप यहाँ फंक्शन के कार्य के बारे में कुछ लिख सकते हैं  
    उदाहरण के लिए, यह फंक्शन इनपुट को 2 से गुणा करता है"""  
    # आप फंक्शन का मुख्य भाग यहाँ लिख सकते हैं, इंडेंटेशन याद रखें  
    return x * 2  

फंक्शन का उपयोग

Python में, फंक्शन ‘फर्स्ट-क्लास ऑब्जेक्ट’ होते हैं, जिसका अर्थ है कि हम एक फंक्शन को एक वैरिएबल असाइन कर सकते हैं, और इसे दूसरे फंक्शन में एक पैरामीटर के रूप में पास भी कर सकते हैं:

def apply_to_one(f):  
    """फंक्शन f को कॉल करता है और 1 को फंक्शन पैरामीटर के रूप में पास करता है"""  
    return f(1)  
my_double = double          # double ऊपर परिभाषित फंक्शन को इंगित करता है  
x = apply_to_one(my_double) # x बराबर 2  

अनाम फंक्शन (Anonymous Functions)

आप lambda का उपयोग करके अनाम फंक्शन भी बना सकते हैं:

y = apply_to_one(lambda x: x + 4)     # बराबर 5  

आप lambda को अन्य वैरिएबल्स को असाइन कर सकते हैं, लेकिन अधिकांश लोग सलाह देंगे कि आप def का ही यथासंभव उपयोग करें:

another_double = lambda x: 2 * x      # सलाह नहीं दी जाती  
def another_double(x): return 2 * x   # सलाह योग्य तरीका  

अतिरिक्त जानकारी:

• lambda सिर्फ एक एक्सप्रेशन है, और इसका फंक्शन बॉडी def की तुलना में बहुत सरल होता है।
• lambda का मुख्य भाग एक एक्सप्रेशन होता है, न कि एक कोड ब्लॉक। आप lambda एक्सप्रेशन में केवल सीमित लॉजिक ही डाल सकते हैं।

फंक्शन पैरामीटर पास करना

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

def my_print(message="my default message"):  
    print message  
my_print("hello")     # "hello" आउटपुट करता है  
my_print()            # "my default message" आउटपुट करता है  

कभी-कभी पैरामीटर नामों से सीधे पैरामीटर निर्दिष्ट करना भी बहुत उपयोगी होता है:

def subtract(a=0, b=0):  
    return a - b  
subtract(10, 5)   # 5 लौटाता है  
subtract(0, 5)    # -5 लौटाता है  
subtract(b=5)     # पिछले वाले के समान, -5 लौटाता है  

स्ट्रिंग (Strings)

आप सिंगल कोट्स या डबल कोट्स का उपयोग करके स्ट्रिंग बना सकते हैं (कोट्स का जोड़ा होना चाहिए):

single_quoted_string = 'data science'  
double_quoted_string = "data science"  

एस्केप कैरेक्टर को दर्शाने के लिए बैकस्लैश का उपयोग करें, जैसे:

tab_string = "\t"      # टैब कैरेक्टर को दर्शाता है  
len(tab_string)        # 1 के बराबर  

जब आप बैकस्लैश का स्वयं उपयोग करना चाहते हैं (जैसे Windows डायरेक्टरी या रेगुलर एक्सप्रेशन के लिए), तो आप इसे रॉ स्ट्रिंग r"" का उपयोग करके परिभाषित कर सकते हैं:

not_tab_string = r"\t" # कैरेक्टर '\' और 't' को दर्शाता है  
len(not_tab_string)    # 2 के बराबर  

तीन डबल कोट्स का उपयोग करके मल्टी-लाइन स्ट्रिंग बनाएँ:

multi_line_string = """यह पहली लाइन है  
यह दूसरी लाइन है  
यह तीसरी लाइन है"""  

अपवाद प्रबंधन (Exception Handling)

जब प्रोग्राम में कोई गलती होती है, तो Python एक अपवाद (exception) उत्पन्न करता है। यदि हम इसे हैंडल नहीं करते हैं, तो प्रोग्राम का निष्पादन रुक जाएगा। अपवादों को try और except स्टेटमेंट का उपयोग करके पकड़ा जा सकता है:

try:  
    print 0 / 0  
except ZeroDivisionError:  
    print "शून्य से भाग नहीं दे सकते"  

हालांकि अन्य भाषाओं में अपवादों को एक बुरी बात माना जाता है, लेकिन Python में, अपवादों को ज़्यादा हैंडल करने से आपका कोड अधिक संक्षिप्त और साफ-सुथरा बनता है।

लिस्ट (Lists)

लिस्ट बनाना

लिस्ट एक सरल, क्रमिक संग्रह है, और यह Python में सबसे बुनियादी डेटा संरचना है (यह अन्य भाषाओं में एरे के समान है, लेकिन लिस्ट में कुछ अतिरिक्त विशेषताएँ होती हैं)। एक लिस्ट बनाएँ:

integer_list = [1, 2, 3]  
heterogeneous_list = ["string", 0.1, True]  
list_of_lists = [ integer_list, heterogeneous_list, [] ]  
list_length = len(integer_list)   # 3 के बराबर  
list_sum = sum(integer_list)      # 6 के बराबर  

लिस्ट के मानों को एक्सेस करना

आप स्क्वायर ब्रैकेट इंडेक्स का उपयोग करके लिस्ट के मानों तक पहुँच सकते हैं:

x = range(10)       # लिस्ट x = [0, 1, ..., 9] प्राप्त करता है  
zero = x[0]         # 0 के बराबर, लिस्ट इंडेक्स 0 से शुरू होता है  
one = x[1]          # 1 के बराबर  
nine = x[-1]        # 9 के बराबर, लिस्ट का आखिरी तत्व  
eight = x[-2]       # 8 के बराबर, लिस्ट का दूसरा आखिरी तत्व  
x[0] = -1           # वर्तमान लिस्ट x = [-1, 1, 2, 3, ..., 9]  

लिस्ट को स्लाइस करना

आप स्क्वायर ब्रैकेट का उपयोग करके लिस्ट को स्लाइस कर सकते हैं:

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

आप यह देखने के लिए in का उपयोग कर सकते हैं कि कोई तत्व लिस्ट में है या नहीं:

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

यह तत्व खोजने का तरीका बहुत अक्षम है। इसका उपयोग तभी करें जब लिस्ट बहुत छोटी हो या आपको खोजने के समय की परवाह न हो।

लिस्ट जोड़ना (Concatenation)

Python में दो लिस्टों को जोड़ना बहुत आसान है:

x = [1, 2, 3]  
x.extend([4, 5, 6])   # वर्तमान x = [1,2,3,4,5,6]  

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

x = [1, 2, 3]  
y = x + [4, 5, 6]     # वर्तमान y = [1, 2, 3, 4, 5, 6]; x में कोई बदलाव नहीं  

अक्सर लिस्ट में एक बार में एक तत्व जोड़ने के लिए इस तरीके का उपयोग किया जाता है:

x = [1, 2, 3]  
x.append(0)           # वर्तमान x = [1, 2, 3, 0]  
y = x[-1]             # 0 के बराबर  
z = len(x)            # 4 के बराबर  

लिस्ट डीकंस्ट्रक्शन (Deconstruction)

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

x, y = [1, 2]         # वर्तमान x = 1, y = 2  

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

_, y = [1, 2]         # वर्तमान y == 2, पहले तत्व की परवाह किए बिना  

टुपल्स (Tuples)

लिस्ट और टुपल्स बहुत समान होते हैं, लेकिन लिस्ट से एकमात्र अंतर यह है कि टुपल्स के तत्वों को संशोधित नहीं किया जा सकता।

टुपल्स बनाना

आप पैरेंथेसिस का उपयोग करके या बिना किसी कोष्ठक के टुपल्स बना सकते हैं:

my_tuple = (1, 2)  
other_tuple = 3, 4  
my_list[1] = 3        # वर्तमान my_list [1, 3] है  
try:  
    my_tuple[1] = 3  
except TypeError:  
    print "टुपल को संशोधित नहीं किया जा सकता"  

टुपल्स का उपयोग करके फंक्शन से कई रिटर्न मान प्राप्त करना बहुत सुविधाजनक होता है:

def sum_and_product(x, y):  
    return (x + y),(x * y)  
sp = sum_and_product(2, 3)    # (5, 6) के बराबर  
s, p = sum_and_product(5, 10) # s = 15, p = 50  

टुपल्स (और लिस्ट) दोनों एक साथ कई तत्वों को असाइन करने का समर्थन करते हैं:

x, y = 1, 2       # वर्तमान x = 1, y = 2  
x, y = y, x       # Python में दो वैरिएबल के मानों को स्वैप करना; वर्तमान x = 2, y = 1  

डिक्शनरी (Dictionaries)

डिक्शनरी बनाना

Python में एक और बुनियादी डेटा संरचना डिक्शनरी है, जो आपको की (key) के माध्यम से संबंधित मान (value) को तेज़ी से प्राप्त करने की सुविधा देती है:

empty_dict = {}                       # बहुत Pythonic खाली डिक्शनरी परिभाषा  
empty_dict2 = dict()                  # कम Pythonic खाली डिक्शनरी परिभाषा  
grades = { "Joel" : 80, "Tim" : 95 }  # डिक्शनरी स्टोरेज  

डिक्शनरी तत्वों को खोजना

आप संबंधित मान खोजने के लिए स्क्वायर ब्रैकेट और की का उपयोग कर सकते हैं:

joels_grade = grades["Joel"]          # 80 के बराबर  

यदि खोजी जा रही की डिक्शनरी में नहीं है, तो एक कीएरर (KeyError) उत्पन्न होगा:

try:  
    kates_grade = grades["Kate"]  
except KeyError:  
    print "Kate के लिए कोई ग्रेड नहीं!"  

आप in का उपयोग करके यह देख सकते हैं कि की डिक्शनरी में है या नहीं:

joel_has_grade = "Joel" in grades     # True  
kate_has_grade = "Kate" in grades     # False  

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

joels_grade = grades.get("Joel", 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" : "joelgrus",  
    "text" : "Data Science is Awesome",  
    "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                       # अधिक Pythonic उपयोग, डिक्शनरी में कुशल in सर्च का उपयोग करके  
"joelgrus" in tweet_values            # True  

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

डिफ़ॉल्ट डिक्शनरी (Default Dictionaries)

यदि आप किसी डॉक्यूमेंट में प्रत्येक शब्द की आवृत्ति (frequency) गिनने की कोशिश कर रहे हैं, तो एक स्पष्ट तरीका यह है कि एक डिक्शनरी बनाई जाए जहाँ शब्द की के रूप में हों और उनकी आवृत्ति संबंधित मान के रूप में हो। फिर डॉक्यूमेंट को स्कैन करें, और जब कोई शब्द पहले से मौजूद हो, तो उसकी गणना 1 बढ़ा दें, और यदि कोई नया शब्द मिले, तो उसे डिक्शनरी में एक नए की-वैल्यू पेयर के रूप में जोड़ दें:

word_counts = {}  
for word in document:  
    if word in word_counts:  
        word_counts[word] += 1  
    else:  
        word_counts[word] = 1  

निश्चित रूप से, आप एक गायब की को पहले से हैंडल करने के लिए इस ‘पूछने से बेहतर है माफ़ी मांगना’ (Easier to ask for forgiveness than permission) वाले तरीके का उपयोग कर सकते हैं:

word_counts = {}  
for word in document:  
    try:  
        word_counts[word] += 1  
    except KeyError:  
        word_counts[word] = 1  

तीसरा तरीका get का उपयोग करना है, जो गायब कीज़ को हैंडल करने में उत्कृष्ट प्रदर्शन करता है:

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

डिफ़ॉल्ट डिक्शनरी सामान्य डिक्शनरी की तरह ही होती है, एकमात्र अंतर यह है कि जब आप डिक्शनरी में एक ऐसी की खोजने का प्रयास करते हैं जो मौजूद नहीं है, तो डिफ़ॉल्ट डिक्शनरी आपके द्वारा प्रदान की गई की का उपयोग करके स्वचालित रूप से एक की-वैल्यू पेयर बना देगी। डिफ़ॉल्ट डिक्शनरी का उपयोग करने के लिए, आपको collections लाइब्रेरी इम्पोर्ट करनी होगी:

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(1)                  # वर्तमान dd_list {2: [1]} है  
dd_dict = defaultdict(dict)           # dict() एक खाली डिक्शनरी उत्पन्न करता है  
dd_dict["Joel"]["City"] = "Seattle"   # वर्तमान dd_dict सामग्री { "Joel" : { "City" : Seattle"}} है  
dd_pair = defaultdict(lambda: [0, 0]) # एक डिक्शनरी बनाता है जहाँ की के लिए मान एक लिस्ट है  
dd_pair[2][1] = 1                     # वर्तमान dd_pair सामग्री {2: [0,1]} है  

यह विधि बहुत उपयोगी है, क्योंकि भविष्य में जब हमें डिक्शनरी में कुछ की-वैल्यू परिणाम प्राप्त करने होंगे, तो हमें अब यह जाँचने की आवश्यकता नहीं होगी कि की मौजूद है या नहीं।

काउंटर (Counter)

काउंटर सीधे मानों के एक समूह को डिक्शनरी जैसे ऑब्जेक्ट में बदल सकता है, जहाँ की समूह का एक तत्व होती है, और संबंधित मान उस तत्व के प्रकट होने की संख्या होती है। यह हिस्टोग्राम बनाते समय अक्सर उपयोग किया जाता है:

from collections import Counter  
c = Counter([0, 1, 2, 0]) # c (लगभग) { 0 : 2, 1 : 1, 2 : 1 } है  

इस तरह हमारे पास शब्द आवृत्ति (word frequency) गिनने का एक बहुत ही सुविधाजनक तरीका है:

word_counts = Counter(document)  

काउंटर की एक और बहुत उपयोगी विधि most_common है, जो सीधे सबसे अधिक बार आने वाले कुछ शब्दों और उनकी संबंधित आवृत्तियों को प्राप्त कर सकती है:

# शीर्ष 10 सबसे अधिक बार आने वाले शब्द और उनकी गणना को आउटपुट करता है  
for word, count in word_counts.most_common(10):  
    print word, count  

सेट (Sets)

Python में एक और डेटा संरचना सेट है, जो विभिन्न तत्वों का एक संग्रह है।
आप इस तरह से एक सेट बना सकते हैं और उसमें तत्व जोड़ सकते हैं:

s = set()  
s.add(1)          # s { 1 } है  
s.add(2)          # s { 1, 2 } है  
s.add(2)          # s { 1, 2 } है  
x = len(s)        # 2 के बराबर  
y = 2 in s        # True के बराबर  
z = 3 in s        # False के बराबर  

सेट का उपयोग करने के दो मुख्य कारण:

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

stopwords_list = ["a","an","at"] + hundreds_of_other_words + ["yet", "you"]  
"zip" in stopwords_list               # अक्षम, प्रत्येक तत्व की जाँच करने की आवश्यकता है  
stopwords_set = set(stopwords_list)  
"zip" in stopwords_set                # खोज सफल और तेज़  

दूसरा, डेटा के एक समूह में विभिन्न (distinct) तत्वों को प्राप्त करने के लिए सेट का उपयोग करना बहुत सुविधाजनक होता है:

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]  

हालांकि, व्यवहार में, सेट का उपयोग अभी भी डिक्शनरी और लिस्ट जितना अधिक नहीं होता है।

कंडीशनल स्टेटमेंट (Conditional Statements)

अधिकांश प्रोग्रामिंग भाषाओं में, आप कंडीशनल ब्रांचिंग को दर्शाने के लिए if का उपयोग इस तरह से कर सकते हैं:

if 1 > 2:  
    message = "काश 1 दो से बड़ा होता…"  
elif 1 > 3:  
    message = "elif का मतलब 'else if' है"  
else:  
    message = "जब सब कुछ विफल हो जाए तो else का उपयोग करें (यदि आप चाहते हैं)"  

आप कंडीशनल ब्रांचिंग स्टेटमेंट को एक ही लाइन में भी लिख सकते हैं, लेकिन इसका उपयोग कम ही होता है:

parity = "even" if x % 2 == 0 else "odd"  

लूप स्टेटमेंट (Loop Statements)

while लूप

Python में while लूप:

x = 0  
while x < 10:  
    print x, "10 से कम है"  
    x += 1  

for लूप

अधिकतर for-in लूप का उपयोग किया जाता है:

for x in range(10):  
    print x, "10 से कम है"  

अधिक जटिल लॉजिक एक्सप्रेशन में continue और break स्टेटमेंट का उपयोग किया जा सकता है:

for x in range(10):  
    if x == 3:  
        continue          # सीधे अगले लूप में जाता है  
    if x == 5:  
        break             # लूप से पूरी तरह बाहर निकल जाता है  
    print x  

परिणाम 0, 1, 2, और 4 होगा।

ट्रुथिनेस (Truthiness)

Python में बूलियन वैरिएबल्स (Booleans) का उपयोग अन्य भाषाओं के समान ही होता है, एकमात्र अंतर यह है कि पहला अक्षर हमेशा कैपिटल होना चाहिए:

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

Python None का उपयोग किसी मान के मौजूद न होने को दर्शाने के लिए करता है, जो अन्य भाषाओं में null के समान है:

x = None  
print x == None        # True आउटपुट करता है, कम सुंदर  
print x is None        # True आउटपुट करता है, अधिक सुंदर  

Python आपको बूलियन मानों के स्थान पर अन्य मानों का उपयोग करने की अनुमति देता है, निम्नलिखित सभी False के बराबर हैं:

• False
• None
• [] (एक खाली लिस्ट)
• {} (एक खाली डिक्शनरी)
• “”
• set()
• 0
• 0.0

इसी तरह, True के भी कई समतुल्य मान होते हैं, जिससे आपको खाली लिस्ट, खाली स्ट्रिंग और खाली डिक्शनरी आदि की जाँच करना बहुत सुविधाजनक हो जाता है।

निश्चित रूप से, यदि आप परिणाम का अनुमान नहीं लगा सकते हैं, तो उपयोग करते समय त्रुटियाँ हो सकती हैं:

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

एक सरल तरीका, जिसका प्रभाव ऊपर वाले तरीके के समान है:

first_char = s and s[0]  

यदि पहला मान सत्य है, तो दूसरा मान लौटाया जाएगा, अन्यथा पहला मान लौटाया जाएगा।

इसी तरह, यदि x एक संख्या हो सकता है या खाली हो सकता है, तो आप इस तरह से एक निश्चित रूप से संख्यात्मक x प्राप्त कर सकते हैं:

safe_x = x or 0  

Python में एक all फंक्शन भी होता है, जो तब True लौटाता है जब प्रत्येक तत्व True हो। any फंक्शन तब True लौटाता है जब कम से कम एक तत्व True हो। उदाहरण के लिए, एक लिस्ट के लिए जहाँ प्रत्येक तत्व ‘सत्य’ हो, all फंक्शन True लौटाएगा, अन्यथा False लौटाएगा:

all([True, 1, { 3 }])       # True  
all([True, 1, {}])          # False, {} 'False' के समतुल्य है  
any([True, 1, {}])          # True  
all([])                     # True, कोई भी तत्व 'False' के समतुल्य नहीं है  
any([])                     # False, कोई भी तत्व 'True' के समतुल्य नहीं है  

आगे पढ़ें (एडवांस रीडिंग):
डेटा साइंस में अक्सर इस्तेमाल होने वाले Python सिंटैक्स (एडवांस)