Python Language ट्यूटोरियल
पायथन लैंग्वेज के साथ शुरुआत करना

टिप्पणियों

संस्करण

शुरू करना

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

पायथन के दो प्रमुख संस्करण वर्तमान में सक्रिय उपयोग में हैं:

• पायथन 3.x वर्तमान संस्करण है और सक्रिय विकास के अंतर्गत है।
• पायथन 2.x विरासत संस्करण है और 2020 तक केवल सुरक्षा अद्यतन प्राप्त करेंगे। कोई नई सुविधाएँ लागू नहीं की जाएंगी। ध्यान दें कि कई परियोजनाएं अभी भी पायथन 2 का उपयोग करती हैं, हालांकि पायथन 3 की ओर पलायन आसान हो रहा है।

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

सत्यापित करें कि पायथन स्थापित है या नहीं

यह पुष्टि करने के लिए कि पायथन को सही तरीके से स्थापित किया गया था, आप अपने पसंदीदा टर्मिनल में निम्न कमांड चलाकर सत्यापित कर सकते हैं (यदि आप विंडोज़ ओएस का उपयोग कर रहे हैं, तो आपको कमांड प्रॉम्प्ट में उपयोग करने से पहले पर्यावरण चर में अजगर का रास्ता जोड़ना होगा):

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

यदि आपने पायथन 3 स्थापित किया है, लेकिन $ python --version पायथन 2 संस्करण को आउटपुट करता है, तो आपके पास पायथन 2 भी स्थापित है। यह अक्सर MacOS, और कई लिनक्स वितरण पर मामला होता है। स्पष्ट रूप से अजगर 3 दुभाषिया का उपयोग करने के बजाय $ python3 उपयोग करें।

हैलो, दुनिया में पायल का उपयोग कर आईडीएलई

IDLE Python के लिए एक सरल संपादक है, जो Python के साथ बंडल में आता है।

नमस्कार, IDLE में वर्ल्ड प्रोग्राम कैसे बनाएं

• अपनी पसंद के सिस्टम पर IDLE खोलें।
  • विंडोज के पुराने संस्करणों में, यह विंडोज मेनू के तहत All Programs में पाया जा सकता है।
  • विंडोज 8+ में, IDLE खोज करें या इसे उन ऐप्स में खोजें जो आपके सिस्टम में मौजूद हैं।
  • यूनिक्स-आधारित (मैक सहित) सिस्टम पर आप $ idle python_file.py टाइप करके इसे खोल से खोल सकते हैं।
• यह शीर्ष के साथ विकल्पों के साथ एक खोल खोल देगा।

शेल में, तीन समकोण कोष्ठक का संकेत है:

>>>

अब प्रॉम्प्ट में निम्नलिखित कोड लिखें:

>>> print("Hello, World")

Enter दबाएं।

>>> print("Hello, World")
Hello, World

हैलो वर्ल्ड पायथन फाइल

एक नई फ़ाइल hello.py बनाएँ जिसमें निम्न पंक्ति हो:

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

अपने टर्मिनल में, उस निर्देशिका में नेविगेट करें जिसमें फ़ाइल hello.py ।

python hello.py टाइप करें, फिर Enter कुंजी दबाएं।

$ python hello.py
Hello, World

आपको Hello, World को कंसोल पर प्रिंट करके देखना चाहिए।

आप अपनी फ़ाइल के लिए पथ के साथ hello.py को भी प्रतिस्थापित कर सकते हैं। उदाहरण के लिए, यदि आपके पास अपने घर निर्देशिका में फ़ाइल है और आपका उपयोगकर्ता लिनक्स पर "उपयोगकर्ता" है, तो आप python /home/user/hello.py टाइप कर सकते हैं।

एक इंटरैक्टिव पायथन शेल लॉन्च करें

अपने टर्मिनल में python कमांड को निष्पादित (चलाने) करके, आपको एक इंटरैक्टिव पायथन शेल के साथ प्रस्तुत किया जाता है। इसे पायथन इंटरप्रेटर या एक REPL ('रीड इवैल्यूएट प्रिंट लूप') के रूप में भी जाना जाता है।

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>

यदि आप अपने टर्मिनल से पायथन 3 चलाना चाहते हैं, तो कमांड python3 निष्पादित करें।

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>

वैकल्पिक रूप से, python -i <file.py> साथ इंटरैक्टिव प्रॉम्प्ट और लोड फ़ाइल प्रारंभ करें।

कमांड लाइन में, चलाएं:

$ python -i hello.py
"Hello World"
>>>

पायथन शेल को बंद करने के कई तरीके हैं:

>>> exit()

या

>>> quit()

वैकल्पिक रूप से, CTRL + D शेल को बंद कर देगा और आपको अपने टर्मिनल की कमांड लाइन पर वापस रख देगा।

यदि आप एक कमांड रद्द करना चाहते हैं, तो आप टाइपिंग के बीच में हैं और एक साफ कमांड प्रॉम्प्ट पर वापस जाएं, जबकि इंटरप्रेटर शेल के अंदर रहते हुए, CTRL + C का उपयोग करें।

ऑनलाइन एक इंटरैक्टिव पायथन शेल का प्रयास करें ।

अन्य ऑनलाइन गोले

विभिन्न वेबसाइट पायथन शेल के लिए ऑनलाइन पहुँच प्रदान करती हैं।

ऑनलाइन शेल निम्न उद्देश्यों के लिए उपयोगी हो सकते हैं:

• मशीन से एक छोटा कोड स्निपेट चलाएं जिसमें अजगर स्थापना (स्मार्टफोन, टैबलेट आदि) का अभाव है।
• बेसिक पायथन सीखें या सिखाएं।
• ऑनलाइन जज समस्याओं का समाधान करें।

उदाहरण:

अस्वीकरण: प्रलेखन लेखक (एस) नीचे सूचीबद्ध किसी भी संसाधन से संबद्ध नहीं हैं।

• https://www.python.org/shell/ - आधिकारिक पायथन वेबसाइट द्वारा होस्ट किया गया ऑनलाइन पायथन शेल।
• https://ideone.com/ - कोड स्निपेट व्यवहार को दर्शाने के लिए नेट पर व्यापक रूप से उपयोग किया जाता है।
• https://repl.it/languages/python3 - शक्तिशाली और सरल ऑनलाइन संकलक, आईडीई और दुभाषिया। कोड, संकलन, और पायथन में कोड चलाएं।
• https://www.tutorialspoint.com/execute_python_online.php - पूर्ण-चित्रित UNIX शेल, और उपयोगकर्ता के अनुकूल प्रोजेक्ट एक्सप्लोरर।
• http://rextester.com/l/python3_online_compiler - सरल और आसान आईडीई का उपयोग करने के लिए जो निष्पादन समय दिखाता है

एक स्ट्रिंग के रूप में कमांड चलाएं

पायथन को शेल में एक स्ट्रिंग के रूप में मनमाना कोड पारित किया जा सकता है:

$ python -c 'print("Hello, World")'
Hello, World

