मेन्यू

सिंटैक्स और उदाहरणों के साथ कॉमन पायथन लिस्ट के तरीके

  • मुख्य
  • अन्य
  • सिंटैक्स और उदाहरणों के साथ कॉमन पायथन लिस्ट के तरीके

common python list methods with syntax

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

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

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

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

=> यहां सभी पायथन ट्यूटोरियल देखें

पायथन सूची के तरीके

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

सामान्य पायथन सूची के तरीके

इससे पहले कि हम सामान्य सूची विधियों में तल्लीन हों, पायथन सूची की कुछ विशेषताओं को समझना महत्वपूर्ण है।

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

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

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

जोड़ के लिए विधि

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

# 1) list.append (x)

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

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

उदाहरण 1 :नीचे दिए गए कोड में, हमारी सूची में एक है नाम (स्ट्रिंग) पहले आइटम के रूप में और उम्र (संख्या) दूसरी वस्तु के रूप में। हम एक तीसरा आइटम जोड़ना चाहते हैं वेतन (संख्या) सूची में ऐसा है जो हमारे पास है

list(name, age, salary)

नीचे पायथन शेल का एक वॉकथ्रू है।

>>> name = 'Enow Kevin' # define a name >>> age = 30 # define an age >>> details = (name, age) # create a list with name and age >>> details ('Enow Kevin', 30) >>> salary = 165000 # define a salary >>> details.append(salary) # add the salary to the end of the list >>> details ('Enow Kevin', 30, 165000) >>>

list.append (x) ) के समान है सेवा मेरे (लेन सेवा मेरे ):) = (x)।

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

चौथे आइटम को जोड़ने दें लिंग (स्ट्रिंग) ऊपर वर्णित हमारी विवरण सूची में।

>>> gender = 'Male' # define a gender >>> details(len(details):) = (gender) # add gender to the end of the list >>> details ('Enow Kevin', 30, 165000, 'Male') >>>

ध्यान दें :उपरोक्त उदाहरण में, हमने उपयोग किया लेन () जो एक पायथन बिल्ट-इन फ़ंक्शन है जो एक सूची पर काम कर सकता है।

# 2) सूची। कस्टम (चलने योग्य)

विस्तार (iterable) में लेता है a चलने योग्य एक तर्क के रूप में, और उस सूची में प्रत्येक आइटम को सूची में जोड़ना।

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

उदाहरण 2 :बता दें कि हमारे पास दो छात्रों के शैक्षणिक ग्रेड हैं ग्रेडसाइंस तथा ग्रेडआर्ट और हम ग्रेड पर एक आम ऑपरेशन करने का फैसला करते हैं। एक तरीका यह होगा कि पहले उन्हें एक साथ जोड़ा जाए।

नीचे दिए गए पायथन शेल का एक पूर्वाभ्यास है।

>>> gradeScience = (4,3,9,10) # grades in science >>> gradeArt = (9,11,7,5) # grades in art >>> gradeArt (9, 11, 7, 5) >>> gradeArt.extend(gradeScience) # join grades >>> gradeArt # we can now perform the operation on the joined grades (9, 11, 7, 5, 4, 3, 9, 10)

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

def extend_loop(extender, extended): '''for each item in the extender list, append the item into the extended list''' for item in extender: extended.append(item) if __name__ == '__main__': gradeScience = (4,3,9,10) # grades in science gradeArt = (9,11,7,5) # grades in art print('gradeArt: {} before extended'.format(gradeArt)) # join gradeScience and gradeArt into gradeArt extend_loop(gradeScience, gradeArt) print('gradeArt: {} after extended'.format(gradeArt))

उत्पादन

परिशिष्ट (x)

इसके बीच के अंतर को जानना महत्वपूर्ण है परिशिष्ट (x) ) तथा विस्तार (चलने योग्य) ।

पायथन सूची के तरीकों के बीच अंतर: संलग्न और पुनरावृत्ति।

