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

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

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 होता है।

#list1 नामक एक सूची को प्रारंभ करना
>>> list1 = [2,4,6,8,10,12]
>>> list1[0] #list1 का पहला तत्व लौटाता है
2
>>> list1[3] #list1 का चौथा तत्व लौटाता है
8
#सूची के लिए सीमा से बाहर इंडेक्स मान त्रुटि लौटाता है
>>> list1[15]
IndexError: list index out of range
#एक पूर्णांक इंडेक्स परिणाम देने वाला व्यंजक
>>> list1[1+4]
12
>>> list1[-1] #दाईं ओर से पहला तत्व लौटाता है
12
#list1 की लंबाई n को सौंपी गई है
>>> n = len(list1)
>>> print(n)
6
#list1 का अंतिम तत्व प्राप्त करें_
>>> list1[n-1]
12
#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 इसका उल्टा करता है: यदि तत्व सूची में मौजूद नहीं है तो 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]          #पहला इंडेक्स दूसरे से बड़ा है
[]                      #परिणाम एक खाली सूची है

#इंडेक्स 0 से 4 तक उपसूची लौटाता है

>>> list1[:5]           #पहला इंडेक्स गायब है
['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)

आउटपुट:

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

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

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

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

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

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

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

6. एक मौजूदा तत्व को उसके मान से हटाएं

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

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

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

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

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

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

#Program 4-2
#create an empty list
list1 = []
print(“How many students marks you want to enter: “)
n = int(input())
for i in range(0,n):
print(“Enter marks of student”,(i+1),”:”)
marks = int(input())
#append marks in the list
list1.append(marks)
#initialize total
total = 0
for marks in list1:

#add marks to total
total = total + marks
average = total / n
print(“Average marks of”,n,“students is:",average)

आउटपुट:

How many students marks you want to enter:

5

Enter marks of student 1:

45

Enter marks of student 2:

89

Enter marks of student 3:

79

Enter marks of student 4:

76

Enter marks of student 5:

55

Average marks of 5 students is: 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 n संख्या में कर्मचारियों के नाम और उनके वेतन को इनपुट के रूप में दर्ज करने और उन्हें एक डिक्शनरी में संग्रहीत करने के लिए एक प्रोग्राम लिखें। यहाँ n उपयोगकर्ता द्वारा इनपुट किया जाना है।

#प्रोग्राम 4-4
#एक डिक्शनरी बनाने के लिए प्रोग्राम जो कर्मचारियों के नाम संग्रहीत करता है
#और उनका वेतन
num = int(input(“उन कर्मचारियों की संख्या दर्ज करें जिनका डेटा संग्रहीत करना है: “))
count = 1
employee = dict() $\qquad \qquad \qquad$ #एक खाली डिक्शनरी बनाएं
for count in range (n):
$\qquad$ name = input(“कर्मचारी का नाम दर्ज करें: “)
$\qquad$ salary = int(input(“वेतन दर्ज करें: “))
$\qquad$ employee[name] = salary
print("\n\nकर्मचारी_नाम\tवेतन”)
for k in employee:
$\qquad$ print(k,’\t\t’,employee[k])

आउटपुट:

उन कर्मचारियों की संख्या दर्ज करें जिनका डेटा संग्रहीत करना है: 5

कर्मचारी का नाम दर्ज करें: ‘तरुण’

वेतन दर्ज करें: 12000

कर्मचारी का नाम दर्ज करें: ‘अमीना’

वेतन दर्ज करें: 34000

कर्मचारी का नाम दर्ज करें: ‘जोसेफ’

वेतन दर्ज करें: 24000

कर्मचारी का नाम दर्ज करें: ‘राहुल’

वेतन दर्ज करें: 30000

कर्मचारी का नाम दर्ज करें: ‘ज़ोया’

वेतन दर्ज करें: 25000

कर्मचारी_नाम वेतन

‘तरुण’ $\qquad$ 12000

‘अमीना’ $\qquad$ 34000

‘जोसेफ’ $\qquad$ 24000

‘राहुल’ $\qquad$ 30000

‘ज़ोया’$\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

अनुवाद (हिन्दी):

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

सारांश

• सूचियाँ (Lists) Python में परिवर्तनशील क्रमबद्ध संग्रह होती हैं, अर्थात् हम सूची के तत्वों को बदल सकते हैं।
• सूची के तत्व वर्गाकार कोष्ठकों (square brackets) में अल्पविराम से अलग-अलग रखे जाते हैं।
• सूची की अनुक्रमण (indexing) 0 से प्रारंभ होती है और दो-दिशीय अनुक्रमण (two-way indexing) हमें सूची को आगे तथा पीछे दोनों दिशाओं में पार करने देता है।
• ऑपरेटर + एक सूची को दूसरी सूची के अंत से जोड़ता है।
• ऑपरेटर * सूची की सामग्री को निर्धारित बार दोहराता है।
• सदस्यता ऑपरेटर in बताता है कि कोई तत्व सूची में है या नहीं, और not in इसका विपरीत करता है।
• स्लाइसिंग (Slicing) सूची के किसी भाग को निकालने के लिए प्रयोग होता है।
• सूची पर कई विधियाँ (methods) काम करती हैं; कुछ प्रमुख हैं: len(), list(), append(), extend(), insert(), count(), find(), remove(), pop(), reverse(), sort(), sorted(), min(), max(), sum()।
• शब्दकोश (Dictionary) एक मानचित्रण (mapping) डेटा-प्रकार है; यह क्रमरहित कुंजी-मान (key-value) जोड़ों का संग्रह है, जो घुंघराले कोष्ठकों (curly braces) में रखे जाते हैं।
• प्रत्येक कुंजी अपने मान से कोलन (:) द्वारा अलग की जाती है।
• कुंजियाँ अद्वितीय (unique) होती हैं और सूचकांक (index) का कार्य करती हैं।
• कुंजियाँ अपरिवर्तनीय (immutable) प्रकार की होती हैं, पर मान परिवर्तनीय (mutable) हो सकते हैं।

अभ्यास

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

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

उत्तर: [10, 12, 26, 32, 65, 80]

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

उत्तर: [12, 32, 65, 26, 80, 10]
(क्योंकि sorted() नई सूची लौटाता है, पर मूल list1 नहीं बदलता)

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

उत्तर:
list1[::-2] → [10, 8, 6, 4, 2]
list1[:3] + list1[3:] → [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

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 प्रोग्राम लिखें:

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