SATHEE CUET: Chapter 09 Lists

Chapter 09 Lists

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

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

“कोड की पंक्तियों से प्रोग्रामिंग प्रगति को मापना विमान निर्माण की प्रगति को वजन से मापने जैसा है।”

$\quad$ -बिल गेट्स

उदाहरण 9.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 सूचियों की सूची है जिसे नेस्टेड
#सूची कहा जाता है
>>> list4 =[[‘Physics’,101],[‘Chemistry’,202],[‘Maths’,303]]
>>> print(list4)
[[‘Physics’, 101], [‘Chemistry’, 202],
[‘Maths’, 303]]

9.1.1 सूची में तत्वों तक पहुंच

सूची के तत्वों तक उसी तरह पहुंचा जाता है जैसे स्ट्रिंग में वर्णों तक पहुंचा जाता है।

#एक सूची को प्रारंभ करता है list1
>>> list1 = [2,4,6,8,10,12]
>>> list1[0] $\hspace{1cm}$ #list1 का पहला अवयव लौटाता है
2
>>> list1[3] $\hspace{1cm}$ #list1 का चौथा अवयव लौटाता है
8
#इंडेक्स सीमा से बाहर होने पर त्रुटि लौटाता है
>>> list1[15]
IndexError: list index out of range
#एक पूर्णांक इंडेक्स देने वाला व्यंजक
>>> list1[1+4]
12
>>> list1[-1] $\hspace{1cm}$ #दाएँ से पहला अवयव लौटाता है
12
#सूची list1 की लंबाई n में सौंपी गई है
>>> n = len(list1)
>>> print(n)
6
#सूची list1 का अंतिम अवयव लौटाता है
>>> list1[n-1]
12
#सूची list1 का पहला अवयव लौटाता है
>>> list1[-n]
2

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

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

#रंगों की सूची list1
>>> list1 = [‘Red’,‘Green’,‘Blue’,‘Orange’]
#list1 के चौथे अवयव को बदलें/अधिलेखित करें
>>> list1[3] = ‘Black’
>>> list1 $\hspace{1cm}$ #संशोधित सूची list1 को प्रिंट करें
[‘Red’, ‘Green’, ‘Blue’, ‘Black’]

9.2 सूची संचालन

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

9.2.1 संयोजन

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

#list1 पहले पाँच विषम पूर्णांकों की सूची है
>>> list1 = [1,3,5,7,9]
#list2 पहले पाँच सम पूर्णांकों की सूची है
>>> list2 = [2,4,6,8,10]
#list1 के तत्वों के बाद list2 के तत्व
>>> 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 वैसी की वैसी रहती हैं। यदि हम दो सूचियों को मिलाना चाहते हैं, तो हमें एक असाइनमेंट स्टेटमेंट का प्रयोग करके मिली हुई सूची को किसी अन्य सूची में असाइन करना चाहिए। संयोजन ऑपरेटर ‘+’ यह आवश्यक करता है कि ऑपरेंड केवल सूची प्रकार के हों। यदि हम किसी सूची को किसी अन्य डेटा प्रकार के तत्वों के साथ संयोजित करने का प्रयास करते हैं, तो TypeError आता है।

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

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

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

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

9.2.3 सदस्यता

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

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

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

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

9.2.4 स्लाइसिंग

स्ट्रिंग्स की तरह, स्लाइसिंग ऑपरेशन को सूचियों पर भी लागू किया जा सकता है।

>>> list1 =[‘Red’,‘Green’,‘Blue’,‘Cyan’,‘Magenta’,‘Yellow’,‘Black’]
>>> list1[2:6]
[‘Blue’, ‘Cyan’, ‘Magenta’, ‘Yellow’]

#list1 को सूची के अंत तक छोटा किया गया है
>>> list1[2:20] $\qquad$ #दूसरा इंडेक्स सीमा से बाहर है
[‘Blue’, ‘Cyan’, ‘Magenta’, ‘Yellow’, ‘Black’]

>>> list1[7:2] $\hspace{1.5cm}$ #पहला इंडेक्स > दूसरा इंडेक्स
[] $\hspace{3cm}$ #एक खाली सूची परिणामस्वरूप

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

