Python के बारे में जानकारी

भूमिका

Google के Python ऑनलाइन ट्यूटोरियल में आपका स्वागत है. यह अंदरूनी तौर पर ऑफ़र किए जाने वाले शुरुआती Python कोर्स पर आधारित है. जैसा कि सेटअप पेज पर बताया गया है, यह कॉन्टेंट Python 3 को कवर करता है.

अगर आपको साथ के लिए काम करने वाला MOOC कोर्स चाहिए, तो Udacity और Coursera (प्रोग्रामिंग के बारे में जानकारी [शुरुआत करने वाले] या Python के बारे में शुरुआती जानकारी) में दिए गए कोर्स आज़माएं. आखिर में, अगर आपको वीडियो देखने के लिएबिना उपयोगकर्ता, आसान ऑनलाइन सीखना है, तो इस पोस्ट के आखिर में दिए गए निर्देशों का पालन करें. इनमें लर्निंग से जुड़ा कॉन्टेंट और Python इंटरैक्टिव इंटरप्रेटर भी शामिल है, जिसकी मदद से प्रैक्टिस की जा सकती है. हमने इस "अनुवादक" का किस नाम से ज़िक्र किया है? आपको अगले सेक्शन में इसकी जानकारी मिलेगी!

भाषा के बारे में जानकारी

Python, डाइनैमिक और इंटरप्रेटेड (बाइट कोड से कंपाइल की गई) भाषा है. सोर्स कोड में वैरिएबल, पैरामीटर, फ़ंक्शन या मेथड के बारे में किसी भी तरह की जानकारी नहीं दी गई है. इससे कोड छोटा और सुविधाजनक हो जाता है. साथ ही, सोर्स कोड के कंपाइल-टाइम टाइप की जांच नहीं हो पाती. Python, रनटाइम के दौरान सभी तरह की वैल्यू को ट्रैक करता है और ऐसे कोड को फ़्लैग करता है जिसका कोई मतलब नहीं होता.

Python कोड के काम करने के तरीके को देखने का शानदार तरीका, Python इंटरप्रेटर को चलाना और सीधे इसमें कोड टाइप करना है. अगर आपके मन में कोई सवाल हो, "अगर मैं list में int जोड़ दूं, तो क्या होगा?" जैसी चीज़ों को Python अनुवादक में टाइप करना काफ़ी तेज़ और सबसे अच्छा तरीका है. (असल में क्या होता है, यह जानने के लिए नीचे देखें!)

$ python3        ## Run the Python interpreter
Python 3.X.X (XXX, XXX XX XXXX, XX:XX:XX) [XXX] on XXX
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 6       ## set a variable in this interpreter session
>>> a           ## entering an expression prints its value
6
>>> a + 2
8
>>> a = 'hi'    ## 'a' can hold a string just as well
>>> a
'hi'
>>> len(a)      ## call the len() function on a string
2
>>> a + len(a)  ## try something that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
>>> a + str(len(a))  ## probably what you really wanted
'hi2'
>>> foo         ## try something else that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'foo' is not defined
>>> ^D          ## type CTRL-d to exit (CTRL-z in Windows/DOS terminal)

Python टाइप करने के बाद और >>> प्रॉम्प्ट से पहले, दो लाइनों वाला Python, यह दिखाता है कि आपके इस्तेमाल में अजगर का कौनसा वर्शन इस्तेमाल किया जा रहा है और उसे कहां बनाया गया था. अगर पहली बार प्रिंट किया गया "Python 3" है, तो ये उदाहरण आपके काम आएंगे.

जैसा कि ऊपर देखा जा सकता है, वैरिएबल और ऑपरेटर के साथ प्रयोग करना आसान है. इसके अलावा, Python की सुविधा में अनुवादक थ्रो करता है या "बढ़ाता है". यह एक रनटाइम गड़बड़ी है. ऐसा तब होता है, जब कोड किसी ऐसे वैरिएबल को पढ़ने की कोशिश करता है जिसे कोई वैल्यू असाइन नहीं की गई है. C++ और Java की तरह, Python केस-सेंसिटिव (बड़े और छोटे अक्षरों में अंतर) होता है. इसलिए, "a" और "A" अलग-अलग वैरिएबल होते हैं. लाइन का आखिरी हिस्सा, स्टेटमेंट के आखिरी हिस्से को मार्क करता है. इसलिए, C++ और Java की तरह, Python को हर स्टेटमेंट के आखिर में सेमीकोलन की ज़रूरत नहीं होती. टिप्पणियां '#' से शुरू होती हैं और लाइन के आखिर तक लागू होती हैं.