यह शेल में एक साथ स्क्रिप्ट के परिणामों को समेटते समय उपयोगी हो सकता है।

गोले और परे

पैकेज प्रबंधन - पायथन पैकेज स्थापित करने के लिए PyPA अनुशंसित उपकरण PIP है । स्थापित करने के लिए, अपनी कमांड लाइन पर pip install <the package name> । उदाहरण के लिए, pip install numpy । (नोट: खिड़कियों पर आपको अपने PATH परिवेश चर में पाइप जोड़ना होगा। इससे बचने के लिए, python -m pip install <the package name> )

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

कार्यक्रम - लंबी अवधि के भंडारण के लिए आप / .py फ़ाइलों और संपादित करने के लिए सामग्री को बचा सकता है उन्हें स्क्रिप्ट या बाहरी उपकरण जैसे खोल के साथ कार्यक्रम, के रूप में अमल IDEs (जैसे PyCharm ), Jupyter नोटबुक , आदि मध्यवर्ती उपयोगकर्ता इन उपकरणों का उपयोग कर सकते हैं; हालाँकि, यहां चर्चा की गई विधियाँ आरंभ करने के लिए पर्याप्त हैं।

पायथन ट्यूटर आपको पायथन कोड के माध्यम से कदम रखने की अनुमति देता है ताकि आप कल्पना कर सकें कि कार्यक्रम कैसे बहेगा, और आपको यह समझने में मदद करता है कि आपका कार्यक्रम कहां गलत हुआ।

PEP8 पायथन कोड को फॉर्मेट करने के दिशा-निर्देशों को परिभाषित करता है। कोड को अच्छी तरह से फॉर्मेट करना महत्वपूर्ण है ताकि आप जल्दी से पढ़ सकें कि कोड क्या करता है।

वैरिएबल बनाना और मान निर्दिष्ट करना

पाइथन में एक वैरिएबल बनाने के लिए, आपको केवल वैरिएबल नाम निर्दिष्ट करना होगा, और उसके बाद एक मान निर्दिष्ट करना होगा।

<variable name> = <value>

पायथन वैरिएबल को मान प्रदान करने के लिए = का उपयोग करता है। पहले से एक चर घोषित करने की आवश्यकता नहीं है (या इसके लिए एक डेटा प्रकार निर्दिष्ट करने के लिए), एक चर को एक मूल्य निर्दिष्ट करना जो स्वयं को घोषित करता है और उस मूल्य के साथ चर को आरंभ करता है। एक वैरिएबल घोषित करने का कोई तरीका नहीं है कि इसे प्रारंभिक मूल्य बताए बिना।

# Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None

वैरिएबल असाइनमेंट बाएं से दाएं काम करता है। तो निम्नलिखित आपको एक सिंटैक्स त्रुटि देगा।

0 = x
=> Output: SyntaxError: can't assign to literal

आप अजगर के खोजशब्दों को एक वैध चर नाम के रूप में उपयोग नहीं कर सकते। आप द्वारा कीवर्ड की सूची देख सकते हैं:

import keyword
print(keyword.kwlist)

चर नामकरण के नियम:

1. चर नाम अक्षर या अक्षर से शुरू होना चाहिए।

 x  = True   # valid
 _y = True   # valid

 9x = False  # starts with numeral 
 => SyntaxError: invalid syntax   

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax

2. आपके चर नाम का शेष अक्षर, संख्या और अंडरस्कोर हो सकता है।

has_0_in_it = "Still Valid" 

3. नाम संवेदनशील हैं।

x = 9  
y = X*5   
=>NameError: name 'X' is not defined

हालांकि पाइथन में एक वैरिएबल की घोषणा करते समय डेटा प्रकार निर्दिष्ट करने की आवश्यकता नहीं है, जबकि चर के लिए मेमोरी में आवश्यक क्षेत्र आवंटित करते हुए, पाइथन इंटरप्रेटर स्वचालित रूप से इसके लिए सबसे उपयुक्त अंतर्निहित प्रकार चुनता है:

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>

अब आप असाइनमेंट की मूल बातें जानते हैं, आइए इस सूक्ष्मता को असाइनमेंट के बारे में समझें।

जब आप असाइनमेंट ऑपरेशन करने के लिए = का उपयोग करते हैं, तो बाईं ओर = जो दाईं ओर ऑब्जेक्ट के लिए एक नाम है । अंत में, क्या = बाईं ओर नाम के दाईं ओर ऑब्जेक्ट के संदर्भ को असाइन करता है।

अर्थात्:

a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"

तो, कई काम उदाहरण से, ऊपर हम लेने अगर pi = 3.14 , तो pi एक नाम है (न नाम, के बाद से एक वस्तु से अधिक नाम हो सकता है) वस्तु के लिए 3.14 । यदि आपको नीचे कुछ समझ में नहीं आता है, तो इस बिंदु पर वापस आएं और इसे फिर से पढ़ें! इसके अलावा, आप बेहतर समझ के लिए इस पर एक नज़र डाल सकते हैं।

आप एक से अधिक चर में एक से अधिक मानों को एक पंक्ति में निर्दिष्ट कर सकते हैं। ध्यान दें कि = ऑपरेटर के दाईं और बाईं ओर समान तर्क होने चाहिए:

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack

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

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2

ध्यान दें कि _ और शेष मानों की संख्या बराबर होनी चाहिए। अन्यथा 'त्रुटि को अनपैक करने के लिए बहुत अधिक मान' को ऊपर दिया गया है:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)

आप एक साथ कई वेरिएबल्स के लिए एक मान भी असाइन कर सकते हैं।

a = b = c = 1
print(a, b, c)
# Output: 1 1 1

ऐसे कैस्केडिंग असाइनमेंट का उपयोग करते समय, यह ध्यान रखना महत्वपूर्ण है कि सभी तीन चर a , b और c एक ही ऑब्जेक्ट को मेमोरी में संदर्भित करते हैं, 1. के मान के साथ एक int ऑब्जेक्ट। दूसरे शब्दों में, a , b और c तीन अलग-अलग नाम हैं उसी इंट ऑब्जेक्ट को दिया गया। बाद में उनमें से एक को एक अलग वस्तु सौंपना दूसरों को नहीं बदलता है, जैसा कि अपेक्षित है:

a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.

उपरोक्त भी उत्परिवर्तनीय प्रकारों (जैसे list , dict इत्यादि) के लिए सही है, क्योंकि यह अपरिवर्तनीय प्रकारों (जैसे int , string , tuple , आदि) के लिए सत्य है:

x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]

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

x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected

नेस्टेड सूचियां भी अजगर में मान्य हैं। इसका मतलब है कि एक सूची में तत्व के रूप में एक और सूची हो सकती है।

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4

अंत में, पायथन में चर को उसी प्रकार नहीं रहना पड़ता है, जिसके रूप में वे पहले परिभाषित किए गए थे - आप किसी चर को नया मान देने के लिए = का उपयोग कर सकते हैं, भले ही वह मान किसी भिन्न प्रकार का हो।

