पायथन सूची - तत्वों को बनाएं, एक्सेस, स्लाइस, जोड़ें या हटाएं

python list create

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

ऑपरेटिंग सिस्टम का चयन करें प्रक्षेपण का एक कार्यक्रम चुनें (वैकल्पिक रूप से)

अपनी समस्या का वर्णन करें

इस पायथन लिस्ट के ट्यूटोरियल में, हम पाइथन लिस्ट में क्रिएट, एक्सेस, स्लाइस, ऐड / डिलीट एलिमेंट्स के तरीके तलाशेंगे, जो यकीनन सबसे उपयोगी डेटा टाइप्स में से एक हैं:

पायथन में नीचे उल्लिखित 4 संग्रह डेटा प्रकार शामिल हैं:

सूची
सेट
शब्दकोश
टपल

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

=> यहाँ पायथन प्रशिक्षण श्रृंखला का अन्वेषण करें

यदि आपके पास जावा, सी, सी ++ आदि जैसी किसी भी अन्य प्रोग्रामिंग भाषाओं में अनुभव है, तो आप सरणियों की अवधारणा से परिचित होंगे। सूची लगभग सरणियों के समान है।

आप क्या सीखेंगे:

पायथन सूची क्या हैं
पायथन में सूचियों के बारे में अधिक जानकारी
निष्कर्ष
- अनुशंसित पाठ

पायथन सूची क्या हैं

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

ध्यान दें :आगे बढ़ते हुए, इस ट्यूटोरियल के सभी उदाहरण सीधे पायथन शेल से चलेंगे, जब तक कि अन्यथा न कहा जाए।

नीचे 5 आइटमों के साथ सूची का एक उदाहरण है।

>>> l = ('what','who','where','when','how') >>>l ('what','who','where','when','how')

उपरोक्त उदाहरण में, हम देख सकते हैं कि सूची में है स्ट्रिंग वस्तुओं आइटम के रूप में, और प्रत्येक आइटम को अल्पविराम द्वारा अलग किया जाता है।

अजगर सूची के लक्षण

इससे पहले कि हम यह देखें कि हम किसी सूची में आइटमों में कैसे हेरफेर कर सकते हैं, आइए कुछ विशेषताओं पर ध्यान दें जो पायथन सूची को इष्ट बनाती हैं।

अजगर सूचियाँ कंटेनर अनुक्रम हैं

फ्लैट अनुक्रमों के विपरीत ( तार , array.array , स्मृति दर्शन , आदि) जो केवल एक प्रकार की वस्तुओं को पकड़ सकते हैं, एक सूची एक है कंटेनर अनुक्रम जो एक प्रकार की वस्तुओं के साथ-साथ विभिन्न प्रकारों को भी पकड़ सकता है।

एक प्रकार की वस्तुओं के साथ उदाहरण

आइए हमारे अजगर के खोल को खोलें और संख्याओं की एक सूची को परिभाषित करें।

>>> numbers = ('one','two','three','four','five') >>> numbers ('one','two','three','four','five')

ऊपर का उदाहरण उसी प्रकार के आइटमों की सूची दिखाता है, जो इस प्रकार के हैं स्ट्रिंग (str) ।

विभिन्न प्रकारों की वस्तुओं के साथ उदाहरण

आइए हमारे पायथन शेल को खोलें और संख्याओं की सूची के दूसरे संस्करण को परिभाषित करें।

>>> numbers = ('one',2,3,'four',5.0) >>> numbers ('one',2,3,'four',5.0)

ऊपर दिया गया उदाहरण विभिन्न प्रकारों की वस्तुओं की सूची दिखाता है। प्रकार हैं तार , पूर्णांक, तथा तैरना ।

// a sketch showing the list of items and their types as annotation

पायथन सूची सभी वस्तुओं को भी पकड़ सकती है जैसे कि कार्यों , कक्षाओं , मॉड्यूल , सूचियों , टुपल्स, और भी बहुत कुछ।

एक संपादक खोलें और नीचे दिए गए कोड को चिपकाएँ:

def test(): '''This is a function''' print('This is a test') if __name__ == '__main__': print(test) # return instance object of function 'test' instance = type(test) print(instance) # create a list of colors colors = ('red','blue','green') print(colors) # create a list holding all the various data types defined above, including boolean. my_list = (test, instance, colors, False) print(my_list)

उत्पादन

अजगर सूचियाँ कंटेनर क्रम हैं

अजगर सूचियाँ क्रमबद्ध क्रम हैं

एक पायथन सूची वस्तुओं का एक आदेशित संग्रह है। एक सूची में प्रत्येक आइटम की स्थिति बहुत महत्वपूर्ण है। वास्तव में, एक ही आइटम के साथ दो सूचियां समान नहीं हैं यदि आइटम जिस क्रम में तैनात हैं, वह समान नहीं है।

>>> ('a','b','c','d') == ('a','c','b','d') False

पायथन सूची की यह विशेषता सूचकांक और स्लाइसिंग द्वारा इसके आइटम तक पहुंचना संभव बनाती है (इस पर बाद में)।

पायथन लिस्ट्स म्यूटेबल सीक्वेंस हैं

पायथन सूची परस्पर हैं। लेकिन एक परस्पर वस्तु क्या है? यह बस एक ऐसी वस्तु है जिसे बनने के बाद संशोधित किया जा सकता है। उदाहरण अन्य परिवर्तनशील क्रम के हैं शब्दकोश , array.array , संग्रह ।

परस्पर क्यों? जटिल प्रक्रियाओं के लिए सूचियों जैसे अनुक्रम का उपयोग किया जाता है, इसलिए यह समझ में आता है कि उन्हें सक्षम होना चाहिए परिवर्तन , बढ़ना , हटना , अद्यतन, आदि । यह केवल परिवर्तनशीलता के साथ संभव है। म्यूटेबिलिटी हमें सूचियों को स्थान पर संशोधित करने में सक्षम बनाती है (इस पर अधिक)

नीचे दी गई उदाहरण के साथ किसी सूची की परिवर्तनशीलता को सत्यापित करें।

बस एक संपादक खोलें और कोड पेस्ट करें:

def veryfiy_mutability(): # create a list l = (9,0,4,3,5) print('Display before modifying') print('List: {}
Id: {}'.format(l,id(l))) # modify the list by replacing the item at # index 3 to the item -2. l(3) = -2 print('Display after modifying') print('List: {}
Id: {}'.format(l,id(l))) if __name__ == '__main__': veryfiy_mutability()

उत्पादन

पायथन लिस्ट्स म्यूटेबल सीक्वेंस हैं

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

यह हमें बताता है कि, हालांकि सूची सामग्री बदल गई है, यह अभी भी वही वस्तु है। इसलिए, यह हमारी परिभाषा को संतुष्ट करता है: यह बस एक ऐसी वस्तु है जिसे बनने के बाद संशोधित किया जा सकता है '

ध्यान दें :ऊपर के उदाहरण में, हमने सूची को संशोधित करने के लिए अनुक्रमण (इस पर अधिक) का उपयोग किया।

पायथन सूचियों में हेरफेर

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

इस खंड में, हम कुछ सामान्य रूप से उपयोग किए जाने वाले सूची कार्यों को देख रहे हैं।

एक सूची बनाना

एक सूची बनाने के लिए, आप बस अल्पविराम द्वारा अलग किए गए एक वर्ग ब्रैकेट में कई आइटम या भाव डालते हैं।

(expression1, expression2,...,expresionN) >>> l = (4,3,5,9+3,False) >>> l (4, 3, 5, 12, False)

इसके अलावा, पायथन में एक अंतर्निहित वस्तु होती है जिसे कहा जाता है सूची () जिनका उपयोग सूचियां बनाने के लिए किया जा सकता है।

list( sequence ) >>> l = list() # create an empty list >>> l ()

अजगर सूची () अनुक्रम प्रकारों में ले जा सकते हैं और उन्हें सूचियों में परिवर्तित कर सकते हैं। यह ट्यूपल को सूची में परिवर्तित करने का विशिष्ट तरीका है।

>>> t = (4,3,5) # tuple >>>l = list(t) # convert into list (4,3,5)

ऊपर दिए गए उदाहरण में, हमने डेटा प्रकार का उपयोग किया टपल । यह एक सूची के समान है लेकिन सूचियों के विपरीत, यह अपरिवर्तनीय है और इसके आइटम कोष्ठक में संलग्न हैं।

एक अन्य साधन जिसके द्वारा हम एक सूची बना सकते हैं, का उपयोग करके है सूची की समझ जिसका सिंटैक्स है।

(expression for item in sequence) >>> (i**2 for i in range(4)) (0, 1, 4, 9)

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

>>> l1 = l2 = (4,3) # wrong way to create separate list objects >>> l1 (4,3) >>> l2 (4,3)

यहाँ, हम सोच सकते हैं कि हमने दो अलग-अलग सूचियाँ बनाई हैं, लेकिन सही मायने में हमने सिर्फ एक बनाई है। किसी एक चर को संशोधित करके इसे प्रदर्शित करें।

>>> l1(0) = 0 >>> l1 (0,3) >>> l2 (0,3)

हम ध्यान देते हैं कि एक चर को संशोधित करने से दूसरा परिवर्तन होता है। ऐसा इसलिए है क्योंकि दोनों चर l1 और l2 एक ही मेमोरी लोकेशन पहचान रखते हैं, इसलिए वे दोनों एक ही ऑब्जेक्ट को इंगित करते हैं।

एक सूची में आइटम जोड़ना

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

# 1) परिशिष्ट () विधि का उपयोग करना

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

>>>l = list() # create empty list >>> l () >>> l.append(4) # add an integer >>> l (4) >>> l.append((0,1)) # add a list >>> l (4, (0, 1)) >>> l.append(4 >> l (4, (0, 1), True) >>> l.append(x for x in range(3)) # add result of a tuple comprehension >>> l (4, (0, 1), True, )

उपरोक्त उदाहरण से ध्यान देने योग्य कुछ बातें:

यहां आइटम अभिव्यक्ति, डेटा प्रकार, अनुक्रम, और कई और अधिक हो सकते हैं।
परिशिष्ट () विधि की एक समय जटिलता है (0) 1। मतलब यह स्थिर है।

# 2) विस्तार () विधि का उपयोग करना

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

मूल रूप से, विस्तार () विधि अपने तर्क पर पुनरावृत्ति करती है और प्रत्येक आइटम को सूची में जोड़ देती है। एपेंड () पद्धति की तरह, यह एक नई सूची नहीं लौटाती है लेकिन सूची में जगह को संशोधित करती है।

>>> l1 = (3,2,5) # create a list of items >>> l1 (3, 2, 5) >>> l2 = (0,0,-1) # create a second list of items >>> l2 (0, 0, -1) >>> str = 'hello' # create a string(iterable) >>> str 'hello' >>> l1.extend(l2) # append all items from l2 to l1 >>> l1 (3, 2, 5, 0, 0, -1) >>> l1.extend(str) # append all items from str to l1 >>> l1 (3, 2, 5, 0, 0, -1, 'h', 'e', 'l', 'l', 'o')

उपरोक्त उदाहरण से ध्यान देने योग्य कुछ बातें:

एक स्ट्रिंग चलने योग्य है, इसलिए हमारी विस्तार () विधि अपने वर्णों पर पुनरावृति करेगी।
विस्तार () विधि की एक समय जटिलता है (0) K जहां K अपने तर्क की लंबाई है।

एक सूची से आइटम तक पहुँचने

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

(१) अनुक्रमण

एक पायथन सूची का उपयोग करता है शून्य-आधारित संख्या प्रणाली। मतलब, इसके सभी आइटम विशिष्ट रूप से 0 से n-1 से शुरू होने वाले एक इंडेक्स नंबर से पहचाने जाते हैं जहां n सूची की लंबाई है।

नीचे दी गई सूची पर विचार करें:

>>> colors = ('red','blue','green','yellow','black') # create list >>> colors ('red','blue','green','yellow','black') >>> len(colors) # get list length 5

नीचे दी गई तालिका में उनके संबंधित सूचकांकों को दिखाया गया है किसी सूची की शून्य-आधारित संख्या।

मद	जाल	नीला	हरा	पीला	काली
पॉप ()	किसी सूची में अंतिम से तत्व को हटाने / हटाने के लिए।
सूची	०	एक	दो	३	४