Python सोर्स कोड

Python सोर्स फ़ाइलें, ".py" एक्सटेंशन का इस्तेमाल करती हैं. इन्हें "मॉड्यूल" कहा जाता है. Python मॉड्यूल hello.py की मदद से, इसे चलाने का सबसे आसान तरीका शेल कमांड "python hello.py Alice" है, जो hello.py में कोड को चलाने के लिए Python इंटरप्रेटर को कॉल करता है. साथ ही, यह कमांड लाइन तर्क "ऐलिस" को पास करता है. कमांड-लाइन से Python चलाने के दौरान आपके पास मौजूद सभी अलग-अलग विकल्पों पर आधिकारिक दस्तावेज़ पेज देखें.

यहां एक बहुत ही आसान hello.py प्रोग्राम दिया गया है (ध्यान दें कि कोड के ब्लॉक को कर्ली ब्रैकेट के बजाय, इंडेंटेशन का इस्तेमाल करके व्यवस्थित किया जाता है — इस बारे में ज़्यादा जानकारी बाद में पाएं!):

#!/usr/bin/python3

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
    print('Hello there', sys.argv[1])
    # Command line args are in sys.argv[1], sys.argv[2] ...
    # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
    main()

इस प्रोग्राम को कमांड लाइन से चलाने पर ऐसा लगता है:

$ python3 hello.py Guido
Hello there Guido
$ ./hello.py Alice  ## without needing 'python3' first (Unix)
Hello there Alice

इंपोर्ट, कमांड लाइन तर्क, और len()

Python फ़ाइल या "मॉड्यूल" में मौजूद सबसे बाहरी स्टेटमेंट, एक बार का सेटअप करते हैं — मॉड्यूल को पहली बार इंपोर्ट करने पर, ये स्टेटमेंट ऊपर से नीचे तक चलते हैं. इससे इसके वैरिएबल और फ़ंक्शन सेट अप हो जाते हैं. Python मॉड्यूल सीधे तौर पर चलाया जा सकता है — जैसा कि python3 hello.py Bob ऊपर बताया गया है — या इसे कोई अन्य मॉड्यूल इंपोर्ट और इस्तेमाल कर सकता है. जब किसी Python फ़ाइल को सीधे चलाया जाता है, तो खास वैरिएबल "__name__" को "__main__" पर सेट किया जाता है. इसलिए, ऊपर दिखाए गए बॉयलरप्लेट if __name__ ==... का इस्तेमाल करके मुख्य() फ़ंक्शन को कॉल किया जाना आम बात है. ऐसा तब होता है, जब मॉड्यूल सीधे चलाया जाता है. हालांकि, जब मॉड्यूल को किसी अन्य मॉड्यूल से इंपोर्ट किया जाता है, तो ऐसा नहीं होता.

स्टैंडर्ड Python प्रोग्राम की सूची में, sys.argv में स्टैंडर्ड तरीके से कमांड लाइन आर्ग्युमेंट शामिल होते हैं. sys.ardv[0] यह प्रोग्राम होता है और पहला आर्ग्युमेंट sys. आर्ग्युमेंट[1]. यह क्रम इसी तरह चलता रहता है. अगर आपको argc या तर्कों की संख्या के बारे में पता है, तो इस वैल्यू के लिए Python से len(sys.argv) का इस्तेमाल करें. यह अनुरोध वैसा ही है जैसा हमने स्ट्रिंग की लंबाई के लिए, ऊपर दिए इंटरैक्टिव इंटरप्रेटर कोड में किया था. आम तौर पर, len() आपको बता सकता है कि स्ट्रिंग कितनी लंबी है, सूचियों और टपल में एलिमेंट की संख्या (डेटा स्ट्रक्चर जैसा एक और अरे), और शब्दकोश में की-वैल्यू पेयर की संख्या.

उपयोगकर्ता के तय किए गए फ़ंक्शन

Python में फ़ंक्शन इस तरह से परिभाषित किए जाते हैं:

# Defines a "repeat" function that takes 2 arguments.
def repeat(s, exclaim):
    """
    Returns the string 's' repeated 3 times.
    If exclaim is true, add exclamation marks.
    """

    result = s + s + s # can also use "s * 3" which is faster (Why?)
    if exclaim:
        result = result + '!!!'
    return result