#परिशिष्ट (x)विस्तार (चलने योग्य)
1एक तर्क में ले जाता है और चलने योग्य हो सकता हैएक तर्क में ले जाता है और चलना चाहिए
दोकिसी आइटम को सूची में जोड़ता हैएक सूची में चलने योग्य के प्रत्येक आइटम को जोड़ता है।

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

>>> listApp = () # empty list >>> listExt = () # empty list >>> listApp.append((1,2,3)) # append an iterable >>> listExt.extend((1,2,3)) # extend an iterable >>> listApp # check output ((1, 2, 3)) >>> listExt # check output (1, 2, 3)

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

# 3) सूची.सूची (i, x)

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

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

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

समाधान यह होगा कि हम उस नाम की अनुक्रमणिका स्थिति प्राप्त करें, जिसके पहले हम अपना नया नाम और उपयोग जोड़ना चाहते हैं डालें () उस स्थिति में जोड़ने के लिए।

>>> names = ('kevin','john','petter','tony','luke','andrew')# list of names >>> new_name = 'enow' # new name to be insert into the list of names >>> given_name = 'tony' # name before which to insert our new name >>> idx_given_name = names.index(given_name) # get index of given name >>> idx_given_name 3 >>> names.insert(idx_given_name, new_name) # insert new name >>> names ('kevin', 'john', 'petter', 'enow', 'tony', 'luke', 'andrew')

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

इसकी अवधारणा डालने (index, x) को समझना बहुत जरूरी है। पहला तर्क है सूचकांक स्थिति जिस तत्व को डालने से पहले।

जिसका अर्थ है कि सूची .insert (0, x) इंडेक्स 0 पर आइटम के सामने x सम्मिलित करेगा, और सूची । डालने (केवल ( सूची ), एक्स ) सूचकांक के स्थान से पहले सूची के अंत में (सूची के समान। xend (x)) एक्स को सम्मिलित करेगा लेन (सूची) (यह सूची किसी भी सूची के लिए मौजूद नहीं है)

घटाव के लिए विधि

पाइथन में, जितना हम एक सूची में आइटम जोड़ सकते हैं, उतना ही पायथन सूची हमें सूची से आइटम हटाने या हटाने की भी अनुमति देती है।

# 1) सूची। Pop ((i))

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

यदि कोई नहीं दिया गया है, तो यह -1 को डिफॉल्ट करता है यानी सूची के अंतिम आइटम को हटा दिया जाएगा और वापस कर दिया जाएगा।

उदाहरण 5 :नीचे दी गई कारों की सूची को देखते हुए, हम किसी भी सूचकांक स्थिति में इस सूची से आइटम को हटाने का फैसला कर सकते हैं, जिसकी हम इच्छा करते हैं पॉप ()

>>> cars = ('Toyota','Audi','BMW','Bugatti','Bently','Aston Martin') #cars >>> cars ('Toyota', 'Audi', 'BMW', 'Bugatti', 'Bently', 'Aston Martin') >>> toyota = cars.pop(0) # remove and return car at index 0 >>> cars ('Audi', 'BMW', 'Bugatti', 'Bently', 'Aston Martin') >>> toyota 'Toyota' >>> bugatti = cars.pop(2) # remove and return car at index 2 >>> cars ('Audi', 'BMW', 'Bently', 'Aston Martin') >>> bugatti 'Bugatti' >>> aston_martin = cars.pop() # remove and return the last car in the list(at index -1) >>> cars ('Audi', 'BMW', 'Bently') >>> aston_martin 'Aston Martin'

# 2) list.remove (x)

पायथन सूची विधि निकालें (x) किसी आइटम की पहली घटना को निकालता है जो x के बराबर है।

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

उदाहरण 6 :हमारे पास पुस्तकों की एक सूची है और हम सूची से नाम के अनुसार एक विशिष्ट पुस्तक निकालना चाहते हैं, क्योंकि हमें अब इसकी आवश्यकता नहीं है।

>>> books = ('python for beginners','python in a nutshell','python in action') # list of books >>> books ('python for beginners', 'python in a nutshell', 'python in action') >>> book_to_remove = 'python in a nutshell' # book to be removed >>> books.remove(book_to_remove) # remove book >>> books ('python for beginners', 'python in action')

