पाइथन रिवीजन टूर - II — अध्ययन नोट्स

1. परिचय

पाइथन रिवीजन टूर-II में हम कक्षा 11 में पढ़ी गई संग्रह (collection) अवधारणाओं - सूची (List), टपल (Tuple), शब्दकोश (Dictionary) और सेट (Set) - का विस्तृत पुनरावलोकन करेंगे। ये डेटा संरचनाएँ प्रोग्राम में एक से अधिक मानों को एक साथ संग्रहीत करने की सुविधा देती हैं। कक्षा 12 की परीक्षा में इन संरचनाओं पर आधारित कोड-आउटपुट प्रश्न बहुत अधिक पूछे जाते हैं, इसलिए इनकी विधियों (methods) और विशेषताओं की पूर्ण जानकारी आवश्यक है।

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

2. सूची (List)

सूची विभिन्न प्रकार के तत्वों का क्रमबद्ध, परिवर्तनशील (mutable) संग्रह है। इसे वर्गाकार कोष्ठक [ ] में लिखा जाता है। सूची के तत्वों को इंडेक्स द्वारा एक्सेस किया जाता है (0 से प्रारंभ)।

marks = [85, 90, 78, 92, 88]
mixed = [10, "अनु", 3.14, True]

print(marks[0])        # 85
print(marks[-1])       # 88 (अंतिम तत्व)
print(marks[1:3])      # [90, 78] स्लाइसिंग

सूची संचालन और विधियाँ:

fruits = ["सेब", "आम"]
fruits.append("केला")         # अंत में जोड़ना → ['सेब', 'आम', 'केला']
fruits.insert(1, "संतरा")     # निर्दिष्ट स्थान पर जोड़ना
fruits.extend(["पपीता"])      # एकाधिक तत्व जोड़ना
fruits.remove("आम")           # पहले मेल वाले तत्व को हटाना
item = fruits.pop()           # अंतिम तत्व निकालना
fruits.sort()                 # सॉर्ट करना
fruits.reverse()              # उल्टा करना
print(len(fruits))            # लंबाई
print(fruits.index("सेब"))    # अनुक्रमांक

सूची में लूप:

numbers = [1, 2, 3, 4]
total = 0
for num in numbers:
    total += num
print(total)   # 10

for i in range(len(numbers)):
    print(numbers[i])

3. टपल (Tuple)

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

point = (10, 20)
student = ("अनु", 17, 92.5)

print(point[0])        # 10
print(student[1:])     # (17, 92.5)

# टपल अनपैकिंग
x, y = point
print(x, y)            # 10 20

# एकल तत्व टपल
single = (5,)

टपल विधियाँ:

• count(value): किसी मान की आवृत्ति।
• index(value): किसी मान का पहला अनुक्रमांक।

t = (1, 2, 2, 3, 2)
print(t.count(2))    # 3
print(t.index(3))    # 3

टपल बनाम सूची:

4. शब्दकोश (Dictionary)

शब्दकोश कुंजी-मूल्य (key-value) जोड़ों का अक्रमबद्ध, परिवर्तनशील संग्रह है। इसे घुंघराले कोष्ठक { } में लिखा जाता है। प्रत्येक कुंजी अद्वितीय होती है और उसके साथ एक मूल्य जुड़ा होता है।

student = {
    "रोलनो": 101,
    "नाम": "अनु",
    "कक्षा": "XII"
}

print(student["नाम"])      # अनु
print(student.get("नाम"))  # अनु (सुरक्षित)
print(student.keys())      # सभी कुंजियाँ
print(student.values())    # सभी मूल्य
print(student.items())     # सभी जोड़े

शब्दकोश संचालन:

student = {"नाम": "अनु", "अंक": 92}

student["अंक"] = 95        # मूल्य अपडेट
student["शहर"] = "दिल्ली"  # नई कुंजी जोड़ना
del student["अंक"]          # कुंजी हटाना
student.pop("शहर")          # कुंजी निकालना