यह भी ध्यान दें कि फ़ंक्शन या if-स्टेटमेंट को बनाने वाली लाइनों को, एक जैसे लेवल के इंडेंटेशन के आधार पर किस तरह ग्रुप किया जाता है. हमने स्ट्रिंग को दोहराने के दो अलग-अलग तरीके भी बताए हैं. + ऑपरेटर का इस्तेमाल करना, लोगों के लिए ज़्यादा आसान होता है. हालांकि, * भी काम करता है, क्योंकि यह Python का "repeat" ऑपरेटर है. इसका मतलब है कि '-' * 10, '----------' की मदद से ऑनस्क्रीन "लाइन" बनाता है. कोड टिप्पणी में, हमने बताया कि * + से तेज़ी से काम करता है. इसकी वजह यह है कि * नतीजे के ऑब्जेक्ट के साइज़ का आकलन एक बार करता है, जबकि + से, हर बार + को कॉल किया जाता है. + और * दोनों को "ओवरलोड किया गया" ऑपरेटर कहा जाता है, क्योंकि उनका मतलब संख्याओं के लिए बनाम स्ट्रिंग (और दूसरे डेटा टाइप) के लिए अलग-अलग होता है.

def कीवर्ड, ब्रैकेट में पैरामीटर डालकर और कोड इंडेंट करके फ़ंक्शन को तय करता है. फ़ंक्शन की पहली लाइन एक डॉक्यूमेंटेशन स्ट्रिंग ("docstring") हो सकती है, जो बताता है कि फ़ंक्शन क्या करता है. जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है, docstrings में एक लाइन या कई लाइनों वाला ब्यौरा हो सकता है. (हां, वे "ट्रिपल कोट्स" हैं, जो Python के लिए खास तौर पर उपलब्ध है!) फ़ंक्शन में तय किए गए वैरिएबल उस फ़ंक्शन में लोकल होते हैं. इसलिए, ऊपर दिए गए फ़ंक्शन में "नतीजे" किसी दूसरे फ़ंक्शन के "नतीजे" वैरिएबल से अलग होते हैं. return स्टेटमेंट एक तर्क ले सकता है, जिस स्थिति में यही मान कॉलर को वापस किया जाता है.

यहां एक कोड दिया गया है जो ऊपर दिए गए दोहराव() फ़ंक्शन को कॉल करता है और यह प्रिंट करता है कि यह क्या दिखाता है:

def main():
    print(repeat('Yay', False))      ## YayYayYay
    print(repeat('Woo Hoo', True))   ## Woo HooWoo HooWoo Hoo!!!

रन टाइम के दौरान, फ़ंक्शन को कॉल करने से पहले, उन्हें "def" का इस्तेमाल करके तय करना चाहिए. यह एक सामान्य तरीका है, जिसे फ़ाइल के निचले हिस्से में उन फ़ंक्शन के साथ परिभाषित किया जाता है जो इसके ऊपर कॉल करते हैं.

इंडेंट करना

Python की एक असामान्य सुविधा यह है कि कोड के किसी हिस्से का खाली सफ़ेद हिस्सा, उसके मतलब पर असर डालता है. फ़ंक्शन बनाने वाले स्टेटमेंट के लॉजिकल ब्लॉक का इंडेंट एक जैसा होना चाहिए. उन्हें उनके पैरंट फ़ंक्शन के इंडेंटेशन से सेट किया जाना चाहिए या "if" या कुछ और पॉइंट से सेट किया जाना चाहिए. अगर ग्रुप की किसी लाइन का इंडेंट अलग है, तो उसे सिंटैक्स की गड़बड़ी के तौर पर फ़्लैग किया जाता है.

Python में खाली सफ़ेद जगह का इस्तेमाल करना शुरू में थोड़ा अजीब लगता है. हालांकि, यह तार्किक है और मैंने पाया कि मुझे इसकी आदत तुरंत हो गई है. टैब का इस्तेमाल करने से बचें, क्योंकि ये इंडेंटेशन स्कीम को बहुत जटिल बनाते हैं (ज़रूरी नहीं है कि Tab का इस्तेमाल अलग-अलग प्लैटफ़ॉर्म पर अलग-अलग चीज़ों के लिए किया जा सकता है). अपने संपादक को Python कोड के लिए Tab के बजाय स्पेस डालें.