उपरोक्त तालिका से, हम देखते हैं कि पहला आइटम ('लाल') सूचकांक स्थिति 0 पर है और अंतिम आइटम ('काला') सूचकांक स्थिति 4 (n-1) पर है जहाँ n = 5 (ऑब्जेक्ट की लंबाई) रंग की)।

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

ऊपर बनाए गए रंग ऑब्जेक्ट के विशेष सूचकांकों पर आइटम तक पहुँचने के लिए इंडेक्सिंग का उपयोग करें।

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0) # access item at index 0 'red' >>> colors(4) # access item at index 4 'black' >>> colors(9) # access item at index 9 Traceback (most recent call last): File '', line 1, in IndexError: list index out of range

ध्यान दें :ऊपर दिया गया अंतिम कथन सूची वस्तु 9 की लंबाई से वस्तु की स्थिति में पहुँचने का प्रयास कर रहा है। 5. पायथन सूची में, किसी ऐसी वस्तु पर पहुँचना, जो मौजूद नहीं है अनुक्रमणिका अपवाद।

अनुक्रमण की एक महत्वपूर्ण अवधारणा यह है कि हम ऋणात्मक अनुक्रमण का उपयोग कर सकते हैं अर्थात् हम किसी सूची की वस्तुओं को अंतिम आइटम के लिए -1 से शुरू करके और अंतिम वस्तु के लिए n पर समाप्त कर सकते हैं जहां n सूची वस्तु की लंबाई है।

उपरोक्त तालिका में, यदि हम नकारात्मक अनुक्रमण का उपयोग करते हैं, तो यह नीचे दिखाए अनुसार होगा:

मद	जाल	नीला	हरा	पीला	काली
सूची	-5	-4	-3	-2	-1

ऊपर बनाई गई रंग वस्तु के कुछ आइटम तक पहुँचने के लिए नकारात्मक अनुक्रमण का उपयोग करें।

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-1) # access item and index -1(first item counting backward) 'black' >>> colors(-3) # access item at index -3(third item counting backward) 'green' >>> colors(-5) # access item at index -5 (last item counting backward) 'red'

# 2) टुकड़ा करना

अनुक्रमण के विपरीत जो केवल एक आइटम लौटाता है, टुकड़ा करने की क्रिया दूसरी ओर वस्तुओं की एक श्रृंखला वापस कर सकते हैं।

इसमें निम्नलिखित सिंटैक्स है:

L(n:m)

जब n सूचकांक संख्या होती है जहां टुकड़ा शुरू होता है (चूक 0 से), और मीटर अनन्य सूचकांक संख्या है जहां टुकड़ा समाप्त होता है (लंबाई -1 के लिए चूक)। वे एक बृहदान्त्र द्वारा अलग हो जाते हैं (:)

नीचे दिए गए उदाहरण पर विचार करें जो ऊपर बनाए गए रंग ऑब्जेक्ट के विशेष सूचकांकों पर आइटम तक पहुंचने के लिए स्लिंगिंग का उपयोग करता है।

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:2) # get first two items ('red', 'blue') >>> colors(1:4) # get items at index 1,2 and 3 ('blue', 'green', 'yellow') >>> colors(2:len(colors) # get items from index 2 to the last item ('green', 'yellow', 'black') >>> colors(3:4) # get one item at index 3. Same as colors(3) ('yellow') >>>

सिंटैक्स L (n: m) में, n डिफॉल्ट से 0, और m डिफॉल्ट से लिस्ट की लंबाई तक। तो, में उदाहरण एक तथा ३ ऊपर, हम n और m को रंगों के रूप में छोड़ सकते हैं (: 2) और रंगों को क्रमशः (2:)। या (:) जो इस मामले में संपूर्ण सूची ऑब्जेक्ट की एक उथली प्रतिलिपि लौटाता है।

हम सूचियों को काटते समय नकारात्मक सूचकांक संख्याओं का भी उपयोग कर सकते हैं। इसका उपयोग आमतौर पर तब किया जाता है जब हम सूची को उल्टे तरीके से एक्सेस करना चाहते हैं।

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(-3:-2) ('green') >>> colors(-2:) ('yellow', 'black')

इसके अलावा, एक तीसरा पैरामीटर है जिसे स्लिंगिंग सपोर्ट कहा जाता है कदम (एस)। यह निर्धारित करता है कि सूची से पहला आइटम पुनर्प्राप्त होने के बाद कितने आइटम आगे बढ़ना है। यह 1 को डिफॉल्ट करता है।

L(n:m:s)

ऊपर परिभाषित हमारी समान रंग सूची का उपयोग करते हुए, दो चरणों को स्थानांतरित करने के लिए स्लाइस के तीसरे पैरामीटर का उपयोग करें।

>>> colors # original list ('red','blue','green','yellow','black') >>> colors(0:3:2) ('red', 'green')

# 3) छोरों का उपयोग करना

आइटमों में हेरफेर करने के लिए लूप का उपयोग सूची में वस्तुओं तक पहुंचने के लिए किया जाता है। इसलिए, यदि हम किसी सूची की वस्तुओं पर काम करना चाहते हैं, तो हम इसका उपयोग कर सकते हैं पाश के लिए वस्तुओं तक पहुँचने के लिए और उन्हें संचालित करने के लिए खत्म कर दें।

कहें, हम प्रत्येक आइटम के लिए अक्षरों की संख्या गिनना चाहते हैं। हम उपयोग कर सकते हैं पाश के लिए उसे पूरा करने के लिए।

एक संपादक खोलें और नीचे दिए गए कोड को चिपकाएँ:

def count_letters(l): count = {} # define a dict to hold our count for i in l: # loop through the list count(i) = len(i) # for each item, compute its length and store it in the dict return count # return the count if __name__ == '__main__': colors = ('red', 'blue', 'green', 'yellow', 'black') print(count_letters(colors))

उत्पादन

छोरों का उपयोग करना

इस अनुभाग को समाप्त करने के लिए, दो ठंडे सामानों पर नज़र डालते हैं जिन्हें स्लाइसिंग के साथ किया जा सकता है।

किसी सूची की उथली प्रतिलिपि बनाएं

