Chapter 10 Tuples and Dictionaries

10.1 टपल का परिचय

टपल विभिन्न डेटा प्रकारों—जैसे पूर्णांक, फ्लोट, स्ट्रिंग, सूची या यहाँ तक कि एक और टपल—के क्रमबद्ध तत्वों का एक क्रम होता है। टपल के तत्व कोष्ठक (गोल ब्रैकेट) में लिखे जाते हैं और अल्पविराम से अलग किए जाते हैं। सूची और स्ट्रिंग की तरह, टपल के तत्वों को सूचकांक मानों से एक्सेस किया जा सकता है, जो 0 से शुरू होते हैं।

“कंप्यूटर कंप्यूटिंग के लिए वही हैं जो वाद्ययंत्र संगीत के लिए। सॉफ़्टवेयर वह संगीत-पत्र है जिसकी व्याख्या हमारी पहुँच को बढ़ाती है और हमारी आत्मा को उठाती है। लियोनार्डो दा विंची ने संगीत को अदृश्य का आकार देना कहा था, और उनकी पंक्ति सॉफ़्टवेयर के वर्णन के लिए और भी अधिक उपयुक्त है।”

$\quad$ - ए. के

उदाहरण 10.1

#tuple1 पूर्णांकों का टपल है
>>> tuple1 = (1,2,3,4,5)
>>> tuple1
(1, 2, 3, 4, 5)

#tuple2 मिश्रित डेटा प्रकारों का टपल है
>>> tuple2 =(‘अर्थशास्त्र’,87,‘अकाउंटेंसी’,89.6)
>>> tuple2
(‘अर्थशास्त्र’, 87, ‘अकाउंटेंसी’, 89.6)

#tuple3 एक ऐसा टपल है जिसमें सूची तत्व के रूप में है
>>> tuple3 = (10,20,30,[40,50])
>>> tuple3
(10, 20, 30, [40, 50])

#tuple4 एक ऐसा टपल है जिसमें टपल तत्व के रूप में है
>>> tuple4 = (1,2,3,4,5,(10,20))
>>> tuple4
(1, 2, 3, 4, 5, (10, 20))

यदि टपल में केवल एक ही तत्व है तो उस तत्व के बाद अल्पविराम लगाना चाहिए। यदि हम अल्पविराम के बिना मान निर्धारित करते हैं तो वह पूर्णांक माना जाता है। यह ध्यान रखना चाहिए कि कोष्ठक रहित क्रम डिफ़ॉल्ट रूप से टपल माना जाता है।

#tuple में single element assign करने का गलत तरीका
#tuple
#tuple5 को एक single element assign किया गया है
>>> tuple5 = (20)
>>> tuple5
20
>>>type(tuple5) $\qquad$ #tuple5 का type tuple नहीं है
<class ‘int’> $\qquad$ #इसे integer माना गया

#tuple में single element assign करने का सही तरीका
#tuple
#tuple5 को एक single element assign किया गया है
>>> tuple5 = (20,) $\qquad$ #element के बाद comma
>>> tuple5
(20,)
>>>type(tuple5) #tuple5 का type tuple है
<class ’tuple’>

#parentheses के बिना एक sequence को
#default रूप से tuple माना जाता है
>>> seq = 1,2,3 $\qquad$ #comma से अलग elements
>>> type(seq) $\qquad$ #tuple के रूप में treat किया गया
<class ’tuple’>
>>> print(seq) $\qquad$ #seq एक tuple है
(1, 2, 3)

हम आमतौर पर same data types के elements store करने के लिए list का उपयोग करते हैं जबकि different data types के elements store करने के लिए हम tuples का उपयोग करते हैं।

10.1.1 Tuple में Elements Access करना

Tuple के elements को list या string की तरह indexing और slicing का उपयोग करके access किया जा सकता है।

>>> tuple1 = (2,4,6,8,10,12)
#एक tuple tuple1 initialize करता है
#tuple1 का पहला element लौटाता है
>>> tuple1[0]
2
#tuple1 का चौथा element लौटाता है
>>> tuple1[3]
8
#error लौटाता है क्योंकि index range से बाहर है
>>> tuple1[15]
IndexError: tuple index out of range
#एक integer index परिणाम देने वाला expression
>>> tuple1[1+4]
12
#दाएं से पहला element लौटाता है
>>> tuple1[-1]
12

10.1.2 Tuple Immutable होता है

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

>>> tuple1 = (1, 2, 3, 4, 5)
>>> tuple1[4] = 10
TypeError: 'tuple' object does not support item assignment

हालाँकि, टपल का कोई तत्व स्वयं परिवर्तनीय प्रकार का हो सकता है, जैसे कि एक सूची।

# tuple2 का चौथा तत्व एक सूची है
>>> tuple2 = (1, 2, 3, [8, 9])
# टपल tuple2 के सूची तत्व को संशोधित करना
>>> tuple2[3][1] = 10
# संशोधन tuple2 में दिखाई देता है
>>> tuple2
(1, 2, 3, [8, 10])

✓ सूची परिवर्तनीय है, पर टपल अपरिवर्तनीय। इसलिए टपल पर पुनरावृति सूची की तुलना में तेज़ होती है।
✓ यदि हमारे पास ऐसा डेटा है जो नहीं बदलता, तो उसे टपल में रखने से यह सुनिश्चित होता है कि वह गलती से बदला न जाए।

10.2 टपल संचालन

10.2.1 संयोजन (Concatenation)

Python हमें + चिह्न द्वारा दर्शाए गए संयोजन संचालक का उपयोग करके टपलों को जोड़ने की अनुमति देता है। हम एक नया टपल भी बना सकते हैं जिसमें इस संयोजन संचालन का परिणाम हो।

>>> tuple1 = (1, 3, 5, 7, 9)
>>> tuple2 = (2, 4, 6, 8, 10)
>>> tuple1 + tuple2          # दो टपलों को संयोजित करता है
(1, 3, 5, 7, 9, 2, 4, 6, 8, 10)

>>> tuple3 = ('Red', 'Green', 'Blue')
>>> tuple4 = ('Cyan', 'Magenta', 'Yellow', 'Black')
# tuple5, tuple3 और tuple4 के तत्वों को संग्रहीत करता है
>>> tuple5 = tuple3 + tuple4
>>> tuple5
('Red', 'Green', 'Blue', 'Cyan', 'Magenta', 'Yellow', 'Black')