एक आम सवाल जो शुरुआत करने वाले लोग पूछते हैं, "मुझे कितनी जगहों पर इंडेंट करना चाहिए?" Python की आधिकारिक स्टाइल गाइड (PEP 8) के मुताबिक, आपको चार स्पेस के साथ इंडेंट करना चाहिए. (मज़ेदार जानकारी: Google का अंदरूनी स्टाइल दिशा-निर्देश दो स्पेस के ज़रिए इंडेंट करने के बारे में बताता है!)

रनटाइम में कोड की जांच की गई

Python, कंपाइलेशन के समय बहुत कम जांच करता है और करीब सभी टाइप, नाम वगैरह को रोककर हर लाइन पर तब तक जांच करता है, जब तक कि वह लाइन न चलती हो. मान लें कि ऊपर दिया गया मुख्य() फ़ंक्शन इस तरह से दोहराव() को कॉल करता है:

def main():
    if name == 'Guido':
        print(repeeeet(name) + '!!!')
    else:
        print(repeat(name))

if-स्टेटमेंट में साफ़ तौर पर एक गड़बड़ी है, जहांrepeat() फ़ंक्शन गलती से repeeeet() के तौर पर टाइप हो जाता है. Python में यह मज़ेदार चीज़ है ... यह कोड कंपाइल करता है और तब तक चलता है, जब तक रनटाइम का नाम 'Guido' न हो. जब कोई रन असल में repeeeet() को एक्ज़ीक्यूट करने की कोशिश करता है, सिर्फ़ तब ही उसे पता चलेगा कि ऐसा कोई फ़ंक्शन नहीं है और ऐसी गड़बड़ी पैदा होगी. इस स्निपेट में एक दूसरी गड़बड़ी भी है. नाम को 'Guido' से तुलना करने से पहले कोई मान असाइन नहीं किया गया था. अगर असाइन न किए गए किसी वैरिएबल का आकलन करने की कोशिश की जाती है, तो Python आपके लिए 'NameError' दिखाएगा. यहां दिए गए कुछ उदाहरणों से पता चलता है कि जब पहली बार Python प्रोग्राम चलाया जाता है, तो आपको सबसे पहले दिखने वाली कुछ गड़बड़ियां, टाइपिंग की गलतियों या बिना शुरुआत वाले वैरिएबल के तौर पर दिखती हैं. यह ऐसा क्षेत्र है जहां ज़्यादा वर्बोज़ टाइप सिस्टम वाली भाषाओं, जैसे कि Java का फ़ायदा होता है ... वे कंपाइलेशन के समय ऐसी गड़बड़ियों का पता लगा सकते हैं (लेकिन आपको इस तरह की सारी जानकारी को संभालकर रखना होगा ... यह एक ट्रेडऑफ़ है).

Python 3 में टाइप के सुझाव दिखाए गए. टाइप संकेतों की मदद से यह बताया जा सकता है कि फ़ंक्शन में हर आर्ग्युमेंट के लिए कौनसा टाइप है. साथ ही, इससे यह भी पता चलता है कि फ़ंक्शन से मिलने वाले ऑब्जेक्ट का टाइप क्या है. उदाहरण के लिए, जानकारी वाले फ़ंक्शन def is_positive(n: int) -> bool: में, आर्ग्युमेंट n एक int है और रिटर्न वैल्यू एक bool है. हम बाद में इन टाइप के मतलब पर बात करेंगे. हालांकि, टाइप के संकेत ज़रूरी नहीं हैं. आपको कोड इस्तेमाल करने वाले टाइप के संकेत ज़्यादा से ज़्यादा दिखेंगे, क्योंकि अगर आप उनका इस्तेमाल करते हैं, तो sideer-v और VS.code जैसे कुछ एडिटर यह पुष्टि करने के लिए जांच कर सकते हैं कि आपके फ़ंक्शन सही तरह के आर्ग्युमेंट के साथ कॉल किए जाते हैं या नहीं. कोड में बदलाव करते समय, वे तर्कों का सुझाव भी दे सकते हैं और उनकी पुष्टि भी कर सकते हैं. इस ट्यूटोरियल में टाइप संकेतों को शामिल नहीं किया गया है. हालांकि, हम यह पक्का करना चाहते हैं कि अगर आप इन संकेतों के बारे में सुनें या इन्हें जंगल में देखें, तो आपको इनकी जानकारी हो.

वैरिएबल नाम