का उपयोग करने का मूल तरीका है कॉपी () सूची ऑब्जेक्ट या अंतर्निहित फ़ंक्शन की विधि कॉपी । हालांकि, यह टुकड़ा करके प्राप्त किया जा सकता है।

>>> colors # original list ('red','blue','green','yellow','black') >>> colors_copy = colors(:) # make a shallow copy >>> colors_copy ('red', 'blue', 'green', 'yellow', 'black') >>> colors_copy(0) = 0 # modify item at index 0 by changing its value to 0 >>> colors_copy # the copied version now has 0 at index 0 (0, 'blue', 'green', 'yellow', 'black') >>> colors # the original version is unchanged ('red', 'blue', 'green', 'yellow', 'black') >>>

एक सूची को उलट दें

मूल तरीका है का उपयोग करने के लिए उलटना सूची ऑब्जेक्ट या अंतर्निहित फ़ंक्शन की विधि उलट () । हालांकि, यह टुकड़ा करके प्राप्त किया जा सकता है।

>>> colors # original list object ('red', 'blue', 'green', 'yellow', 'black') >>> colors(::-1) # returns a reversed shallow copy of the the original list ('black', 'yellow', 'green', 'blue', 'red') >>>

एक सूची से आइटम निकालना

जैसा कि हम एक सूची में कई आइटम जोड़ सकते हैं, उन्हें एक सूची से भी हटाया जा सकता है। वे तीन तरीके जिनसे आइटम निकाले जा सकते हैं:

(1) डेल स्टेटमेंट का उपयोग करना

इसमें निम्नलिखित सिंटैक्स है:

del target_list

लक्ष्य सूची ( लक्ष्य_सूची ) संपूर्ण सूची हो सकती है (यदि आप सूची को हटाना चाहते हैं) या किसी सूची में कोई वस्तु या आइटम (इस मामले में आप अनुक्रमण या स्लाइसिंग का उपयोग करते हैं)।

नीचे दिए गए उदाहरण पर विचार करें ।

कहो, हम ऊपर बनाई गई रंग सूची से कुछ आइटम हटाना चाहते हैं।

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> del c_copy(0) # delete item at index 0 >>> c_copy ('blue', 'green', 'yellow', 'black') >>> del c_copy(0:2) # delete items at index 0 and 1(slicing) >>> c_copy ('yellow', 'black') >>> del c_copy(:) # delete all items in a list. Same as ‘c_copy.clear()’ () >>> del c_copy # delete the list object >>> c_copy # access object that doesn't exist Traceback (most recent call last): File '', line 1, in NameError: name 'c_copy' is not defined >>>

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

# 2) list.remove (x) का उपयोग करना

यह सूची से पहला आइटम निकालता है जिसका मूल्य बराबर है एक्स । ऐसा कोई आइटम नहीं है, तो यह एक ValueError बढ़ाता है।

इस विधि का उपयोग अधिकतर सूची से नाम की वस्तुओं को हटाने के लिए किया जाता है, विपरीत कथन के साथ जो अनुक्रमण और स्लाइसिंग का उपयोग करता है।

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # create shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # remove first item with name 'blue' >>> c_copy ('red', 'green', 'yellow', 'black') >>> c_copy.remove('blue') # try to remove item that doesn't exist Traceback (most recent call last): File '', line 1, in ValueError: list.remove(x): x not in list >>>

ध्यान दें :सूची वस्तु हटाना() विधि हटाता है के स्थान पर अर्थात् , यह नई सूची ऑब्जेक्ट को वापस करने के बजाय मूल सूची ऑब्जेक्ट को संशोधित करेगा।

# 3) list.pop ((i)) का उपयोग करना

यह किसी सूची ऑब्जेक्ट में दिए गए स्थान पर आइटम को निकालता है और वापस करता है। यदि कोई i (इंडेक्स) प्रदान नहीं किया गया है, तो यह सूची में अंतिम आइटम को हटा और वापस कर देता है।

ध्यान दें :मेरे ऊपर के चौकोर कोष्ठक का अर्थ i की सूची नहीं है, बल्कि इसका अर्थ है कि मैं वैकल्पिक हूं।

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy.pop(3) # pop out the item at index 3 'yellow' >>> c_copy ('red', 'blue', 'green', 'black') >>> c_copy.pop() # pop out the last item in the list 'black' >>> c_copy ('red', 'blue', 'green') >>>

ध्यान दें: सूची। पॉप ((i)) विधि हटाता है के स्थान पर अर्थात् , यह नई सूची ऑब्जेक्ट को वापस करने के बजाय मूल सूची ऑब्जेक्ट को संशोधित करेगा। इसके अलावा, यह सूची से हटाए गए आइटम को लौटाता है

एक सूची से आइटम की जगह

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

# 1) इंडेक्सिंग का उपयोग करके बदलें

L(index) = value

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy(0) = 'brown' # replace item at index 0 with 'brown' >>> c_copy ('brown', 'blue', 'green', 'yellow', 'black') >>>

# 2) स्लाइसिंग का उपयोग करके प्रतिस्थापित करना

L(n:m) = value

ध्यान दें : मूल्य होना चाहिए एक चलने योग्य , या और त्रुटि प्रकार अपवाद उठाया जाएगा।

>>> colors # original list ('red', 'blue', 'green', 'yellow', 'black') >>> c_copy = colors(:) # make a shallow copy to work on >>> c_copy(0:2) = ('brown') # replace items at index 0 and 1 with 'brown' >>> c_copy ('brown', 'green', 'yellow', 'black') >>> c_copy(1:3) = ('white','purple') # replace items at index 1 and 2 with 'white' and 'purple' >>> c_copy ('brown', 'white', 'purple', 'black') >>> c_copy(1:4) = ('white','purple') # replace items at index 1,2 and 3 with 'white' and 'purple'. Here we replace 3 items with 2 items >>> c_copy ('brown', 'white', 'purple') >>>

बार बार पूछे जाने वाले प्रश्न

Q # 1) पायथन में सूचियों की सूची क्या है?

उत्तर: पायथन में सूचियों की एक सूची एक सूची है जिसमें इसके आइटम के रूप में सूचियां शामिल हैं।

उदाहरण के लिए

(('a','b'),('c','d'))