ध्यान दें: यदि किसी वस्तु को दिया जाता है हटाना() एक तर्क के रूप में लेकिन यह सूची में मौजूद नहीं है, ए मान उठाया है। तो, इस विधि को हमेशा अंदर बुलाया जाना चाहिए कोशिश-सिवाय अपवाद को संभालने के लिए।

हम तरीकों के बीच कुछ अंतर देख सकते हैं पॉप () तथा हटाना() नीचे दिखाए गए रूप में:

#पॉप ()हटाना()
1एक वैकल्पिक तर्क को स्वीकार करता है और हटाए जाने वाले आइटम की एक सूचकांक स्थिति होनी चाहिए। यदि इंडेक्स आउट ऑफ़ रेंज होता है, तो IndexError उठाया जाता हैएक तर्क को स्वीकार करता है और हटाए जाने वाले आइटम होना चाहिए। यदि आइटम सूची में नहीं है, तो एक ValueError उठाया जाता है
दोआइटम को सूची से निकालता है और उसे वापस करता है।आइटम को सूची से निकालता है लेकिन उसे वापस नहीं करता है।

# 3) सूची। अस्पष्ट ()

पायथन सूची विधि स्पष्ट () सूची से सभी आइटम निकालता है, जिससे यह खाली हो जाता है। यह कोई तर्क नहीं लेता है।

नए ऑब्जेक्ट के साथ सूची ऑब्जेक्ट को फिर से असाइन करने के लिए यह विधि उपयोगी है।

उदाहरण 7 :हमारे पास एक सूची है जो नामों का एक संग्रह रखती है, लेकिन हम नामों को नए नामों से बदलना चाहते हैं। इस मामले में, हम पहले सूची को खाली करके पिछले नामों को खाली करते हैं, फिर एक अलग पायथन सूची विधियों में से एक के साथ अपने नए नामों को जोड़ते हैं जो हमने ऊपर देखा था।

>>> names = ('enow','kevin','eyong') # our collection of names >>> names.clear() # clear the list object >>> names () >>> names.extend(('ayamba','derrick','fred')) # add new names with the extend() method >>> names ('ayamba', 'derrick', 'fred')

ध्यान दें :हम उसी चीज को हासिल कर सकते हैं का सूची(:)।

कई यकीनन कह सकते हैं कि उपयोग करने के बजाय स्पष्ट (), क्यों न हम इस तरह से खाली सूची के साथ सूची को फिर से असाइन करें

>>> a = (4,5,3) # list object containing numbers >>> a= () # re-assign to an empty list >>> a ()

वैसे यहाँ ऐसा करने में समस्या है। यदि आपके पास दो चर हैं ( सेवा मेरे तथा ख ) जो सूची ऑब्जेक्ट ((4,5,3)) को संदर्भित करता है, चर (या तो कहें) पर स्पष्ट () सेवा मेरे ) उस संदर्भित सूची ऑब्जेक्ट से आइटम निकाल देगा।

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

>>> a = (4,5,3) # define a list object with numbers >>> b = a # assign 'a' to a new variable 'b' >>> b (4, 5, 3) >>> a = () # re-assign 'a' to an empty list. This changes its referenced object >>> a () >>> b # 'b' doesn't change because it doesn't reference the same list object as 'a' (4, 5, 3)

विश्लेषण के लिए तरीके

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

# 1) सूची .index (x (, प्रारंभ (, अंत)))

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

यह डेस्क साक्षात्कार के सवालों और जवाबों की मदद करता है

अंतिम दो तर्क (शुरू, समाप्त ) एक स्टार्ट और एंड (अनन्य) इंडेक्स निर्धारित करें, जिसमें से खोज करें। जावास्क्रिप्ट जैसी अन्य प्रोग्रामिंग भाषाओं के विपरीत जहां इसकी समकक्ष विधि है के सूचकांक () रिटर्न -1 जब ऐसी कोई वस्तु नहीं है, तो पायथन सूची विधि सूची () इसके बजाय ValueError उठाता है।

