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

प्रीलूड

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

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

Python सोर्स कोड

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

किसी स्टैंडर्ड Python प्रोग्राम में, sys.argv सूची में स्टैंडर्ड तरीके से कमांड-लाइन आर्ग्युमेंट होते हैं. इसमें sys.argv[0] प्रोग्राम होता है, sys.argv[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

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

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

यहां ऊपर दिए गए repeat() फ़ंक्शन को कॉल करने वाला कोड दिया गया है. इसमें फ़ंक्शन से मिलने वाले आउटपुट को प्रिंट किया गया है:

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

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

इंडेंट करना

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

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

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

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

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

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

if-स्टेटमेंट में एक साफ़ तौर पर गड़बड़ी है, जहां repeat() फ़ंक्शन को गलती से 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 वैरिएबल के लिए, सोर्स कोड में कोई टाइप नहीं लिखा जाता. इसलिए, अपने वैरिएबल को काम के नाम देना ज़्यादा मददगार होता है, ताकि आपको याद रहे कि क्या हो रहा है. इसलिए, अगर एक ही नाम है, तो "नाम" और अगर नामों की सूची है, तो "नाम" का इस्तेमाल करें. अगर शब्दों की सूची है, तो "ट्यूपल" का इस्तेमाल करें. Python की कई बुनियादी गड़बड़ियां, यह भूलने की वजह से होती हैं कि हर वैरिएबल में किस तरह की वैल्यू है. इसलिए, चीज़ों को सही तरीके से रखने के लिए, अपने वैरिएबल के नामों (आपके पास सभी चीज़ें) का इस्तेमाल करें.

नाम रखने के लिए, कुछ भाषाओं में "एक से ज़्यादा शब्दों" वाले वैरिएबल के नाम के लिए, underscored_parts का इस्तेमाल किया जाता है. हालांकि, अन्य भाषाओं में camelCasing का इस्तेमाल किया जाता है. आम तौर पर, Python अंडरस्कोर वाले तरीके को प्राथमिकता देता है. हालांकि, अगर किसी मौजूदा Python कोड में इंटिग्रेट करने के लिए, डेवलपर को पहले से इस्तेमाल किए जा रहे स्टाइल का इस्तेमाल करना है, तो उन्हें कैमलकेसिंग का इस्तेमाल करने के लिए कहा जाता है. पढ़ने में आसानी से जुड़ी गिनती. ज़्यादा जानकारी के लिए, PEP 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 के लिए मदद पाने के कई तरीके हैं.

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

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

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