“कंप्यूटर विज्ञान अमूर्तता का विज्ञान है - किसी समस्या के लिए सही मॉडल बनाना और उसे हल करने के लिए उपयुक्त यांत्रिक तकनीकें तैयार करना।”

– ए. अहो और जे. उलमैन

4.1 सूची का परिचय

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

उदाहरण 4.1

#list1 छह सम संख्याओं की सूची है
>>> list1 =[2,4,6,8,10,12]
>>> print(list1)
[2,4,6,8,10,12]

#list2 स्वरों की सूची है
>>> list2 = [‘a’,’e’,‘i’,‘o’,‘u’]
>>> print(list2)
[‘a’, ’e’, ‘i’, ‘o’, ‘u’]

#list3 मिश्रित डेटा प्रकारों की सूची है
>>> list3 = [100,23.5,‘Hello’]
>>> print(list3)
[100, 23.5, ‘Hello’]

#list4 सूचियों की सूची है जिसे नेस्टेड सूची कहा जाता है
#list
>>> list4 =[[‘Physics’,101],[‘Chemistry’,202],
[‘Mathematics’,303]]
>>> print(list4)_
[[‘Physics’, 101], [‘Chemistry’, 202],
[‘Mathematics’, 303]]

4.1.1 सूची में तत्वों तक पहुंचना

प्रत्येक तत्व सूची में एक मान जिसे इंडेक्स कहा जाता है, का उपयोग करके पहुँचा जाता है। पहला इंडेक्स मान 0 होता है, दूसरा इंडेक्स 1 होता है और इसी तरह आगे बढ़ता है। सूची में तत्वों को 0 से शुरू करते हुए बढ़ते क्रम में इंडेक्स मान दिए जाते हैं।

किसी तत्व तक पहुँचने के लिए, उस तत्व के इंडेक्स [] मान के साथ वर्ग कोष्ठक का उपयोग करें। हम अंतिम तत्व से शुरू करते हुए तत्वों तक पहुँचने के लिए ऋणात्मक इंडेक्स मान का भी उपयोग कर सकते हैं, जिसमें अंतिम तत्व का इंडेक्स मान -0 होता है।

#initialing a list named list1
>>> list1 = [2,4,6,8,10,12]
>>> list1[0] #returns first element of list1
2
>>> list1[3] #returns fourth element of list1
8
#Out of range index value for the list returns error
>>> list1[15]
IndexError: list index out of range
#an expression resulting in an integer index
>>> list1[1+4]
12
>>> list1[-1] #return first element from right
12
#length of the list1 is assigned to n
>>> n = len(list1)
>>> print(n)
6
#Get the last element of the list1_
>>> list1[n-1]
12
_#Get the first element of list1 _
>>> list1[-n]
2

4.1.2 सूचियाँ परिवर्तनीय होती हैं

Python में, सूचियाँ परिवर्तनीय होती हैं। इसका अर्थ है कि सूची के अंदर की सामग्री को बनाने के बाद बदला जा सकता है।

#List list1 of colors
>>> list1 = [‘Red’,‘Green’,‘Blue’,‘Orange’]
#change/override the fourth element of list1
>>> list1[3] = ‘Black’
>>> list1 #print the modified list list1
[‘Red’, ‘Green’, ‘Blue’, ‘Black’]

4.2 सूची संचालन

डेटा प्रकार सूची नीचे दिखाए गए विभिन्न संचालनों के माध्यम से अपनी सामग्री को हेरफेर करने की अनुमति देता है।

4.2.1 संयोजन

Python हमें + प्रतीक का उपयोग करके संयोजन ऑपरेटर का उपयोग करके दो या अधिक सूचियों को जोड़ने की अनुमति देता है।

संयोजन दो या अधिक मानों का विलय है। उदाहरण: हम स्ट्रिंग्स को एक साथ संयोजित कर सकते हैं।

