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

Prelude

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

अगर आपको साथ में कोई MOOC कोर्स करना है, तो Udacity और Coursera के कोर्स आज़माएं. जैसे, इंट्रो टू प्रोग्रामिंग [नए लोगों के लिए] या इंट्रो टू 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 की भाषा में इसे "raises" कहा जाता है. C++ और Java की तरह, Python भी केस सेंसिटिव (छोटे और बड़े अक्षरों में अंतर करने वाली) होती है. इसलिए, "a" और "A" अलग-अलग वैरिएबल हैं. लाइन के आखिर में स्टेटमेंट खत्म हो जाता है. इसलिए, C++ और Java के उलट, Python में हर स्टेटमेंट के आखिर में सेमीकोलन की ज़रूरत नहीं होती. टिप्पणियां '#' से शुरू होती हैं और लाइन के आखिर तक होती हैं.

Python सोर्स कोड

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

स्टैंडर्ड Python प्रोग्राम में, sys.argv लिस्ट में कमांड-लाइन आर्ग्युमेंट स्टैंडर्ड तरीके से शामिल होते हैं. इसमें sys.argv[0] प्रोग्राम होता है, sys.argv[1] पहला आर्ग्युमेंट होता है, और इसी तरह आगे भी. अगर आपको argv या आर्ग्युमेंट की संख्या के बारे में पता है, तो argv की मदद से 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-statement बनाने वाली लाइनों को एक साथ ग्रुप किया गया है, क्योंकि उन सभी में इंडेंटेशन का लेवल एक जैसा है. हमने स्ट्रिंग को दोहराने के दो अलग-अलग तरीके भी बताए हैं. इनमें से एक तरीका, + ऑपरेटर का इस्तेमाल करना है. यह तरीका, उपयोगकर्ताओं के लिए ज़्यादा आसान है. हालांकि, * ऑपरेटर का इस्तेमाल भी किया जा सकता है, क्योंकि यह Python का "दोहराएं" ऑपरेटर है. इसका मतलब है कि '-' * 10 से '----------' मिलता है. यह स्क्रीन पर "लाइन" बनाने का एक आसान तरीका है. कोड की टिप्पणी में, हमने बताया है कि * का इस्तेमाल करने पर, + के मुकाबले ज़्यादा तेज़ी से काम होता है. इसकी वजह यह है कि * का इस्तेमाल करने पर, नतीजे के तौर पर मिले ऑब्जेक्ट के साइज़ का हिसाब एक बार लगाया जाता है. वहीं, + का इस्तेमाल करने पर, हर बार + को कॉल करने पर हिसाब लगाया जाता है. + और * दोनों को "ओवरलोड" ऑपरेटर कहा जाता है, क्योंकि संख्याओं और स्ट्रिंग (और अन्य डेटा टाइप) के लिए इनका मतलब अलग-अलग होता है.

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

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

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

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

इंडेंटेशन

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

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

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

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

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

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 है. हम बाद में बताएंगे कि इन टाइप का क्या मतलब है. हालांकि, टाइप हिंट देना ज़रूरी नहीं है. आपको ज़्यादा से ज़्यादा कोड में टाइप हिंट का इस्तेमाल होता दिखेगा. ऐसा इसलिए, क्योंकि इनका इस्तेमाल करने पर, cider-v और VS.code जैसे कुछ एडिटर, यह पुष्टि करने के लिए जांच कर सकते हैं कि आपके फ़ंक्शन को सही आर्ग्युमेंट टाइप के साथ कॉल किया गया है या नहीं. ये कोड में बदलाव करते समय, तर्कों का सुझाव दे सकते हैं और उनकी पुष्टि कर सकते हैं. इस ट्यूटोरियल में टाइप हिंट के बारे में नहीं बताया गया है. हालांकि, हम यह पक्का करना चाहते हैं कि अगर आपको इनके बारे में पता चले या आपको ये कहीं दिखें, तो आपको इनकी जानकारी हो.

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

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

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

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

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

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

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

  import sys

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

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

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

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

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

ऑनलाइन मदद, help(), और dir()

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

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

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

• help(len) — बिल्ट-इन 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() तरीके के लिए मदद वाली स्ट्रिंग