#दिए गए स्टेप साइज़ के साथ स्लाइसिंग
>>> list1[0:6:2]
[‘Red’,‘Blue’,‘Magenta’]

#नकारात्मक इंडेक्स
#index -6,-5,-4,-3 पर तत्वों को स्लाइस किया गया है
>>> list1[-6:-2]
[‘Green’,‘Blue’,‘Cyan’,‘Magenta’]

#पहला और आखिरी दोनों इंडेक्स गायब हैं
>>> list1[::2] $\qquad$ #पूरी सूची पर स्टेप साइज़ 2
[‘Red’,‘Blue’,‘Magenta’,‘Black’]

#नकारात्मक स्टेप साइज़
#पूरी सूची उल्टे क्रम में
>>> list1[::-1]
[‘Black’,‘Yellow’,‘Magenta’,‘Cyan’,‘Blue’,‘Green’,‘Red’]

9.3 सूची का ट्रैवर्सल

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

(A) for लूप का उपयोग करके सूची ट्रैवर्सल:

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

आउटपुट:

Red
Green
Blue
Yellow
Black

len(list1) सूची 1 की लंबाई या कुल तत्वों की संख्या लौटाता है।

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

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

आउटपुट:

Red
Green
Blue
Yellow
Black

(B) while लूप का उपयोग करके सूची ट्रैवर्सल:

>>> list1 = [‘Red’,‘Green’,‘Blue’,‘Yellow’,‘Black’]
>>> i = 0
>>> while i < len(list1):
$\qquad$ print(list1[i])
$\qquad$ i += 1

आउटपुट:

Red
Green
Blue
Yellow
Black

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

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

$\hspace{3cm}$ तालिका 9.1 सूची हेरफेर के लिए अंतर्निहित फ़ंक्शन