कंकैटिनेशन ऑपरेटर का उपयोग मौजूदा टपल को बढ़ाने के लिए भी किया जा सकता है। जब हम कंकैटिनेशन का उपयोग करके टपल को बढ़ाते हैं, तो एक नया टपल बनता है।

>>> tuple6 = (1,2,3,4,5)

#tuple6 में एक single element जोड़ा गया
>>> tuple6 = tuple6 + (6,)
>>> tuple6
(1, 2, 3, 4, 5, 6)

#एक से अधिक elements जोड़े गए
>>> tuple6 = tuple6 + (7,8,9)
>>> tuple6
(1, 2, 3, 4, 5, 6, 7, 8, 9)

10.2.2 रिपीटिशन

रिपीटिशन ऑपरेशन को * प्रतीक द्वारा दर्शाया जाता है। इसका उपयोग टपल के elements को दोहराने के लिए किया जाता है। हम टपल के elements को दोहरा सकते हैं। रिपीटिशन ऑपरेटर के लिए पहला ऑपरेंड टपल होना चाहिए और दूसरा ऑपरेंड केवल पूर्णांक होना चाहिए।

>>> tuple1 = (‘Hello’,‘World’)
>>> tuple1 * 3
(‘Hello’, ‘World’, ‘Hello’, ‘World’, ‘Hello’, \ ‘World’)
#single element वाला tuple
>>> tuple2 = (“Hello”,)
>>> tuple2 * 4
(‘Hello’, ‘Hello’, ‘Hello’, ‘Hello’)

10.2.3 मेंबरशिप

in ऑपरेटर यह जांचता है कि element टपल में मौजूद है या नहीं और True लौटाता है, अन्यथा False लौटाता है।

>>> tuple1 = (‘Red’, ‘Green’, ‘Blue’)
>>> ‘Green’ in tuple1
True

not in ऑपरेटर True लौटाता है यदि element टपल में मौजूद नहीं है, अन्यथा False लौटाता है।

>>> tuple1 = (‘Red’,‘Green’,‘Blue’)
>>> ‘Green’ not in tuple1
False

10.2.4 स्लाइसिंग

स्ट्रिंग और लिस्ट की तरह, टपल पर भी स्लाइसिंग लागू की जा सकती है।

#tuple1 एक tuple है
>>> tuple1 = (10,20,30,40,50,60,70,80)

#इंडेक्स 2 से इंडेक्स 6 तक के तत्व
>>> tuple1[2:7]
(30, 40, 50, 60, 70)

#टपल के सभी तत्व प्रिंट किए गए हैं
>>> tuple1[0:len(tuple1)]
(10, 20, 30, 40, 50, 60, 70, 80)

#स्लाइस ज़ीरो इंडेक्स से शुरू होता है
>>> tuple1[:5]
(10, 20, 30, 40, 50)

#स्लाइस टपल के अंत तक है
>>> tuple1[2:]
(30, 40, 50, 60, 70, 80)

#स्टेप साइज़ 2
>>> tuple1[0:len(tuple1):2]
(10, 30, 50, 70)
#नकारात्मक इंडेक्सिंग
>>> tuple1[-6:-4]
(30, 40)

#टपल उल्टे क्रम में ट्रैवर्स किया गया है
>>> tuple1[::-1]
(80, 70, 60, 50, 40, 30, 20, 10)

10.3 टपल मेथड्स और बिल्ट-इन फंक्शन्स

Python टपल्स पर काम करने के लिए कई फंक्शन्स प्रदान करता है। तालिका 10.1 कुछ सामान्यतः प्रयुक्त टपल मेथड्स और बिल्ट-इन फंक्शन्स की सूची देती है।

$\hspace{3cm}$ तालिका 10.1 टपल्स के लिए बिल्ट-इन फंक्शन्स और मेथड्स

विधि विवरण उदाहरण
len() तर्क के रूप में पास किए गए टपल की लंबाई या
तत्वों की संख्या लौटाता है		 >>> tuple1 $=(10,20,30,40,50)$
>>> len $($ tuple 1$)$
5
tuple() यदि कोई तर्क नहीं दिया गया है तो एक खाली टपल बनाता है
यदि एक अनुक्रम तर्क के रूप में पास किया गया है तो एक टपल बनाता है		 >>> tuple1 = tuple( $)$
>>> tuple1
$($ )
>>> tuple1 = tuple(‘aeiou’)#string
>>> tuple1
$\left(’ a{ }^{\prime}\right.$ ’ ’e’, ‘i’, ‘o’, ‘u’)
>>> tuple2 = tuple ([1,2,3]) # l i s t$
>>> tuple2
$(1,2,3)$
$>>>$ tuple3 = tuple(range $(5))$
>>> tuple3
$(0,1,2,3,4)$
count() दिए गए तत्व के टपल में दिखाई देने की संख्या लौटाता है >>> tuple $1=(10,20,30,10,40,10,50)$
$>>>$ tuple $1 \cdot \operatorname{count}(10)$
3
$>>>$ tuple $1 . \operatorname{count}(90)$
$0$
index() दिए गए टपल में तत्व की पहली उपस्थिति का सूचकांक लौटाता है >>> tuple1 $=(10,20,30,40,50)$
>>> tuple1.index $(30)$
2
>>> tuple1.index $(90)$
ValueError: tuple.index $(x): x$ not
in tuple
sorted() टपल के तत्वों को लेता है और एक नई क्रमबद्ध सूची लौटाता है। यह ध्यान देना चाहिए कि sorted() मूल टपल में कोई बदलाव नहीं करता >>> tuple1 = (“Rama”, “Heena”, “Raj”,
“Mohsin”,“Aditya”)
>>> sorted(tuple1)
[‘Aditya’, ‘Heena’, ‘Mohsin’, ‘Raj’,
‘Rama’]
$\min ()$ टपल का न्यूनतम या सबसे छोटा तत्व लौटाता है >>> tuple1 $=(19,12,56,18,9,87,34)$
>>> min(tuple 1$)$
9
$\max ()$ टपल का अधिकतम या सबसे बड़ा तत्व लौटाता है >>> $\max ($ tuple 1$)$
87
$\operatorname{sum}()$ टपल के तत्वों का योग लौटाता है >>> sum(tuple1)
235

10.4 ट्यूपल असाइनमेंट