#list1 पहले पाँच विषम पूर्णांकों की सूची है
>>> list1 = [1,3,5,7,9]
#list2 पहले पाँच सम पूर्णांकों की सूची है
>>> list2 = [2,4,6,8,10]
#list2 के बाद list1 के तत्व प्राप्त करें
>>> list1 + list2
[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
>>> list3 = [‘Red’,‘Green’,‘Blue’]
>>> list4 = [‘Cyan’, ‘Magenta’, ‘Yellow’
,‘Black’]
>>> list3 + list4
[‘Red’,‘Green’,‘Blue’,‘Cyan’,‘Magenta’,
‘Yellow’,‘Black’]

ध्यान दें कि मूल सूचियों में कोई बदलाव नहीं होता है, अर्थात् संयोजन संचालन के बाद list1, list2, list3, list4 वैसी ही रहती हैं। यदि हम दो संयोजित सूचियों के परिणाम का उपयोग करना चाहते हैं, तो हमें असाइनमेंट ऑपरेटर का उपयोग करना चाहिए।

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

#सूची 2 को सूची के अंत में जोड़ें
>>> new List = list 1 + list 2
[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

नई सूची संयोजन ऑपरेटर ‘+’ यह आवश्यक करता है कि ऑपरेंड केवल सूची प्रकार के हों। यदि हम किसी सूची को किसी अन्य डेटा प्रकार के तत्वों के साथ संयोजित करने का प्रयास करते हैं, तो TypeError आता है।

»> list1 = [1,2,3]
»> str1 = “abc”
»> list1 + str1
(TypeError: can only concatenate list (not “str”) to list)

4.2.2 पुनरावृत्ति

Python हमें * प्रतीक द्वारा दर्शाए गए पुनरावृत्ति ऑपरेटर का उपयोग करके सूची की सामग्री को दोहराने की अनुमति देता है।

»> list1 = [‘Hello’]
#list1 के तत्व 4 बार दोहराए गए
»> list1 * 4
[‘Hello’, ‘Hello’, ‘Hello’, ‘Hello’]

4.2.3 सदस्यता

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

»> list1 = [‘Red’,‘Green’,‘Blue’]
»> ‘Green’ in list1
True
»> ‘Cyan’ in list1
False

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

»> list1 = [‘Red’,‘Green’,‘Blue’]
»> ‘Cyan’ not in list1
True
»> ‘Green’ not in list1
False

4.2.4 स्लाइसिंग

स्लाइसिंग संचालन हमें किसी मौजूदा सूची से तत्वों को निकाल कर नई सूची बनाने की अनुमति देते हैं।

»> list1 =[‘Red’,‘Green’,‘Blue’,‘Cyan’,
‘Magenta’,‘Yellow’,‘Black’]
#list1 के सूचकांक 2 से 5 तक के तत्व
»> list1[2:6]
[‘Blue’, ‘Cyan’, ‘Magenta’, ‘Yellow’]

#list1 सूची के अंत तक छँटा हुआ है
>>> list1[2:20] #दूसरा सूचकांक सीमा से बाहर है
[‘Blue’, ‘Cyan’, ‘Magenta’, ‘Yellow’,‘Black’]

>>> list1[7:2] $\qquad \qquad \qquad $ #पहला सूचकांक दूसरे से बड़ा है
[] $\qquad \qquad \qquad $ #एक खाली सूची परिणामित होती है

#सूचकांक 0 से 4 तक उपसूची लौटाता है
>>> list1[:5] $\qquad \qquad $ #पहला सूचकांक गायब है
[‘Red’,‘Green’,‘Blue’,‘Cyan’,‘Magenta’]

#दी गई चरण-आकार के साथ स्लाइसिंग
>>> list1[0:6:2]
[‘Red’,‘Blue’,‘Magenta’]
#ऋणात्मक सूचकांक
#सूचकांक -6,-5,-4,-3 पर तत्व स्लाइस किए गए हैं
>>> list1[-6:-2]
[‘Green’,‘Blue’,‘Cyan’,‘Magenta’]

#पहला और अंतिम दोनों सूचकांक गायब हैं
>>> list1[::2] #पूरी सूची पर चरण-आकार 2
[‘Red’,‘Blue’,‘Magenta’,‘Black’]

#ऋणात्मक चरण-आकार का उपयोग करके सूची को उल्टे क्रम में पहुँचना
>>> list1[::-1]
[‘Black’,‘Yellow’,‘Magenta’,‘Cyan’,‘Blue’, ‘Green’,‘Red’]

4.3 एक सूची को पार करना

हम for लूप या while लूप का उपयोग करके सूची के प्रत्येक तत्व तक पहुँच सकते हैं या एक सूची को पार कर सकते हैं।

(A) for लूप का उपयोग करके सूची पार करना:

>>> list1 = [‘Red’,‘Green’,‘Blue’,‘Yellow’, ‘Black’]
>>> for item in list1:
print(item)

आउटपुट: print(item)

Red

Green

Blue

Yellow

Black

सूची के तत्वों तक पहुँचने का एक अन्य तरीका range() और len() फ़ंक्शनों का उपयोग करना है:

>>> for i in range(len(list1)):
print(list1[i])

आउटपुट:

Red

Green

Blue

पीला

काला

len (list1) list1 की लंबाई या कुल तत्वों की संख्या लौटाता है। range(n) 0 से शुरू होने वाली संख्याओं का एक क्रम लौटाता है, 1 से बढ़ता है और n-1 पर समाप्त होता है (निर्दिष्ट संख्या से एक कम)।

4.4 सूची विधियाँ और अंतर्निहित फ़ंक्शन

डेटा प्रकार सूची में कई अंतर्निहित विधियाँ होती हैं जो प्रोग्रामिंग में उपयोगी होती हैं। उनमें से कुछ तालिका 4.1 में सूचीबद्ध हैं।

तालिका 4.1 सूची हेरफेर के लिए अंतर्निहित फ़ंक्शन

4.5 सूची हेरफेर

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

प्रोग्राम 4-1 एक प्रोग्राम लिखें जो उपयोगकर्ता को एक मेनू में दी गई किसी भी सूची संचालन को करने की अनुमति दे। मेनू इस प्रकार है:

1. एक तत्व जोड़ें

2. एक तत्व सम्मिलित करें

3. दी गई सूची में एक सूची जोड़ें

4. एक मौजूदा तत्व संशोधित करें

5. अपनी स्थिति से एक मौजूदा तत्व हटाएं

6. एक दिए गए मान वाला मौजूदा तत्व हटाएं

7. सूची को आरोही क्रम में क्रमबद्ध करें

8. सूची को अवरोही क्रम में क्रमबद्ध करें

9. सूची प्रदर्शित करें।

#कार्यक्रम 4-1
#विभिन्न सूची संचालनों को करने के लिए मेनू-चालित कार्यक्रम
myList $=[22,4,16,38,13]$ #myList में 5 अवयव हैं
choice $=0$
For attempt in range (3): print (“प्रयास संख्या:”, attempt)
print(“सूची ‘myList’ में निम्नलिखित अवयव हैं”, myList)
print("\nसूची संचालन")
print(" 1. एक अवयव जोड़ें")
print(" 2. इच्छित स्थान पर एक अवयव डालें")
print(" 3 . दी गई सूची में एक सूची जोड़ें")
print(" 4. कोई मौजूदा अवयव संशोधित करें")
print(" 5 . स्थान देकर कोई मौजूदा अवयव हटाएँ")
print(" 6. मान देकर कोई मौजूदा अवयव हटाएँ")
print(" 7. सूची को आरोही क्रम में क्रमबद्ध करें")
print(" 8. सूची को अवरोही क्रम में क्रमबद्ध करें")
print(" 9. सूची प्रदर्शित करें")
choice = int(input(“अपनी पसंद दर्ज करें (1-9): “))

#अवयव जोड़ना
if choice == 1:
element = eval(input(“जोड़ने वाला अवयव दर्ज करें: “))
myList.append(element)
print(“अवयव जोड़ दिया गया है\n”)

#इच्छित स्थान पर अवयव डालना
elif choice == 2:
element = eval(input(“डालने वाला अवयव दर्ज करें: “))
pos = int(input(“स्थान दर्ज करें:”))
myList.insert(pos,element)
print(“अवयव डाल दिया गया है\n”)

#दी गई सूची में एक सूची जोड़ें
elif choice == 3:
newList = eval(input(“जोड़ने के लिए सूची दर्ज करें: “))
myList.extend(newList)
print(“सूची जोड़ दी गई है\n”)

#मौजूदा तत्व को संशोधित करें
elif choice == 4:
i = int(input(“संशोधित किए जाने वाले तत्व की स्थिति दर्ज करें: “))
if i < len(myList):
newElement = eval(input(“नया तत्व दर्ज करें: “))
oldElement = myList[i]
myList[i] = newElement
print(“तत्व”,oldElement,“को संशोधित कर दिया गया है\n”)
else:
print(“तत्व की स्थिति सूची की लंबाई से अधिक है”)

#स्थिति के अनुसार मौजूदा तत्व को हटाएं
elif choice == 5:
i = int(input(“हटाए जाने वाले तत्व की स्थिति दर्ज करें: “))
if i < len(myList):
element = myList.pop(i)
print(“तत्व”,element,“को हटा दिया गया है\n”)
else:
print("\nतत्व की स्थिति सूची की लंबाई से अधिक है”)

#मान के अनुसार मौजूदा तत्व को हटाएं
elif choice == 6:
element = int(input("\nहटाए जाने वाला तत्व दर्ज करें: “))
if element in myList:
myList.remove(element)
print("\nतत्व”,element,“को हटा दिया गया है\n”)
else:
print("\nतत्व”,element,“सूची में मौजूद नहीं है”)

#सूची को क्रमबद्ध क्रम में
elif choice == 7:
myList.sort()
print("\nसूची को क्रमबद्ध कर दिया गया है”)

#list in reverse sorted order
elif choice == 8:
myList.sort(reverse = True)
print("\nThe list has been sorted in reverse order”)

#display the list

#display the list
elif choice == 9:
print("\nThe list is:”, myList)
else:
print(“Choice is not valid”)

Output:

The list ‘myList’ has the following elements $[22,4,16,38,13]$ Attempt number : 1

L I S T 0 P E R A T I O N S

1. Append an element

2. Insert an element at the desired position

3. Append a list to the given list

4. Modify an existing element

5. Delete an existing element by its position

6. Delete an existing element by its value

7. Sort the list in ascending order

8. Sort the list in descending order

9. Display the list

ENTER YOUR CHOICE (1-10): 8

The list has been sorted in reverse order

The list ‘myList’ has the following elements $[38,22,16,13,4]$

Attempt number : 2

L I S T O P E R A T I O N S

1. Append an element

2. Insert an element at the desired position

3. Append a list to the given list

4. Modify an existing element

5. Delete an existing element by its position

6. Delete an existing element by its value

7. Sort the list in ascending order

8. Sort the list in descending order

9. Display the list

ENTER YOUR CHOICE (1-9) 5

Enter the position of the element to be deleted: 2

The element 16 has been deleted

सूची ‘myList’ में निम्नलिखित तत्व हैं $[38,22,13,4]$

प्रयास संख्या : 3

एल आई एस टी ओ पी ई आर ए ष ण ए स

1. एक तत्व जोड़ें

2. इच्छित स्थान पर एक तत्व डालें

3. दी गई सूची में एक सूची जोड़ें

4. मौजूदा तत्व को संशोधित करें

5. स्थान के आधार पर मौजूदा तत्व को हटाएं

6. मान के आधार पर मौजूदा तत्व को हटाएं

7. सूची को आरोही क्रम में सॉर्ट करें

8. सूची को अवरोही क्रम में सॉर्ट करें

9. सूची प्रदर्शित करें

अपनी पसंद दर्ज करें (1-9) 10

पसंद मान्य नहीं है

प्रोग्राम 4-2 एक प्रोग्राम जो n विद्यार्थियों के औसत अंक गणना करता है जहाँ n उपयोगकर्ता द्वारा दर्ज किया जाता है।

#प्रोग्राम 4-2
#एक खाली सूची बनाएं
list1 = []
print(“आप कितने विद्यार्थियों के अंक दर्ज करना चाहते हैं: “)
n = int(input())
for i in range(0,n):
print(“विद्यार्थी”,(i+1),“के अंक दर्ज करें:”)
marks = int(input())
#सूची में अंक जोड़ें
list1.append(marks)
#कुल प्रारंभ करें
total = 0
for marks in list1:

#अंकों को कुल में जोड़ें
total = total + marks
average = total / n
print(n,“विद्यार्थियों के औसत अंक हैं:",average)

आउटपुट:

आप कितने विद्यार्थियों के अंक दर्ज करना चाहते हैं:

5

विद्यार्थी 1 के अंक दर्ज करें:

45

विद्यार्थी 2 के अंक दर्ज करें:

89

विद्यार्थी 3 के अंक दर्ज करें:

79

विद्यार्थी 4 के अंक दर्ज करें:

76

विद्यार्थी 5 के अंक दर्ज करें:

55

5 विद्यार्थियों के औसत अंक हैं: 68.8

प्रोग्राम 4-3 एक प्रोग्राम लिखें जो यह जांचे कि कोई संख्या सूची में मौजूद है या नहीं। यदि संख्या मौजूद है, तो संख्या की स्थिति प्रिंट करें। यदि संख्या सूची में मौजूद नहीं है, तो उपयुक्त संदेश प्रिंट करें।

#प्रोग्राम 4-3
list1 = [] $\qquad \qquad\qquad$ #एक खाली सूची बनाएं
print(“आप सूची में कितनी संख्याएँ दर्ज करना चाहते हैं: “)
maximum = int(input())
print(“संख्याओं की एक सूची दर्ज करें: “)
for i in range(0,maximum):
n = int(input())
list1.append(n) $\qquad \qquad\qquad$ #संख्याओं को सूची में जोड़ें
num = int(input(“खोजी जाने वाली संख्या दर्ज करें: “))

position = -1
for i in range (0, len(list1)):
if list1[i] == num: $\qquad \qquad\qquad$ #संख्या मौजूद है
position = i+1 #संख्या की स्थिति सहेजें
if position == -1 :
print(“संख्या”,num,“सूची में मौजूद नहीं है”)
else:
print(“संख्या”,num,“स्थिति”,position + 1,“पर मौजूद है”)

आउटपुट:

आप सूची में कितनी संख्याएँ दर्ज करना चाहते हैं

5

संख्याओं की एक सूची दर्ज करें:

23

567

12

89

324

खोजी जाने वाली संख्या दर्ज करें:12

संख्या 12 स्थिति 3 पर मौजूद है

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

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

4.6.1 डिक्शनरी बनाना

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

उदाहरण 4.2

#dict1 एक खाली डिक्शनरी है
>>> dict1 = {}
>>> dict1
{}
#dict3 एक डिक्शनरी है जो छात्रों के नामों को
#प्रतिशत में अंकों से मैप करती है
>>> dict3 = {‘Mohan’:95,‘Ram’:89,‘Suhel’:92,
‘Sangeeta’:85}
>>> dict3
{‘Mohan’: 95, ‘Ram’: 89, ‘Suhel’: 92,
‘Sangeeta’: 85}

4.6.2 डिक्शनरी में आइटम्स तक पहुँचना

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

निम्न उदाहरण दिखाता है कि एक dictionary दिए गए key के अनुरूप value कैसे लौटाती है:

>>> dict3 = {‘Mohan’:95,‘Ram’:89,‘Suhel’:92,
‘Sangeeta’:85}
>>> dict3[‘Ram’]
89
>>> dict3[‘Sangeeta’]
85
#using unspecified key
>>> dict3[‘Shyam’]
KeyError: ‘Shyam’

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

4.6.3 Membership Operation

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

>>> dict1 = {‘Mohan’:95,‘Ram’:89,‘Suhel’:92,
‘Sangeeta’:85}
>>> ‘Suhel’ in dict1
True

not in operator True लौटाता है यदि key dictionary में मौजूद नहीं है, अन्यथा False लौटाता है।

>>> dict1 = {‘Mohan’:95,‘Ram’:89,‘Suhel’:92,
‘Sangeeta’:85}
>>> ‘Suhel’ not in dict1
False

4.6.4 Dictionaries are Mutable

Dictionaries mutable होती हैं जिसका अर्थ है कि dictionary की सामग्री को बनाने के बाद बदला जा सकता है।

(A) Adding a new item

हम dictionary में एक नया item इस प्रकार जोड़ सकते हैं:

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

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

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

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

4.7 डिक्शनरी को ट्रैवर्स करना

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

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

विधि 1:

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

विधि 2:

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

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

पायथन डिक्शनरीज़ पर काम करने के लिए कई फंक्शन्स प्रदान करता है। तालिका 4.2 कुछ सामान्यतः प्रयुक्त डिक्शनरी मेथड्स की सूची देती है।

तालिका 4.2 डिक्शनरी के लिए बिल्ट-इन फंक्शन्स और मेथड्स

4.9 शब्दकोशों को संचालित करना

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

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

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

(b) शब्दकोश ‘ODD’ में कुंजियाँ प्रदर्शित करें।

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

(c) शब्दकोश ‘ODD’ में मान प्रदर्शित करें।

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

(d) शब्दकोश ‘ODD’ से आइटम प्रदर्शित करें

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

(e) शब्दकोश ‘ODD’ की लंबाई ज्ञात करें।

>>> len(ODD)
5

(f) जाँचें कि 7 शब्दकोश ‘ODD’ में है या नहीं

>>> 7 in ODD
True

(g) जाँचें कि 2 शब्दकोश ‘ODD’ में है या नहीं » 2 in ODD

>>> 2 in ODD
False

(h) कुंजी 9 के संगत मान प्राप्त करें

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

(i) कुंजी 9 के संगत आइटम को शब्दकोश से हटाएँ। ‘ODD’

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

प्रोग्राम 4-4 $\sigma$ n संख्या में एक प्रोग्राम लिखें जो कर्मचारियों के नाम और उनके वेतन को इनपुट के रूप में दर्ज करे और उन्हें एक डिक्शनरी में संग्रहित करे। यहाँ $\mathrm{n}$ उपयोगकर्ता द्वारा इनपुट किया जाना है।

#प्रोग्राम 4-4
#एक डिक्शनरी बनाने के लिए प्रोग्राम जो कर्मचारियों के नाम संग्रहित करता है
#और उनका वेतन
num = int(input(“Enter the number of employees whose data to be stored: “))
count = 1
employee = dict() $\qquad \qquad \qquad$ #एक खाली डिक्शनरी बनाएं
for count in range (n):
$\qquad$ name = input(“Enter the name of the Employee: “)
$\qquad$ salary = int(input(“Enter the salary: “))
$\qquad$ employee[name] = salary
print("\n\nEMPLOYEE_NAME\tSALARY”)
for k in employee:
$\qquad$ 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 SALARY

‘Tarun’ $\qquad$ 12000

‘Amina’ $\qquad$ 34000

‘Joseph’ $\qquad$ 24000

‘Rahul’ $\qquad$ 30000

‘Zoya’$\qquad$ 25000

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

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

for key in dic:
$\qquad$ print(key,’:’,dic[key])

आउटपुट:

एक स्ट्रिंग दर्ज करें: Helloworld

H : 1

e : 1

l : 3

o : 2

W : 1

r : 1

d : 1

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

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

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

$\quad$ $\quad$ result = result + ’ ’ + value
print(“संख्या है:",num)
print(“संख्या का नाम है:",result)

आउटपुट:

कोई भी संख्या दर्ज करें: 6512

संख्या है: 6512

संख्या का नाम है: छह पाँच एक दो

सारांश

• सूचियाँ Python में परिवर्तनीय क्रम होती हैं, अर्थात हम सूची के तत्वों को बदल सकते हैं।
• सूची के तत्व वर्गाकार कोष्ठकों में अल्पविराम से अलग-अलग रखे जाते हैं।
• सूची अनुक्रमण सूची के समान है और 0 से प्रारंभ होता है। दो-तरफ़ा अनुक्रमण सूची को आगे और पीछे दोनों दिशाओं में पार करने की अनुमति देता है।
• ऑपरेटर + एक सूची को दूसरी सूची के अंत से जोड़ता है।
• ऑपरेटर * सूची की सामग्री को निर्धारित बार दोहराता है।
• सदस्यता ऑपरेटर in बताता है कि कोई तत्व सूची में है या नहीं और not in इसका विपरीत करता है।
• स्लाइसिंग सूची के एक भाग को निकालने के लिए प्रयोग होता है।
• कई सूची हेरफेर विधियाँ हैं। कुछ हैं: len(), list(), append(), extend(), insert(), count(), find(), remove(), pop(), reverse(), sort(), sorted(), $\min (), \max (), \operatorname{sum}()$।
• शब्दकोश एक मैपिंग (गैर-अदिश) डेटा प्रकार है। यह कुंजी-मान युगल का अक्रमित संग्रह है; कुंजी-मान युगल घुंघराले कोष्ठकों में रखे जाते हैं।
• प्रत्येक कुंजी अपने मान से दो बिंदुओं (:) से अलग होती है।
• कुंजियाँ अद्वितीय होती हैं और सूचकांक का काम करती हैं।
• कुंजियाँ अपरिवर्तनीय प्रकार की होती हैं पर मान परिवर्तनीय हो सकते हैं।

अभ्यास

1. निम्नलिखित कथनों का आउटपुट क्या होगा?

a) list1 = [12,32,65,26,80,10]
$\quad$ list1.sort()
$\quad$ print(list1)

b) list1 = [12,32,65,26,80,10]
$\quad$ sorted(list1)
$\quad$ print(list1)

c) list1 = [1,2,3,4,5,6,7,8,9,10]
$\quad$ list1[::-2]
$\quad$ list1[:3] + list1[3:]

d) list1 = [1,2,3,4,5]
$\quad$ list1[len(list1)-1]

2. निम्नलिखित सूची myList पर विचार करें। निम्नलिखित प्रत्येक संचालन के बाद myList के तत्व क्या होंगे?

myList =[10,20,30,40]

a) myList.append ([50,60])

b) myList.extend( [80,90])

3. निम्नलिखित कोड खंड की आउटपुट क्या होगी?

myList = [1,2,3,4,5,6,7,8,9,10]
for i in range(0,len(myList)):
$\quad$if i%2 == 0:
$\quad\quad$ print(myList[i])

4. निम्नलिखित कोड खंड की आउटपुट क्या होगी?

a) myList = [1,2,3,4,5,6,7,8,9,10]
$\quad$ del myList[3:]
$\quad$ print(myList)

b) myList = [1,2,3,4,5,6,7,8,9,10]
$\quad$ del myList[:5]
$\quad$ print(myList)

c) myList = [1,2,3,4,5,6,7,8,9,10]
$\quad$ del myList[::2]
$\quad$ print(myList)

del myList[::2] print (myList)

5. सूची की append() और extend() विधियों के बीच अंतर बताएं।

6. एक सूची पर विचार करें:

list1 = [6,7,8,9]

list1 पर निम्नलिखित संचालनों के बीच क्या अंतर है:

a) list1 * 2

b) list1 *=2

c) list1 = list 1 * 2

7. एक छात्र का रिकॉर्ड (नाम, रोल नंबर, पाँच विषयों में अंक और प्रतिशत) निम्नलिखित सूची में संग्रहीत है:

stRecord = [’ ‘Raman’ ,‘A-36’, [56,98,99,72,69], 78.8]

सूची stRecord से निम्नलिखित जानकारी पुनः प्राप्त करने के लिए Python कथन लिखें।

a) छात्र का प्रतिशत

b) पाँचवें विषय में अंक