a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value

यदि यह आपको परेशान करता है, तो इस तथ्य के बारे में सोचें कि क्या = के बाईं ओर एक वस्तु के लिए सिर्फ एक नाम है। सबसे पहले आप फोन int मान 2 के साथ वस्तु a है, तो आप अपना मन बदल और नाम देने का फैसला a एक करने के लिए string वस्तु, होने मूल्य 'नई मूल्य'। सरल, सही?

उपयोगकर्ता का निवेश

इंटरएक्टिव इनपुट

उपयोगकर्ता से इनपुट प्राप्त करने के लिए, input फ़ंक्शन का उपयोग करें ( ध्यान दें : पायथन 2.x में, फ़ंक्शन को इसके बजाय raw_input कहा जाता है, हालांकि Python 2.x के input का अपना संस्करण है जो पूरी तरह से अलग है):

name = raw_input("What is your name? ")
# Out: What is your name? _

name = input("What is your name? ")
# Out: What is your name? _

इस उदाहरण के शेष पायथन 3 सिंटैक्स का उपयोग किया जाएगा।

फ़ंक्शन एक स्ट्रिंग तर्क लेता है, जो इसे एक संकेत के रूप में प्रदर्शित करता है और एक स्ट्रिंग लौटाता है। उपर्युक्त कोड एक संकेत प्रदान करता है, जो इनपुट के लिए उपयोगकर्ता की प्रतीक्षा कर रहा है।

name = input("What is your name? ")
# Out: What is your name?

यदि उपयोगकर्ता "बॉब" और हिट दर्ज करता है, तो चर का name स्ट्रिंग "Bob" को सौंपा जाएगा:

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob

ध्यान दें कि input प्रकार की हमेशा होता है str है, जो महत्वपूर्ण है अगर आप उपयोगकर्ता नंबर दर्ज करना चाहते हैं। इसलिए, आपको संख्या के रूप में उपयोग करने की कोशिश करने से पहले str को रूपांतरित करना होगा:

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0

NB: उपयोगकर्ता इनपुट के साथ काम करते समय अपवादों को पकड़ने के लिए ब्लॉक को except / try का उपयोग try की अनुशंसा की जाती है। उदाहरण के लिए, यदि आपका कोड एक raw_input को एक int में डालना चाहता है, और उपयोगकर्ता जो लिखता है, वह उपलब्ध नहीं है, तो यह एक ValueError उठाता है।

IDLE - पायथन जीयूआई

IDLE पायथन का एकीकृत विकास और सीखने का वातावरण है और कमांड लाइन का एक विकल्प है। जैसा कि नाम से पता चलता है, IDLE नए कोड विकसित करने या अजगर सीखने के लिए बहुत उपयोगी है। विंडोज पर यह पायथन इंटरप्रेटर के साथ आता है, लेकिन अन्य ऑपरेटिंग सिस्टम में आपको इसे अपने पैकेज मैनेजर के माध्यम से इंस्टॉल करना पड़ सकता है।

IDLE के मुख्य उद्देश्य हैं:

• सिंटैक्स हाइलाइटिंग, स्वतः पूर्णता और स्मार्ट इंडेंट के साथ मल्टी-विंडो टेक्स्ट एडिटर
• सिंटैक्स हाइलाइटिंग के साथ पायथन शेल
• स्टेपिंग, लगातार ब्रेकपॉइंट और कॉल स्टैक विजिबिलिटी के साथ एकीकृत डिबगर
• स्वचालित इंडेंटेशन (पायथन इंडेंटेशन के बारे में जानने वाले शुरुआती लोगों के लिए उपयोगी)
• पायथन प्रोग्राम को .py फ़ाइलों के रूप में सहेजना और उन्हें चलाना और बाद में उन्हें किसी भी आईडीएलई का उपयोग करके संपादित करें।

IDLE में, F5 हिट करें या दुभाषिया लॉन्च करने के लिए run Python Shell । नए उपयोगकर्ताओं के लिए IDLE का उपयोग करना एक बेहतर शिक्षण अनुभव हो सकता है क्योंकि कोड की व्याख्या उपयोगकर्ता द्वारा लिखी गई है।

ध्यान दें कि बहुत सारे विकल्प हैं, उदाहरण के लिए इस चर्चा या इस सूची को देखें ।

समस्या निवारण

• खिड़कियाँ

  यदि आप विंडोज पर हैं, तो डिफ़ॉल्ट कमांड python । यदि आपको "'python' is not recognized" त्रुटि, तो सबसे संभावित कारण यह है कि पायथन का स्थान आपके सिस्टम के PATH पर्यावरण चर में नहीं है। यह 'मेरा कंप्यूटर' पर राइट-क्लिक करके और 'गुण' का चयन करके या 'कंट्रोल पैनल' के माध्यम से 'सिस्टम' पर नेविगेट करके पहुँचा जा सकता है। 'उन्नत सिस्टम सेटिंग्स' और फिर 'पर्यावरण चर ...' पर क्लिक करें। अपने अजगर स्थापना, साथ ही स्क्रिप्ट फ़ोल्डर (आमतौर पर C:\Python27;C:\Python27\Scripts ) की निर्देशिका को शामिल करने के लिए PATH चर को संपादित करें। इसके लिए प्रशासनिक विशेषाधिकारों की आवश्यकता होती है और इन्हें पुनः आरंभ करने की आवश्यकता होती है।

  एक ही मशीन पर अजगर के कई संस्करणों का उपयोग करते समय, संभव समाधान python.exe फ़ाइलों में से एक का नाम बदलना है। उदाहरण के लिए, एक संस्करण नामकरण python27.exe कारण होगा python27 उस संस्करण के लिए अजगर आदेश हो गया है।

  आप विंडोज के लिए पायथन लॉन्चर का भी उपयोग कर सकते हैं, जो इंस्टॉलर के माध्यम से उपलब्ध है और डिफ़ॉल्ट रूप से आता है। यह आप का उपयोग करके चलाने के लिए अजगर के संस्करण का चयन करने की अनुमति देता है py -[xy] के बजाय python[xy] । आप py -2 साथ स्क्रिप्ट चलाकर पायथन 2 के नवीनतम संस्करण का उपयोग कर सकते हैं और py -3 साथ स्क्रिप्ट चलाकर पायथन 3 के नवीनतम संस्करण का उपयोग कर सकते हैं।

• Debian / Ubuntu / MacOS

  यह खंड मानता है कि python निष्पादन योग्य का स्थान PATH पर्यावरण चर में जोड़ा गया है।

  आप Debian / Ubuntu / MacOS पर हैं, तो टर्मिनल और प्रकार को खोल python अजगर 2.x या के लिए python3 अजगर 3.x. के लिए

  टाइप करें which python को देखना है कि पायथन इंटरप्रेटर का उपयोग किया जाएगा।

• आर्क लिनक्स

  डिफ़ॉल्ट आर्क लिनक्स (और वंश) पर पायथन अजगर 3 है, इसलिए उपयोग python या python3 अजगर 3.x और के लिए python2 अजगर 2. x के लिए