विधि	विवरण	उदाहरण
len()	तर्क के रूप में पास की गई सूची की लंबाई लौटाता है	>>> list1 = [10, 20, 30, 40, 50] >>> len (list1) 5
list()	यदि कोई तर्क नहीं दिया गया है तो एक खाली सूची बनाता है यदि एक अनुक्रम तर्क के रूप में पास किया गया है तो एक सूची बनाता है	>>> list1 = list ( ) >>> list1 [] >>> str1 = ‘aeiou’ >>> list1 = list(str1) >>> list1 [‘a’, ’e’, ‘i’, ‘o’, ‘u’]
append()	तर्क के रूप में पास किए गए एकल तत्व को सूची के अंत में जोड़ता है एकल तत्व एक सूची भी हो सकती है	>>> list1 $=[10,20,30,40]$ >>> list1.append $(50)$ >>> list1 $[10,20,30,40,50]$ >>> list1 $=[10,20,30,40]$ >>> list1.append $([50,60])$ >>> list1 $[10,20,30,40,[50,60]]$
extend()	तर्क के रूप में पास की गई सूची के प्रत्येक तत्व को दी गई सूची के अंत में जोड़ता है	>>> list1 $=[10,20,30]$ >>> list2 $=[40,50]$ >>> list1.extend $(1$ ist2 $)$ >>> list1 $[10,20,30,40,50]$
insert()	सूची में एक विशेष सूचकांक पर एक तत्व डालता है	>>> list1 $=[10,20,30,40,50]$ >>> list1.insert $(2,25)$ >>> list1 $[10,20,25,30,40,50]$ >>> list1.insert $(0,5)$ >>> list1 $[5,10,20,25,30,40,50]$
count()	दी गई सूची में किसी तत्व के आने की संख्या लौटाता है	>>> list1 $=[10,20,30,10,40,10]$ >>> list1.count $(10)$ 3 $>>>$ list1. count $(90)$ 0
index()	सूची में तत्व की पहली उपस्थिति का सूचकांक लौटाता है। यदि तत्व मौजूद नहीं है, तो ValueError उत्पन्न होता है	>>> list1 $=[10,20,30,20,40,10]$ >>> list1.index $(20)$ 1 >>> list1.index $(90)$ ValueError: 90 is not in list
remove()	सूची से दिया गया तत्व हटाता है। यदि तत्व कई बार मौजूद है, तो केवल पहली उपस्थिति हटाई जाती है। यदि तत्व मौजूद नहीं है, तो ValueError उत्पन्न होता है	>>> list1 $=[10,20,30,40,50,30]$ >>> list1.remove $(30)$ >>> list1 $[10,20,40,50,30]$ >>> list1.remove $(90)$ ValueError:list.remove $(x): x$ not in list
pop()	उस तत्व को लौटाता है जिसका सूचकांक इस फ़ंक्शन को पैरामीटर के रूप में पास किया गया है और उसे सूची से भी हटाता है। यदि कोई पैरामीटर नहीं दिया गया है, तो यह सूची के अंतिम तत्व को लौटाता और हटाता है	>>> list1 $=[10,20,30,40,50,60]$ >>> list1. $\operatorname{pop}(3)$ 40 >>> list1 $[10,20,30,50,60]$ >>> list1 $=[10,20,30,40,50,60]$ >>> list1. $\operatorname{pop}()$ 60 >>> list1 $[10,20,30,40,50]$
reverse()	दी गई सूची में तत्वों के क्रम को उलट देता है	>>> list1 $=[34,66,12,89,28,99]$ >>> list1.reverse() >>> list1 $[99,28,89,12,66,34]$ >>> list1 = [ ‘Tiger’,‘Zebra’ ’ ‘Lion’, ‘Cat’,‘Elephant’ ,‘Dog’] >>> list1.reverse() >>> list1 ‘Elephant’, ‘Cat’, ‘Lion’,’ ‘Zebra’
sort()	दी गई सूची के तत्वों को स्थान पर ही क्रमबद्ध करता है	>>>list1=[‘Tiger’,‘Zebra’, ‘Lion’, ‘Cat’, ‘Elephant’,’ ‘Dog’] >>> list1.sort() >>> list1 [‘Cat’, ‘Dog’, ‘Elephant’, ‘Lion’, ‘Tiger’, ‘Zebra’] >>> list1 = $[34,66,12,89,28,99]$ >>> list1.sort(reverse = True) >>> list1 $[99,89,66,34,28,12]$
sorted()	यह एक सूची को पैरामीटर के रूप में लेता है और एक नई सूची बनाता है जिसमें वही तत्व क्रमबद्ध क्रम में होते हैं	>>> list1 $=[23,45,11,67,85,56]$ >>> list2 $=$ sorted $($ list1) >>> list1 $[23,45,11,67,85,56]$ >>> list2 $[11,23,45,56,67,85]$
$\max ()$ $\operatorname{sum}()$	सूची का न्यूनतम या सबसे छोटा तत्व लौटाता है सूची का अधिकतम या सबसे बड़ा तत्व लौटाता है सूची के तत्वों का योग लौटाता है	>>> $\operatorname{list1}=[34,12,63,39,92,44]$ >>> $\min (1$ ist1 $)$ 12 >>> $\max (1$ ist1) 92 >>> $\operatorname{sum}($ list 1$)$ 284

9.5 नेस्टेड लिस्ट्स

जब एक लिस्ट दूसरी लिस्ट के एक एलिमेंट के रूप में आती है, तो उसे नेस्टेड लिस्ट कहा जाता है।

उदाहरण 9.2

>>> list1 = [1,2,‘a’,‘c’,[6,7,8],4,9]
#लिस्ट का पाँचवाँ एलिमेंट भी एक लिस्ट है
>>> list1[4]
[6, 7, 8]

list1 की नेस्टेड लिस्ट के एलिमेंट तक पहुँचने के लिए हमें दो इंडेक्स list1[i][j] देने होते हैं। पहला इंडेक्स $i$ हमें वांछित नेस्टेड लिस्ट तक ले जाता है और दूसरा इंडेक्स j हमें उस नेस्टेड लिस्ट के भीतर वांछित एलिमेंट तक ले जाता है।

>>> list1[4][1]
7
#इंडेक्स i list1 का पाँचवाँ एलिमेंट देता है
#जो एक लिस्ट है
#इंडेक्स j नेस्टेड लिस्ट में दूसरा एलिमेंट देता है