इसे एक के रूप में भी संदर्भित किया जा सकता है नेस्टेड सूची ।

Q # 2) आप पायथन में सूची कैसे घोषित करते हैं?

उत्तर: पायथन में, एक सूची को दो तरीकों से घोषित किया जा सकता है। या तो अंतर्निहित फ़ंक्शन का उपयोग करके सूची() या ब्रैकेट संकेतन का उपयोग करके ()। सूची() अल्पविराम द्वारा अलग किए गए किसी भी प्रकार की वस्तुओं में एक पुनरावृत्त और () लेता है।

(pytyon)>>> list('hello') # a string is iterable ('h', 'e', 'l', 'l', 'o') >>> (3,4,5,23) # numbers are separated by comma (3, 4, 5, 23) >>> (/python)

Q # 3) क्या आप एक सूची पायथन में सूची में डाल सकते हैं?

उत्तर: हां, हम एक सूची के अंदर एक सूची डाल सकते हैं। तथ्य की बात के रूप में, एक सूची एक कंटेनर अनुक्रम है जो किसी भी डेटा प्रकार की वस्तुओं में लेता है।

क्यू # 4) पायथन में सूची () क्या करती है?

उत्तर: सूची ( ) पायथन में एक अंतर्निहित फ़ंक्शन है जो सूची ऑब्जेक्ट बनाता है। यह अपने तर्क के रूप में एक पुनरावृत्त में लेता है।

>>> list((3,2,4)) # The iterable object here is a tuple. (3, 2, 4) >>>

Q # 5) क्या पायथन सूची में विभिन्न प्रकार हो सकते हैं?

उत्तर: एक सूची एक कंटेनर अनुक्रम है जो किसी भी प्रकार के डेटा में लेता है ( सूची , टपल , पूर्णांक , तैरना , स्ट्रिंग्स , आदि)

पायथन में सूचियों के बारे में अधिक जानकारी

डेटा संरचना क्या है?

कंप्यूटर का उपयोग बड़ी संख्या में डेटा को स्टोर करने या उच्च गति और सटीकता के साथ बड़ी संख्या में डेटा को संसाधित करने के लिए किया जाता है। इसलिए, त्वरित पहुँच के लिए डेटा को स्थायी रूप से संग्रहीत करना सबसे अच्छा है।

जबकि डाटा प्रोसेसिंग होता है, यह सटीकता खोए बिना कम से कम संभव समय के भीतर होना चाहिए। हम डेटा संरचना को संगठित तरीके से डेटा से निपटने और प्रसंस्करण के लिए मेमोरी में डेटा स्टोर करने के लिए उपयोग करते हैं।

चूंकि पायथन एक उच्च-स्तरीय और व्याख्या की गई प्रोग्रामिंग भाषा है, इसलिए पायथन में डेटा संरचना का उपयोग करना बहुत महत्वपूर्ण है।

सूची क्या है?

एक सूची एक डेटा संरचना है जिसका उपयोग एक साथ कई डेटा को संग्रहीत करने के लिए किया जाता है।

किसी सूची में संग्रहीत डेटा सजातीय है और यह, बदले में, इसे पायथन में सूची का सबसे शक्तिशाली फीचर बनाता है। हम विभिन्न डेटा प्रकारों जैसे स्ट्रिंग, इंटेगर और ऑब्जेक्ट्स के कई डेटा को एक ही सूची में संग्रहीत कर सकते हैं।

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

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

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

एक सूची बनाना

एक सूची में डेटा अल्पविराम से अलग और एक वर्ग ब्रैकेट (()) में संलग्न है। सूची में आइटम एक ही प्रकार के नहीं होने चाहिए।

Syntax: List = (item1, item2, item3)

उदाहरण 1:

List = ( )

उदाहरण 2:

List = (2, 5, 6.7)

उदाहरण 3:

List = (2, 5, 6.7, ‘Hi’)

उदाहरण 4:

List = (‘Hi’, ‘Python’, ‘Hello’)

उपरोक्त उदाहरणों में, हम देख सकते हैं कि हमारे पास अलग-अलग डेटा प्रकारों के आइटम कॉमा से अलग किए गए हैं, 2 और 5 प्रकार के हैं इंटेगर, 6.7 प्रकार फ्लोट का है और 'हाय' टाइप स्ट्रिंग का है, ये सभी आइटम एक में संलग्न हैं। सूची और वह इसे एक सूची बनाता है।

हम एक खाली सूची भी घोषित कर सकते हैं। हम दूसरी सूची के अंदर भी सूची की घोषणा कर सकते हैं, और हम इसे एक नेस्टेड सूची के रूप में कहते हैं।

उदाहरण 5:

List = (‘Hi’, (2, 4, 5), (‘Hello’))

उपरोक्त उदाहरण में, आप देख सकते हैं कि एक सूची को दूसरी सूची के अंदर घोषित किया गया है।

सूची में मान तक पहुँच

विभिन्न तरीके हैं जिनके माध्यम से हम पायथन में सूची के अंदर मौजूद वस्तुओं तक पहुंच सकते हैं।

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

उदाहरण 1:

List = (2, 5, 6.7, ‘Hi’) print(“List is:”, List)

आउटपुट:

सूची है: (२, ५, ६.,,) हाय ’)

Accessing_values_in_list_example_1

आउटपुट:

बेसिक sql साक्षात्कार प्रश्न और फ्रेशर्स के लिए उत्तर

Accessing_values_in_list_example_1_output

उपरोक्त उदाहरण में, हम सीधे प्रिंट फ़ंक्शन का उपयोग करके सूची को प्रिंट कर रहे हैं, हम सूची से अलग-अलग तत्व तक नहीं पहुंच रहे हैं।

आइए सूची से अलग-अलग तत्व को एक्सेस करें।

उदाहरण: २

List = (2, 5, 6.7, ‘Hi’) print(“Second element of the list is:”, List(1))

आउटपुट:

सूची का दूसरा तत्व है: 5

Accessing_values_in_list_example_2

आउटपुट:

Accessing_values_in_list_example_2_output