• अन्य सिस्टम

  अजगर 3 कभी-कभी अजगर 3 के बजाय python से python3 । इन प्रणालियों पर पायथन 2 का उपयोग करने के लिए जहां यह स्थापित है, आप python2 उपयोग कर सकते हैं।

जानकारी का प्रकार

अंतर्निहित प्रकार

बूलियन्स

bool : True या False दोनों में से एक बूलियन मान। लॉजिकल ऑपरेशन जैसे and , or , बूलियन पर प्रदर्शन not जा सकता है।

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True

पायथन में 2.x और पायथन 3.x में, एक बूलियन भी एक int । bool प्रकार का एक उपवर्ग है int प्रकार और True और False इसके केवल उदाहरण हैं:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True

यदि बूलियन मानों का उपयोग अंकगणितीय परिचालनों में किया जाता है, तो पूर्णांक परिणाम वापस करने के लिए उनके पूर्णांक मान ( 1 और 0 True और False ) का उपयोग किया जाएगा:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1

नंबर

• int : पूर्णांक संख्या

  a = 2
  b = 100
  c = 123456789
  d = 38563846326424324
  

  पायथन में इंटेगर मनमाने आकार के हैं।

  नोट: पायथन के पुराने संस्करणों में, एक long प्रकार उपलब्ध था और यह int से अलग था। दोनों का एकीकरण किया गया है।

• float : फ्लोटिंग पॉइंट नंबर; परिशुद्धता कार्यान्वयन और सिस्टम आर्किटेक्चर पर निर्भर करती है, सीपीथॉन के लिए float डेटेटाइप सी डबल से मेल खाती है।

  a = 2.0
  b = 100.e0
  c = 123456789.e1
  

• complex : जटिल संख्या

  a = 2 + 1j
  b = 100 + 10j
  

< , <= , > और >= ऑपरेटर किसी भी जटिल संख्या के होने पर TypeError अपवाद उठाएंगे।

स्ट्रिंग्स

अनुक्रम और संग्रह

पायथन क्रमबद्ध अनुक्रमों और अनियंत्रित संग्रहों (जैसे set और dict ) के बीच अंतर करता है।

• स्ट्रिंग्स ( str , bytes , unicode ) सीक्वेंस हैं

• reversed : reversed समारोह के साथ str का उलटा क्रम

  a = reversed('hello')
  

• tuple : किसी भी प्रकार के n मानों का एक आदेश दिया गया संग्रह ( n >= 0 )।

  a = (1, 2, 3)
  b = ('a', 1, 'python', (1, 2))
  b[2] = 'something else' # returns a TypeError
  

  अनुक्रमण का समर्थन करता है; अपरिवर्तनीय; यदि इसके सभी सदस्य हैं, तो हशेबल

• list : n मानों का एक संग्रहित संग्रह ( n >= 0 )

  a = [1, 2, 3]
  b = ['a', 1, 'python', (1, 2), [1, 2]]
  b[2] = 'something else' # allowed
  

  धोने योग्य नहीं; परिवर्तनशील।

• set : अद्वितीय मूल्यों का एक अनियंत्रित संग्रह। वस्तुएं हवादार होनी चाहिए।

  a = {1, 2, 'a'}
  

• dict : अनूठे की-वैल्यू जोड़े का एक अनियंत्रित संग्रह; चाबियां धोए जाना चाहिए।

  a = {1: 'one',
       2: 'two'}
  
  b = {'a': [1, 2, 3],
       'b': 'a string'}
  

यदि कोई हैश वैल्यू है, तो एक ऑब्जेक्ट हैश है, जो उसके जीवनकाल के दौरान कभी नहीं बदलता है (इसे __hash__() विधि) की आवश्यकता होती है, और इसकी तुलना अन्य वस्तुओं से की जा सकती है (इसे __eq__() विधि की आवश्यकता होती है)। सम-साम्य की तुलना करने वाली हश्र वस्तुओं का समान हैश मान होना चाहिए।

निर्मित स्थिरांक

अंतर्निहित डेटाटिप्स के साथ संयोजन में निर्मित नामस्थानों में बहुत कम संख्या में अंतर्निहित स्थिरांक होते हैं:

• True : बिल्ट-इन टाइप bool का सही मूल्य
• False : बिल्ट-इन टाइप bool का गलत मान
• None : एक सिंगलटन ऑब्जेक्ट संकेत देने के लिए उपयोग किया जाता है कि एक मूल्य अनुपस्थित है।
• Ellipsis या ... : सरणी संकेतन के हिस्से के रूप में कहीं भी और Python2.7 + में सीमित उपयोग में कोर python3 + इस्तेमाल किया। numpy और संबंधित पैकेज इसका उपयोग सरणियों में 'सब कुछ शामिल करें' संदर्भ के रूप में करते हैं।
• NotImplemented : पायथन को इंगित करने के लिए इस्तेमाल किया गया एक सिंगलटन कि एक विशेष विधि विशिष्ट तर्कों का समर्थन नहीं करती है, और यदि उपलब्ध हो तो पायथन विकल्प का प्रयास करेगा।

a = None # No value will be assigned. Any valid datatype can be assigned later

चर के प्रकार का परीक्षण

अजगर में, हम अंतर्निहित फ़ंक्शन type का उपयोग करके किसी ऑब्जेक्ट के डेटाटाइप की जांच कर सकते हैं।

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>

सशर्त बयानों में isinstance साथ डेटाटाइप का परीक्षण करना संभव है। हालांकि, यह आमतौर पर चर के प्रकार पर भरोसा करने के लिए प्रोत्साहित नहीं किया जाता है।

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1

type() और isinstance() बीच अंतर के बारे में जानकारी के लिए पढ़ें: आइंस्टीन और पायथन में टाइप के बीच अंतर

परीक्षण के लिए कुछ की है अगर NoneType :

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')

डेटाटाइप्स के बीच रूपांतरण

आप स्पष्ट डेटाटाइप रूपांतरण कर सकते हैं।

उदाहरण के लिए, '123' str प्रकार का है और इसे int फंक्शन का उपयोग करके पूर्णांक में परिवर्तित किया जा सकता है।

a = '123'
b = int(a)

फ्लोट स्ट्रिंग से '123.456' जैसे float फ़ंक्शन का उपयोग करके किया जा सकता है।

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123

आप अनुक्रम या संग्रह प्रकार भी परिवर्तित कर सकते हैं

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

शाब्दिक की परिभाषा में स्पष्ट स्ट्रिंग प्रकार

एक पत्र लेबल के साथ सिर्फ उद्धरणों के सामने आप बता सकते हैं कि आप किस प्रकार की स्ट्रिंग को परिभाषित करना चाहते हैं।

• b'foo bar' : पायथन 3 में परिणाम bytes , पायथन 2 में str
• u'foo bar' : परिणाम str अजगर 3 में, unicode अजगर 2 में
• 'foo bar' : परिणाम str
• r'foo bar' : परिणाम तथाकथित रॉ स्ट्रिंग, जहां विशेष पात्रों से बचना आवश्यक नहीं है, सब कुछ मौखिक रूप से लिया जाता है जिसे आपने पसंद किया है

normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

उत्परिवर्तनीय और अपरिवर्तनीय डेटा प्रकार

एक वस्तु को उत्परिवर्तनीय कहा जाता है यदि इसे बदला जा सकता है। उदाहरण के लिए, जब आप किसी फ़ंक्शन को सूची देते हैं, तो सूची को बदला जा सकता है:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list

किसी वस्तु को अपरिवर्तनीय कहा जाता है यदि उसे किसी भी तरह से बदला नहीं जा सकता है। उदाहरण के लिए, पूर्णांक अपरिवर्तनीय हैं, क्योंकि उन्हें बदलने का कोई तरीका नहीं है:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)

ध्यान दें कि चर स्वयं परिवर्तनशील हैं, इसलिए हम चर x को फिर से असाइन कर सकते हैं, लेकिन यह उस वस्तु को नहीं बदलता है जिसे x ने इंगित किया था। इसने केवल एक नई वस्तु के लिए x बिंदु बनाया।

डेटा प्रकार जिनके उदाहरण उत्परिवर्तनीय होते हैं उन्हें उत्परिवर्तनीय डेटा प्रकार कहा जाता है, और इसी तरह अपरिवर्तनीय वस्तुओं और डेटाटिप्स के लिए।

अपरिवर्तनीय डेटा प्रकार के उदाहरण:

• int , long , float , complex
• str
• bytes
• tuple
• frozenset

परिवर्तनशील डेटा प्रकार के उदाहरण:

• bytearray
• list
• set
• dict

मॉड्यूल और कार्यों में निर्मित

एक मॉड्यूल एक फाइल है जिसमें पायथन परिभाषाएँ और कथन हैं। फ़ंक्शन कोड का एक टुकड़ा है जो कुछ तर्क निष्पादित करता है।

>>> pow(2,3)    #8

अजगर में फ़ंक्शन में निर्मित की जांच करने के लिए हम dir(). उपयोग कर सकते हैं dir(). यदि एक तर्क के बिना कहा जाता है, तो मौजूदा दायरे में नाम वापस करें। एल्स, दिए गए ऑब्जेक्ट की विशेषता (और कुछ) में शामिल नामों की वर्णमाला सूची लौटाएं, और इसमें से उपलब्ध विशेषताएँ।

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]

किसी फ़ंक्शन की कार्यक्षमता जानने के लिए, हम फ़ंक्शन फ़ंक्शन में निर्मित का उपयोग कर सकते help ।

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.

मॉड्यूल में निर्मित में अतिरिक्त कार्यक्षमताओं होते हैं। उदाहरण के लिए एक संख्या का वर्गमूल प्राप्त करने के लिए हमें math मॉड्यूल को शामिल करना होगा।

>>> import math
>>> math.sqrt(16) # 4.0

एक मॉड्यूल में सभी फ़ंक्शन को जानने के लिए हम फ़ंक्शंस की सूची को एक वैरिएबल पर असाइन कर सकते हैं, और फिर वेरिएबल को प्रिंट कर सकते हैं।

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']

ऐसा लगता है कि __doc__ कुछ प्रलेखन प्रदान करने के लिए उपयोगी है, कहते हैं, कार्य करता है

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'

कार्यों के अलावा, मॉड्यूल में प्रलेखन भी प्रदान किया जा सकता है। तो, अगर आपके पास इस तरह की helloWorld.py नाम की फाइल है:

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'

आप इसके डॉकस्ट्रिंग्स को इस तरह एक्सेस कर सकते हैं:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'

• किसी भी उपयोगकर्ता परिभाषित प्रकार के लिए, उसकी विशेषताओं, उसकी कक्षा की विशेषताओं और पुनरावर्ती रूप से उसके वर्ग के आधार वर्गों की विशेषताओं को dir () का उपयोग करके पुनर्प्राप्त किया जा सकता है

>>> class MyClassObject(object):
...     pass
... 
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

किसी भी डेटा प्रकार बस बुलाया अंतर्निहित फ़ंक्शन का उपयोग कर स्ट्रिंग में बदला जा सकता str । जब डेटा टाइप करने के लिए print किया जाता है, तो यह फ़ंक्शन डिफ़ॉल्ट रूप से कहा जाता है

>>> str(123)    # "123"

ब्लॉक इंडेंटेशन

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

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

उदाहरण के लिए:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block

या

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block

ऐसे ब्लॉक जिनमें बिल्कुल एक एकल-पंक्ति विवरण होता है, उन्हें एक ही पंक्ति में रखा जा सकता है, हालांकि इस रूप को आमतौर पर अच्छी शैली नहीं माना जाता है:

if a > b: print(a)
else: print(b)  

एक से अधिक कथन के साथ ऐसा करने का प्रयास करने से काम नहीं चलेगा:

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax

एक खाली ब्लॉक एक IndentationError कारण बनता है। pass उपयोग करें (एक कमांड जो कुछ भी नहीं करता है) जब आपके पास एक ब्लॉक होता है जिसमें कोई सामग्री नहीं होती है:

def will_be_implemented_later():
    pass

रिक्त स्थान बनाम टैब

संक्षेप में: हमेशा इंडेंटेशन के लिए 4 स्थानों का उपयोग करें।

विशेष रूप से टैब का उपयोग करना संभव है लेकिन PEP 8 , पायथन कोड के लिए शैली गाइड, बताता है कि रिक्त स्थान पसंद किए जाते हैं।

कई संपादकों के पास "टैब टू स्पेस" कॉन्फ़िगरेशन है। संपादक को कॉन्फ़िगर करते समय, एक को टैब वर्ण ('\ t') और टैब कुंजी के बीच अंतर करना चाहिए।

• भाषा के शब्दार्थ से मेल खाने के लिए टैब वर्ण को 8 स्थान दिखाने के लिए कॉन्फ़िगर किया जाना चाहिए - कम से कम ऐसे मामलों में जब (आकस्मिक) मिश्रित इंडेंटेशन संभव है। संपादक स्वचालित रूप से टैब वर्ण को रिक्त स्थान में बदल सकते हैं।
• हालाँकि, यह संपादक को कॉन्फ़िगर करने में सहायक हो सकता है ताकि टैब कुंजी को डालने के बजाय टैब कुंजी को दबाकर 4 रिक्त स्थान डाले जाएँ।

पायथन स्रोत कोड को टैब और रिक्त स्थान के मिश्रण के साथ लिखा गया है, या गैर-मानक संख्या के साथ इंडेंटेशन रिक्त स्थान को ऑटोपेप 8 का उपयोग करके pep8- अनुरूप बनाया जा सकता है। (एक कम शक्तिशाली विकल्प अधिकांश पायथन स्थापनाओं के साथ आता है: reindent.py )

संग्रह के प्रकार