उदाहरण 8 :संदर्भ उदाहरण 4 जहाँ हमने उपयोग किया सूची () नामों की सूची में एक नाम की सूचकांक स्थिति प्राप्त करने के लिए। इस उदाहरण 8 में, हम देखेंगे कि सूची के किसी विशेष परिणाम के लिए खोज को सीमित करने के लिए वैकल्पिक तर्कों का उपयोग कैसे करें।

>>> fruits = ('Apples','Avocados','Eggfruit','Apples','Cantaloupe','Cucumbers') # list of fruits >>> fruits.index('Apples',1,3) # find index of 'Apples' from index 1 to index 3(exclusive) Traceback (most recent call last): File '', line 1, in ValueError: 'Apples' is not in list >>> fruits.index('Apples',1,4) # find index of 'Apples' from index 1 to index 4(exclusive) 3 >>> fruits.index('Cucumbers',3) # find index of 'Cucumbers' from index 3 to end of list. 5

# 2) सूची। क्राउन (एक्स)

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

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

उदाहरण 9 : कहो कि हमारे पास एक सूची वस्तु है जो अपने मतों के आधार पर सीनेटरों के नाम रखती है। जितना अधिक एक सीनेट मतदान किया जाता है, उतना ही उसका नाम सूची ऑब्जेक्ट में दिखाई देता है। अब, हम यह पता लगाना चाहते हैं कि किसी विशेष सीनेट के पास कितने वोट हैं।

>>> senate_votes = ('Tammy','John','Tammy','Tammy','Thomas','Maria','Maria') # list of senate names based on their votes >>> senate_votes ('Tammy', 'John', 'Tammy', 'Tammy', 'Thomas', 'Maria', 'Maria') >>> tammy_votes = senate_votes.count('Tammy') # get tammy's vote count >>> tammy_votes 3 >>> thomas_votes = senate_votes.count('Thomas') # get thomas's vote count >>> thomas_votes 1 >>> mike_votes = senate_votes.count('Mike') # get mike's vote count >>> mike_votes 0

ध्यान दें :पायथन सूची विधि गिनती () यदि आइटम सूची में दिखाई नहीं देता है तो शून्य (0) देता है।

# 3) सूची। शब्द (कुंजी = कोई नहीं, उल्टा = गलत)

पायथन सूची विधि तरह () सॉर्ट सूची डेटा जगह में है। यह दो खोजशब्द तर्क देता है।

  • चाभी( कोई नहीं करने के लिए चूक ) : यह सूची से आइटम निकालने के लिए उपयोग किए गए एक तर्क का एक फ़ंक्शन निर्दिष्ट करता है और तुलना के लिए उन्हें तैयार करता है। उदाहरण के लिए, यदि हमारे पास सकारात्मक संख्याओं की एक सूची है, लेकिन हम चाहते हैं कि हमारा प्रकार उनके नकारात्मक मानों को क्रमित करे, तो हम इसे प्राप्त करने के लिए इस कुंजी का उपयोग कर सकते हैं।
  • उलटना( गलत करने के लिए चूक ) : यह एक बूलियन मूल्य है और यदि इसे True पर सेट किया जाता है, तो यह अवरोही क्रम में क्रमबद्ध होगा। इसका मान डिफ़ॉल्ट रूप से गलत है इसलिए यह आरोही क्रम में है।

उदाहरण १० :हमारे पास संख्याओं की एक सूची है और हम उस सूची में सबसे बड़ी संख्या जानना चाहते हैं।

>>> numbers = (4,34,6,1,0, 9,33,82,2) # list of numbers >>> numbers (4, 34, 6, 1, 0, 9, 33, 82, 2) >>> sort_numb = numbers.copy() # make a copy to work with >>> sort_numb.sort(reverse=True) # sort in descending order >>> sort_numb (82, 34, 33, 9, 6, 4, 2, 1, 0) >>> sort_numb(0) # get the first item which is the largest number 82

ध्यान दें: हमने पायथन सूची पद्धति का उपयोग किया प्रतिलिपि () हमारी सूची की उथली प्रतिलिपि बनाने के लिए ( इस पर और बाद)।