c) छात्र के अधिकतम अंक

d) छात्र का रोल नंबर

e) छात्र का नाम ‘Raman’ से ‘Raghav’ बदलें

8. निम्नलिखित शब्दकोश stateCapital पर विचार करें:

stateCapital = {“Assam”:“Guwahati”, “Bihar”:“Patna”,“Maharashtra”:“Mumbai”, “Rajasthan”:“Jaipur”}

निम्नलिखित कथनों का आउटपुट ज्ञात करें:

a) print(stateCapital.get(“Bihar”))

b) print (statecapital.keys())

c) print (statecapital.values())

d) print(statecapital.items())

e) print(len(stateCapital))

f) print(“Maharashtra” in stateCapital)

g) print(stateCapital.get(“Assam”))

h) del stateCapital[“Assam”] print(stateCapital)

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

1. एक प्रोग्राम लिखें जो किसी सूची में एक तत्व कितनी बार आता है, उसकी गिनती करे।

2. एक प्रोग्राम लिखें जो $n$ पूर्णांकों (धनात्मक और ऋणात्मक दोनों) की सूची पढ़े। दो नई सूचियाँ बनाएँ, एक में सभी धनात्मक संख्याएँ और दूसरी में सभी ऋणात्मक संख्याएँ हों। तीनों सूचियाँ प्रिंट करें।