# लूप
for key, value in student.items():
    print(key, ":", value)

5. सेट (Set)

सेट अद्वितीय तत्वों का अक्रमबद्ध, परिवर्तनशील संग्रह है। इसे घुंघराले कोष्ठक में लिखा जाता है। सेट में डुप्लिकेट मान स्वतः हट जाते हैं।

numbers = {1, 2, 3, 3, 2}
print(numbers)    # {1, 2, 3} - डुप्लिकेट हट जाते हैं

numbers.add(4)             # तत्व जोड़ना
numbers.remove(2)          # तत्व हटाना

सेट ऑपरेशन:

a = {1, 2, 3}
b = {2, 3, 4}

print(a | b)    # यूनियन: {1, 2, 3, 4}
print(a & b)    # इंटरसेक्शन: {2, 3}
print(a - b)    # अंतर: {1}
print(a ^ b)    # सममित अंतर: {1, 4}

6. संग्रहों की तुलना (Comparison of Collections)

अनपैकिंग और अन्य संचालन:

# एक सूची को स्थिरांकों में बाँटना
marks = [10, 20, 30]
a, b, c = marks

# टपल को फलन से लौटाना
def min_max(lst):
    return min(lst), max(lst)

small, big = min_max([3, 7, 2])
print(small, big)   # 2 7

7. सामान्य गलतियों से बचने के उपाय

• डुप्लिकेट कुंजी शब्दकोश में अंतिम मान ही रखती है।
• सेट खाली करने के लिए {} नहीं, set() का उपयोग करें (क्योंकि {} खाली शब्दकोश है)।
• टपल पर append/pop करने की कोशिश न करें - यह अपरिवर्तनशील है।

8. सूची समझ (List Comprehension)

सूची समझ एक संक्षिप्त तरीका है जिससे एक पंक्ति में नई सूची बनाई जा सकती है। इसका सामान्य रूप है:

new_list = [expression for item in iterable if condition]

numbers = [1, 2, 3, 4, 5]

# वर्गों की सूची
squares = [n ** 2 for n in numbers]
print(squares)          # [1, 4, 9, 16, 25]

# केवल सम संख्याएँ
even = [n for n in numbers if n % 2 == 0]
print(even)             # [2, 4]

# शब्दों की लंबाई
words = ["अनु", "रवि", "कविता"]
lengths = [len(w) for w in words]
print(lengths)          # [3, 3, 5]

सूची समझ सामान्य for लूप की तुलना में संक्षिप्त और अधिक पठनीय होती है। परीक्षा में इसका आउटपुट पूछने वाले प्रश्न अक्सर आते हैं।

9. शब्दकोश का व्यावहारिक उपयोग

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

students = {}
students["अनु"] = 92
students["रवि"] = 85
students["कविता"] = 78

# अधिकतम अंक वाले विद्यार्थी को खोजना
best = max(students, key=students.get)
print(best, students[best])   # अनु 92

# शब्दकोश में लूप
for name, score in students.items():
    print(f"{name}: {score}")

# उपस्थिति जाँच
if "रवि" in students:
    print("रवि मौजूद है")

# मूल्यों का योग और औसत
total = sum(students.values())
average = total / len(students)
print("औसत:", average)   # 85.0

इस प्रकार शब्दकोश डेटा को व्यवस्थित रखता है और उसे कुंजी द्वारा तेज़ी से एक्सेस करने की सुविधा देता है। get, keys, values, items विधियाँ शब्दकोश संचालन को सरल बनाती हैं।

10. संग्रह चयन का निर्णय (Choosing the Right Collection)

सही संग्रह का चयन डेटा की प्रकृति पर निर्भर करता है:

1. यदि तत्वों का क्रम महत्वपूर्ण है और डेटा बदलना है तो सूची चुनें।
2. यदि डेटा स्थिर है और सुरक्षा चाहिए तो टपल चुनें।
3. यदि कुंजी द्वारा तेज़ खोज आवश्यक है तो शब्दकोश चुनें।
4. यदि केवल अद्वितीय तत्वों की आवश्यकता है और क्रम महत्वपूर्ण नहीं तो सेट चुनें।
5. यदि किसी तत्व की उपस्थिति बार-बार जाँचनी है तो सेट सूची से अधिक कुशल है।

उदाहरण के लिए, विद्यार्थी के नाम और अंक के बीच संबंध के लिए शब्दकोश सबसे उपयुक्त है, जबकि प्रश्नों की सूची के लिए सूची सही चुनाव है। इस प्रकार के तर्क को परीक्षा में लिखित उत्तरों में समझाना चाहिए।

त्वरित पुनरावृत्ति तालिकाएँ

सूची की मुख्य विधियाँ

शब्दकोश की मुख्य विधियाँ

माइंड मैप

महत्वपूर्ण आरेख (SVG)

आरेख 1: सूची और टपल की तुलना

आरेख 2: शब्दकोश की संरचना

सामान्य गलतियाँ

1. खाली सेट बनाना: {} से खाली शब्दकोश बनता है, सेट नहीं। खाली सेट के लिए set() उपयोग करें।
2. टपल को बदलने की कोशिश: t[0] = 5 टपल पर त्रुटि देता है क्योंकि टपल अपरिवर्तनशील है।
3. शब्दकोश में डुप्लिकेट कुंजी: डुप्लिकेट कुंजी में अंतिम मान ही रहता है, पिछला मान मिट जाता है।
4. index() और find() में भ्रम: सूची/टपल में index() उपयोग होता है; स्ट्रिंग में find() भी होता है।
5. append और extend में अंतर: append एक तत्व (पूरा तर्क) जोड़ता है; extend सूची के तत्वों को अलग-अलग जोड़ता है।
6. pop() में इंडेक्स भूलना: सूची का pop() अंतिम तत्व निकालता है; pop(0) पहला तत्व निकालता है।

परीक्षा युक्तियाँ

1. सभी संग्रहों की विधियों की तालिका याद रखें - विधियों से संबंधित आउटपुट प्रश्न सबसे अधिक पूछे जाते हैं।
2. सूची पर स्लाइसिंग (lst[1:4], lst[::-1]) के परिणाम लिखने का अभ्यास करें।
3. शब्दकोश में get() और [] के बीच अंतर समझें - get अनुपलब्ध कुंजी पर KeyError नहीं देता।
4. सेट के यूनियन (|), इंटरसेक्शन (&) ऑपरेशन के प्रश्न हल करें।
5. टपल अनपैकिंग और फलन से अनेक मान लौटाने के उदाहरण तैयार रखें।
6. दिए गए कोड का आउटपुट लिखते समय प्रत्येक विधि के प्रभाव को चरणबद्ध दिखाएँ।

निष्कर्ष

पाइथन रिवीजन टूर-II में संग्रह डेटा प्रकारों - सूची, टपल, शब्दकोश और सेट - का अध्ययन किया गया। सूची परिवर्तनशील और क्रमबद्ध है, टपल अपरिवर्तनशील है, शब्दकोश कुंजी-मूल्य संग्रह है और सेट अद्वितीय तत्व रखता है। इनकी विधियों (append, pop, keys, values आदि) की पूर्ण जानकारी कोड-आउटपुट प्रश्नों को हल करने के लिए अनिवार्य है। संग्रहों के चयन का निर्णय डेटा की प्रकृति पर निर्भर करता है - यदि डेटा बदलना है तो सूची, यदि स्थिर है तो टपल, यदि कुंजी से खोजना है तो शब्दकोश। नियमित अभ्यास से इन अवधारणाओं में दक्षता प्राप्त होती है और परीक्षा में उच्च अंक सुनिश्चित होते हैं।