9.6 लिस्ट्स की कॉपी करना

एक लिस्ट दी गई हो, तो लिस्ट की कॉपी बनाने का सबसे सरल तरीका है उसे दूसरी लिस्ट में असाइन करना।

>>> list1 = [1,2,3]
>>> list2 = list1
>>> list1
[1, 2, 3]
>>> list2
[1, 2, 3]

स्टेटमेंट list2 = list1 एक नई लिस्ट नहीं बनाती। बल्कि, यह सिर्फ list1 और list2 को एक ही लिस्ट ऑब्जेक्ट की ओर इशारा कराती है। यहाँ list2 वास्तव में list1 का उपनाम बन जाती है। इसलिए, इनमें से किसी एक में किया गया कोई भी बदलाव दूसरी लिस्ट में भी दिखाई देगा।

>>> list1.append(10)
>>> list1
[1, 2, 3, 10]
>>> list2
[1, 2, 3, 10]

हम एक लिस्ट की कॉपी या क्लोन को एक अलग ऑब्जेक्ट के रूप में तीन तरीकों से भी बना सकते हैं। पहला तरीका स्लाइसिंग का उपयोग करता है, दूसरा तरीका बिल्ट-इन फंक्शन list() का उपयोग करता है और तीसरा तरीका python लाइब्रेरी copy के copy() फंक्शन का उपयोग करता है।

तरीका 1

हम अपनी मूल सूची को स्लाइस कर सकते हैं और इसे एक नए चर में इस प्रकार संग्रहित कर सकते हैं:

newList = oldList[:]

उदाहरण 9.3

>>> list1 = [1,2,3,4,5]
>>> list2 = list1[:]
>>> list2
[1, 2, 3, 4, 5]

विधि 2

हम निर्मित फ़ंक्शन list() का इस प्रकार उपयोग कर सकते हैं:

newList = list(oldList)

उदाहरण 9.4

>>> list1 = [10,20,30,40]
>>> list2 = list(list1)
>>> list2
[10, 20, 30, 40]

विधि 3

हम copy() फ़ंक्शन का इस प्रकार उपयोग कर सकते हैं:

import copy $\hspace{1cm}$ #import the library copy
#use copy()function of library copy
newList = copy.copy(oldList)

उदाहरण 9.5

>>> import copy
>>> list1 = [1,2,3,4,5]
>>> list2 = copy.copy(list1)
>>> list2 [1, 2, 3, 4, 5]

9.7 फ़ंक्शन के तर्क के रूप में सूची

जब भी कोई सूची एक फ़ंक्शन के तर्क के रूप में पास की जाती है, हमें दो परिदृश्यों पर विचार करना होता है:

(A) मूल सूची के तत्व बदले जा सकते हैं, अर्थात् फ़ंक्शन में सूची में किए गए परिवर्तन कॉल करने वाले फ़ंक्शन में परिलक्षित होते हैं।

उदाहरण के लिए निम्नलिखित प्रोग्राम में संख्याओं की सूची list1 को तर्क के रूप में फ़ंक्शन increment() में पास किया जाता है। यह फ़ंक्शन सूची के प्रत्येक तत्व को 5 से बढ़ाता है।

प्रोग्राम 9-1 सूची के तत्वों को बढ़ाने के लिए प्रोग्राम। सूची को फ़ंक्शन के तर्क के रूप में पास किया जाता है।

#प्रोग्राम 9-1
#सूची के तत्वों को बढ़ाने के लिए फ़ंक्शन जो तर्क के रूप में पास की गई है
def increment(list2):
$\quad$i के लिए range(0,len(list2)) में:
$\qquad$ #सूची के व्यक्तिगत तत्वों में 5 जोड़ा जाता है
$\qquad$ list2[i] += 5
$\quad$ print(‘फ़ंक्शन के अंदर सूची का संदर्भ’,id(list2))
#फ़ंक्शन का अंत
list1 = [10,20,30,40,50] $\qquad$#एक सूची बनाएं
print(“मुख्य में सूची का संदर्भ”,id(list1))
print(“फ़ंक्शन कॉल से पहले सूची”)
print(list1)
increment(list1) $\qquad$#list1 को पैरामीटर के रूप में पास किया गया है
print(“फ़ंक्शन कॉल के बाद सूची”)
print(list1)