उपर्युक्त उदाहरण में, आप देख सकते हैं कि हम सूची के दूसरे तत्व को मुद्रित कर रहे हैं जो 5 है, लेकिन आपको एक प्रश्न मिल सकता है कि प्रिंट स्टेटमेंट में हम सूची (1) को क्यों छाप रहे हैं? ऐसा इसलिए है क्योंकि सूचकांक शून्य से शुरू होता है, इसलिए सूची (1) सूची के दूसरे तत्व को संदर्भित करता है।

उदाहरण: 3

List = (2, 5, 6.7, ‘Hi’) print(“First element in the List is: ”, List(0)) print(“Last element in the List is: ”, List(3))

आउटपुट:

सूची में पहला तत्व है: 2
सूची में अंतिम तत्व है: हाय

एक्सेसिंग_वापस_इन_लिस्ट_एक्सप्लान_3

आउटपुट:

Accessing_values_in_list_example_3_output

उदाहरण: ४

List = (‘Hi’, (2, 4, 5)) print(“First element of the list is: ”, List(0)(1)) print(“Elements present inside another list is: ”, List(1)(2))

आउटपुट:

सूची का पहला तत्व है: i
एक अन्य सूची के अंदर मौजूद तत्व हैं: 5

एक्सेसिंग_वापस_इन_लिस्ट_एक्सप्ले_४

आउटपुट:

एक्सेसिंग_वाप्स_इन_लिस्ट_एक्सप्लान_4_आउटपुट

उपरोक्त कार्यक्रम में, यदि आप ध्यान से निरीक्षण करते हैं, तो आप देख सकते हैं कि हम तत्वों को नेस्टेड सूची से एक्सेस कर रहे हैं।

आंतरिक रूप से डेटा को नीचे दिखाए गए अनुसार मैट्रिक्स प्रारूप में संग्रहीत किया जाएगा:

नमस्ते

२ ४ ५

इसलिए, जब हम सूची (0) (1) तक पहुंचने का प्रयास करते हैं, तो यह 1 को इंगित करेगा^{अनुसूचित जनजाति}पंक्ति और २^{एन डी}स्तंभ, जिससे डेटा ’i’ होगा

इसी तरह, जब हम सूची (1) (२) तक पहुँचने का प्रयास करते हैं तो यह २ को इंगित करेगा^{एन डी}पंक्ति और ३^{तृतीय}कॉलम, इसके अलावा, डेटा 5 होगा।

नकारात्मक अनुक्रमण

हम एक नकारात्मक सूचकांक के साथ-साथ डेटा का उपयोग कर सकते हैं। एक नकारात्मक सूचकांक हमेशा -1 से शुरू होगा और -1 अंतिम तत्व को संदर्भित करता है और -2 अंतिम दूसरे आइटम को संदर्भित करता है और इसी तरह।

उदाहरण 1

List = (2, 5, 7, 3) print(“Last element in the list is: ”, List(-1))

आउटपुट:

सूची में अंतिम तत्व है: 3

नेगेटिव_इंडैक्सिंग_एक्सप्ले १/१

आउटपुट:

नेगेटिव_इंडैक्सिंग_एक्सप्ले_1_आउटपुट 1

उदाहरण: २

List = (2, 5, 7, 3) print(“Second element in the list is: ”, List(-3))

आउटपुट:

सूची में दूसरा तत्व है: 5

नेगेटिव_इंडैक्सिंग_एक्सप्ले २.२

आउटपुट:

निगेटिव_इंडैक्सिंग_एक्सप्लान्ट 2_आउटपुट 1

सूची का टुकड़ा करना

स्लाइस ऑपरेटर (:) का उपयोग करके हम सूची से तत्वों की एक श्रृंखला का उपयोग कर सकते हैं

उदाहरण 1

List = (1, 2, 3, 4, 5, 6, 7) print(“Elements from 2nd to 5th is: ”, List(1:5)) print(“Elements beginning to 2rd is: ”, List(:-3)) print(“Elements 4th to end is: ”, List(3:)) print(“Elements from start to end is: “, List(:))

आउटपुट:

2 से 5 वें तत्व हैं: (2, 3, 4, 5)
2 वें से शुरू होने वाले तत्व हैं: (1, 2, 3, 4)
चौथे से अंत तक के तत्व हैं: (४, ५, ६,:)
आरंभ से अंत तक के तत्व हैं: (१, २, ३, ४, ५, ६, end)

Slicing_list_example_1.1

आउटपुट:

Slicing_list_example_1_output1

हम लूप का उपयोग करके सूची के अंदर मौजूद तत्वों तक भी पहुंच सकते हैं।

उदाहरण: २

List = (1, 2, 3, 4, 5, 6, 7) forele in List: print(ele)

आउटपुट:

एक
दो
३
४
५
६
।

Slicing_list_example_2

आउटपुट:

Slicing_list_example_2_output1

नीचे दिए गए अनुक्रमण प्रारूप को याद रखें:

एच	है	एल	एल	या	५	।	९	४
०	एक	दो	३	४	५	६	।	।
-9	-8	-7	-6	-5	-4	-3	-2	-1

जैसा कि पहले चर्चा की गई है, अजगर में सूची परिवर्तनशील है, जिसका अर्थ है कि तत्वों को बदल दिया जा सकता है भले ही यह एक इंटेगर या स्ट्रिंग या कोई डेटाटाइप हो।

हम असाइनमेंट ऑपरेटर का उपयोग करके सूची को अपडेट कर सकते हैं।

उदाहरण: 3

List = (2, 4, 6, 9) #updating the first element List(0) = 7 print(“Updated list is: ”, List)

आउटपुट:

अद्यतन सूची है: (7, ४, ६, ९)

Slicing_list_example_3.1

आउटपुट:

Slicing_list_example_3_output1

उपरोक्त उदाहरण में, हम सूची के पहले तत्व above 2 'को एक नए तत्व we 7' के साथ अपडेट कर रहे हैं।

उदाहरण: ४

List = (2, 5, 1, 3, 6, 9, 7) #updating one or more elements of the list at once List(2:6) = (2, 4, 9, 0) print(“Updated List is: ”, List)

आउटपुट:

अद्यतन सूची है: (२, ५, २, ४, ९, ०, ()

उपरोक्त उदाहरण में, हम सूची में डेटा की सूची को अपडेट कर रहे हैं।

Slicing_list_example_4.1

आउटपुट:

Slicing_list_example_4_output1

सूची में तत्वों को जोड़ना

ऐसे कई तरीके हैं जिनसे हम सूची में तत्वों को जोड़ सकते हैं, और अजगर में एक अंतर्निहित फ़ंक्शन है जिसे ऐपेंड () कहा जाता है।

परिशिष्ट () का उपयोग करते हुए, हम सूची में केवल एक तत्व जोड़ सकते हैं, यदि आप सूची में कई तत्व जोड़ना चाहते हैं तो हमें इसका उपयोग करना होगा पाश के लिए । append () फ़ंक्शन हमेशा सूची के अंत में तत्व जोड़ता है, append () फ़ंक्शन केवल एक तर्क लेता है।

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

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

उदाहरण 1

List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List)

आउटपुट:

मूल्य निर्धारण से पहले सूची है: ('नमस्ते', 'गुड मॉर्निंग')
मूल्य निर्धारण के बाद सूची है: ('नमस्ते', 'गुड मॉर्निंग', 'पायथन', 'हाय')

उपरोक्त उदाहरण में, हम सूची के अंत में 'पायथन' और 'हाय' मान जोड़ रहे हैं।

अजगर में जोड़ें ()

आउटपुट:

अजगर उत्पादन में संलग्न ()

उदाहरण: २

List = (“Hello”, “Good Morning”) print(“List before appending values is: “, List) print(“Length of the list before appending is: “, len(List)) List.append(“Python”) List.append(“Hi”) print(“List after appending values is: ”, List) print(“Length of the list after appending is: “, len(List))

आउटपुट:

मूल्य निर्धारण से पहले सूची है: ('नमस्ते', 'गुड मॉर्निंग')
आवेदन करने से पहले सूची की लंबाई है: 2
मूल्य निर्धारण के बाद सूची है: ('नमस्ते', 'गुड मॉर्निंग', 'पायथन', 'हाय')
आवेदन करने के बाद सूची की लंबाई है: 4

हम लेन () फ़ंक्शन का उपयोग करके सूची की लंबाई पा सकते हैं, जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है।

Add_element_to_the_list_example_2

आउटपुट:

Add_element_to_the_list_example_2_output

हम लूप का उपयोग करके सूची में कई मान जोड़ सकते हैं।

उदाहरण: 3

List = (7, 9, 8) print(“List before adding elements is: “, List) print(“Length of List before adding elements is: “, len(List)) for i in range(2, 6): List.append(i) print(“List after adding elements is: “, List) print(“Length of List after adding elements is: “, len(List))

आउटपुट:

तत्वों को जोड़ने से पहले सूची है: (:, ९, is)
तत्वों को जोड़ने से पहले सूची की लंबाई है: 3
तत्वों को जोड़ने के बाद सूची है: (7, 9, 8, 2, 3, 4, 5)
तत्वों को जोड़ने के बाद सूची की लंबाई है: 7

Add_element_to_the_list_example_3

आउटपुट:

Add_element_to_the_list_example_3_output1

यदि हम सूची से सूची में जोड़ देते हैं तो क्या होगा? नीचे के उदाहरण में देखते हैं।

उदाहरण: ४

List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.append(List2) print(“List1 after appending List2 is: “, List1)

आउटपुट:

सूची 2 को शामिल करने के बाद सूची 1 है: ('हाय', 'पायथन', (1, 5, 7, 2))

यदि आप उपरोक्त उदाहरण में देखते हैं, जब हम List2 को List1 में जोड़ते हैं तो List1 एक नेस्टेड सूची बन जाएगी।

Add_element_to_the_list_example_4

आउटपुट:

Add_element_to_the_list_example_4_output

यदि आप सूची को संलग्न करने के बाद सूची को नेस्टेड सूची के रूप में बनाना चाहते हैं, तो विस्तार () विधि का उपयोग करना बेहतर है।

उदाहरण: ५

List1 = (“Hi”, “Python”) List2 = (1, 5, 7, 2) List1.extend(List2) print(“List1 after appending List2 is: “, List1)

आउटपुट:

सूची 2 को शामिल करने के बाद सूची 1 है: ('हाय', 'पायथन', 1, 5, 7, 2)

जब हम विस्तार () विधि का उपयोग करते हैं, तो List1 के तत्वों को List2 के तत्वों के साथ बढ़ाया जाएगा। याद रखें कि जब हम विस्तार () विधि का उपयोग करते हैं तो यह सूची में शामिल नहीं होगी।

Add_element_to_the_list_example_5

आउटपुट:

Add_element_to_the_list_example_5_output

जब आप एक स्ट्रिंग के साथ एक सूची का विस्तार करते हैं, तो यह स्ट्रिंग के प्रत्येक चरित्र को सूची में जोड़ देगा, क्योंकि एक स्ट्रिंग चलने योग्य है।

उदाहरण: ६

List = (1, 5, 7, 2) List.extend(“Python”) print(“List after extending the String is: “, List)

आउटपुट:

स्ट्रिंग का विस्तार करने के बाद सूची है: (१, ५, St, २,, पी ’,’ y ’,‘ t ’,’ h ’,’ o ’,’ n ’)

Add_element_to_the_list_example_6

आउटपुट:

Add_element_to_the_list_example_6_output

सूची परिशिष्ट () बनाम विस्तार ()

आइए विस्तार () और परिशिष्ट () के लिए कुछ उदाहरण देखें।

उदाहरण 1

def my_fun(): List1 = (“Hi”, 1, “Hello”, 2, 5) print(“The elements of List is: “, List) List.append(“Python”) print(“List after appending the String is: “, List) List.append((“one”, “two”, 3)) print(“List after appending the list is: “, List) List2 = (“Apple”, “Orange”, 2, 8) List1.extend(List2) print(“List1 after extending the List2 is: “, List1) if __name__ == “__main__”: my_fun()

आउटपुट:

सूची के तत्व हैं: ('हाय', १, 'नमस्कार', २, ५)
स्ट्रिंग को जोड़ने के बाद सूची है: ('हाय', १, 'हैलो', २, ५, 'पायथन')
सूची संलग्न करने के बाद सूची है: ('हाय', 1, 'हैलो', 2, 5, 'पायथन', ('एक', 'दो', 3))
List1 का विस्तार करने के बाद List1 है: ('Hi', 1, 'Hello', 2, 5, 'Python', ('one', 'two', 3), 'Apple', 'Orange', 2, 8)