ट्यूपल असाइनमेंट पायथन में एक उपयोगी विशेषता है। यह असाइनमेंट ऑपरेटर के बाईं ओर ट्यूपल में रखे चरों को दाईं ओर के ट्यूपल से संगत मानों को असाइन करने की अनुमति देता है। बाईं ओर चरों की संख्या ट्यूपल में तत्वों की संख्या के समान होनी चाहिए।

उदाहरण 10.2

#पहला तत्व 10, num1 को असाइन किया जाता है और
#दूसरा तत्व 20, num2 को असाइन किया जाता है।
>>> (num1,num2) = (10,20)
>>> print(num1)
10
>>> print(num2)
20
>>> record = ( “Pooja”,40,“CS”)
>>> (name,rollNo,subject) = record
>>> name
‘Pooja’
>>> rollNo
40
>>> subject
‘CS’
>>> (a,b,c,d) = (5,6,8)
ValueError: not enough values to unpack
(expected 4, got 3)

यदि दाईं ओर कोई अभिव्यक्ति है तो पहले वह अभिव्यक्ति मूल्यांकित की जाती है और अंत में परिणाम ट्यूपल को असाइन किया जाता है।

## उदाहरण 10.3

#15, num3 को असाइन किया जाता है और
#25, num4 को असाइन किया जाता है
>>> (num3,num4) = (10+5,20+5)
>>> print(num3)
15
>>> print(num4)
25

10.5 नेस्टेड ट्यूपल्स

एक ट्यूपल के अंदर एक और ट्यूपल को नेस्टेड ट्यूपल कहा जाता है। प्रोग्राम 10-1 में, छात्रों का रोल नंबर, नाम और अंक (प्रतिशत में) एक ट्यूपल में सहेजे गए हैं। ऐसे कई छात्रों का विवरण स्टोर करने के लिए हम एक नेस्टेड ट्यूपल बना सकते हैं।

प्रोग्राम 10-1 यह एक प्रोग्राम है जो रोल नंबर, नाम और छात्रों के अंक स्टोर करने के लिए एक नेस्टेड ट्यूपल बनाता है

#प्रोग्राम 10-1
#छात्रों के रिकॉर्ड्स को टपल में संग्रहित करना और उन्हें प्रिंट करना
st=((101,“Aman”,98),(102,“Geet”,95),(103,“Sahil”,87),(104,“Pawan”,79))
print(“S_No”," Roll_No"," Name"," Marks")
for i in range(0,len(st)):
$\quad$ print((i+1),’\t’,st[i][0],’\t’,st[i][1],’\t’,st[i][2])

आउटपुट:

S_No $\quad$ Roll_No $\qquad$ Name $\qquad$ Marks
1 $\hspace{1cm}$ 101 $\hspace{1cm}$ Aman $\hspace{0.8cm}$ 98
2 $\hspace{1cm}$ 102 $\hspace{1cm}$ Geet $\hspace{1cm}$ 95
3 $\hspace{1cm}$ 103 $\hspace{1cm}$ Sahil $\hspace{1cm}$ 87
4 $\hspace{1cm}$ 104 $\hspace{1cm}$ Pawan $\hspace{0.7cm}$ 79

10.6 टपल हैंडलिंग

प्रोग्राम 10-2 एक अस्थायी वेरिएबल का उपयोग किए बिना दो संख्याओं को स्वैप करने के लिए एक प्रोग्राम लिखें।