आउटपुट:

मुख्य में सूची का संदर्भ 70615968
फ़ंक्शन कॉल से पहले सूची
[10, 20, 30, 40, 50]
फ़ंक्शन के अंदर सूची का संदर्भ 70615968 $\quad$ #id समान रहता है
फ़ंक्शन कॉल के बाद सूची
[15, 25, 35, 45, 55]

ध्यान दें कि जब हम सूची को तर्क के रूप में पास करते हैं, तो हम वास्तव में सूची के संदर्भ को पास करते हैं। इसलिए फ़ंक्शन के अंदर list2 में किया गया कोई भी परिवर्तन वास्तविक सूची list1 में परिलक्षित होता है।

(बी) यदि सूची को फ़ंक्शन के अंदर एक नया मान दिया जाता है तो एक नई सूची ऑब्जेक्ट बनाई जाती है और यह फ़ंक्शन की स्थानीय प्रति बन जाती है। फ़ंक्शन की स्थानीय प्रति में किए गए कोई भी परिवर्तन कॉलिंग फ़ंक्शन में परिलक्षित नहीं होते हैं।

प्रोग्राम 9-2 पैरामीटर के रूप में पास की गई सूची के तत्वों को बढ़ाने के लिए प्रोग्राम।

#प्रोग्राम 9-2
#फ़ंक्शन तर्क के रूप में पास की गई सूची के तत्वों को बढ़ाने के लिए
def increment(list2):
$\quad$ print("\nफ़ंक्शन के अंदर असाइनमेंट से पहले सूची की ID:",
id(list2))
$\quad$ list2 = [15,25,35,45,55] #List2 को एक नई सूची असाइन की गई
$\quad$ print(“फ़ंक्शन के अंदर असाइनमेंट के बाद सूची की ID बदल जाती है:”,
id(list2))
$\quad$ print(“असाइनमेंट के बाद फ़ंक्शन के अंदर सूची है:”)
$\quad$ print(list2)
#फ़ंक्शन का अंत

