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

शुरुआत

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

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

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

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

Python कोड कैसे काम करता है, यह देखने का सबसे अच्छा तरीका है कि Python अनुवादक को चलाएं और उसमें कोड टाइप करें. अगर आपके मन में कभी ऐसा सवाल है, "अगर मैं int को list में जोड़ दूं, तो क्या होगा?" इसे 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 का वर्शन क्या है और वह कहां बनाया गया था. अगर प्रिंट की गई पहली चीज़ "Python 3" के ये उदाहरण आपके काम आ सकते हैं.

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

Python सोर्स कोड

Python सोर्स फ़ाइलें ".py" का इस्तेमाल करती हैं एक्सटेंशन कहा जाता है और इन्हें "मॉड्यूल" कहा जाता है. Python मॉड्यूल hello.py के साथ, इसे चलाने का सबसे आसान तरीका शेल कमांड "python hello.py Alice" है यह कमांड लाइन तर्क "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__ ==... का इस्तेमाल करना, आम तौर पर तब होता है, जब मॉड्यूल सीधे तौर पर चलाया जाता है. हालांकि, किसी दूसरे मॉड्यूल से मॉड्यूल इंपोर्ट किए जाने पर, इसे Main() फ़ंक्शन का इस्तेमाल किया जा सकता है.

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

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

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

यहां दिया गया कोड, ऊपर दिए गए Bard() फ़ंक्शन को कॉल करके, नतीजे के तौर पर मिलने वाले नतीजों को प्रिंट करता है:

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

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

इंडेंट करना

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

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

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

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

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

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

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

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

वैरिएबल के नाम

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

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

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

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

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

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

  import sys

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

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

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

• sys — बाहर निकलें(), आर्गव, एसटीडीन, stdout, ... तक ऐक्सेस
• re — रेगुलर एक्सप्रेशन
• os — ऑपरेटिंग सिस्टम का इंटरफ़ेस, फ़ाइल सिस्टम

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

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

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

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

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

• 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() तरीके की सहायता स्ट्रिंग