सोर्स कोड में Python वैरिएबल के किसी टाइप को नहीं लिखा गया है. इसलिए, अपने वैरिएबल को सही नाम देना ज़्यादा मददगार होता है. इससे खुद को यह याद रखने में मदद मिलती है कि क्या चल रहा है. इसलिए, अगर एक ही नाम है, तो "name" और अगर नामों की सूची है, तो "names" और अगर यह टूपल की सूची है, तो "tuples" इस्तेमाल करें. Python की कई बुनियादी गड़बड़ियां, हर वैरिएबल में मौजूद वैल्यू को भूलने की वजह से होती हैं. इसलिए, सही वैल्यू पाने के लिए अपने वैरिएबल के नामों का इस्तेमाल करें (जो आपके पास हैं).

जहां तक नाम के असल नाम के बारे में बात की जाती है, कुछ भाषाएं "एक से ज़्यादा शब्द" से बने वैरिएबल नामों के लिए अंडरस्कोरd_parts पसंद करती हैं, लेकिन अन्य भाषाएं ऊंट केसिंग को पसंद करती हैं. आम तौर पर, Python, अंडरस्कोर वाले तरीके को प्राथमिकता देता है. साथ ही, अगर मौजूदा Python कोड को पहले से इस्तेमाल कर रहे Python कोड में इंटिग्रेट किया जाता है, तो डेवलपर को CamCasing का इस्तेमाल रोकने में मदद मिलती है. कॉन्टेंट को पढ़ना कितना आसान है. ज़्यादा जानकारी के लिए, पीईपी 8 में नाम रखने के तरीकों के सेक्शन में जाएं.

जैसा कि आप अनुमान लगा सकते हैं, 'if' और 'while' जैसे कीवर्ड का इस्तेमाल वैरिएबल नामों के रूप में नहीं किया जा सकता है. अगर ऐसा किया जाता है, तो आपको सिंटैक्स में गड़बड़ी दिखेगी. हालांकि, ध्यान रखें कि बिल्ट-इन का इस्तेमाल वैरिएबल के नामों के तौर पर न करें. उदाहरण के लिए, हालांकि 'str', 'list', और 'print' अच्छे नाम लग सकते हैं, लेकिन आपने उन सिस्टम वैरिएबल को बदल दिया है. बिल्ट-इन कीवर्ड नहीं हैं. इसलिए, नए Python डेवलपर इन्हें गलती से इस्तेमाल कर सकते हैं.

मॉड्यूल और उनके नेमस्पेस के बारे में ज़्यादा जानकारी

मान लें कि आपके पास एक "binky.py" मॉड्यूल है जिसमें एक "def foo()" है. इस फ़ंक्शन का पूरी तरह क्वालिफ़ाइड नाम "binky.foo" है. इस तरह, अलग-अलग Python मॉड्यूल अपने फ़ंक्शन और वैरिएबल को अपनी पसंद के मुताबिक नाम दे सकते हैं, और वैरिएबल के नाम एक-दूसरे से विरोध नहीं करते हैं —मॉड्यूल1.foo,Module2.foo से अलग है. Python शब्दावली में, हम मान लेंगे कि binकी, मॉड्यूल1, और मॉड्यूल2 में से हर का अपना अलग "नेमस्पेस" होता है, जो अनुमान के हिसाब से नाम-से-ऑब्जेक्ट की अलग-अलग बाइंडिंग हैं.

उदाहरण के लिए, हमारे पास स्टैंडर्ड "sys" मॉड्यूल है, जिसमें कुछ स्टैंडर्ड सिस्टम सुविधाएं शामिल हैं, जैसे कि orgv सूची और exit() फ़ंक्शन. "import sys" स्टेटमेंट की मदद से आप sys मॉड्यूल की परिभाषाओं को ऐक्सेस कर सकते हैं और उन्हें उनके पूरी तरह क्वालिफ़ाइड नाम, जैसे कि sys.exit() से उपलब्ध करा सकते हैं. (हां, 'sys' में एक नेमस्पेस भी है!)

  import sys

  # Now can refer to sys.xxx facilities
  sys.exit(0)

इंपोर्ट करने के लिए एक और फ़ॉर्म कुछ इस तरह दिखता है: "sys इंपोर्ट करें, बाहर निकलें". इसकी वजह से, orgv और exit() को उनके छोटे नामों के साथ उपलब्ध कराया जाता है. हालांकि, हम पूरी तरह क्वालिफ़ाइड नामों के साथ मूल फ़ॉर्म का इस्तेमाल करने का सुझाव देते हैं, क्योंकि यह तय करना बहुत आसान है कि कोई फ़ंक्शन या एट्रिब्यूट कहां से आया है.