list1 = [10,20,30,40,50] $\quad$ #एक सूची बनाएं
print(“फ़ंक्शन कॉल से पहले सूची की ID:",id(list1))
print(“फ़ंक्शन कॉल से पहले सूची:”)
print(list1)
increment(list1) $\quad$ #list1 को फ़ंक्शन में पैरामीटर के रूप में पास किया गया
print(’\nफ़ंक्शन कॉल के बाद सूची की ID:’,id(list1))
print(“फ़ंक्शन कॉल के बाद सूची:”)
print(list1)

आउटपुट:

फ़ंक्शन कॉल से पहले सूची की ID: 65565640
फ़ंक्शन कॉल से पहले सूची:
[10, 20, 30, 40, 50]

फ़ंक्शन के अंदर असाइनमेंट से पहले सूची की ID:65565640
फ़ंक्शन के अंदर असाइनमेंट के बाद सूची की ID बदल जाती है:65565600
असाइनमेंट के बाद फ़ंक्शन के अंदर सूची है:
[15, 25, 35, 45, 55]

फ़ंक्शन कॉल के बाद सूची की ID: 65565640
फ़ंक्शन कॉल के बाद सूची:
[10, 20, 30, 40, 50]

9.8 सूची हेरफेर

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

प्रोग्राम 9-3 विभिन्न सूची संचालनों को करने के लिए एक मेनू-चालित प्रोग्राम लिखें, जैसे कि:

एक तत्व जोड़ना
एक तत्व सम्मिलित करना
दी गई सूची में एक सूची जोड़ना
एक मौजूदा तत्व को संशोधित करना
किसी स्थान से मौजूदा तत्व को हटाना
किसी दिए गए मान वाले मौजूदा तत्व को हटाना
सूची को आरोही क्रम में सॉर्ट करना
सूची को अवरोही क्रम में सॉर्ट करना
सूची प्रदर्शित करना

#प्रोग्राम 9-3
#विभिन्न सूची संचालनों के लिए मेनू-चालित प्रोग्राम
myList = [22,4,16,38,13] $\quad$ $\quad$ #myList में पहले से 5 तत्व हैं
choice = 0
while True:
$\quad$ print(“सूची ‘myList’ में निम्नलिखित तत्व हैं”, myList)
$\quad$ print("\nL I S T O P E R A T I O N S”)
$\quad$ print(" 1. एक तत्व जोड़ें")
$\quad$ print(" 2. एक तत्व इच्छित स्थान पर सम्मिलित करें")
$\quad$ print(" 3. दी गई सूची में एक सूची जोड़ें")
$\quad$ print(" 4. एक मौजूदा तत्व को संशोधित करें")
$\quad$ print(" 5. किसी स्थान के आधार पर मौजूदा तत्व को हटाएं")
$\quad$ print(" 6. किसी मान के आधार पर मौजूदा तत्व को हटाएं")
$\quad$ print(" 7. सूची को आरोही क्रम में सॉर्ट करें")
$\quad$ print(" 8. सूची को अवरोही क्रम में सॉर्ट करें")
$\quad$ print(" 9. सूची प्रदर्शित करें")
$\quad$ print(" 10. बाहर निकलें")
$\quad$ choice = int(input(“अपनी पसंद दर्ज करें (1-10): “))

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

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

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

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

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

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

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

$\quad$ #सूची को उल्टे क्रमबद्ध क्रम में
$\quad$ elif choice == 8:
$\qquad$ myList.sort(reverse = True)
$\qquad$ print("\nसूची को उल्टे क्रम में क्रमबद्ध कर दिया गया है”)

$\quad$ #सूची को प्रदर्शित करना
$\quad$ elif choice == 9:
$\qquad$ print("\nसूची है:”, myList)

$\quad$ #मेनू से बाहर निकलना
$\quad$ elif choice == 10:
$\qquad$ break
$\quad$ else:
$\qquad$ print(“पसंद मान्य नहीं है”)
$\qquad$ print("\n\nजारी रखने के लिए कोई भी कुंजी दबाएं…………..”)
$\qquad$ ch = input()

आउटपुट:

सूची ‘myList’ में निम्नलिखित तत्व हैं [22,4,16,38,13]
L I S T O P E R A T I O N S

1. कोई तत्व जोड़ना
2. इच्छित स्थान पर तत्व डालना
3. दी गई सूची में एक सूची जोड़ना
4. मौजूदा तत्व को संशोधित करना
5. मौजूदा तत्व को उसके स्थान द्वारा हटाना
6. मौजूदा तत्व को उसके मान द्वारा हटाना
7. सूची को आरोही क्रम में क्रमबद्ध करना
8. सूची को अवरोही क्रम में क्रमबद्ध करना
9. सूची प्रदर्शित करना
10. बाहर निकलना

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

सूची को उलटे क्रम में क्रमबद्ध कर दिया गया है
सूची ‘myList’ में निम्नलिखित तत्व हैं [38,22,16,13,4]

सूची संचालन

एक तत्व जोड़ें
इच्छित स्थान पर एक तत्व डालें
दी गई सूची में एक सूची जोड़ें
किसी मौजूदा तत्व को संशोधित करें
किसी मौजूदा तत्व को उसके स्थान से हटाएं
किसी मौजूदा तत्व को उसके मान से हटाएं
सूची को आरोही क्रम में क्रमबद्ध करें
सूची को अवरोही क्रम में क्रमबद्ध करें
सूची प्रदर्शित करें
बाहर निकलें

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

हटाए जाने वाले तत्व का स्थान दर्ज करें: 2
तत्व 16 को हटा दिया गया है
सूची ‘myList’ में निम्नलिखित तत्व हैं [38,22,13,4]

सूची संचालन

एक तत्व जोड़ें
इच्छित स्थान पर एक तत्व डालें
दी गई सूची में एक सूची जोड़ें
किसी मौजूदा तत्व को संशोधित करें
किसी मौजूदा तत्व को उसके स्थान से हटाएं
किसी मौजूदा तत्व को उसके मान से हटाएं
सूची को आरोही क्रम में क्रमबद्ध करें
सूची को अवरोही क्रम में क्रमबद्ध करें
सूची प्रदर्शित करें
बाहर निकलें

प्रोग्राम 9-4 एक कार्यक्रम जो n छात्रों के औसत अंक एक फ़ंक्शन का उपयोग करके गणना करता है, जहाँ n उपयोगकर्ता द्वारा दर्ज किया जाता है।

#प्रोग्राम 9-4
#n विद्यार्थियों के औसत अंक गणना करने के लिए फ़ंक्शन
def computeAverage(list1,n):
$\quad$ #कुल योग प्रारंभ करें
$\quad$ total = 0
$\quad$ for marks in list1:
$\qquad$ #कुल में अंक जोड़ें
$\qquad$ total = total + marks
$\quad$ average = total / n
$\quad$ return average

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

आउटपुट:

आप कितने विद्यार्थियों के अंक दर्ज करना चाहते हैं:
5
विद्यार्थी 1 के अंक दर्ज करें:
45
विद्यार्थी 2 के अंक दर्ज करें:
89
विद्यार्थी 3 के अंक दर्ज करें:
79
विद्यार्थी 4 के अंक दर्ज करें:
76
विद्यार्थी 5 के अंक दर्ज करें:
55
5 विद्यार्थियों के औसत अंक हैं: 68.8

प्रोग्राम 9-5 एक उपयोगकर्ता-परिभाषित फ़ंक्शन लिखें जो यह जाँचे कि कोई संख्या सूची में मौजूद है या नहीं। यदि संख्या मौजूद है, तो उसका स्थान लौटाए। यदि संख्या सूची में मौजूद नहीं है, तो एक उपयुक्त संदेश प्रिंट करें।

#प्रोग्राम 9-5
#फंक्शन जांचने के लिए कि कोई संख्या सूची में है या नहीं
def linearSearch(num,list1):
$\quad$for i in range(0,len(list1)):
$\qquad$ if list1[i] == num: $\hspace{1cm}$ #num मौजूद है
$\hspace{1cm}$ return i $\hspace{2cm}$ #स्थान लौटाएं
$\quad$ return None $\hspace{2cm}$ #num सूची में मौजूद नहीं है
#फंक्शन का अंत

list1 = [] $\hspace{2cm}$ #एक खाली सूची बनाएं
print(“आप सूची में कितनी संख्याएँ दर्ज करना चाहते हैं: “)
maximum = int(input())
print(“संख्याओं की एक सूची दर्ज करें: “)
for i in range(0,maximum):
$\quad$ n = int(input())
$\quad$ list1.append(n) $\hspace{2cm}$ #संख्याओं को सूची में जोड़ें
num = int(input(“खोजी जाने वाली संख्या दर्ज करें: “))
result = linearSearch(num,list1)
if result is None:
$\quad$ print(“संख्या”,num,“सूची में मौजूद नहीं है”)
else:
$\quad$ print(“संख्या”,num,“स्थान”,result + 1,“पर मौजूद है”)

आउटपुट:

आप सूची में कितनी संख्याएँ दर्ज करना चाहते हैं:
5
संख्याओं की एक सूची दर्ज करें:
23
567
12
89
324
खोजी जाने वाली संख्या दर्ज करें:12
संख्या 12 स्थान 3 पर मौजूद है

सारांश

Lists are mutable sequences in Python, i.e., we can change the elements of the list.
Lists are mutable sequences in Python, i.e., we can change the elements of the list.
Elements of a list are put in square brackets separated by comma.
Elements of a list are put in square brackets separated by comma.
A list within a list is called a nested list. List indexing is same as that of strings and starts at 0 . Two way indexing allows traversing the list in the forward as well as in the backward direction.
A list within a list is called a nested list. List indexing is same as that of strings and starts at 0 . Two way indexing allows traversing the list in the forward as well as in the backward direction.
Operator + concatenates one list to the end of other list.
Operator + concatenates one list to the end of other list.
Operator * repeats a list by specified number of times.
Operator * repeats a list by specified number of times.
Membership operator in tells if an element is present in the list or not and not in does the opposite.
Membership operator in tells if an element is present in the list or not and not in does the opposite.
Slicing is used to extract a part of the list.
Slicing is used to extract a part of the list.
There are many list manipulation functions including: len(), list(), append(), extend(), insert(), count(), find(), remove(), pop(), reverse(), sort(), sorted(), $\min (), \max (), \operatorname{sum}()$.
There are many list manipulation functions including: len(), list(), append(), extend(), insert(), count(), find(), remove(), pop(), reverse(), sort(), sorted(), $\min (), \max (), \operatorname{sum}()$.

EXERCISE

1. What will be the output of the following statements?
1. What will be the output of the following statements?

i.
i.

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

ii.
ii.

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

iii.
iii.

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

iv.
iv.

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

2. Consider the following list myList. What will be the elements of myList after the following two operations:
2. Consider the following list myList. What will be the elements of myList after the following two operations:

myList = [10,20,30,40] \
$\quad$ i. myList.append([50,60]) \
$\quad$ ii. myList.extend([80,90])

3. What will be the output of the following code segment:
3. What will be the output of the following code segment:

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

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

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

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

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

5. लिस्ट की append() और extend() फ़ंक्शंस के बीच अंतर बताइए।

6. एक लिस्ट पर विचार कीजिए:

list1 = [6,7,8,9]

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

a. list1 * 2
b. list1 *= 2
c. list1 = list1 * 2

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

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

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

a) छात्र का प्रतिशत
b) पाँचवें विषय में अंक
c) छात्र के अधिकतम अंक
d) छात्र का रोल नं.
e) छात्र का नाम ‘Raman’ से बदलकर ‘Raghav’ करें

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