उदाहरण 11: कुंजी के उपयोग को प्रदर्शित करने के लिए, सूची में मौजूद वस्तुओं के ऋणात्मक मान को छाँटें।

>>> numbers # list of num (4, 34, 6, 1, 0, 9, 33, 82, 2) >>> sort_neg_numb = numbers.copy() # make a copy to work with >>> sort_neg_numb (4, 34, 6, 1, 0, 9, 33, 82, 2) >>> sort_neg_numb.sort(key=lambda x: -x, reverse=True) # sort in descending order the negative value of each item. >>> sort_neg_numb (0, 1, 2, 4, 6, 9, 33, 34, 82) >>>

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

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

अन्य तरीके

इस खंड में, हम कुछ पायथन सूची विधियों को देखेंगे जो ऊपर वर्णित श्रेणियों में से किसी में नहीं गिर सकती हैं।

(1) सूची। कोपी ()

पायथन विधि प्रतिलिपि () रिटर्न ए उथला सूची की प्रति। शैलो का अर्थ है कि यह सूची के पहले स्तर की एक प्रति बनाता है ( इस पर बाद में ) का है।

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

इसलिए, एक को बदलने से दूसरे को बदलने का कारण होगा।

उदाहरण 12 :संदर्भ उदाहरण १० तथा ग्यारह यह देखने के लिए कि इस पद्धति का उपयोग कैसे किया गया था।

ध्यान दें :यह जानना दिलचस्प है कि, वही हासिल किया जा सकता है टुकड़ा करने की क्रिया () सेवा मेरे (:))

उदाहरण 13 :के अर्थ को बेहतर ढंग से समझने के लिए उथला के वर्णन में प्रतिलिपि (), नीचे दिए गए उदाहरण पर विचार करें।

>>> list1 = (1,2,3) # object list 1 >>> list2 = (0,list1) # object list 2 containing reference to list 1 >>> list2 (0, (1, 2, 3)) >>> list2_copy = list2.copy() # make a shallow copy of list 2 >>> list2_copy (0, (1, 2, 3)) >>> list2(0) = -1 # modify list 2's first level item >>> list2 (-1, (1, 2, 3)) >>> list2_copy # list 2's copy doesn't change (0, (1, 2, 3)) >>> list1(0) = 'a' # modify list 1 >>> list1 ('a', 2, 3) >>> list2 # list 2 changes since it has reference to list 1 (-1, ('a', 2, 3)) >>> list2_copy # list 2's copy changes because the nested list ‘list 1’ wasn't copied. (0, ('a', 2, 3)) >>>

ऊपर दिए गए उदाहरण से पता चलता है कि उथली नकल का मतलब है कि किसी सूची में शामिल किसी भी नेस्टेड को कॉपी नहीं किया जाएगा।

# 2) सूची। पिछला ()

पायथन सूची विधि उलटना () जगह की सूची की वस्तुओं को उलट देता है। यह कोई तर्क नहीं लेता है।

यह विधि तब उपयोगी होती है जब हम क्रमबद्ध करने के बाद आरोही या अवरोही के क्रम को बदलना चाहते हैं।

उदाहरण 14 :हमने अपनी सूची को बढ़ते क्रम में क्रमबद्ध किया है, फिर बाद में, हम क्रमबद्ध सूची के अवरोही क्रम को प्राप्त करना चाहते हैं। हम पायथन सूची पद्धति का भी उपयोग कर सकते हैं तरह () और सेट करें उलटना सच करने के लिए, या हम उपयोग कर सकते हैं उलटना () सूची विधि जैसा कि नीचे दिखाया गया है।

>>> numbs = (3,4,1,8,0,44,5) # our list of disordered numbers >>> numbs (3, 4, 1, 8, 0, 44, 5) >>> numbs.sort() # sort, in ascending by default >>> numbs (0, 1, 3, 4, 5, 8, 44) >>> numbs.reverse() # reverse to arrange in descending order >>> numbs (44, 8, 5, 4, 3, 1, 0) >>>

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

क्यू # 1) मैं पायथन में एक सूची से कुछ कैसे निकालूं?