3. एक प्रोग्राम लिखें जो दी गई सूची के तत्वों में सबसे बड़ा और दूसरा सबसे बड़ा तत्व खोजे।

4. एक प्रोग्राम लिखें जो $n$ पूर्णांकों की सूची पढ़े और उनका माध्यक (median) ज्ञात करे।

नोट: मानों की सूची का माध्यक वह मध्य मान होता है जब उन्हें क्रम में व्यवस्थित किया जाता है। यदि दो मध्य मान हों तो उनका औसत लें।

संकेत: सूची को क्रमबद्ध करने के लिए एक अंतर्निहित फ़ंक्शन का प्रयोग करें।

5. एक प्रोग्राम लिखें जो तत्वों की सूची पढ़े। इस सूची को इस प्रकार संशोधित करें कि उसमें कोई दोहराव वाले तत्व न हों, अर्थात् सूची में कई बार आने वाले सभी तत्व केवल एक बार दिखाई दें।

6. एक कार्यक्रम लिखें तत्वों की एक सूची बनाने के लिए। उपयोगकर्ता से एक तत्व इनपुट करें जिसे सूची में डालना है। साथ ही वह स्थान भी इनपुट करें जिस पर उसे डालना है।

7. एक कार्यक्रम लिखें किसी सूची के तत्व पढ़ने के लिए और निम्नलिखित करें।

a) कार्यक्रम सूची से हटाए जाने वाले तत्व का स्थान पूछे और सूची में वांछित स्थान पर मौजूद तत्व को हटा दे।

b) कार्यक्रम सूची से हटाए जाने वाले तत्व का मान पूछे और सूची से इस मान को हटा दे।

8. एक Python कार्यक्रम लिखें किसी शब्दकोश में सबसे ऊँचे 2 मान खोजने के लिए।

9. एक Python कार्यक्रम लिखें स्ट्रिंग ‘w3resource’ से एक शब्दकोश बनाने के लिए इस प्रकार कि प्रत्येक व्यक्तिगत अक्षर एक कुंजी बनता है और उसकी पहली बार प्रकट होने की सूचकांक मान संगत मान बनता है शब्दकोश में।

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

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

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

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

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

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

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

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

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

1. एक कार्यक्रम लिखें जो कक्षा X के n विद्यार्थियों का रोल नंबर, नाम और प्रतिशत अंक ले और निम्नलिखित कार्य करे:

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

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

केस स्टडी

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

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

अपने बैंक में आवश्यक न्यूनतम शेष राशि की जानकारी प्राप्त करें।

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

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

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

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

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

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

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

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

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