पायथन में कई प्रकार के संग्रह हैं। हालांकि इस प्रकार के int और str एक ही मान रखते हैं, लेकिन संग्रह प्रकार कई मान रखते हैं।

सूचियाँ

list प्रकार शायद पायथन में सबसे अधिक इस्तेमाल किया जाने वाला संग्रह प्रकार है। अपने नाम के बावजूद, एक सूची अन्य भाषाओं में एक सरणी की तरह अधिक है, ज्यादातर जावास्क्रिप्ट। पायथन में, एक सूची केवल वैध पायथन मूल्यों का एक संग्रह है। वर्गाकार कोष्ठकों में अल्पविराम द्वारा अलग किए गए मानों को संलग्न करके एक सूची बनाई जा सकती है:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']

एक सूची खाली हो सकती है:

empty_list = []

किसी सूची के तत्व एकल डेटा प्रकार तक ही सीमित नहीं हैं, जिससे समझ में आता है कि पायथन एक गतिशील भाषा है:

mixed_list = [1, 'abc', True, 2.34, None]

एक सूची में इसके तत्व के रूप में एक और सूची हो सकती है:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]

एक सूची के तत्वों को एक सूचकांक , या उनकी स्थिति के संख्यात्मक प्रतिनिधित्व के माध्यम से पहुँचा जा सकता है। पायथन में सूचियाँ शून्य-अनुक्रमित हैं जिसका अर्थ है कि सूची में पहला तत्व सूचकांक 0 पर है, दूसरा तत्व सूचकांक 1 पर है और इसी तरह:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig

संकेत नकारात्मक भी हो सकते हैं जिसका अर्थ है सूची के अंत से गिनती ( -1 अंतिम तत्व का सूचकांक)। इसलिए, उपरोक्त उदाहरण से सूची का उपयोग कर:

print(names[-1]) # Eric
print(names[-4]) # Bob

सूचियाँ परिवर्तनशील हैं, इसलिए आप किसी सूची में मान बदल सकते हैं:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

इसके अलावा, तत्वों को सूची से जोड़ना और / या निकालना संभव है:

L.append(object) साथ सूची के अंत में ऑब्जेक्ट जोड़ें, None लौटाता है।

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

एक विशिष्ट सूचकांक में सूचीबद्ध करने के लिए एक नया तत्व जोड़ें। L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

L.remove(value) साथ किसी मान की पहली घटना को निकालें, None लौटाता है

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

पहले आइटम की सूची में सूचकांक प्राप्त करें जिसका मूल्य x है। यदि ऐसा कोई आइटम नहीं है, तो यह एक त्रुटि दिखाएगा।

name.index("Alice")
0

सूची की लंबाई गिनें

len(names)
6

सूची में किसी भी वस्तु की गणना

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3

सूची को उलट दें

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]

L.pop([index]) साथ इंडेक्स पर आइटम निकालें और वापस L.pop([index]) अंतिम आइटम के लिए डिफ़ॉल्ट L.pop([index])

names.pop() # Outputs 'Sia'

आप नीचे दिए गए सूची तत्वों पर पुनरावृति कर सकते हैं:

for element in my_list:
    print (element)

tuples

tuple एक सूची के समान है सिवाय इसके कि यह निश्चित-लंबाई और अपरिवर्तनीय है। इसलिए टुपल में मौजूद मानों को नहीं बदला जा सकता है और न ही टुपल से मूल्यों को जोड़ा या हटाया जा सकता है। ट्यूपल्स का उपयोग आमतौर पर उन मूल्यों के छोटे संग्रह के लिए किया जाता है जिन्हें बदलने की आवश्यकता नहीं होगी, जैसे कि आईपी एड्रेस और पोर्ट। वर्ग कोष्ठक के बजाय टुपल्स को कोष्ठकों से दर्शाया जाता है:

ip_address = ('10.20.30.40', 8080)

सूचियों के लिए समान अनुक्रमण नियम भी टुपल्स पर लागू होते हैं। ट्यूपल्स को भी नेस्ट किया जा सकता है और मान किसी भी मान्य पायथन मान्य हो सकते हैं।

केवल एक सदस्य के साथ एक टपल को परिभाषित किया जाना चाहिए (अल्पविराम पर ध्यान दें)

one_member_tuple = ('Only member',)

या

one_member_tuple = 'Only member',   # No brackets

या सिर्फ tuple सिंटैक्स का उपयोग कर

one_member_tuple = tuple(['Only member'])

शब्दकोश

पायथन में एक dictionary कुंजी-मूल्य जोड़े का एक संग्रह है। शब्दकोश घुंघराले ब्रेसिज़ से घिरा हुआ है। प्रत्येक जोड़ी को अल्पविराम द्वारा अलग किया जाता है और कुंजी और मूल्य को एक बृहदान्त्र द्वारा अलग किया जाता है। यहाँ एक उदाहरण है:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

मान प्राप्त करने के लिए, इसकी कुंजी द्वारा देखें:

ca_capital = state_capitals['California']

आप सभी कुंजियों को एक शब्दकोश में भी प्राप्त कर सकते हैं और फिर उन पर पुनरावृति कर सकते हैं:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))

शब्दकोश जोर से JSON वाक्यविन्यास जैसा दिखता है। पायथन मानक पुस्तकालय में देशी json मॉड्यूल का उपयोग JSON और शब्दकोशों के बीच परिवर्तित करने के लिए किया जा सकता है।

सेट

एक set तत्वों का एक संग्रह है जिसमें कोई दोहराव नहीं है और बिना प्रविष्टि क्रम लेकिन क्रमबद्ध क्रम के बिना। उनका उपयोग उन स्थितियों में किया जाता है जहां यह केवल महत्वपूर्ण है कि कुछ चीजों को एक साथ समूहीकृत किया जाता है, और न कि उन्हें किस क्रम में शामिल किया गया था। डेटा के बड़े समूहों के लिए, यह बहुत तेजी से किया जाए या नहीं एक तत्व एक में है की जाँच करने के set की तुलना में यह एक के लिए भी ऐसा ही करने के लिए है list ।

किसी dictionary को परिभाषित करने के लिए एक set को परिभाषित करना बहुत समान है:

first_names = {'Adam', 'Beth', 'Charlie'}

या आप मौजूदा list का उपयोग करके एक set बना सकते हैं:

my_list = [1,2,3]
my_set = set(my_list)

की सदस्यता की जाँच करें set का उपयोग कर in :

if name in first_names:
    print(name)

आप एक सूची की तरह एक set पर पुनरावृति कर सकते हैं, लेकिन याद रखें: मान एक मनमाना, कार्यान्वयन-परिभाषित क्रम में होगा।

defaultdict

एक defaultdict डिक्शनरी कुंजी के लिए एक डिफॉल्ट मान है, जिसके लिए ऐसी कोई भी कुंजी जिसके लिए कोई मूल्य स्पष्ट रूप से परिभाषित नहीं किया गया है, बिना त्रुटियों के एक्सेस किया जा सकता है। defaultdict विशेष रूप से तब उपयोगी होता है जब डिक्शनरी में वैल्यूज़ इस अर्थ में संग्रह (सूचियाँ, डिक्ट्स इत्यादि) होती हैं कि इसे हर बार आरम्भ करने की आवश्यकता नहीं होती है जब एक नई कुंजी का उपयोग किया जाता है।