उत्तर: हम पायथन सूची विधियों और फ़ंक्शन डेल में निर्मित पायथन का उपयोग करके कई तरह से सूची से आइटम निकाल सकते हैं।

  • का उपयोग कर निकालें list.remove (x) : यह सूची से आइटम x निकाल देगा।
>>> a = (4, 3, 6, 1) # our list of numbers >>> a (4, 3, 6, 1) >>> a.remove(3) # remove item '3' from the list >>> a (4, 6, 1) >>>
  • का उपयोग कर निकालें list.pop ((i)) : इसका उपयोग सूची में किसी भी स्थिति में किसी आइटम को हटाने और वापस करने के लिए किया जाता है। यदि कोई अनुक्रमणिका स्थिति नहीं दी गई है, तो यह सूची के अंत में आइटम को हटा देती है।
>>> a = (4, 3, 6, 1) # our list of numbers >>> a.pop() # remove the last item in the list 1 >>> a (4, 3, 6) >>> a.pop(1) # remove the item at index position 1 3 >>> a (4, 6) >>>
  • का उपयोग कर निकालें सूची। अस्पष्ट () : यह सूची में सभी आइटम निकाल देगा।
>>> a = (4, 3, 6, 1) # list of numbers >>> a (4, 3, 6, 1) >>> a.clear() # delete all items >>> a ()
  • का उपयोग कर निकालें का : पायथन में निर्मित फंक्शन डेल का उपयोग सूची से आइटम हटाने के लिए किया जा सकता है।
>>> a = (4, 3, 6, 1) # list of numbers >>> a (4, 3, 6, 1) >>> del a(0) # delete item at index 0 >>> a (3, 6, 1) >>> del a(1) # delete item at index 1 >>> a (3, 1) >>> del a(:) # delete all items. Same as clear() >>> a () >>>

Q # 2) आप पायथन में सूची कैसे छांटते हैं?

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

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

Q # 3) क्या आप पायथन में एक सूची में कई आइटम जोड़ सकते हैं?

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

def append_loop(): list1 = (0,1,2,3) # list 1 list2 = (4,5,6,7) # list 2 # iterate through ‘list 2’ using ‘for loop’, and append each item to list1 for item in list2: list1.append(item) print('Concatenated list is {}'.format(list1)) if __name__ == '__main__': append_loop()

उत्पादन

पायथन में एक सूची में कई आइटम

हम पायथन सूची पद्धति का उपयोग करके कई वस्तुओं को जोड़ सकते हैं विस्तार ()। यह 'की तरह काम करता है संलग्न () में पाश के लिए “जैसा कि हमने ऊपर देखा।

>>> list1 = (0,1,2,3) # list 1 >>> list2 = (4,5,6,7) # list 2 >>> list1.extend(list2) # append each item in list2 into list1 >>> list1 (0, 1, 2, 3, 4, 5, 6, 7) >>>

वैकल्पिक रूप से, हम + ऑपरेटर का उपयोग करके सहमति दे सकते हैं। हालाँकि, यह काम नहीं करता है जगह में । इसका मतलब यह है कि मूल सूची अपरिवर्तित रहने के दौरान संक्षिप्त सूची वापस आ जाएगी।

>>> list1 = (0,1,2,3) # list 1 >>> list2 = (4,5,6,7) # list 2 >>> list3 = list1 + list2 # concatenate using the + operator >>> list3 (0, 1, 2, 3, 4, 5, 6, 7) >>>

निष्कर्ष

इस ट्यूटोरियल में, हम कुछ सामान्य पायथन लिस्ट के तरीकों से गुजरे अपेंड, एक्सटेंड, इंसर्ट, पॉप, रिमूव, क्लियर, इंडेक्स, काउंट, कॉपी, तथा उलटना ।

हमने विभिन्न स्थितियों में इन तरीकों को कैसे लागू किया जाए, इसके कई उदाहरण भी देखे।

=> सभी के लिए पायथन प्रशिक्षण श्रृंखला देखने के लिए यहां जाएं

अनुशंसित पाठ

^