#प्रोग्राम 10-2
#दो संख्याओं को स्वैप करने का प्रोग्राम
num1 = int(input(‘पहली संख्या दर्ज करें: ‘))
num2 = int(input(‘दूसरी संख्या दर्ज करें: ‘))
print("\nस्वैपिंग से पहले संख्याएँ:")
print(“पहली संख्या:",num1)
print(“दूसरी संख्या:",num2)
(num1,num2) = (num2,num1)
print("\nस्वैपिंग के बाद संख्याएँ:”)
print(“पहली संख्या:",num1)
print(“दूसरी संख्या:",num2)

आउटपुट:

पहली संख्या दर्ज करें: 5
दूसरी संख्या दर्ज करें: 10

_स्वैपिंग से पहले संख्याएँ:
पहली संख्या: 5
दूसरी संख्या: 10 _

स्वैपिंग के बाद संख्याएँ:
पहली संख्या: 10
दूसरी संख्या: 5

प्रोग्राम 10-3 एक फ़ंक्शन का उपयोग करके एक वृत्त का क्षेत्रफल और परिधि की गणना करने के लिए एक प्रोग्राम लिखें।

Here is the Hindi translation of the requested chunk:

प्रोग्राम 10-3
वृत्त का क्षेत्रफल और परिधि निकालने के लिए फंक्शन।

def circle(r):
    area = 3.14*r*r
    circumference = 2*3.14*r
    # एक टपल लौटाता है जिसमें दो तत्व हैं: क्षेत्रफल और परिधि
    return (area, circumference)
# फंक्शन का अंत

radius = int(input('वृत्त की त्रिज्या दर्ज करें: '))
area, circumference = circle(radius)
print('वृत्त का क्षेत्रफल है:', area)
print('वृत्त की परिधि है:', circumference)

आउटपुट:

वृत्त की त्रिज्या दर्ज करें: 5
वृत्त का क्षेत्रफल है: 78.5
वृत्त की परिधि है: 31.400000000000002

प्रोग्राम 10-4: एक ऐसा प्रोग्राम लिखें जो उपयोगकर्ता से $n$ संख्याएँ इनपुट करे। इन संख्याओं को एक टपल में संग्रहित करें। इस टपल से अधिकतम और न्यूनतम संख्या प्रिंट करें।

numbers = tuple()  # एक खाली टपल 'numbers' बनाएं
n = int(input("आप कितनी संख्याएँ दर्ज करना चाहते हैं?: "))
for i in range(0, n):
    num = int(input())
    # उपयोगकर्ता द्वारा दर्ज की गई संख्या को टपल 'numbers' में जोड़ेगा
    numbers = numbers + (num,)
print('\nटपल में संख्याएँ हैं:')
print(numbers)
print("\nअधिकतम संख्या है:")
print(max(numbers))
print("न्यूनतम संख्या है:")
print(min(numbers))

आउटपुट:

आप कितनी संख्याएँ दर्ज करना चाहते हैं?: 5
9
8
10
12
15

टपल में संख्याएँ हैं:
(9, 8, 10, 12, 15)

अधिकतम संख्या है:
15
न्यूनतम संख्या है:
8

10.7 शब्दकोशों का परिचय

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

10.7.1 शब्दकोश बनाना

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

उदाहरण 10.4

#dict1 एक खाली शब्दकोश है जिसे बनाया गया है
#शब्दकोश के लिए घुंघराले ब्रेसिज़ का उपयोग किया जाता है
>>> dict1 = {}
>>> dict1
{}
#dict2 एक खाली शब्दकोश है जिसे बिल्ट-इन फंक्शन का उपयोग करके बनाया गया है
>>> dict2 = dict()
>>> dict2
{}
#dict3 एक शब्दकोश है जो छात्रों के नामों को
#संबंधित प्रतिशत अंकों से मैप करता है
>>> dict3 = {‘मोहन’:95,‘राम’:89,‘सुहेल’:92, ‘संगीता’:85}
>>> dict3
{‘मोहन’: 95, ‘राम’: 89, ‘सुहेल’: 92, ‘संगीता’: 85}

10.7.2 शब्दकोश में आइटम तक पहुँचना

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

निम्नलिखित उदाहरण दिखाता है कि एक डिक्शनरी दी गई कुंजी के अनुरूप मान कैसे लौटाती है:

>>> dict3 = {‘Mohan’:95,‘Ram’:89,‘Suhel’:92,‘Sangeeta’:85}
>>> dict3[‘Ram’]
89
>>> dict3[‘Sangeeta’]
85
#the key does not exist
>>> dict3[‘Shyam’]
KeyError: ‘Shyam’

उपरोक्त उदाहरणों में कुंजी ‘Ram’ हमेशा मान 89 पर मैप करती है और कुंजी ‘Sangeeta’ हमेशा मान 85 पर मैप करती है। इसलिए आइटम्स का क्रम मायने नहीं रखता। यदि कुंजी डिक्शनरी में मौजूद नहीं है तो हमें KeyError मिलता है।

10.8 डिक्शनरीज़ म्यूटेबल हैं

डिक्शनरीज़ म्यूटेबल होती हैं जिसका अर्थ है कि डिक्शनरी की सामग्री को बनाने के बाद बदला जा सकता है।

10.8.1 एक नया आइटम जोड़ना

हम डिक्शनरी में एक नया आइटम निम्नलिखित उदाहरण के अनुसार जोड़ सकते हैं:

>>> dict1 = {‘Mohan’:95,‘Ram’:89,‘Suhel’:92, ‘Sangeeta’:85}
>>> dict1[‘Meena’] = 78
>>> dict1
{‘Mohan’: 95, ‘Ram’: 89, ‘Suhel’: 92, ‘Sangeeta’: 85, ‘Meena’: 78}

10.8.2 मौजूदा आइटम को संशोधित करना

मौजूदा डिक्शनरी को बस कुंजी-मान जोड़ी को ओवरराइट करके संशोधित किया जा सकता है। डिक्शनरी में दिए गए आइटम को संशोधित करने का उदाहरण:

>>> dict1 = {‘मोहन’:95,‘राम’:89,‘सुहेल’:92, ‘संगीता’:85}
#सुहेल के अंक बदलकर 93.5 कर दिए गए
>>> dict1[‘सुहेल’] = 93.5
>>> dict1
{‘मोहन’: 95, ‘राम’: 89, ‘सुहेल’: 93.5, ‘संगीता’: 85}

10.9 डिक्शनरी संचालन

10.9.1 सदस्यता

सदस्यता ऑपरेटर in यह जांचता है कि कुंजी डिक्शनरी में मौजूद है या नहीं और True लौटाता है, अन्यथा False लौटाता है.

>>> dict1 = {‘मोहन’:95,‘राम’:89,‘सुहेल’:92, ‘संगीता’:85}
>>> ‘सुहेल’ in dict1
True

not in ऑपरेटर True लौटाता है यदि कुंजी डिक्शनरी में मौजूद नहीं है, अन्यथा False लौटाता है.

>>> dict1 = {‘मोहन’:95,‘राम’:89,‘सुहेल’:92, ‘संगीता’:85}
>>> ‘सुहेल’ not in dict1
False

10.10 डिक्शनरी का पारगमन

हम डिक्शनरी की प्रत्येक वस्तु तक पहुँच सकते हैं या for लूप का उपयोग करके डिक्शनरी का पारगमन कर सकते हैं.

>>> dict1 = {‘मोहन’:95,‘राम’:89,‘सुहेल’:92, ‘संगीता’:85}

विधि 1

>>> for key in dict1:
$\quad$ print(key,’:’,dict1[key])
मोहन: 95
राम: 89
सुहेल: 92
संगीता: 85

विधि 2

>>> for key,value in dict1.items():
$\quad$ print(key,’:’,value)
मोहन: 95
राम: 89
सुहेल: 92
संगीता: 85

10.11 डिक्शनरी विधियाँ और अंतर्निहित फ़ंक्शन

Python डिक्शनरी पर काम करने के लिए कई फ़ंक्शन प्रदान करता है। तालिका 10.2 कुछ सामान्यतः प्रयुक्त डिक्शनरी विधियों की सूची देती है.

$\hspace{2cm}$ तालिका 10.2 डिक्शनरी के लिए अंतर्निहित फ़ंक्शन और विधियाँ

विधि विवरण उदाहरण
len() डिक्शनरी की लंबाई या
key: value जोड़ों की संख्या लौटाता है
जो तर्क के रूप में पास किया गया है		 >>> dict1 = {‘मोहन’: 95, ‘राम’: 89,
‘सुहेल’:92, ‘संगीता’: 85}
>>> len(dict1)
4
$\operatorname{dict}($ ) key-value जोड़ों की
अनुक्रम से एक डिक्शनरी बनाता है		 pair1 $=[($ ‘मोहन’,95), (‘राम’,89),
(‘सुहेल’,92), (‘संगीता’,85)]
>>> pair1
$[($ ‘मोहन’, 95), (‘राम’, 89), (‘सुहेल’,
$92),(’ स ग त ‘, 85)]$
>>> dict1 = dict(pair1)
>>> dict1
{‘मोहन’: 95, ‘राम’: 89, ‘सुहेल’: 92,
‘संगीता’: 85}
keys() डिक्शनरी में मौजूद
keys की सूची लौटाता है		 >>> dict1 = {‘मोहन’:95, ‘राम’:89,
‘सुहेल’:92, ‘संगीता’:85}
>>> dict1.keys()
dict_keys([‘मोहन’, ‘राम’, ‘सुहेल’,
‘संगीता’])
values() डिक्शनरी में मौजूद
values की सूची लौटाता है		 >>> dict1 = { ‘मोहन’:95, ‘राम’:89,
‘सुहेल’:92, ‘संगीता’:85}
>>> dict1.values()
dict_values([95, 89, 92, 85])
items() tuples(key -
value) जोड़ों की सूची लौटाता है		 >>> dict1 = {‘मोहन’:95, ‘राम’ $: 89$,
‘सुहेल’:92, ‘संगीता’:85}
>>> dict1.items()
dict_items([(‘मोहन’, 95), (‘राम’’
89), (‘सुहेल’, 92), (‘संगीता’, 85)])
$\operatorname{get}()$ तर्क के रूप में पास किए गए
key के अनुरूप value लौटाता है
यदि key डिक्शनरी में मौजूद नहीं है
तो यह None लौटाएगा		 >>> dict1 = { ‘मोहन’:95, ‘राम’:89,
‘सुहेल’:92, ‘संगीता’:85}
>>> dict1.get(‘संगीता’)
85
>>> dict1.get(‘सोहन’)
>>>
update() तर्क के रूप में पास की गई
डिक्शनरी के key-value जोड़ों को
दी गई डिक्शनरी के key-value जोड़ों में जोड़ता है		 >>> dict1 ={ ‘मोहन’:95, ‘राम’:89,
‘सुहेल’:92, ‘संगीता’:85}
>>> dict2 = {‘सोहन’:79, ‘गीता’:89}
>>> dict1.update(dict2)
>>> dict1
{‘मोहन’: 95, ‘राम’: 89, ‘सुहेल’: 92,
‘संगीता’: 85, ‘सोहन’: 79, ‘गीता’:
89}
>>> dict2
{ ‘सोहन’: 79, ‘गीता’: 89}
$\operatorname{del}()$ दिए गए key वाले आइटम को हटाता है
मेमोरी से डिक्शनरी को हटाने के लिए हम लिखते हैं:
del Dict_name		 >>> dict1 = {‘मोहन’:95,‘राम’:89,
‘सुहेल’:92, ‘संगीता’:85}
>>> del dict1[‘राम’]
>>> dict1
{‘मोहन’:95, ‘सुहेल’:92, ‘संगीता’: 85}
>>> del dict1 [‘मोहन’]
>>> dict1
{‘सुहेल’: 92, ‘संगीता’: 85}
>>> del dict1
>>> dict1
NameError: name ‘dict1’ is not defined
clear() डिक्शनरी के सभी आइटमों को
हटाता है या साफ करता है		 >>> dict1 = {‘मोहन’:95, ‘राम’:89,
‘सुहेल’:92, ‘संगीता’: 85 }
>>> dict1.clear $($ )
>>> dict1
{}

10.12 शब्दकोशों को मैनिपुलेट करना

इस अध्याय में हमने सीखा है कि शब्दकोश कैसे बनाया जाता है और उसे मैनिपुलेट करने के लिए विभिन्न विधियों को कैसे लागू किया जाता है। निम्नलिखित प्रोग्राम उन मैनिपुलेशन विधियों के शब्दकोशों पर अनुप्रयोग को दर्शाते हैं।

प्रोग्राम 10-5 1 और 10 के बीच की विषम संख्याओं का एक शब्दकोश ‘ODD’ बनाएं, जहाँ कुंजी दशमलव संख्या है और मान संबंधित संख्या शब्दों में है। इस शब्दकोश पर निम्नलिखित संचालन करें:

(a) कुंजियाँ प्रदर्शित करें
(b) मान प्रदर्शित करें
(c) आइटम प्रदर्शित करें
(d) शब्दकोश की लंबाई ज्ञात करें
(e) जांचें कि 7 मौजूद है या नहीं
(f) जांचें कि 2 मौजूद है या नहीं
(g) कुंजी 9 के अनुरूप मान प्राप्त करें
(h) कुंजी 9 के अनुरूप शब्दकोश से आइटम हटाएं

>>> ODD = {1:‘एक’,3:‘तीन’,5:‘पाँच’,7:‘सात’,9:‘नौ’}
>>> ODD
{1: ‘एक’, 3: ‘तीन’, 5: ‘पाँच’, 7: ‘सात’, 9: ‘नौ’}

(a) कुंजियाँ प्रदर्शित करें

>>> ODD.keys()
dict_keys([1, 3, 5, 7, 9])

(b) मान प्रदर्शित करें

>>> ODD.values()
dict_values([‘एक’, ‘तीन’, ‘पाँच’, ‘सात’, ‘नौ’])

(c) आइटम प्रदर्शित करें

>>> ODD.items()
dict_items([(1, ‘एक’), (3, ‘तीन’), (5, ‘पाँच’), (7, ‘सात’),
(9, ‘नौ’)])

(d) शब्दकोश की लंबाई ज्ञात करें

>>> len(ODD)
5

(e) जांचें कि 7 मौजूद है या नहीं

>>> 7 in ODD
True

(f) जांचें कि 2 मौजूद है या नहीं

>>> 2 in ODD
False

(g) कुंजी 9 के अनुरूप मान प्राप्त करें

>>> ODD.get (9)
‘नौ’

(h) कुंजी 9 के अनुरूप शब्दकोश से आइटम हटाएँ

_>>> del ODD[9]
>>> ODD
{1: ‘One’, 3: ‘Three’, 5: ‘Five’, 7: ‘Seven’}_

प्रोग्राम 10-6 एक प्रोग्राम लिखें जो कर्मचारियों के नाम और उनके वेतन को इनपुट के रूप में दर्ज करे और उन्हें एक शब्दकोश में संग्रहीत करे।

#प्रोग्राम 10-6
#प्रोग्राम जो एक शब्दकोश बनाता है जो कर्मचारी के नामों को संग्रहीत करता है
#और उनका वेतन
num = int(input(“Enter the number of employees whose data to be stored: “))
count = 1
employee = dict() $\quad$ #एक खाली शब्दकोश बनाएँ
while count <= num:
$\quad$ name = input(“Enter the name of the Employee: “)
$\quad$ salary = int(input(“Enter the salary: “))
$\quad$ employee[name] = salary
$\quad$ count += 1
print("\n\nEMPLOYEE_NAME\tSALARY”)
for k in employee:
$\quad$ print(k,’\t\t’,employee[k])

आउटपुट:

Enter the number of employees to be stored: 5
Enter the name of the Employee: ‘Tarun’
Enter the salary: 12000
Enter the name of the Employee: ‘Amina’
Enter the salary: 34000
Enter the name of the Employee: ‘Joseph’
Enter the salary: 24000
Enter the name of the Employee: ‘Rahul’
Enter the salary: 30000
Enter the name of the Employee: ‘Zoya’
Enter the salary: 25000
EMPLOYEE_NAME $\hspace{1.5cm}$ SALARY
‘Tarun’ $\hspace{3.1cm}$ 12000
‘Amina’ $\hspace{3cm}$ 34000
‘Joseph’ $\hspace{3cm}$ 24000
‘Rahul’ $\hspace{3cm}$ 30000
‘Zoya’ $\hspace{3.1cm}$ 25000

प्रोग्राम 10-7 एक प्रोग्राम लिखें जो एक दिए गए स्ट्रिंग में किसी वर्ण के आने की संख्या गिने।

#प्रोग्राम 10-7
#दिए गए स्ट्रिंग में किसी वर्ण के आने की संख्या गिनें
st = input(“एक स्ट्रिंग दर्ज करें: “)
dic = {} #एक खाली डिक्शनरी बनाता है
for ch in st:
$\quad$ if ch in dic: #अगर अगला वर्ण पहले से डिक्शनरी में है
$\qquad$ dic[ch] += 1
$\quad$ else:
$\qquad$ dic[ch] = 1 #अगर ch पहली बार आया है
for key in dic:
$\quad$ print(key,’:’,dic[key])

आउटपुट:

एक स्ट्रिंग दर्ज करें: HelloWorld
H : 1
e : 1
l : 3
o : 2
W : 1
r : 1
d : 1

प्रोग्राम 10-8 एक फ़ंक्शन लिखें जो यूज़र द्वारा दर्ज किए गए नंबर को उसके शब्दों में बदले। उदाहरण के लिए, अगर इनपुट 876 है तो आउटपुट ‘Eight Seven Six’ होना चाहिए।

#प्रोग्राम 10-8
#एक फ़ंक्शन लिखें जो नंबर को उसके शब्दों में बदले
def convert(num):
$\quad$ #numberNames एक डिक्शनरी है जिसमें अंक और उनके नाम हैं
$\quad$ numberNames = {0:‘Zero’,1:‘One’,2:‘Two’,3:‘Three’,4:‘Four’,
5:‘Five’,6:‘Six’,7:‘Seven’,8:‘Eight’,9:‘Nine’}

$\quad$ result = ’’
$\quad$ for ch in num:
$\qquad$ key = int(ch) $\quad$ #वर्ण को पूर्णांक में बदलता है
$\qquad$ value = numberNames[key]
$\qquad$ result = result + ’ ’ + value
$\quad$ return result

num = input(“Enter any number: “) $\quad$ #number is stored as string
result = convert(num)
print(“The number is:",num)
print(“The numberName is:",result)

Output:

Enter any number: 6512
The number is: 6512
The numberName is: Six Five One Two

सारांश

  • टपल अपरिवर्तनीय क्रम (immutable sequences) होते हैं, अर्थात् एक बार टपल बन जाने पर हम उसके तत्वों को बदल नहीं सकते।
  • टपल के तत्व गोल कोष्ठकों (round brackets) में अल्पविराम से अलग-अलग रखे जाते हैं।
  • यदि किसी क्रम में कोष्ठक के बिना अल्पविराम से अलग तत्व हों, तो भी वह टपल माना जाता है।
  • टपल क्रमबद्ध क्रम होते हैं क्योंकि प्रत्येक तत्व की एक निश्चित स्थिति होती है।
  • टपल के तत्वों को पहुँचने के लिए अनुक्रमण (indexing) प्रयोग होता है; दो-तरफ़ा अनुक्रमण डिक्शनरी में भी स्ट्रिंग और सूचियों की तरह लागू होता है।
  • ऑपरेटर ‘+’ एक क्रम (स्ट्रिंग, सूची, टपल) को दूसरे क्रम के अंत में जोड़ता है।
  • ऑपरेटर “*” एक क्रम (स्ट्रिंग, सूची, टपल) को निर्धारित बार दोहराता है।
  • सदस्यता ऑपरेटर ‘in’ बताता है कि कोई तत्व क्रम में है या नहीं, और ’not in’ इसका विपरीत करता है।
  • टपल संचालन फ़ंक्शन हैं: len(), tuple(), count(), index(), sorted(), $\min ($ ), $\max ($ ), sum()।
  • डिक्शनरी एक मैपिंग (non-scalar) डेटा प्रकार है। यह key-value जोड़ों का अक्रमित संग्रह है; key-value जोड़े घुंघराले कोष्ठकों में रखे जाते हैं।
  • प्रत्येक key को अपने value से अर्धविराम द्वारा अलग किया जाता है।
  • keys अद्वितीय होती हैं और सूचकांक का काम करती हैं।
  • keys अपरिवर्तनीय प्रकार की होती हैं, पर values परिवर्तनीय हो सकती हैं।

अभ्यास

1. निम्न टपलों, tuple1 और tuple2 पर विचार कीजिए:

ट्रांसलेशन (हिंदी में)

1. निम्नलिखित कोड के आउटपुट बताइए:

tuple1 = (23, 1, 45, 67, 45, 9, 55, 45)
tuple2 = (100, 200)

निम्नलिखित स्टेटमेंट्स का आउटपुट क्या होगा:

i. print(tuple1.index(45))
→ यह बताएगा कि 45 पहली बार किस इंडेक्स पर है। आउटपुट: 2

ii. print(tuple1.count(45))
→ यह गिनेगा कि 45 कितनी बार आया है। आउटपुट: 3

iii. print(tuple1 + tuple2)
→ दोनों टपल्स को जोड़ेगा। आउटपुट: (23, 1, 45, 67, 45, 9, 55, 45, 100, 200)

iv. print(len(tuple2))
→ टपल2 की लंबाई। आउटपुट: 2

v. print(max(tuple1))
→ सबसे बड़ा नंबर। आउटपुट: 67

vi. print(min(tuple1))
→ सबसे छोटा नंबर। आउटपुट: 1

vii. print(sum(tuple2))
→ टपल2 के सभी अंकों का योग। आउटपुट: 300

viii. print(sorted(tuple1))
→ टपल1 को सॉर्ट करके लिस्ट देगा। आउटपुट: [1, 9, 23, 45, 45, 45, 55, 67]
(नोट: टपल अपरिवर्तित रहेगा)

2. निम्नलिखित डिक्शनरी पर विचार करें:

stateCapital = {"AndhraPradesh":"Hyderabad", "Bihar":"Patna", "Maharashtra":"Mumbai", "Rajasthan":"Jaipur"}

निम्नलिखित स्टेटमेंट्स का आउटपुट:

i. print(stateCapital.get(“Bihar”))
→ आउटपुट: Patna

ii. print(stateCapital.keys())
→ आउटपुट: dict_keys([‘AndhraPradesh’, ‘Bihar’, ‘Maharashtra’, ‘Rajasthan’])

iii. print(stateCapital.values())
→ आउटपुट: dict_values([‘Hyderabad’, ‘Patna’, ‘Mumbai’, ‘Jaipur’])

iv. print(stateCapital.items())
→ आउटपुट: dict_items([(‘AndhraPradesh’, ‘Hyderabad’), …])

v. print(len(stateCapital))
→ आउटपुट: 4

vi. print(“Maharashtra” in stateCapital)
→ आउटपुट: True

vii. print(stateCapital.get(“Assam”))
→ आउटपुट: None

viii. del stateCapital[“Rajasthan”]
→ आउटपुट: {‘AndhraPradesh’: ‘Hyderabad’, ‘Bihar’: ‘Patna’, ‘Maharashtra’: ‘Mumbai’}

3. “Lists और Tuples ऑर्डर्ड होते हैं” – व्याख्या:
इसका मतलब है कि इनमें आइटम्स का क्रम (order) बना रहता है। जैसे:
[10, 20, 30] में 10 पहले, 20 दूसरे और 30 तीसरे स्थान पर रहेगा। यही बात टपल्स पर भी लागू होती है।

4. एक फंक्शन से एक से अधिक वैल्यू कैसे रिटर्न करें – उदाहरण:

def get_min_max(numbers):
    return min(numbers), max(numbers)

result = get_min_max([5, 2, 9, 1])
print(result)  # आउटपुट: (1, 9)

5. टपल्स की लिस्ट्स से क्या अडवांटेज हैं?

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

6. कब टपल और कब डिक्शनरी इस्तेमाल करें?

स्थिति डेटा स्ट्रक्चर उदाहरण
स्थिर डेटा जो बदलेगा नहीं टपल RGB कलर: (255, 0, 0)
की-वैल्यू पेयर डिक्शनरी स्टूडेंट मार्क्स: {"Rahul": 90}
फंक्शन से मल्टिपल वैल्यू रिटर्न टपल (x, y) कोऑर्डिनेट
कॉन्फ़िगरेशन सेटिंग्स डिक्शनरी {"theme": "dark", "lang": "hi"}

7. इम्यूटेबल डेटा टाइप्स में वैरिएबल रीबिल्ट होता है – उदाहरण:

x = 10
print(id(x))  # मेमोरी एड्रेस: 140234567890
x = x + 1
print(id(x))  # नया एड्रेस: 140234567906

यह दिखाता है कि x का पुराना ऑब्जेक्ट नहीं बदला, बल्कि नया ऑब्जेक्ट बन गया।

8. TypeError क्यों आता है और कैसे ठीक करें?

कारण:
अगर आप टपल या स्ट्रिंग जैसे इम्यूटेबल ऑब्जेक्ट को बदलने की कोशिश करेंगे, जैसे:

t = (1, 2, 3)
t[0] = 10  # TypeError

समाधान:
इम्यूटेबल ऑब्जेक्ट को बदलने के बजाय नया ऑब्जेक्ट बनाएं:

t = (10, 2, 3)

यदि आप चाहें तो मैं इसे PDF या नोट्स फॉर्मेट में भी तैयार कर सकता हूँ।

>>> tuple1 = (5)  #कथन 1
>>> len(tuple1)  #कथन 2

प्रोग्रामिंग समस्याएँ

1. n विद्यार्थियों की ईमेल आईडी पढ़कर उन्हें एक टपल में संग्रहित करने वाला प्रोग्राम लिखिए। दो नए टपल बनाइए, पहला टपल ईमेल आईडी से केवल उपयोगकर्ता-नाम संग्रहित करे और दूसरा टपल डोमेन नाम संग्रहित करे। प्रोग्राम के अंत में तीनों टपल प्रिंट कीजिए। [संकेत: आप split() फंक्शन का उपयोग कर सकते हैं]

2. n विद्यार्थियों के नाम इनपुट करके उन्हें एक टपल में संग्रहित करने वाला प्रोग्राम लिखिए। साथ ही उपयोगकर्ता से एक नाम इनपुट करें और जांचें कि वह विद्यार्थी टपल में मौजूद है या नहीं।

हम इसे निम्न तरीकों से पूरा कर सकते हैं:

(a) उपयोगकर्ता-परिभाषित फंक्शन लिखकर

(b) अंतर्निहित फंक्शन का उपयोग करके

3. एक डिक्शनरी में सबसे ऊँचे 2 मान खोजने के लिए एक Python प्रोग्राम लिखिए।

4. एक स्ट्रिंग से डिक्शनरी बनाने के लिए एक Python प्रोग्राम लिखिए।

नोट: स्ट्रिंग में अक्षरों की गिनती ट्रैक कीजिए।

नमूना स्ट्रिंग : ‘w3resource’

अपेक्षित आउटपुट: {‘3’: 1, ’s’: 1, ‘r’: 2, ‘u’: 1, ‘w’: 1, ‘c’: 1, ’e’: 2 , ‘o’: 1 }

5. अपने मित्रों के नाम और उनके फोन नंबर इनपुट करें और उन्हें कुंजी-मान युग्म के रूप में डिक्शनरी में संग्रहित करें। डिक्शनरी पर निम्नलिखित संचालन करें:

a) अपने सभी मित्रों के नाम और फोन नंबर प्रदर्शित करें

b) इस डिक्शनरी में एक नया कुंजी-मान युग्म जोड़ें और संशोधित डिक्शनरी प्रदर्शित करें

c) डिक्शनरी से एक विशेष मित्र को हटा दें

d) किसी मौजूदा मित्र का फोन नंबर संशोधित करें

e) जांचें कि कोई मित्र शब्दकोश में मौजूद है या नहीं

f) नामों के क्रमबद्ध क्रम में शब्दकोश को प्रदर्शित करें

केस स्टडी-आधारित प्रश्न

अध्याय 5 में दी गई SMIS प्रणाली के लिए, आइए निम्नलिखित करें:

एक कार्यक्रम लिखें जो कक्षा X के n विद्यार्थियों का रोल नंबर, नाम और अंकों का प्रतिशत ले। उपयोगकर्ता-परिभाषित फलन लिखें

  • n विद्यार्थियों के विवरण स्वीकार करने के लिए (n विद्यार्थियों की संख्या है)
  • रोल नंबर के आधार पर किसी विशेष विद्यार्थी का विवरण खोजने और परिणाम प्रदर्शित करने के लिए
  • सभी विद्यार्थियों का परिणाम प्रदर्शित करने के लिए
  • उनमें से टॉपर खोजने के लिए
  • उनमें से विषयवार टॉपर खोजने के लिए

(संकेत: शब्दकोश का प्रयोग करें, जहाँ कुंजी रोल नंबर हो सकता है और मान एक अपरिवर्तनीय डेटा प्रकार होगा जिसमें नाम और प्रतिशत हो)

आइए अध्याय 5 के अंत में “प्रलेखन युक्तियाँ” के तहत दिए गए मापदंडों के आधार पर अन्य लोगों की केस स्टडीज़ की सहकर्मी समीक्षा करें और उन्हें प्रतिक्रिया प्रदान करें।

केस स्टडी-आधारित प्रश्न

1. एक बैंक एक वित्तीय संस्था है जो पैसे उधार लेने और देने में शामिल होती है। तकनीक की प्रगति के साथ, ऑनलाइन बैंकिंग, जिसे इंटरनेट बैंकिंग भी कहा जाता है, बैंक के ग्राहकों को किसी भी समय, कहीं भी बैंक की वेबसाइट के माध्यम से वित्तीय लेनदेन की एक श्रृंखला संचालित करने की अनुमति देती है। प्रारंभिक जांच के हिस्से के रूप में आपको सुझाव दिया जाता है

  • एक बैंक का आवेदन फॉर्म इकट्ठा करें। फॉर्म की सावधानीपूर्वक जांच करने के बाद, बचत खाता खोलने के लिए आवश्यक जानकारी की पहचान करें। साथ ही बचत खाते पर दी जाने वाली ब्याज दर के बारे में पूछताछ करें।
  • खाते पर किए जाने वाले दो मूल संचालन जमा (Deposit) और निकासी (Withdrawal) हैं। एक मेनू-चालित प्रोग्राम लिखें जो जमा या निकासी में से किसी एक विकल्प को स्वीकार करता है, फिर राशि लेता है, लेन-देन करता है और तदनुसार शेष राशि प्रदर्शित करता है। याद रखें, हर बैंक में न्यूनतम शेष राशि की आवश्यकता होती है जिसे निकासी संचालन के दौरान ध्यान में रखना होता है। अपने बैंक में आवश्यक न्यूनतम शेष राशि के बारे में पूछताछ करें।
  • बचत बैंक खाते में विभिन्न स्लैब्स में निश्चित जमा (Fixed Deposit) खोलने के लिए ब्याज दरें इकट्ठा करें। याद रखें, वरिष्ठ नागरिकों के लिए दरें भिन्न हो सकती हैं।

अंत में, निम्नलिखित विकल्पों वाला एक मेनू-चालित प्रोग्राम लिखें (फ़ंक्शन और उपयुक्त डेटा प्रकारों का प्रयोग करें):

  • बचत बैंक खाता खोलें
  • धन जमा करें
  • धन निकालें
  • एक विशेष ग्राहक के लिए निश्चित जमा के लिए राशि और अवधि जैसे विवरण लें और उसकी परिपक्वता राशि प्रदर्शित करें।

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

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

3. हमारे विरासत स्मारक हमारी संपत्ति हैं। ये हमारे समृद्ध और गौरवशाली अतीत का प्रतिबिंब हैं और हमारे भविष्य के लिए प्रेरणा। यूनेस्को ने भारतीय विरासत स्थलों में से कुछ को विश्व विरासत स्थलों के रूप में चिन्हित किया है। इन स्थलों के बारे में निम्नलिखित जानकारी एकत्र करें:

  • स्थल का नाम क्या है?
  • यह कहाँ स्थित है?
  • ज़िला
  • राज्य
  • इसे कब बनाया गया था?
  • इसे किसने बनाया था?
  • इसे क्यों बनाया गया था?
  • वेबसाइट लिंक (यदि कोई हो)।

एक Python प्रोग्राम लिखें

  • एक प्रशासनिक उपयोगकर्ता आईडी और पासवर्ड बनाएं ताकि सूचीबद्ध विरासत स्थलों में कोई दर्ज किया गया स्थल जोड़ा, संशोधित या हटाया जा सके
  • भारत के विश्व धरोहर स्थलों की सूची प्रदर्शित करें
  • उपयोगकर्ता द्वारा दर्ज किए गए विश्व धरोहर स्थल की जानकारी खोजकर प्रदर्शित करें
  • उपयोगकर्ता द्वारा दर्ज राज्य के आधार पर विश्व धरोहर स्थल(ों) का नाम प्रदर्शित करें

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

पहचाने गए परिवहन साधन की आरक्षण आवश्यकताओं को स्वचालित करने के लिए पायथन कोड लिखें।

चित्र 1: रेलवे आरक्षण प्रणाली

CUET Preparation

CUET UG (About Exam)

CUET PG (About Exam)

Exam Pattern

CUET (UG)

CUET (PG)

International Students

Application Process

Eligibility

Exam Centres

Fees

Life In India

Middle East

Visa and Admission

NCERT Books

Class 11

Class 12

Important Resources

CUET Syllabus

Last 7 Days Preparation Strategy

Last 15 Days Preparation Strategy

Last 30 Days Preparation Strategy

Contact Us

Forum

Sathee Forum

icon  BETA

© 2014-2026 Copyright SATHEE

Privacy Policy

Powered by Prutor@IITK

sathee@iitk.ac.in
Media coverage of SATHEE
google

Play Store
apple

App Store
The Ministry of Education has launched the SATHEE initiative in association with IIT Kanpur to provide free guidance for competitive exams. SATHEE offers a range of resources, including reference video lectures, mock tests, and other resources to support your preparation. Please note that participation in the SATHEE program does not guarantee clearing any exam or admission to any institute.