पायथन का विकास 1980 के दशक के उत्तरार्ध में डच कंप्यूटर वैज्ञानिक गुइडो वैन रोसुम (Guido van Rossum) द्वारा नीदरलैंड के Centrum Wiskunde & Informatica (CWI) में प्रारंभ किया गया था। इसका पहला आधिकारिक संस्करण फरवरी 1991 में जारी हुआ। पायथन की मूल अवधारणा कोड की सरलता, स्पष्ट सिंटैक्स और बहु-प्रतिमान (Multi-paradigm: प्रक्रियात्मक, ऑब्जेक्ट-उन्मुख एवं कार्यात्मक) प्रोग्रामिंग का समर्थन करना है।

पायथन में कोड ब्लॉक को दर्शाने के लिए कर्ली ब्रैकेट्स {} का प्रयोग नहीं होता; इसके स्थान पर इंडेंटेशन (खाली स्थान) अनिवार्य है:

• इंडेंटेशन नियम (PEP 8): प्रत्येक स्तर के ब्लॉक हेतु ठीक 4 स्पेस (Spaces) का उपयोग मानक माना जाता है। टैब और स्पेस का मिश्रण वर्जित है (पायथन 3 में इससे TabError उत्पन्न होता है)।
• चरों के नामकरण के नियम (Identifiers): नाम वर्णमाला (A-Z, a-z) अथवा अंडरस्कोर (_) से ही प्रारंभ होना चाहिए। यह केस-संवेदी (Case-sensitive) है (उदा. Total और total अलग हैं)। आरक्षित कीवर्ड्स (उदा. def, class, if, return) का चर के रूप में उपयोग वर्जित है।
• टिप्पणियां (Comments) एवं डॉकस्ट्रिंग: एकल पंक्ति टिप्पणी हेतु # तथा बहु-पंक्ति दस्तावेज़ीकरण हेतु ट्रिपल कोट्स """...""" का प्रयोग किया जाता है, जिसे .doc से पढ़ा जा सकता है।

पारंपरिक भाषाओं में चर एक मेमोरी बॉक्स होता है जिसमें डेटा सुरक्षित होता है। पायथन में सब कुछ एक ऑब्जेक्ट है। चर केवल हीप मेमोरी में उपस्थित ऑब्जेक्ट का एक संदर्भ सूचक (Reference Pointer / Name Tag) होता है:

# मेमोरी संदर्भ एवं id() का प्रदर्शन
x = 300
y = x
print(id(x) == id(y))  # True: दोनों एक ही ऑब्जेक्ट को इंगित करते हैं
print(x is y)          # True: पहचान समानता

x = x + 1              # नया इंटीजर ऑब्जेक्ट 301 बना; x को नया पता मिला
print(id(x) == id(y))  # False: x अब नए पते पर है
print(y)               # 300: y मूल ऑब्जेक्ट को ही इंगित कर रहा है

प्रत्येक ऑब्जेक्ट में तीन गुण होते हैं: पहचान (id()), प्रकार (type()), एवं मान (Value)।

पायथन ऑपरेटरों की प्रमुख कार्यप्रणाली:

• अंकगणितीय ऑपरेटर: +, -, *, वास्तविक विभाजन / (सदैव फ्लोट देता है: 7 / 2 = 3.5), फ्लोर विभाजन // (पूर्णांक भाग: 7 // 2 = 3, -7 // 2 = -4), शेषफल %, एवं घातांक (दाईं ओर से सम्बद्ध: 2 3 ** 2 = 512)।
• श्रृंखलाबद्ध तुलना (Chained Comparisons): ==, !=, >, <, >=, <=। पायथन में 10 < x <= 50 सीधे मान्य है जो (10 < x) and (x <= 50) के समतुल्य है।
• तार्किक शॉर्ट-सर्किट ऑपरेटर:
  • and: प्रथम असत्य मान मिलने पर उसे ही लौटाता है, अन्यथा अंतिम सत्य मान (उदा. 0 and 8 देता है 0; 4 and 9 देता है 9)।
  • or: प्रथम सत्य मान मिलते ही लौटा देता है (उदा. 7 or 12 देता है 7)।
  • not: बूलियन मान को उलट देता है।
• पहचान ऑपरेटर (is, is not) बनाम मान समानता (==, !=): == केवल मानों की समानता जांचता है, जबकि is यह जांचता है कि क्या दोनों चर मेमोरी के एक ही पते (id) को इंगित कर रहे हैं।
• सदस्यता ऑपरेटर (Membership): in तथा not in किसी अनुक्रम में तत्व की उपस्थिति $O(N)$ अथवा सेट में औसत $O(1)$ समय में जांचते हैं।

पायथन में शून्य (0, 0.0), None, False एवं कोई भी रिक्त संग्रह ("", [], (), {}, set()) स्वतः असत्य (Falsey) माने जाते हैं। शेष सभी मान सत्य (Truthy) होते हैं।