एक defaultdict एक KeyError कभी नहीं बढ़ाएगा। कोई भी कुंजी मौजूद नहीं है जो डिफ़ॉल्ट मान लौटाता है।

उदाहरण के लिए, निम्नलिखित शब्दकोष पर विचार करें

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}

यदि हम एक गैर-मौजूद कुंजी तक पहुंचने का प्रयास करते हैं, तो अजगर हमें एक त्रुटि देता है जो निम्नानुसार है

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'

आइए हम defaultdict साथ प्रयास करते हैं। यह संग्रह मॉड्यूल में पाया जा सकता है।

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')

यदि हमने कुंजी नहीं दी है, तो हमने डिफ़ॉल्ट मान ( बोस्टन ) सेट करने के लिए क्या किया है। अब पहले की तरह तानाशाही आबाद करें:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'

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

>>> state_capitals['Alabama']
'Boston'

और एक सामान्य dictionary तरह मौजूदा कुंजी के लिए बनाए गए मानों को लौटाता है

>>> state_capitals['Arkansas']
'Little Rock'

उपयोगिता की मदद करें

पायथन में दुभाषिया में निर्मित कई कार्य हैं। यदि आप कीवर्ड, बिल्ट-इन फ़ंक्शंस, मॉड्यूल या विषयों की जानकारी प्राप्त करना चाहते हैं, तो पायथन कंसोल खोलें और दर्ज करें:

>>> help()

आप सीधे कीवर्ड दर्ज करके जानकारी प्राप्त करेंगे:

>>> help(help)

या उपयोगिता के भीतर:

help> help

जो एक स्पष्टीकरण दिखाएगा:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

आप मॉड्यूल के उपवर्गों का भी अनुरोध कर सकते हैं:

help(pymysql.connections)

आप अपने द्वारा आयात किए गए विभिन्न मॉड्यूलों के डॉकस्ट्रिंग्स तक पहुंचने में मदद का उपयोग कर सकते हैं, उदाहरण के लिए, निम्नलिखित प्रयास करें:

>>> help(math)

और आपको एक त्रुटि मिलेगी

>>> import math
>>> help(math)

और अब आपको मॉड्यूल में उपलब्ध तरीकों की एक सूची मिलेगी, लेकिन केवल उसके बाद ही आपने इसे आयात किया है।

सहायक को quit साथ quit

एक मॉड्यूल बनाना

एक मॉड्यूल एक आयात करने योग्य फ़ाइल है जिसमें परिभाषाएं और कथन हैं।

एक .py फ़ाइल बनाकर एक मॉड्यूल बनाया जा सकता है।

# hello.py
def say_hello():
    print("Hello!")

एक मॉड्यूल में फंक्शंस का उपयोग मॉड्यूल आयात करके किया जा सकता है।

आपके द्वारा बनाए गए मॉड्यूल के लिए, उन्हें उसी निर्देशिका में होना चाहिए, जिस फ़ाइल में आप उन्हें आयात कर रहे हैं। (हालांकि, आप उन्हें पूर्व-शामिल मॉड्यूल के साथ पायथन के कार्यकारी निर्देशिका में भी डाल सकते हैं, लेकिन यदि संभव हो तो इसे टाला जाना चाहिए।)

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"

मॉड्यूल अन्य मॉड्यूल द्वारा आयात किया जा सकता है।

# greet.py
import hello
hello.say_hello()

एक मॉड्यूल के विशिष्ट कार्यों को आयात किया जा सकता है।

# greet.py
from hello import say_hello
say_hello()

मॉड्यूल को अलियास किया जा सकता है।

# greet.py
import hello as ai
ai.say_hello()

एक मॉड्यूल स्टैंड-अलोन रननीय स्क्रिप्ट हो सकता है।

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()

चलाओ!

$ python run_hello.py
=> "Hello!"

यदि मॉड्यूल किसी निर्देशिका के अंदर है और उसे अजगर द्वारा पता लगाने की आवश्यकता है, तो निर्देशिका में __init__.py नाम की एक फ़ाइल होनी चाहिए।

स्ट्रिंग फ़ंक्शन - str () और repr ()

ऐसे दो कार्य हैं जिनका उपयोग किसी वस्तु के पठनीय प्रतिनिधित्व को प्राप्त करने के लिए किया जा सकता है।

repr(x) कॉल x.__repr__() : x प्रतिनिधित्व। eval आमतौर पर इस फ़ंक्शन के परिणाम को मूल ऑब्जेक्ट में बदल देगा।

str(x) कॉल x.__str__() : एक मानव-पठनीय स्ट्रिंग जो ऑब्जेक्ट का वर्णन करता है। यह कुछ तकनीकी विवरण के साथ हो सकता है।

रेपर ()

कई प्रकारों के लिए, यह फ़ंक्शन एक स्ट्रिंग को वापस करने का प्रयास करता है जो किसी वस्तु को उसी मान के साथ प्राप्त करेगा जब उसे eval() । अन्यथा, प्रतिनिधित्व कोण कोष्ठक में संलग्न एक स्ट्रिंग है जिसमें अतिरिक्त जानकारी के साथ ऑब्जेक्ट के प्रकार का नाम होता है। इसमें अक्सर ऑब्जेक्ट का नाम और पता शामिल होता है।

str ()

स्ट्रिंग्स के लिए, यह स्ट्रिंग को स्वयं लौटाता है। इस और repr(object) बीच का अंतर यह है कि str(object) हमेशा एक स्ट्रिंग को वापस करने का प्रयास नहीं करता है जो eval() लिए स्वीकार्य है। बल्कि, इसका लक्ष्य एक मुद्रण योग्य या 'मानव पठनीय' स्ट्रिंग को वापस करना है। यदि कोई तर्क नहीं दिया जाता है, तो यह खाली स्ट्रिंग लौटाता है, '' ।

उदाहरण 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True

उदाहरण 2:

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'

कक्षा लिखते समय, आप इन विधियों को ओवरराइड कर सकते हैं जो आप चाहते हैं:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)

उपरोक्त वर्ग का उपयोग करके हम परिणाम देख सकते हैं:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects

पाइप का उपयोग करके बाहरी मॉड्यूल स्थापित करना

pip आपका दोस्त है जब आपको अजगर पैकेज इंडेक्स (PyPon) पर उपलब्ध विकल्पों के ढेर से कोई भी पैकेज स्थापित करने की आवश्यकता होती है। यदि आप Python 2> = 2.7.9 या Python 3> = 3.4 का उपयोग python.org से कर रहे हैं, तो pip पहले से इंस्टॉल है। मूल पैकेज प्रबंधक के साथ लिनक्स या किसी अन्य * निक्स पर चलने वाले कंप्यूटरों के लिए, pip को अक्सर मैन्युअल रूप से स्थापित किया जाना चाहिए ।

