पायथन प्रोग्रामिंग भाषा का एक अनौपचारिक परिचय

पायथन प्रोग्रामिंग लैंग्वेज क्या है?

पायथन एक उच्च-स्तरीय, सामान्य-उद्देश्य वाली प्रोग्रामिंग भाषा है जिसे पहली बार 1991 में गुइडो वैन रोसुम द्वारा जारी किया गया था। यह अपनी सादगी और उपयोग में आसानी के लिए जाना जाता है, जो इसे शुरुआती और अनुभवी डेवलपर्स के लिए समान रूप से लोकप्रिय विकल्प बनाता है। पायथन भी एक बहुमुखी भाषा है जिसका उपयोग वेब विकास, डेटा विश्लेषण, मशीन सीखने, वैज्ञानिक कंप्यूटिंग और अधिक सहित कई प्रकार के कार्यों के लिए किया जा सकता है।

                        
                            # this is the first comment
                            x = 5  # and this is the second comment
                                    # ... and now a third!
                            text = "# This is not a comment because it's inside quotes."
                        
                    

                        
                            >>> 5+15
                            20
                            >>> 25 + 32*8
                            281
                            # division always returns a floating point number
                            >>> (65 - 9*6)/4
                            2.75
                            >>> 168/7
                            24.0
                            >>>
                        
                    

                        
                            >>> 23/6   # classic division returns a float
                            3.8333333333333335
                            >>> 23//6  # floor division discards the fractional part
                            3
                            >>> 23%6   # the % operator returns the remainder of the division
                            5
                            >>> 3*6 + 5    # floored quotient * divisor + remainder
                            23
                            >>>
                        
                    

                        
                            >>> 9**2   # square of 9
                            81
                            >>> 13**8  # 13 to the power of 8
                            815730721
                            >>>
                        
                    

                        
                            >>> num1 = 8
                            >>> num2 = 7
                            >>> num1 * num2
                            56
                            >>>
                        
                    

                        
                            >>> num3   # try to access an undefined variable
                            Traceback (most recent call last):
                            File "<stdin>", line 1, in <module>
                            NameError: name 'num3' is not defined. Did you mean: 'num1'?
                            >>>
                        
                    

                        
                            >>> 89 * 4.62 -29
                            382.18
                            >>>
                        
                    

                        
                            >>> val1 = 250 *32
                            >>> val2 = 56.25
                            >>> val1 * val2
                            450000.0
                            >>> val2 + _
                            450056.25
                            >>> round(_, 1)
                            450056.2
                            >>>
                        
                    

पायथन में स्ट्रिंग्स

पायथन में, तार को कई तरीकों से व्यक्त किया जा सकता है, उन्हें एक उद्धरण ('...') या दोहरे उद्धरण ("...") से जोड़ा जा सकता है, दोनों का एक ही परिणाम होगा। बैकस्लैश '\' का उपयोग उद्धरणों से बचने के लिए किया जा सकता है। यहाँ एक उदाहरण है:

                    
                        >>> 'John Doe' # single quotes
                        'John Doe'
                        >>> 'shouldn\'t'   # use \' to escape the single quote...
                        "shouldn't"
                        >>> "shouldn't"  # ...or use double quotes instead
                        "shouldn't"
                        >>> '"Yes", he said.'
                        '"Yes", he said'
                        >>> "\"Yes,\" he said."
                        '"Yes," he said.'
                        >>> '"Isn\'t," he said.'
                        '"Isn\'t," he said.'
                        >>>
                    
                

इंटरएक्टिव दुभाषिया में, आउटपुट स्ट्रिंग्स को उद्धरणों में संलग्न किया जाता है और विशेष वर्ण बैकस्लैश का उपयोग करके बच जाते हैं। हालांकि यह कभी-कभी इनपुट से अलग दिख सकता है (संलग्न उद्धरण बदल सकते हैं), दो तार बराबर हैं। यदि स्ट्रिंग में एकल उद्धरण है और कोई दोहरा उद्धरण नहीं है, तो स्ट्रिंग को दोहरे उद्धरण चिह्नों से जोड़ा जाता है, अन्यथा यह एकल उद्धरण से जुड़ा होता है। प्रिंट () फ़ंक्शन संलग्न उद्धरणों और मुद्रण भगोड़े और विशेष वर्णों को छोड़कर अधिक पठनीय आउटपुट उत्पन्न करता है:

                    
                        >>> '"Isn\'t," he said.'
                        '"Isn\'t," he said.'
                        >>> print('"Isn\'t," he said.')
                        "Isn't," he said.
                        >>> s = 'This is first line.\n This is second line.'   # \n means newline
                        >>> s  # without print(), \n is included in the output
                        'This is first line.\nThis is second line.'
                        >>> print(s)   # with print(), \n produces a new line
                        This is first line.
                        This is second line.
                        >>>
                    
                