# बहु-शाखा निर्णय संरचना एवं टर्नरी ऑपरेटर
score = 88

if score >= 90:
    grade = 'AA'
elif score >= 80:
    grade = 'A+'
elif score >= 70:
    grade = 'A'
else:
    grade = 'Pass'

# एकल-पंक्ति टर्नरी अभिव्यक्ति:
result = "Distinction" if score >= 80 else "Regular"

पुनरावृत्ति हेतु दो प्रमुख लूप होते हैं:

• while लूप: स्थिति-नियंत्रित लूप जो शर्त सत्य रहने तक चलता है। लूप चर में वृद्धि/संशोधन न करने पर अनंत लूप (Infinite loop) बन जाता है।
• for लूप: अनुक्रम-नियंत्रित लूप जो संग्रह के प्रत्येक तत्व पर क्रमशः कार्य करता है।
• range(start, stop, step) ऑब्जेक्ट: यह मेमोरी में पूरी सूची न बनाकर मांग पर संख्याएं उत्पन्न करता है:
  • range(6): 0 से 5 तक संख्याएं उत्पन्न करता है (अंतिम मान 6 शामिल नहीं)।
  • range(2, 11, 2): 2, 4, 6, 8, 10 देता है।
  • range(10, 0, -2): अवरोही क्रम में 10, 8, 6, 4, 2 देता है।

लूप प्रवाह को नियंत्रित करने हेतु तीन कीवर्ड्स होते हैं:

• break: लूप को तत्काल समाप्त कर नियंत्रण को लूप के बाहर ले जाता है।
• continue: वर्तमान पुनरावृत्ति के शेष कोड को छोड़कर अगली पुनरावृत्ति पर चला जाता है।
• pass: केवल एक सिंटैक्टिक रिक्त स्थान (No-op) के रूप में कार्य करता है।
• लूप के साथ else खंड: लूप का else खंड केवल तभी निष्पादित होता है जब लूप बिना किसी break के स्वाभाविक रूप से अपनी पुनरावृत्ति पूरी कर ले:

# अभाज्य संख्या परीक्षण में for-else का उपयोग
val = 43
for i in range(2, int(val ** 0.5) + 1):
    if val % i == 0:
        print(f"{val} भाज्य संख्या है।")
        break
else:
    # यह तब चलेगा जब लूप में कोई break न लगा हो
    print(f"{val} एक अभाज्य संख्या है!")

स्ट्रिंग, लिस्ट और टपल में द्विदिशीय इंडेक्सिंग समर्थित होती है:

• धनात्मक इंडेक्स: प्रथम तत्व 0 से लेकर अंतिम तत्व n - 1 तक।
• ऋणात्मक इंडेक्स: अंतिम तत्व -1 से लेकर प्रथम तत्व -n तक।
• स्लाइसिंग सिंटैक्स seq[start:stop:step]: start से लेकर stop से ठीक पहले तक step के अंतराल पर उप-अनुक्रम निकालता है।
  • seq[::-1] लिखने पर संपूर्ण अनुक्रम उलट जाता है।
  • स्लाइसिंग में सीमा पार होने पर भी IndexError नहीं आता।

स्ट्रिंग यूनिकोड वर्णों का अपरिवर्तनीय अनुक्रम है। प्रमुख मेथड्स:

• .upper(), .lower(), .title(), .capitalize(): अक्षरों का आकार बदलना।
• .strip(), .lstrip(), .rstrip(): रिक्त स्थान या अवांछित वर्ण हटाना।
• .find(sub): अनुपस्थिति पर -1 देता है; .index(sub): अनुपस्थिति पर ValueError देता है।
• .split(sep): स्ट्रिंग को तोड़कर लिस्ट बनाता है; sep.join(list): लिस्ट के शब्दों को जोड़कर स्ट्रिंग बनाता है।
• f-strings: आधुनिक स्ट्रिंग प्रारूपण: f"विद्यार्थी: {name}, अंक: {marks:.1f}"।

लिस्ट परिवर्तनीय, विषम तत्वों को धारण करने वाली गतिशील संरचना है।

टपल कोष्ठक () द्वारा परिबद्ध अपरिवर्तनीय अनुक्रम है। एकल तत्व के टपल में अल्पविराम (Comma) अनिवार्य है: t = (50,) (अन्यथा (50) को सामान्य पूर्णांक 50 माना जाएगा)।

• पैकिंग एवं अनपैकिंग: मानों को एक साथ बांधना पैकिंग कहलाता है: t = 10, 20। उन्हें अलग-अलग चरों में खोलना अनपैकिंग कहलाता है: a, b = t। मानों को परस्पर बदलने हेतु यह आदर्श है: x, y = y, x।
• टपल के लाभ: लिस्ट की तुलना में कम मेमोरी और अधिक निष्पादन गति। अपरिवर्तनीय होने के कारण यह डिक्शनरी कीज के रूप में सुरक्षित है।