ऐसे कई मॉड्यूल और पैकेज हैं जिन्हें Python इंटरप्रेटर के स्टैंडर्ड इंस्टॉलेशन के साथ बंडल किया जाता है. इसलिए, आपको उनका इस्तेमाल करने के लिए अलग से कुछ नहीं करना पड़ता. इन्हें सामूहिक रूप से "Python Standard Library" के रूप में जाना जाता है. आम तौर पर इस्तेमाल किए जाने वाले मॉड्यूल/पैकेज में ये शामिल हैं:

• sys — exit(), orgv, stmin, stdout का ऐक्सेस
• re — रेगुलर एक्सप्रेशन
• os — ऑपरेटिंग सिस्टम इंटरफ़ेस, फ़ाइल सिस्टम

स्टैंडर्ड लाइब्रेरी के सभी मॉड्यूल और पैकेज के दस्तावेज़ देखने के लिए, http://docs.python.org/library पर जाएं.

ऑनलाइन सहायता, help(), और dir()

Python से जुड़ी मदद पाने के कई तरीके हैं.

• "python" शब्द से शुरू करते हुए Google Search करें, जैसे कि "Python list" या "Python स्ट्रिंग लोअरकेस". पहला हिट अक्सर जवाब होता है. किसी वजह से, यह तकनीक अन्य भाषाओं की तुलना में Python के लिए बेहतर काम करती है.
• Python की आधिकारिक दस्तावेज़ साइट — docs.python.org — में अच्छी क्वालिटी के दस्तावेज़ मौजूद हैं. फिर भी, मुझे अक्सर कुछ शब्दों के लिए Google पर की जाने वाली खोज जल्दी होती है.
• एक आधिकारिक ट्यूटर ईमेल सूची भी है जिसे खास तौर पर Python और/या प्रोग्रामिंग के नए लोगों के लिए डिज़ाइन किया गया है!
• StackOverflow और Quora पर कई सवाल (और जवाब) देखे जा सकते हैं.
• सहायता() और der() फ़ंक्शन का इस्तेमाल करें (नीचे देखें).

Python इंटरप्रेटर में, help() फ़ंक्शन अलग-अलग मॉड्यूल, फ़ंक्शन, और तरीकों के लिए दस्तावेज़ स्ट्रिंग इकट्ठा करता है. ये डॉक स्ट्रिंग, Java के javadoc की तरह होती हैं. direct() फ़ंक्शन आपको बताता है कि किसी ऑब्जेक्ट की विशेषताएं क्या हैं. नीचे कुछ ऐसे तरीके दिए गए हैं जिनकी मदद से इंटरप्रेटर से, help() और direct() को कॉल किया जा सकता है:

• help(len) — पहले से मौजूद len() फ़ंक्शन के लिए सहायता स्ट्रिंग. ध्यान दें कि यह "len" है, न कि "len()". यह फ़ंक्शन को कॉल करती है, जिसे हम नहीं चाहते
• help(sys) — sys मॉड्यूल के लिए सहायता स्ट्रिंग (पहले import sys करनी होगी)
• dir(sys) — dir(), help() की तरह है, लेकिन यह बस इसके तय किए गए प्रतीकों की एक सूची या "एट्रिब्यूट" को फटाफट दिखाता है
• help(sys.exit) — sys मॉड्यूल में exit() फ़ंक्शन के लिए सहायता स्ट्रिंग
• help('xyz'.split) — स्ट्रिंग ऑब्जेक्ट के लिए, split() तरीके के लिए सहायता स्ट्रिंग. help() को उसी ऑब्जेक्ट के साथ या उस ऑब्जेक्ट के किसी उदाहरण और उसकी एट्रिब्यूट के साथ कॉल किया जा सकता है. उदाहरण के लिए, help('xyz'.split) को कॉल करना और help(str.split) को कॉल करना एक जैसा ही है.
• help(list) — list ऑब्जेक्ट के लिए सहायता स्ट्रिंग
• dir(list) — यह list ऑब्जेक्ट एट्रिब्यूट और उनके तरीकों की जानकारी दिखाता है
• help(list.append) — list ऑब्जेक्ट के लिए, append() तरीके के लिए सहायता स्ट्रिंग