स्थापित दोनों अजगर 2 और अजगर 3 के साथ उदाहरणों पर, pip अक्सर अजगर 2 और को संदर्भित करता है pip3 पायथन 3. करने के लिए उपयोग करना pip केवल अजगर 2 और के लिए संकुल स्थापित हो जाएगा pip3 केवल अजगर 3 के लिए संकुल स्थापित हो जाएगा।

पैकेज खोजना / स्थापित करना

एक पैकेज के लिए खोज टाइपिंग के रूप में सरल है

$ pip search <query>
# Searches for packages whose name or summary contains <query>

पैकेज स्थापित करना उतना ही सरल है जितना टाइपिंग (टर्मिनल / कमांड-प्रॉम्प्ट में, पायथन इंटरप्रेटर में नहीं)

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package

जहां xxx उस पैकेज का संस्करण संख्या है जिसे आप इंस्टॉल करना चाहते हैं।

जब आपका सर्वर प्रॉक्सी के पीछे होता है, तो आप नीचे कमांड का उपयोग करके पैकेज स्थापित कर सकते हैं:

$ pip --proxy http://<server address>:<port> install

अपग्रेड किए गए पैकेज

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

$ pip list --outdated

एक विशिष्ट पैकेज के उपयोग को अपग्रेड करने के लिए

$ pip install [package_name] --upgrade

सभी पुराने पैकेजों को अपडेट करना pip की मानक कार्यक्षमता नहीं है।

अपग्रेडिंग पाइप

आप निम्न आदेशों का उपयोग करके अपने मौजूदा पाइप स्थापना को अपग्रेड कर सकते हैं

• लिनक्स या macOS X पर:

  $ pip install -U pip
  

  आपको कुछ लिनक्स सिस्टम पर पाइप के साथ sudo का उपयोग करने की आवश्यकता हो सकती है

• विंडोज पर:

  py -m pip install -U pip
  

  या

  python -m pip install -U pip
  

पाइप के संबंध में अधिक जानकारी के लिए यहां पढ़ें ।

पायथन की स्थापना 2.7.x और 3.x

नोट : निम्नलिखित निर्देश पायथन 2.7 के लिए लिखे गए हैं (जब तक निर्दिष्ट नहीं किए गए हैं): पायथन 3.x के लिए निर्देश समान हैं।

खिड़कियाँ

सबसे पहले, आधिकारिक वेबसाइट ( https://www.python.org/downloads/) से पायथन 2.7 का नवीनतम संस्करण डाउनलोड करें । संस्करण को MSI पैकेज के रूप में प्रदान किया गया है। इसे मैन्युअल रूप से स्थापित करने के लिए, बस फ़ाइल को डबल-क्लिक करें।

डिफ़ॉल्ट रूप से, पायथन एक निर्देशिका में स्थापित होता है:

 C:\Python27\

चेतावनी: स्थापना स्वतः पाथ पर्यावरण चर को संशोधित नहीं करती है।

यह मानते हुए कि आपका पायथन इंस्टॉलेशन C: \ Python27 में है, इसे अपने PATH में जोड़ें:

C:\Python27\;C:\Python27\Scripts\

अब यह जाँचने के लिए कि क्या पायथन इंस्टालेशन cmd में मान्य है:

python --version

पायथन 2.x और 3.x साइड-बाय-साइड

विंडोज मशीन पर पायथन 2.x और 3.x अगल-बगल दोनों को इंस्टॉल और उपयोग करने के लिए:

1. MSI इंस्टॉलर का उपयोग करके पायथन 2.x स्थापित करें।

   • सुनिश्चित करें कि पायथन सभी उपयोगकर्ताओं के लिए स्थापित है।
   • वैकल्पिक: करने के लिए अजगर जोड़ने PATH अजगर कमांड लाइन का उपयोग करने से प्रतिदेय 2.x बनाने के लिए python ।

2. अपने संबंधित इंस्टॉलर का उपयोग करके पायथन 3.x स्थापित करें।

   • फिर से, सुनिश्चित करें कि पायथन सभी उपयोगकर्ताओं के लिए स्थापित किया गया है।
   • वैकल्पिक: करने के लिए अजगर जोड़ने PATH अजगर कमांड लाइन का उपयोग करने से प्रतिदेय 3.x बनाने के लिए python । यह पायथन 2.x PATH सेटिंग्स को ओवरराइड कर सकता है, इसलिए अपने PATH दोबारा जांचें और सुनिश्चित करें कि यह आपकी प्राथमिकताओं में कॉन्फ़िगर किया गया है।
   • सभी उपयोगकर्ताओं के लिए py launcher स्थापित करना सुनिश्चित करें।

पायथन 3 पायथन लॉन्चर स्थापित करेगा जिसका उपयोग पाइथन 2.x और पाइथन 3.x को कमांड-लाइन से इंटरचेंज करने के लिए किया जा सकता है:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

विशिष्ट पायथन संस्करण के लिए pip के संगत संस्करण का उपयोग करने के लिए, उपयोग करें:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)

लिनक्स

CentOS, Fedora, Redhat Enterprise (RHEL) और उबंटू के नवीनतम संस्करण पायथन 2.7 के साथ आते हैं।

मैन्युअल रूप से लिनक्स पर पायथन 2.7 स्थापित करने के लिए, बस टर्मिनल में निम्नलिखित कार्य करें:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install

PATH पर्यावरण चर में नए अजगर का मार्ग भी जोड़ें। यदि नया अजगर /root/python-2.7.X तो export PATH = $PATH:/root/python-2.7.X

अब यह जांचने के लिए कि क्या टर्मिनल में पायथन इंस्टॉलेशन मान्य है:

python --version

उबंटू (स्रोत से)

यदि आपको Python 3.6 की आवश्यकता है, तो आप इसे स्रोत से नीचे बताए अनुसार स्थापित कर सकते हैं (Ubuntu 16.10 और 17.04 में सार्वभौमिक संस्करण में 3.6 संस्करण है)। नीचे दिए गए चरणों को Ubuntu 16.04 और निम्न संस्करणों के लिए पालन किया जाना है:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall

मैक ओ एस

जैसा कि हम बोलते हैं, macOS Python 2.7.10 के साथ स्थापित होता है, लेकिन यह संस्करण पुराना है और नियमित Python से थोड़ा संशोधित है।

पायथन का संस्करण जो ओएस एक्स के साथ जहाज सीखने के लिए बहुत अच्छा है, लेकिन यह विकास के लिए अच्छा नहीं है। ओएस एक्स के साथ भेज दिया गया संस्करण आधिकारिक वर्तमान पायथन रिलीज से पुराना हो सकता है, जिसे स्थिर उत्पादन संस्करण माना जाता है। ( स्रोत )

होमब्रे स्थापित करें:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

पायथन 2.7 स्थापित करें:

brew install python

Python 3.x के लिए, इसके बजाय कमांड brew install python3 उपयोग करें।