डिक्शनरी एक परिवर्तनीय, कुंजी-मान (Key-Value) जोड़ों का साहचर्य संग्रह है। पायथन 3.7+ में डिक्शनरी प्रविष्टियों के क्रम (Insertion order) को सुरक्षित रखती है।

प्रमुख डिक्शनरी विधियां:

• d.get(key, default): कुंजी न होने पर KeyError दिए बिना सुरक्षित रूप से डिफॉल्ट मान लौटाता है।
• d.setdefault(key, default): कुंजी उपस्थित होने पर उसका मान देता है, अन्यथा नया मान दर्ज कर लौटाता है।
• d.pop(key, [default]): कुंजी को हटाकर उसका मान लौटाता है।
• d.update(other): दूसरी डिक्शनरी के जोड़ों से वर्तमान डिक्शनरी को अद्यतन करता है।
• d.keys(), d.values(), d.items(): गतिशील दृश्य (Views) लौटाते हैं।
• डिक्शनरी कॉम्प्रिहेंशन: {k: v for k, v in it} जैसे {x: x**3 for x in range(5)}।

सेट अद्वितीय (Unique) एवं अपरिवर्तनीय तत्वों का परिवर्तनीय एवं अव्यवस्थित (Unordered) संग्रह है। रिक्त सेट बनाने हेतु set() का उपयोग अनिवार्य है (क्योंकि {} रिक्त डिक्शनरी बनाता है)।

पायथन में फंक्शन्स प्रथम श्रेणी के नागरिक (First-class citizens) हैं।

• आर्गुमेंट्स के प्रकार:
  • पोजिशनल आर्गुमेंट्स: दिए गए क्रम अनुसार ग्रहण किए जाते हैं।
  • डिफ़ॉल्ट आर्गुमेंट्स: पूर्व निर्धारित मान रखते हैं (उदा. def calc(rate=0.05):)। नियम: डिफ़ॉल्ट आर्गुमेंट के बाद कोई गैर-डिफ़ॉल्ट आर्गुमेंट नहीं आ सकता।
  • परिवर्तनीय आर्गुमेंट्स: *args अतिरिक्त पोजिशनल मानों को टपल में तथा **kwargs अतिरिक्त कीवर्ड मानों को डिक्शनरी में संचित करता है।
• LEGB स्कोप नियम: किसी चर को खोजते समय पायथन 4 स्तरों में जांच करता है:
  1. L (Local): वर्तमान फंक्शन के भीतर परिभाषित चर।
  2. E (Enclosing): बाहरी नेस्टेड फंक्शन के चर।
  3. G (Global): मॉड्यूल स्तर पर परिभाषित ग्लोबल चर अथवा global कीवर्ड।
  4. B (Built-in): पायथन के अंतर्निहित नाम (जैसे len, print, range)।
• global एवं nonlocal कीवर्ड्स: फंक्शन के भीतर से ग्लोबल चर को बदलने हेतु global तथा नेस्टेड फंक्शन में बाहरी चर को बदलने हेतु nonlocal का प्रयोग होता है।

फाइल ऑपरेशंस हेतु कॉन्टेक्स्ट मैनेजर (with open(...) as f:) सर्वश्रेष्ठ विधि है, जो कार्य पूर्ण होने पर फाइल को स्वतः व सुरक्षित रूप से बंद कर देती है:

पॉइंटर नियंत्रण: f.tell() वर्तमान बाइट स्थिति बताता है। f.seek(offset, whence) पॉइंटर को वांछित स्थान पर ले जाता है (whence=0 प्रारंभ से, whence=1 वर्तमान स्थान से, whence=2 अंत से)।

रनटाइम त्रुटियों से प्रोग्राम को सुरक्षित रखने हेतु पायथन का 4-स्तरीय अपवाद मॉडल उपयोग किया जाता है:

# संपूर्ण अपवाद प्रबंधन संरचना
try:
    with open("data.txt", "r") as f:
        val = int(f.readline())
        res = 500 / val
except FileNotFoundError:
    print("त्रुटि: अभीष्ट फाइल उपस्थित नहीं है।")
except ZeroDivisionError:
    print("त्रुटि: शून्य से भाग संभव नहीं है।")
except ValueError:
    print("त्रुटि: फाइल में मान्य संख्यात्मक डेटा नहीं है।")
else:
    # केवल तब जब try ब्लॉक में कोई अपवाद न आए
    print(f"सफल गणना परिणाम: {res}")
finally:
    # अपवाद आए या न आए, यह अवश्य चलेगा
    print("संसाधन सफाई कार्य पूर्ण हुआ।")