1. एक प्रोग्राम लिखिए जो यह पता लगाए कि कोई तत्व लिस्ट में कितनी बार आता है।

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

3. एक ऐसा फ़ंक्शन लिखिए जो पैरामीटर के रूप में पास की गई सूची का सबसे बड़ा तत्व लौटाता है।

4. एक फ़ंक्शन लिखिए जो संख्याओं की सूची से दूसरी सबसे बड़ी संख्या लौटाता है।

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

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

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

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

7. एक ऐसा प्रोग्राम लिखिए जो तत्वों की एक सूची पढ़े। उपयोगकर्ता से एक ऐसा तत्व इनपुट करें जिसे सूची में डालना है। यह भी इनपुट करें कि उसे किस स्थान पर डालना है। तत्व को सूची में वांछित स्थान पर डालने के लिए एक उपयोगकर्ता-परिभाषित फ़ंक्शन लिखिए।

8. एक ऐसा प्रोग्राम लिखिए जो सूची के तत्व पढ़े।

a) प्रोग्राम सूची से किस तत्व को हटाना है, उसकी स्थिति पूछे। सूची में वांछित स्थान पर तत्व को हटाने के लिए एक फ़ंक्शन लिखिए।

b) प्रोग्राम सूची से किस तत्व को हटाना है, उसका मान पूछे। सूची से इस मान के तत्व को हटाने के लिए एक फ़ंक्शन लिखिए।

9. $n$ तत्वों की एक सूची पढ़िए। इस सूची को एक ऐसे फ़ंक्शन को पास कीजिए जो इस सूची को नई सूची बनाए बिना उसी स्थान पर उलट दे।

Chapter 09 Lists

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

9.1.1 सूची में तत्वों तक पहुंच

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

9.2 सूची संचालन

9.2.1 संयोजन

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

9.2.3 सदस्यता

9.2.4 स्लाइसिंग

9.3 सूची का ट्रैवर्सल

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

9.5 नेस्टेड लिस्ट्स

9.6 लिस्ट्स की कॉपी करना

9.7 फ़ंक्शन के तर्क के रूप में सूची

9.8 सूची हेरफेर

सारांश

EXERCISE

EXERCISE

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

CUET Preparation

Exam Pattern

International Students

NCERT Books

Important Resources

Forum