यदि आप नहीं चाहते कि चरित्र को '\' का उपयोग करके विशेष वर्णों के रूप में प्रस्तुत किया जाए, तो आप पहले उद्धरण से पहले 'r' जोड़कर कच्चे तार का उपयोग कर सकते हैं:

                    
                        >>> print('C:\some\name')  # here \n means newline!
                        C:\some
                        ame
                        >>> print(r'C:\some\name') # note the r before the quote
                        C:\some\name
                        >>>
                    
                

कच्चे तार में एक पहलू है, एक कच्चा तार '\' वर्ण के साथ समाप्त नहीं हो सकता, क्योंकि यह एक त्रुटि फेंकता है।

                    
                        >>> print(r'C:\file\name\')
                            File "<stdin>", line 1
                                print(r'C:\file\name\')
                                      ^
                        SyntaxError: unterminated string literal (detected at line 1)
                        >>>
                    
                

पायथन में, स्ट्रिंग शाब्दिक कई पंक्तियों को फैला सकता है। ऐसा करने का एक तरीका ट्रिपल कोट्स """...""" या ''''...'''' है।

                    
                        # using double quotes
                        >>> """abc
                        ... xyz"""
                        'abc\nxyz'
                        >>>
                        # or using single quotes
                        >>> '''abc
                        ... xyz'''
                        'abc\nxyz'
                        >>>
                    
                

पायथन में + ऑपरेटर का उपयोग करके स्ट्रिंग संघनन की अनुमति देता है और इसे * के साथ दोहराया जा सकता है।

                    
                        # 3 times 'o', followed by 'ps'
                        >>> 'o' * 3 + 'ps'
                        'ooops'
                        >>>
                    
                

पायथन में एक दूसरे के बगल में दो या दो से अधिक तार स्वचालित रूप से समाप्‍त हो जाते हैं।

                    
                        >>> 'py' 'thon'
                        'python'
                        >>> 'py' "thon"
                        'python'
                        >>>
                    
                

जब आप लंबे तार तोड़ना चाहते हैं तो यह सुविधा विशेष रूप से उपयोगी होती है:

                    
                        >>> text = ('Put several strings within parentheses '
                        ... 'to have them joined together.')
                        >>> text
                        'Put several strings within parentheses to have them joined together.'
                        >>>
                    
                

यह केवल दो अक्षर के साथ काम करता है, चर या भाव के साथ नहीं:

                    
                        >>> prefix = 'ooo'
                        >>> prefix 'ps'
                            File "<stdin>", line 1
                                prefix 'ps'
                                        ^^^^
                        SyntaxError: invalid syntax
                        >>> ('o' * 3) 'ps'
                            File "<stdin>", line 1
                                ('o' * 3) 'ps'
                                            ^^^^
                        SyntaxError: invalid syntax
                        >>>
                    
                

यदि आप चर या चर और शाब्दिक को जोड़ना चाहते हैं, तो + ऑपरेटर का उपयोग करें:

                    
                        >>> prefix = 'ooo'
                        ... prefix + 'ps'
                        'ooops'
                        >>>
                    
                

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

                    
                        >>> word = 'Gamosoftstudio'
                        # counting from left to right
                        >>> word[0]    # character in position 0
                        'G'
                        >>> word[7]    # character in position 7
                        't'
                        # counting from right to left
                        >>> word[-1]   # last character
                        'o'
                        >>> word[-7]   # seventh-last character
                        't'
                        >>>
                    
                

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

                    
                        >>> word = 'Gamosoftstudio'
                        >>> word[0:4]  # characters from position 0 (included) to 4 (excluded)
                        'Gamo'
                        >>> word[4:8]  # characters from position 4 (included) to 8 (excluded)
                        'soft'
                        >>>
                    
                

हम पहले सूचकांकों को 0 के आकार और दूसरे सूचकांकों को कटा हुआ आकार के लिए डिफ़ॉल्ट छोड़ सकते हैं। और हम इसे दूसरे तरीके से भी कर सकते हैं, पहले सूचकांकों को कुछ संख्या निर्दिष्ट करके और दूसरे सूचकांकों को खाली छोड़ कर ताकि डिफ़ॉल्ट रूप से यह स्ट्रिंग की अंतिम अनुक्रमणिका ले ले।

                    
                        >>> word = 'Gamosoftstudio'
                        >>> word[:8]   # character from the beginning to position 8 (excluded)
                        'Gamosoft'
                        >>> word[8:]   # characters from position 8 (included) to the end
                        'studio'
                        >>> word[-6:]  # characters from the sixth-last (included) to the end
                        'studio'
                        >>>
                    
                

यह याद रखने का एक तरीका है कि स्लाइसिंग कैसे काम करती है, चरम बाएँ वर्ण वाले वर्णों का सूचकांक 0 है और दाईं ओर अंतिम वर्ण की लंबाई 'n' है।

                    
                        |   G   |   a   |   m   |   o   |   s   |   o   |   f   |   t   |   s   |   t   |   u   |   d   |   i   |   o   |
                        0       1       2       3       4       5       6      7      8      9      10     11     12    13    14
                        -14   -13   -12    -11    -10     -9    -8      -7      -6     -5      -4     -3      -2     -1
                    
                

यदि हम उस लंबाई तक पहुँचने की कोशिश कर रहे हैं जो स्ट्रिंग में मौजूद नहीं है तो यह एक त्रुटि फेंकता है, आइए यहाँ एक नज़र डालें:

                    
                        >>> word = 'Gamosoftstudio'
                        >>> word[23]
                        Traceback (most recent call last):
                        File "<stdin>", line 1, in <module>
                        IndexError: string index out of range
                        >>>
                    
                

पायथन स्ट्रिंग्स को इंडेक्स ऑपरेटर का उपयोग करके नहीं बदला जा सकता है, वे अपरिवर्तनीय हैं। इसलिए, इंडेक्स पोजीशन को असाइन करने से त्रुटि होती है।

                    
                        >>> word = 'Gamosoftstudio'
                        >>> word[0] = 'P'
                        Traceback (most recent call last):
                        File "<stdin>", line 1, in <module>
                        TypeError: 'str' object does not support item assignment
                        >>>
                    
                

पायथन अंतर्निर्मित फ़ंक्शन len() स्ट्रिंग की लंबाई प्रदान करता है, यहां एक उदाहरण दिया गया है:

                    
                        >>> word = 'Gamosoftstudio'
                        >>> len(word)
                        14
                        >>>
                    
                

पायथन में सूची

पायथन सूचियों का भी समर्थन करता है, जिन्हें वर्ग कोष्ठक के बीच अल्पविराम से अलग किए गए मान (आइटम) द्वारा लिखा जा सकता है। सूची में विभिन्न प्रकार के डेटा हो सकते हैं लेकिन आमतौर पर हम केवल एक ही प्रकार के डेटा देखते हैं। सूची में हम सूचकांक मूल्यों को अद्यतन कर सकते हैं और यह बहुत आसान है। आइए यहां कुछ उदाहरण देखें।

                    
                        >>> squares = [1, 4, 11, 16, 25]
                        # square of 3 should be 9 but it is written as 11 in the list.
                        # Updating the square of value 3 at the index 2.
                        >>> squares[2] = 3 ** 2
                        # Now print the updated squares list.
                        >>> squares
                        [1, 4, 9, 16, 25]
                        >>>
                    
                

हम दो या अधिक सूचियाँ भी जोड़ सकते हैं, आप इसे + ऑपरेटर का उपयोग करके कर सकते हैं:

                    
                        >>> squares = [1, 4, 11, 16, 25]
                        # Now print the updated squares list.
                        >>> squares + [36, 49, 64, 81]
                        [1, 4, 9, 16, 25, 36, 49, 64, 81]
                        >>>
                    
                

आप एपेंड () का उपयोग करके सूची में नए आइटम जोड़ सकते हैं और रिमूव () का उपयोग करके किसी आइटम को हटा भी सकते हैं, यहां बताया गया है कि हम कैसे कर सकते हैं:

                    
                        >>> squares = [1, 4, 11, 16, 25]
                        # adding item to the list
                        >>> squares.append(6 ** 2)
                        >>> squares
                        [1, 4, 9, 16, 25, 36]
                        # remove items from the list by providing values
                        >>> squares.remove(36)
                        >>> squares
                        [1, 4, 9, 16, 25]
                        # or removing items from the list by providing an index number
                        >>> squares.remove(squares[4])
                        >>> squares
                        [1, 4, 9, 16]
                        >>>
                    
                

हम एक बार में सूची में एक से अधिक आइटम को बदल या हटा सकते हैं या सूची को पूरी तरह से साफ़ कर सकते हैं।

                    
                        >>> letters = ['g', 'a', 'm', 'o', 's', 'o', 'f', 't', 's', 't', 'u', 'd', 'i', 'o']
                        # replace some values
                        >>> letters[4:8] = ['S', 'O', 'F', 'T']
                        >>> letters
                        ['g', 'a', 'm', 'o', 'S', 'O', 'F', 'T', 's', 't', 'u', 'd', 'i', 'o']
                        # now remove them
                        >>> letters[4:8] = []
                        >>> letters
                        ['g', 'a', 'm', 'o', 's', 't', 'u', 'd', 'i', 'o']
                        # clear the list by replacing all the elements with an empty list
                        >>> letters = []
                        >>> letters
                        []
                        >>>
                    
                

बिल्ट-इन len() फ़ंक्शन सूची की लंबाई प्रदान करता है।

                    
                        >>> letters = ['g', 'a', 'm', 'o', 's', 'o', 'f', 't', 's', 't', 'u', 'd', 'i', 'o']
                        >>> len(letters)
                        14
                        >>>
                    
                

हम एक सूची भी बना सकते हैं जिसमें अन्य सूचियाँ शामिल हों, अर्थात पायथन में घोंसला सूची संभव है। यहां बताया गया है कि हम यह कैसे कर सकते हैं:

                    
                        >>> x = ['P', 'y', 't', 'h', 'o', 'n']
                        >>> y = [1, 2, 3]
                        >>> z = [x, y]
                        >>> z
                        [['P', 'y', 't', 'h', 'o', 'n'], [1, 2, 3]]
                        >>> z[0]
                        ['P', 'y', 't', 'h', 'o', 'n']
                        >>> z[0][2]
                        't'
                        >>> z[1]
                        [1, 2, 3]
                        >>> z[1][0]
                        1
                        >>>
                    
                

यहां हमने कुछ ऑपरेटरों, कार्यों और उनके उपयोग को सीखा है, हम अगले ट्यूटोरियल में पायथन का अधिक जटिल उपयोग शुरू करेंगे। हम कदम-दर-कदम आगे बढ़ रहे हैं ताकि आप अवधारणाओं को ठीक से समझ सकें। यदि आपके पास इस ट्यूटोरियल से संबंधित कोई प्रश्न हैं, तो आप मुझसे नीचे दिए गए सोशल मीडिया लिंक पर पूछ सकते हैं। मुझे आपके सवालों का जवाब देने में बहुत खुशी होगी।

यदि आपको यह ब्लॉग उपयोगी लगता है, तो कृपया मुझे एक कॉफी खरीदने पर विचार करें।

राजीव रंजन

मोबाइल और वेब ऐप विकास में विशेषज्ञता के साथ एक डिजिटल सामग्री निर्माता और ब्लॉगर के रूप में, मेरे पास आकर्षक और सूचनात्मक सामग्री बनाने का जुनून है जो मेरे दर्शकों को शिक्षित और सूचित करने में मदद करता है। चाहे वह ब्लॉग लिखने, वीडियो बनाने, या इंटरैक्टिव ग्राफिक्स डिजाइन करने के माध्यम से हो, मैं उच्च गुणवत्ता वाली सामग्री बनाने का प्रयास करता हूं जो मेरे दर्शकों के लिए मूल्य जोड़ता है।