List_append_vs_extend_example_1.1

आउटपुट:

List_append_vs_extend_example_3_output1

उदाहरण: २

List = (“Apple”, “Orange”, “Mango”, “Strawberry”) print(“List before inserting is: “, List) List.insert(2, “Watermelon”) print(“List after inserting is: “, List)

आउटपुट:

डालने से पहले सूची है: ('Apple', 'ऑरेंज', 'मैंगो', 'स्ट्राबेरी')
डालने के बाद सूची है: ('Apple', 'ऑरेंज', 'तरबूज', 'आम', 'स्ट्राबेरी')

List_append_vs_extend_example_2.1

उत्पादन

List_append_vs_extend_example_2_output1

जैसा कि हमने पहले चर्चा की, सूची के एक विशिष्ट सूचकांक में मानों को सम्मिलित करने के लिए सम्मिलित () विधि का उपयोग किया जाता है।

उदाहरण: 3

List1 = (2, 4, 6, 8) print(“List after adding the elements is: “, List1 + (1, 3, 5, 7)) print(“After adding same elements repeatedly is: “, (“Hi”) *5)

आउटपुट:

तत्वों को जोड़ने के बाद सूची है: (2, 4, 6, 8, 1, 3, 5, 7)
एक ही तत्व को बार-बार जोड़ने के बाद है: (the Hi ’,, Hi’,, Hi ’,’ Hi ’, repeatedly Hi’)

List_append_vs_extend_example_3.1

आउटपुट:

List_append_vs_extend_example_3_output1

एक सूची से तत्वों को हटाना या निकालना

हम डेल और रिमूव () स्टेटमेंट का उपयोग करके तत्वों को सूची से हटा या हटा भी सकते हैं।

सबसे अच्छा पीसी अनुकूलन सॉफ्टवेयर क्या है

नीचे के उदाहरण में देखते हैं।

उदाहरण 1

List = (1, 2, 3, 4, 5, 6, 7, 8, 9) print(“List before deleting 3rd element is: ”, List) del List(3) print(“List after deleting 3rd element is: ”, List) del List(1:3) print(“List after deleting multiple elements is: “, List)

आउटपुट:

3 तत्व को हटाने से पहले सूची है: (1, 2, 3, 4, 5, 6, 7, 8, 9)
3 तत्व को हटाने के बाद सूची है: (1, 2, 3, 5, 6, 7, 8, 9)
कई तत्वों को हटाने के बाद सूची है: (१, ५, ६, elements, elements, ९)

उपरोक्त उदाहरण में, आप देख सकते हैं कि हमने सूची से किसी तत्व या एकाधिक विवरण को हटाने के लिए डेल स्टेटमेंट का उपयोग किया है।

हटा रहा है_or_removing_element_from_the_list_example_11

आउटपुट:

हटाया जा रहा है_or_removing_element_from_the_list_example_1_output1

अब हम हटाने () विधि के बारे में देखेंगे।

उदाहरण: २

List = (1, 2, 3, 4, 5, 6, 7) print(“List before removing a element is: “, List) List.remove(3) print(“List after removing a element is: “, List) List.pop() print(“List after poping the element is: “, List)

आउटपुट:

एक तत्व को हटाने से पहले सूची है: (१, २, ३, ४, ५, ६, element)
एक तत्व को हटाने के बाद सूची है: (१, २, ४, ५, ६, element)
तत्व को पॉप करने के बाद सूची है: (१, २, ४, ५, ६)

उपरोक्त उदाहरण में, आप देख सकते हैं कि हम सूची से एक तत्व को हटा () विधि का उपयोग कर रहे हैं। सूची से अंतिम तत्व को हटाने / हटाने के लिए पॉप () विधि का उपयोग किया जाता है।

हटाया जा रहा है_or_removing_element_from_the_list_example_2.1

आउटपुट:

हटाया जा रहा है_or_removing_element_from_the_list_example_2_output1

सूची के तरीके

तरीकों	विवरण
स्पष्ट()	सूची से सभी तत्वों को हटाने के लिए।
परिशिष्ट ()	सूची के अंत में तत्व जोड़ने के लिए।
डालें ()	सूची के एक विशिष्ट सूचकांक में तत्व डालने के लिए।
विस्तार ()	सूची के अंत में तत्वों की सूची जोड़ना।
गिनती ()	विशिष्ट मान वाले तत्वों की संख्या वापस करने के लिए।
सूचकांक ()	पहले तत्व के सूचकांक को वापस करने के लिए।
उलटना()	किसी मौजूदा सूची को उलटने के लिए।
हटाना()	तत्वों को सूची से हटाने के लिए।

निष्कर्ष

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

पायथन सूची पर इस ट्यूटोरियल का समापन निम्न बिंदुओं के साथ किया जा सकता है:

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

=> स्क्रैच से अजगर जानने के लिए यहां जाएं

पायथन सूची - तत्वों को बनाएं, एक्सेस, स्लाइस, जोड़ें या हटाएं

पायथन सूची क्या हैं

अजगर सूची के लक्षण

अजगर सूचियाँ कंटेनर अनुक्रम हैं

अजगर सूचियाँ क्रमबद्ध क्रम हैं

पायथन लिस्ट्स म्यूटेबल सीक्वेंस हैं

पायथन सूचियों में हेरफेर

एक सूची बनाना

एक सूची में आइटम जोड़ना

एक सूची से आइटम तक पहुँचने

किसी सूची की उथली प्रतिलिपि बनाएं

एक सूची को उलट दें

एक सूची से आइटम निकालना

एक सूची से आइटम की जगह

बार बार पूछे जाने वाले प्रश्न

पायथन में सूचियों के बारे में अधिक जानकारी

डेटा संरचना क्या है?

सूची क्या है?

एक सूची बनाना

सूची में मान तक पहुँच

नकारात्मक अनुक्रमण

सूची का टुकड़ा करना

सूची में तत्वों को जोड़ना

सूची परिशिष्ट () बनाम विस्तार ()

एक सूची से तत्वों को हटाना या निकालना

सूची के तरीके

निष्कर्ष

अनुशंसित पाठ