Python लिस्ट से जुड़े 18 सबसे आम सवाल

Python में लिस्ट कैसे बनाएँ, लिस्ट के एलिमेंट्स कैसे चुनें, append() और extend() में क्या अंतर है, NumPy कब उपयोग करें, और बहुत कुछ जानें।

अपडेट किया गया 25 सित॰ 2026 · 15 मि॰ पढ़ें

AI के साथ खोजें

ChatGPT Claude Perplexity

यदि आप सूचियों के बारे में पाठ्यक्रम प्रारूप में सीखना चाहते हैं, तो हमारे Intro to Python for Data Science कोर्स पर नज़र डालें, जिसमें Python की lists पर एक अध्याय है।

पृष्ठभूमि

Lists Python सीखना शुरू करने वालों के साथ-साथ पहले से अनुभवी उपयोगकर्ताओं के बीच भी लगातार लोकप्रिय विषय हैं। यदि हम Google Trends के खोज परिणामों पर भरोसा करें, तो इस विषय में रुचि हर साल बढ़ती रही है।

यदि आप Stack Overflow, Quora या Reddit जैसे फोरम पर Python प्रोग्रामिंग से जुड़े सवाल-जवाब पढ़ते या पूछते हैं, तो आप इसके पीछे का कारण जानते होंगे।

बहुत से Python सवाल इन फोरम तक पहुँचते हैं और वहीं बने रहते हैं, जहाँ उपयोगकर्ता कुछ को ‘डुप्लिकेट’ या ‘स्टिकी’ मार्क करते हैं, उन्हें अपवोट करते हैं या सही समाधान पर चर्चा करते हैं।

इस ब्लॉग पोस्ट के साथ, DataCamp आपका मार्गदर्शन करना चाहता है एक विषय पर—यानी Python में lists से जुड़े सबसे ज़्यादा पूछे जाने वाले सवाल—और वह भी एक इंटरेक्टिव तरीके से!

Python List आखिर है क्या?

Lists Python की चार बिल्ट-इन डेटा स्ट्रक्चर में से एक हैं—साथ में tuples, dictionaries और sets। इनका उपयोग items का एक क्रमबद्ध संग्रह रखने के लिए होता है, जो अलग-अलग प्रकार के हो सकते हैं, हालांकि आमतौर पर एक ही प्रकार के होते हैं। सूची के तत्व कॉमा से अलग होते हैं और स्क्वायर ब्रैकेट्स में लिखे जाते हैं। जैसे इस उदाहरण में:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgVGhlc2UgbGlzdCBlbGVtZW50cyBhcmUgYWxsIG9mIHRoZSBzYW1lIHR5cGVcbnpvbyA9IFsnYmVhcicsICdsaW9uJywgJ3BhbmRhJywgJ3plYnJhJ11cbnByaW50KHpvbylcblxuIyBCdXQgdGhlc2UgbGlzdCBlbGVtZW50cyBhcmUgbm90XG5iaWdnZXJab28gPSBbJ2JlYXInLCAnbGlvbicsICdwYW5kYScsICd6ZWJyYScsIFsnY2hpbXBhbnplZXMnLCAnZ29yaWxsYXMnLCAnb3Jhbmd1dGFucycsICdnaWJib25zJ11dXG5wcmludChiaWdnZXJab28pIn0=

आप देखेंगे कि दूसरी वैरिएबल biggerZoo सूची zoo जैसी ही है। पर आप यह भी देखेंगे कि biggerZoo में एक और सूची शामिल है, जिसमें अलग-अलग तरह के बंदरों के नाम हैं।

क्योंकि Python में lists वस्तुओं या items का क्रमबद्ध संग्रह सहेजती हैं, हम कह सकते हैं कि वे sequence प्रकार हैं—क्योंकि वे sequence की तरह व्यवहार करती हैं। अन्य प्रकार जो sequence माने जाते हैं, वे हैं strings और tuples।

आप सोच सकते हैं कि sequence प्रकारों में खास क्या है? सरल शब्दों में, प्रोग्राम उन पर iterate कर सकता है! इसी कारण lists, strings, tuples और sets को “iterables” कहा जाता है।

यह अवधारणा विशेष रूप से महत्वपूर्ण है; हो सकता है कि आप इसे अन्य डेटा साइंस भाषाओं, जैसे Scala, में भी देखें!

अब असली काम पर आते हैं! आइए उन सवालों में गहराई से जाएँ जो एक Python प्रोग्रामर के रूप में lists को लेकर आपके मन में आते हैं या तंग करते हैं। इस ट्यूटोरियल में हम जिन सभी सवालों के जवाब देंगे, उनकी सूची नीचे है:

1. Python Lists कब उपयोग करें और Tuples, Dictionaries या Sets कब

परिचय पढ़ते समय यह सब सीधा लगता है, लेकिन जब आप कोई छोटा Python स्क्रिप्ट या पूरा प्रोजेक्ट लिख रहे होते हैं, तो list और किसी अन्य sequence प्रकार के बीच चुनाव उतना साफ नहीं रहता।

हालाँकि, अपने डेटा के लिए सही डेटा स्ट्रक्चर चुनना बेहद ज़रूरी है!

और जानने के लिए पढ़ते रहें।

Lists बनाम Tuples

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

आप tuple में तत्व जोड़ नहीं सकते। Tuples के लिए append() या extend() नहीं है,
आप tuple से तत्व हटा नहीं सकते। Tuples में remove() या pop() नहीं है,
आप tuple में तत्व ढूंढ सकते हैं, क्योंकि इससे tuple बदलता नहीं है।
आप in ऑपरेटर का उपयोग करके देख सकते हैं कि कोई तत्व tuple में है या नहीं।

तो, यदि आप मानों का एक स्थिर सेट परिभाषित कर रहे हैं और केवल उस पर iterate करना है, तो list की बजाय tuple का उपयोग करें। यह lists से तेज़ और सुरक्षित होगा, क्योंकि tuples में “write-protect” डेटा होता है।

Lists बनाम Dictionaries

List items का क्रमबद्ध संग्रह सहेजती है, यानी इसमें क्रम बना रहता है। Dictionaries में कोई क्रम नहीं होता।
Dictionaries हर key को किसी value से जोड़ती हैं, जबकि lists में सिर्फ values होती हैं।

जब आपके पास यूनिक keys का अव्यवस्थित सेट हो, जो values से मैप हों, तो dictionary का उपयोग करें।

नोट: क्योंकि keys और values एक-दूसरे से जुड़ी होती हैं, सदस्यता जाँचने जैसे मामलों में प्रदर्शन lists की तुलना में बेहतर होगा।

Lists बनाम Sets

Dictionaries की तरह, sets में items का कोई क्रम नहीं होता। Lists में होता है।
Set में शामिल items का hashable होना ज़रूरी है, जबकि lists non-hashable items भी सहेजती हैं।
Sets में items यूनिक और immutable होने चाहिए। डुप्लिकेट्स मान्य नहीं; lists में डुप्लिकेट्स मान्य हैं और वे mutable हैं।

जब आपके पास hashable, यूनिक और immutable मानों का अव्यवस्थित सेट हो, तो sets का उपयोग करें।

पक्का नहीं कि कौन-से मान hashable हैं?

पक्का करने के लिए नीचे देखें:

Hashable	Non-Hashable
Floats	Dictionaries
Integers	Sets
Tuples	Lists
Strings
`frozenset()`

टिप: हमारी बात पर यक़ीन न करें—खुद आज़माएँ! नीचे आज़माएँ और IPython shell में प्रयोग करें :)

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IHRoZSBgY29sbGVjdGlvbnNgIGxpYnJhcnlcbl9fX18gX19fX1xuXG4jIENoZWNrIGlmIGEgZGljdGlvbmFyeSBpcyBoYXNoYWJsZVxucHJpbnQoaXNpbnN0YW5jZSh7fSwgY29sbGVjdGlvbnMuSGFzaGFibGUpKVxuXG4jIENoZWNrIGlmIGEgZmxvYXQgaXMgaGFzaGFibGVcbnByaW50KGlzaW5zdGFuY2UoMC4xMjUsIGNvbGxlY3Rpb25zLkhhc2hhYmxlKSkiLCJzb2x1dGlvbiI6IiMgSW1wb3J0IHRoZSBgY29sbGVjdGlvbnNgIGxpYnJhcnlcbmltcG9ydCBjb2xsZWN0aW9uc1xuXG4jIENoZWNrIGlmIGEgZGljdGlvbmFyeSBpcyBoYXNoYWJsZVxucHJpbnQoaXNpbnN0YW5jZSh7fSwgY29sbGVjdGlvbnMuSGFzaGFibGUpKVxuXG4jIENoZWNrIGlmIGEgZmxvYXQgaXMgaGFzaGFibGVcbnByaW50KGlzaW5zdGFuY2UoMC4xMjUsIGNvbGxlY3Rpb25zLkhhc2hhYmxlKSkiLCJzY3QiOiJwcmVkZWZfbXNnID0gXCJEaWQgeW91IGFkZCBzb21lIGNvZGUgdG8gaW1wb3J0IGBjb2xsZWN0aW9uc2AgYW5kIHRvIHRlc3QgaWYgYSBmbG9hdCBpcyBoYXNoYWJsZT9cIlxuaW1wb3J0X21zZyA9IFwiRG9uJ3QgZm9yZ2V0IHRvIGltcG9ydCB0aGUgJ2NvbGxlY3Rpb25zJyBsaWJyYXJ5IVwiXG4jIFRlc3QgaW1wb3J0IGBjb2xsZWN0aW9uc2BcbnRlc3RfaW1wb3J0KFwiY29sbGVjdGlvbnNcIiwgc2FtZV9hcyA9IFRydWUsIG5vdF9pbXBvcnRlZF9tc2cgPSBpbXBvcnRfbXNnLCBpbmNvcnJlY3RfYXNfbXNnID0gcHJlZGVmX21zZylcbiMgVGVzdCBwcmludFxudGVzdF9mdW5jdGlvbihcbiAgICBcInByaW50XCIsXG4gICAgbm90X2NhbGxlZF9tc2c9cHJlZGVmX21zZyxcbiAgICBpbmNvcnJlY3RfbXNnPXByZWRlZl9tc2csXG4gICAgZG9fZXZhbD1GYWxzZVxuKVxuc3VjY2Vzc19tc2coXCJBd2Vzb21lIGpvYiFcIikifQ==

नोट: क्योंकि आप hashable items के साथ काम कर रहे हैं, सदस्यता जाँचना (जाँचना कि कोई तत्व आपकी sequence का हिस्सा है या नहीं) sets में lists की तुलना में तेज़ होगा।

2. List से किसी तत्व का चयन कैसे करें

यदि आप इन lists के साथ ठीक से काम करना चाहते हैं, तो आपको इन्हें एक्सेस करना आना चाहिए।

आप आम तौर पर lists को कुछ मान बदलने, अपडेट या डिलीट करने, या उन पर कोई और ऑपरेशन करने के लिए एक्सेस करते हैं। Lists—और विस्तार से अन्य सभी sequence प्रकार—को एक्सेस करने का तरीका index ऑपरेटर [ ] का उपयोग करना है। इसके अंदर आप एक integer मान रखते हैं।

एक उदाहरण देखें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiYmlnZ2VyWm9vID0gWydiZWFyJywgJ2xpb24nLCAncGFuZGEnLCAnemVicmEnLCBbJ2NoaW1wYW56ZWVzJywgJ2dvcmlsbGFzJywgJ29yYW5ndXRhbnMnLCAnZ2liYm9ucyddXSIsInNhbXBsZSI6IiMgU2VsZWN0IHRoZSBmaXJzdCBsaXN0IGVsZW1lbnRcbm9uZVpvb0FuaW1hbCA9IGJpZ2dlclpvb1swXVxuXG4jIFByaW50IGBvbmVab29BbmltYWxgXG5wcmludChfX19fKSIsInNvbHV0aW9uIjoiIyBTZWxlY3QgdGhlIGZpcnN0IGxpc3QgZWxlbWVudFxub25lWm9vQW5pbWFsID0gYmlnZ2VyWm9vWzBdXG5cbiMgUHJpbnQgYG9uZVpvb0FuaW1hbGBcbnByaW50KG9uZVpvb0FuaW1hbCkiLCJzY3QiOiJwcmVkZWZfbXNnID0gXCJEaWQgeW91IHByaW50IGBvbmVab29BbmltYWw/YFwiXG4jIFRlc3Qgb25lWm9vQW5pbWFsXG50ZXN0X29iamVjdChcIm9uZVpvb0FuaW1hbFwiLCB1bmRlZmluZWRfbXNnID0gcHJlZGVmX21zZywgaW5jb3JyZWN0X21zZyA9IHByZWRlZl9tc2cpXG4jVGVzdCBwcmludFxudGVzdF9mdW5jdGlvbihcbiAgICBcInByaW50XCIsXG4gICAgbm90X2NhbGxlZF9tc2c9cHJlZGVmX21zZyxcbiAgICBpbmNvcnJlY3RfbXNnPXByZWRlZl9tc2csXG4gICAgZG9fZXZhbD1GYWxzZVxuKSJ9

कोड चलाएँ और देखें कि यह क्या लौटाता है। आप नोट करेंगे कि biggerZoo का पहला तत्व लौटा है। यह शुरू में थोड़ा भ्रमित कर सकता है, लेकिन indices 1 से नहीं, 0 से शुरू होते हैं।

किसी list का आखिरी तत्व कैसे पाएँ

इस सवाल का उत्तर पिछली व्याख्या का विस्तार है।

इंडेक्स ऑपरेटर में -1 या -2 जैसे नकारात्मक मान डालकर अपनी biggerZoo सूची का आखिरी तत्व निकाल कर देखें!

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiYmlnZ2VyWm9vID0gWydiZWFyJywgJ2xpb24nLCAncGFuZGEnLCAnemVicmEnLCBbJ2NoaW1wYW56ZWVzJywgJ2dvcmlsbGFzJywgJ29yYW5ndXRhbnMnLCAnZ2liYm9ucyddXSIsInNhbXBsZSI6IiMgUGFzcyAtMSB0byB0aGUgaW5kZXggb3BlcmF0b3Igb24gYGJpZ2dlclpvb2Bcbm1vbmtleXMgPSBfX19cbnByaW50KG1vbmtleXMpXG5cbiMgUGFzcyAtMiB0byB0aGUgaW5kZXggb3BlcmF0b3Igb24gYGJpZ2dlclpvb2BcbnplYnJhID0gX19fXG5wcmludCh6ZWJyYSkiLCJzb2x1dGlvbiI6IiMgUGFzcyAtMSB0byB0aGUgaW5kZXggb3BlcmF0b3Igb24gYmlnZ2VyWm9vXG5tb25rZXlzID0gYmlnZ2VyWm9vWy0xXVxucHJpbnQobW9ua2V5cylcblxuIyBQYXNzIC0yIHRvIHRoZSBpbmRleCBvcGVyYXRvciBvbiBiaWdnZXJab29cbnplYnJhID0gYmlnZ2VyWm9vWy0yXVxucHJpbnQoemVicmEpIiwic2N0IjoicHJlZGVmX21zZyA9IFwiTG9vayBhdCB0aGUgcHJldmlvdXMgZXhhbXBsZSB0byBzZWUgaG93IHlvdSBjYW4gY29uc3RydWN0IHRoZSBpbmRleCBvcGVyYXRvciBvbiBgYmlnZ2VyWm9vXCJcbnplYnJhX3ByaW50X21zZyA9IFwiRGlkIHlvdSBwcmludCBgemVicmFgP1wiXG4jIFRlc3Qgb2JqZWN0c1xudGVzdF9vYmplY3QoXCJtb25rZXlzXCIsIHVuZGVmaW5lZF9tc2cgPSBwcmVkZWZfbXNnLCBpbmNvcnJlY3RfbXNnID0gcHJlZGVmX21zZylcbnRlc3Rfb2JqZWN0KFwiemVicmFcIiwgdW5kZWZpbmVkX21zZyA9IHByZWRlZl9tc2csIGluY29ycmVjdF9tc2cgPSBwcmVkZWZfbXNnKVxuI1Rlc3QgcHJpbnRcbnRlc3RfZnVuY3Rpb24oXG4gICAgXCJwcmludFwiLFxuICAgIG5vdF9jYWxsZWRfbXNnPXByZWRlZl9tc2csXG4gICAgaW5jb3JyZWN0X21zZz16ZWJyYV9wcmludF9tc2csXG4gICAgZG9fZXZhbD1GYWxzZVxuKVxuc3VjY2Vzc19tc2coXCJLZWVwIHVwIHRoZSBnb29kIHdvcmshXCIpIn0=

ज़्यादा मुश्किल नहीं है, है ना?

“Index out of range” त्रुटि का मतलब क्या है?

यह त्रुटि आपको अक्सर दिखेगी, खासकर जब आप प्रोग्रामिंग या Python में नए हों।

इसे समझने का सबसे अच्छा तरीका है—खुद आज़माएँ।

ऊपर दिए इंटरेक्टिव विड्जेट का उपयोग करें और बहुत छोटे नकारात्मक या बहुत बड़े धनात्मक नंबर पास करके देखें!

जैसा कि आप देखेंगे, यदि आप इंडेक्स ऑपरेटर को ऐसा integer देते हैं जो आपकी सूची से बड़ा या बहुत छोटा है, तो “Index Out Of Range” त्रुटि मिल सकती है! इसका मतलब है कि आप ऐसे इंडेक्स को संदर्भित कर रहे हैं या मान असाइन कर रहे हैं जो (अभी) अस्तित्व में नहीं है।

यह कोड “Index Out Of Range” त्रुटि ट्रिगर करेगा। चलाएँ और खुद देखें!

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiYmlnZ2VyWm9vID0gWydiZWFyJywgJ2xpb24nLCAncGFuZGEnLCAnemVicmEnLCBbJ2NoaW1wYW56ZWVzJywgJ2dvcmlsbGFzJywgJ29yYW5ndXRhbnMnLCAnZ2liYm9ucyddXSIsInNhbXBsZSI6IiMgUnVuIHRoaXMgY29kZSB0byB0cmlnZ2VyIGFuIFwiSW5kZXggT3V0IE9mIFJhbmdlXCIgRXJyb3JcbmJpZ2dlclpvb1s2XSJ9

Lists में slice नोटेशन

जब आप प्रोग्रामिंग या Python में नए होते हैं, तो यह विषय खासा उलझा सकता है।

आम तौर पर, जब आप एक साथ एक से अधिक तत्व चुनना चाहते हैं, तो आप slice नोटेशन का उपयोग करते हैं। जैसे आप एक तत्व चुनते समय डबल ब्रैकेट्स का उपयोग करते हैं, वैसे ही यहाँ भी करते हैं। खास बात यह है कि integer की जगह आप डबल ब्रैकेट्स के बीच एक : भी रखते हैं, कुछ इस तरह:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiYmlnZ2VyWm9vID0gWydiZWFyJywgJ2xpb24nLCAncGFuZGEnLCAnemVicmEnLCBbJ2NoaW1wYW56ZWVzJywgJ2dvcmlsbGFzJywgJ29yYW5ndXRhbnMnLCAnZ2liYm9ucyddXSIsInNhbXBsZSI6IiMgVXNlIHRoZSBzbGljZSBub3RhdGlvbiBsaWtlIHRoaXNcbnNvbWVab29BbmltYWxzID0gYmlnZ2VyWm9vWzI6IF1cblxuIyBQcmludCB0byBzZWUgd2hhdCB5b3UgZXhhY3RseSBzZWxlY3QgZnJvbSBgYmlnZ2VyWm9vYFxucHJpbnQoc29tZVpvb0FuaW1hbHMpXG5cbiMgVHJ5IHB1dHRpbmcgMiBvbiB0aGUgb3RoZXIgc2lkZSBvZiB0aGUgY29sb25cbm90aGVyWm9vQW5pbWFscyA9IGJpZ2dlclpvb1tfX19fXVxuXG4jIFByaW50IHRvIHNlZSB3aGF0IHlvdSdyZSBnZXR0aW5nIGJhY2tcbnByaW50KG90aGVyWm9vQW5pbWFscykiLCJzb2x1dGlvbiI6IiMgVXNlIHRoZSBzbGljZSBub3RhdGlvbiBsaWtlIHRoaXNcbnNvbWVab29BbmltYWxzID0gYmlnZ2VyWm9vWzI6IF1cblxuIyBQcmludCB0byBzZWUgd2hhdCB5b3UgZXhhY3RseSBzZWxlY3QgZnJvbSBgYmlnZ2VyWm9vYFxucHJpbnQoc29tZVpvb0FuaW1hbHMpXG5cbiMgVHJ5IHB1dHRpbmcgMiBvbiB0aGUgb3RoZXIgc2lkZSBvZiB0aGUgY29sb25cbm90aGVyWm9vQW5pbWFscyA9IGJpZ2dlclpvb1s6Ml1cblxuIyBQcmludCB0byBzZWUgd2hhdCB5b3UncmUgZ2V0dGluZyBiYWNrXG5wcmludChvdGhlclpvb0FuaW1hbHMpIiwic2N0IjoicHJlZGVmX21zZyA9IFwiRGlkIHlvdSBwdXQgcGFzcyBgOjJgIHRvIHRoZSBpbmRleCBvcGVyYXRvcj9cIlxuem9vQW5pbWFsc19wcmludF9tc2cgPSBcIkRpZCB5b3UgcHJpbnQgYG90aGVyWm9vQW5pbWFsc2A/XCJcbiMgVGVzdCBsaXN0IGBsaXN0XG50ZXN0X29iamVjdChcIm90aGVyWm9vQW5pbWFsc1wiLCB1bmRlZmluZWRfbXNnPXByZWRlZl9tc2csIGluY29ycmVjdF9tc2c9cHJlZGVmX21zZylcbiMgVGVzdCBwcmludFxudGVzdF9mdW5jdGlvbihcbiAgICBcInByaW50XCIsXG4gICAgbm90X2NhbGxlZF9tc2c9cHJlZGVmX21zZyxcbiAgICBpbmNvcnJlY3RfbXNnPXpvb0FuaW1hbHNfcHJpbnRfbXNnLFxuICAgIGRvX2V2YWw9RmFsc2VcbilcbnN1Y2Nlc3NfbXNnKFwiWW91IHJvY2shXCIpIn0=

अब हमें biggerZoo सूची मिलती है, लेकिन panda प्रविष्टि (इंडेक्स 2) से आगे की। यानी हम इंडेक्स 2 से शुरू करते हैं और सूची के अंत तक जाते हैं, क्योंकि अन्य कोई integer निर्दिष्ट नहीं है।

अब उल्टा करने पर क्या होगा?

ऊपर का कोड चलाकर जाँचें!

अब हमें केवल bear और lion वापस मिलते हैं। अब हम इंडेक्स 0 से शुरू करते हैं और इंडेक्स 2 तक जाते हैं। आपकी अपेक्षा के विपरीत, परिणाम में panda शामिल नहीं है।

आम तौर पर यह नियम लागू होता है:

# items start through the end (but the end is not included!)
a[start:end]

# items start through the rest of the array
a[start:]    

# items from the beginning through the end (but the end is not included!)
a[:end]

टिप: केवल एक कॉलन : पास करके आप सूची की कॉपी बना लेंगे!

साधारण slice नोटेशन के अलावा, step मान भी होता है, जिसे यूँ लिखा जा सकता है:

# start through not past end, by step
a[start:end:step]

तो step मान करता क्या है?

यह आपको अपनी सूची में “कदम” रखते हुए सिर्फ उन्हीं तत्वों का चयन करने देता है जो step में आते हैं। उदाहरण:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiYmlnZ2VyWm9vID0gWydiZWFyJywgJ2xpb24nLCAncGFuZGEnLCAnemVicmEnLCBbJ2NoaW1wYW56ZWVzJywgJ2dvcmlsbGFzJywgJ29yYW5ndXRhbnMnLCAnZ2liYm9ucyddXSIsInNhbXBsZSI6IiMgUHJpbnQgdG8gc2VlIGhvdyB0aGUgc3RlcCB2YWx1ZSBpbmZsdWVuY2VzIHlvdXIgcmVzdWx0XG5wcmludChiaWdnZXJab29bMjo6Ml0pXG5wcmludChiaWdnZXJab29bMTo6M10pIn0=

नोट: यदि आप step मान निर्दिष्ट नहीं करते, तो यह 1 होता है। तब सूची में चलते समय कोई तत्व नहीं छूटेगा।

याद रखें: slice नोटेशन में जो end इंडेक्स देते हैं, वह परिणाम में शामिल नहीं होता!

List में से कोई तत्व रैंडम तरीके से कैसे चुनें

आप random पैकेज का उपयोग करके अपनी सूची से कोई रैंडम तत्व चुन सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IGBjaG9pY2VgIGZyb20gdGhlIGByYW5kb21gIGxpYnJhcnlcbmZyb20gX19fXyBpbXBvcnQgX19fX1xuXG4jIENvbnN0cnVjdCB5b3VyIGBsaXN0YCB2YXJpYWJsZSB3aXRoIGEgbGlzdCBvZiB0aGUgZmlyc3QgNCBsZXR0ZXJzIG9mIHRoZSBhbHBoYWJldFxubGlzdCA9IFsnXycsJ18nLCdfJywnXyddXG5cbiMgUHJpbnQgeW91ciByYW5kb20gJ2xpc3QnIGVsZW1lbnRcbnByaW50KGNob2ljZShsaXN0KSkiLCJzb2x1dGlvbiI6IiMgSW1wb3J0IGBjaG9pY2VgIGZyb20gdGhlIGByYW5kb21gIGxpYnJhcnlcbmZyb20gcmFuZG9tIGltcG9ydCBjaG9pY2VcblxuIyBDb25zdHJ1Y3QgeW91ciBgbGlzdGAgdmFyaWFibGUgd2l0aCBhIGxpc3Qgb2YgdGhlIGZpcnN0IDQgbGV0dGVycyBvZiB0aGUgYWxwaGFiZXRcbmxpc3QgPSBbJ2EnLCAnYicsICdjJywgJ2QnXVxuXG4jIFByaW50IHlvdXIgcmFuZG9tICdsaXN0JyBlbGVtZW50XG5wcmludChjaG9pY2UobGlzdCkpIiwic2N0IjoicHJlZGVmX21zZyA9IFwiRGlkIHlvdSBhZGQgc29tZSBjb2RlIHRvIGNyZWF0ZSB0aGUgYGxpc3RgIHZhcmlhYmxlP1wiXG5pbXBvcnRfbXNnID0gXCJEb24ndCBmb3JnZXQgdG8gaW1wb3J0IHRoZSAncmFuZG9tJyBsaWJyYXJ5XCJcbnJhbmRvbV9saXN0X3ByaW50X21zZyA9IFwiRGlkIHlvdSBwcmludCB5b3VyIHJhbmRvbSBgbGlzdGAgZWxlbWVudD9cIlxuIyBUZXN0IGxpc3QgbGlzdFxudGVzdF9vYmplY3QoXCJsaXN0XCIsIHVuZGVmaW5lZF9tc2c9cHJlZGVmX21zZywgaW5jb3JyZWN0X21zZz1wcmVkZWZfbXNnKVxuIyBUZXN0IHByaW50XG50ZXN0X2Z1bmN0aW9uKFxuICAgIFwicHJpbnRcIixcbiAgICBub3RfY2FsbGVkX21zZz1wcmVkZWZfbXNnLFxuICAgIGluY29ycmVjdF9tc2c9cmFuZG9tX2xpc3RfcHJpbnRfbXNnLFxuICAgIGRvX2V2YWw9RmFsc2VcbilcbnN1Y2Nlc3NfbXNnKFwiQXdlc29tZSBqb2IhXCIpIn0=

यदि आप अपनी सूची के इंडेक्स के माध्यम से भी कोई रैंडम तत्व चुनना चाहते हैं, तो random लाइब्रेरी के randrange मेथड का उपयोग कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IGByYW5kcmFuZ2VgIGZyb20gdGhlIGByYW5kb21gIGxpYnJhcnlcbmZyb20gX19fXyBpbXBvcnQgX19fX1xuXG4jIENvbnN0cnVjdCB5b3VyIGByYW5kb21MZXR0ZXJzYCB2YXJpYWJsZSB3aXRoIGEgbGlzdCBvZiB0aGUgZmlyc3QgNCBsZXR0ZXJzIG9mIHRoZSBhbHBoYWJldFxucmFuZG9tTGV0dGVycyA9IFsnXycsJ18nLCAnXycsICdfJ11cblxuIyBTZWxlY3QgYSByYW5kb20gaW5kZXggZnJvbSAncmFuZG9tTGV0dGVyc2BcbnJhbmRvbUluZGV4ID0gcmFuZHJhbmdlKDAsbGVuKHJhbmRvbUxldHRlcnMpKVxuXG4jIFByaW50IHlvdXIgcmFuZG9tIGVsZW1lbnQgZnJvbSBgcmFuZG9tYFxucHJpbnQocmFuZG9tTGV0dGVyc1tyYW5kb21JbmRleF0pIiwic29sdXRpb24iOiIjIEltcG9ydCBgcmFuZHJhbmdlYCBmcm9tIHRoZSBgcmFuZG9tYCBsaWJyYXJ5XG5mcm9tIHJhbmRvbSBpbXBvcnQgcmFuZHJhbmdlXG5cbiMgQ29uc3RydWN0IHlvdXIgYHJhbmRvbUxldHRlcnNgIHZhcmlhYmxlIHdpdGggYSBsaXN0IG9mIHRoZSBmaXJzdCA0IGxldHRlcnMgb2YgdGhlIGFscGhhYmV0XG5yYW5kb21MZXR0ZXJzID0gWydhJywgJ2InLCAnYycsICdkJ11cblxuIyBTZWxlY3QgYSByYW5kb20gaW5kZXggZnJvbSAncmFuZG9tTGV0dGVyc2BcbnJhbmRvbUluZGV4ID0gcmFuZHJhbmdlKDAsbGVuKHJhbmRvbUxldHRlcnMpKVxuXG4jIFByaW50IHlvdXIgcmFuZG9tIGVsZW1lbnQgZnJvbSBgcmFuZG9tYFxucHJpbnQocmFuZG9tTGV0dGVyc1tyYW5kb21JbmRleF0pIiwic2N0IjoicHJlZGVmX21zZyA9IFwiRGlkIHlvdSBhZGQgc29tZSBjb2RlIHRvIGltcG9ydCBgcmFuZG9tYCBhbmQgZGlkIHlvdSBjcmVhdGUgdGhlIGBsaXN0YCB2YXJpYWJsZT9cIlxucmFuZG9tX3ByaW50X21zZyA9IFwiRGlkIHlvdSBwcmludCB5b3VyIHJhbmRvbSBlbGVtZW50IGZyb20gYHJhbmRvbWA/XCJcbiMgVGVzdCBsaXN0IGByYW5kb21MZXR0ZXJzYFxudGVzdF9vYmplY3QoXCJyYW5kb21MZXR0ZXJzXCIsIHVuZGVmaW5lZF9tc2c9cHJlZGVmX21zZywgaW5jb3JyZWN0X21zZz1wcmVkZWZfbXNnKVxuIyBUZXN0IHByaW50XG50ZXN0X2Z1bmN0aW9uKFxuICAgIFwicHJpbnRcIixcbiAgICBub3RfY2FsbGVkX21zZz1wcmVkZWZfbXNnLFxuICAgIGluY29ycmVjdF9tc2c9cmFuZG9tX3ByaW50X21zZyxcbiAgICBkb19ldmFsPUZhbHNlXG4pXG5zdWNjZXNzX21zZyhcIldlbGwgZG9uZSFcIikifQ==

टिप: random लाइब्रेरी ज़रूर देखें—Python में प्रोग्रामिंग करते समय यह उपयोगी रहेगी!

3. Python Lists को अन्य डेटा स्ट्रक्चर में कैसे बदलें

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

List को String में कैसे बदलें

आप ''.join() का उपयोग करके list को string में बदलते हैं। यह ऑपरेशन आपकी सूची में मौजूद सभी strings को आपस में जोड़कर एक string लौटा देता है। और पढ़ें यहाँ।

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgTGlzdCBvZiBTdHJpbmdzIHRvIGEgU3RyaW5nXG5saXN0T2ZTdHJpbmdzID0gWydPbmUnLCAnVHdvJywgJ1RocmVlJ11cbnN0ck9mU3RyaW5ncyA9ICcnLmpvaW4obGlzdE9mU3RyaW5ncylcbnByaW50KHN0ck9mU3RyaW5ncylcblxuIyBMaXN0IE9mIEludGVnZXJzIHRvIGEgU3RyaW5nXG5saXN0T2ZOdW1iZXJzID0gWzEsIDIsIDNdXG5zdHJPZk51bWJlcnMgPSAnJy5qb2luKHN0cihuKSBmb3IgbiBpbiBsaXN0T2ZOdW1iZXJzKVxucHJpbnQoc3RyT2ZOdW1iZXJzKSJ9

नोट: यदि आपकी सूची में केवल integers हैं, तो join करने से पहले तत्वों को string में बदलें। ऊपर के दूसरे उदाहरण में यही दिखाया गया है।

Integer को string में बदलना मूल listOfNumbers सूची पर लूप चलाकर किया जाता है। यदि आप सूची पर लूप के बारे में और जानना चाहते हैं, तो सवाल 12 और उसका उत्तर देखें।

List को Tuple में कैसे बदलें

Python में आप tuple() फ़ंक्शन से list को tuple में बदल सकते हैं। अपनी list इसमें पास करें और आपको tuple मिल जाएगा!

याद रखें: tuples अपरिवर्तनीय होते हैं। बाद में आप उन्हें बदल नहीं सकते!

टिप: अगली सेक्शन के इंटरेक्टिव अभ्यास में आप अपनी listOfStrings को tuple में बदल कर देखें।

अपनी List को Python में Set में कैसे बदलें

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

आप set() फ़ंक्शन से list को set में बदल सकते हैं। बस सूची पास करें!

अब अपनी सूची listOfStrings को यहाँ tuple और set में रूपांतरित करने का अभ्यास करें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoibGlzdE9mU3RyaW5ncyA9IFsnT25lJywgJ1R3bycsICdUaHJlZSddIiwic2FtcGxlIjoiIyBQYXNzIHlvdXIgbGlzdCB0byBgdHVwbGUoKWBcbnR1cGxlKF9fXylcblxuIyBUcmFuc2Zvcm0geW91ciBsaXN0IGludG8gYSBzZXRcbnNldChfX18pIiwic29sdXRpb24iOiIjIFBhc3MgeW91ciBsaXN0IHRvIGB0dXBsZSgpYFxudHVwbGUobGlzdE9mU3RyaW5ncylcblxuIyBUcmFuc2Zvcm0geW91ciBsaXN0IGludG8gYSBzZXRcbnNldChsaXN0T2ZTdHJpbmdzKSIsInNjdCI6InByZWRlZl9tc2cgPSBcIkRpZCB5b3UgcGFzcyBgbGlzdE9mU3RyaW5nc2AgdG8gYm90aCBgdHVwbGUoKWAgYW5kIGBzZXQoKWA/XCJcbiMgVGVzdCBsZW5ndGggYGp1c3RBTGlzdGBcbnRlc3RfZnVuY3Rpb24oXG4gICAgXCJ0dXBsZVwiLFxuICAgIG5vdF9jYWxsZWRfbXNnPXByZWRlZl9tc2csXG4gICAgaW5jb3JyZWN0X21zZz1wcmVkZWZfbXNnLFxuICAgIGRvX2V2YWw9RmFsc2VcbilcbnRlc3RfZnVuY3Rpb24oXG4gICAgXCJzZXRcIixcbiAgICBub3RfY2FsbGVkX21zZz1wcmVkZWZfbXNnLFxuICAgIGluY29ycmVjdF9tc2c9cHJlZGVmX21zZyxcbiAgICBkb19ldmFsPUZhbHNlXG4pXG5zdWNjZXNzX21zZyhcIkdvb2Qgam9iIVwiKSJ9

Lists को Dictionaries में कैसे बदलें

Dictionary keys और values के साथ काम करती है, इसलिए list से dictionary में रूपांतरण थोड़ा कम सीधा हो सकता है। मान लें आपके पास ऐसी सूची है:

helloWorld = ['hello','world','1','2']

आपको सुनिश्चित करना होगा कि ‘hello’ और ‘world’ तथा ‘1’ और ‘2’ को key-value युग्मों की तरह समझा जाए। इसका तरीका है slice नोटेशन से इन्हें चुनना और zip() में पास करना।

zip() अपेक्षित तरीके से काम करता है: यह तत्वों को “एक साथ ज़िप” कर देता है। इस मामले में, जब आप helloWorld के तत्व helloWorld[0::2] और helloWorld[1::2] को zip करते हैं, तो आपका आउटपुट होगा:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaGVsbG9Xb3JsZCA9IFsnaGVsbG8nLCd3b3JsZCcsJzEnLCcyJ10iLCJzYW1wbGUiOiJsaXN0KHppcChoZWxsb1dvcmxkKSkifQ==

नोट: zip() के परिणाम को छापने के लिए list() का उपयोग करना होगा।

इसके बाद आप इसे dict() फ़ंक्शन को पास करेंगे, जो hello को key और world को value मानेगा। इसी तरह 1 key और 2 value मानी जाएगी।

पुष्टि करने के लिए नीचे दिया कोड चलाएँ:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaGVsbG9Xb3JsZCA9IFsnaGVsbG8nLCd3b3JsZCcsJzEnLCcyJ10iLCJzYW1wbGUiOiIjIENvbnZlcnQgdG8gYSBkaWN0aW9uYXJ5XG5oZWxsb1dvcmxkRGljdGlvbmFyeSA9IGRpY3QoemlwKGhlbGxvV29ybGRbMDo6Ml0sIGhlbGxvV29ybGRbMTo6Ml0pKVxuXG4jIFByaW50IG91dCB0aGUgcmVzdWx0XG5wcmludChoZWxsb1dvcmxkRGljdGlvbmFyeSkifQ==

नोट: zip() को पास किया गया दूसरा तत्व step मान का उपयोग करता है ताकि केवल world और 2 ही चुने जाएँ। उसी तरह पहला तत्व hello और 1 को चुनता है।

यदि आपकी सूची बड़ी है, तो आप शायद कुछ ऐसा करना चाहेंगे:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImEgPSBbMSwgMiwgMywgNCwgNV1cblxuIyBDcmVhdGUgYSBsaXN0IGl0ZXJhdG9yIG9iamVjdFxuaSA9IGl0ZXIoYSlcblxuIyBaaXAgYW5kIGNyZWF0ZSBhIGRpY3Rpb25hcnlcbnByaW50KGRpY3QoemlwKGksIGkpKSkifQ==

नोट: iterable ऑब्जेक्ट आपको iterator दे सकता है। Iterator, जिसके पास .__next__ मेथड होता है, इस बात की जानकारी रखता है कि आप iteration में अभी कहाँ हैं: उसे अगले तत्व का पता रहता है।

4. Python में अपनी List का आकार कैसे जानें

अपनी सूची को len() फ़ंक्शन में पास करें और सूची की लंबाई प्राप्त करें।

नीचे आज़माएँ! हमने justAList नाम की सूची पहले से बना रखी है, जिसका उपयोग आप कर सकते हैं।

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoianVzdEFMaXN0ID0gWzEsMiwzLCA0LCA1LCA2LCA3LCA4LDksIDEwXSIsInNhbXBsZSI6IiMgUGFzcyBganVzdEFMaXN0YCB0byBgbGVuKClgXG5sZW4oX19fXykiLCJzb2x1dGlvbiI6IiMgUGFzcyBganVzdEFMaXN0YCB0byBgbGVuKClgXG5sZW4oanVzdEFMaXN0KSIsInNjdCI6InByZWRlZl9tc2cgPSBcIkRpZCB5b3UgcGFzcyBganVzdEFMaXN0YCB0byB0aGUgYGxlbigpYCBmdW5jdGlvbj9cIlxuIyBUZXN0IGxlbmd0aCBganVzdEFMaXN0YFxudGVzdF9mdW5jdGlvbihcbiAgICBcImxlblwiLFxuICAgIG5vdF9jYWxsZWRfbXNnPXByZWRlZl9tc2csXG4gICAgaW5jb3JyZWN0X21zZz1wcmVkZWZfbXNnLFxuICAgIGRvX2V2YWw9RmFsc2VcbilcbnN1Y2Nlc3NfbXNnKFwiVGhhdCB3YXMgZWFzeSFcIikifQ==

नोट: len() केवल सूचियों के लिए नहीं, बल्कि अन्य sequences या collections, जैसे dictionaries, sets, strings आदि पर भी काम करता है। और सामान्य बिल्ट-इन फ़ंक्शंस यहाँ देखें।

5. Python के `append()` और `extend()` मेथड में क्या अंतर है?

इस सवाल को समझने के लिए पहले पोस्ट के पहले भाग में समझाए गए iterable के कॉन्सेप्ट को दोहराते हैं:

याद रखें: हम किसी मान को iterable तब कहते हैं जब प्रोग्राम उस पर iterate कर सके। यानी, iterable वह मान है जो एक या अधिक मानों के sequence का प्रतिनिधित्व करता है। जैसा कि आपने पहले भाग में पढ़ा, lists sequences हैं, और Python के सभी sequence प्रकारों के ऑब्जेक्ट iterables होते हैं।

टिप: आप यह जाँच सकते हैं कि कोई वैरिएबल iterable है या नहीं, जब उसके पास .__iter__ मेथड हो—जैसे इस कोड में:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgVGhpcyBpcyB5b3VyIGxpc3Rcbmxpc3QgPSBbNSwgNiwgNywgOCwgOV1cblxuIyBDaGVjayB3aGV0aGVyIGl0J3MgaXRlcmFibGVcbmxpc3QuX19pdGVyX18ifQ==

ऊपर का कोड चलाएँ और IPython shell में कुछ और सरल उदाहरण आज़माएँ!

अब जबकि iterable की अवधारणा स्पष्ट है, हम दोनों मेथड्स का फर्क समझ सकते हैं। एक तरफ, extend() किसी iterable (हाँ, list, set, tuple या string!) को लेता है और उसके हर तत्व को एक-एक करके list में जोड़ देता है।

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

नीचे दिए कोड टुकड़ों का अध्ययन करें और खुद खेलकर देखें ताकि दोनों मेथड्स का फर्क समझ में आए:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoic2hvcnRMaXN0ID0gWzEsIDIsIDNdXG5sb25nZXJMaXN0ID0gWzEsIDIsIDMsIDQsIDUsIDZdIiwic2FtcGxlIjoiIyBBcHBlbmQgWzQsNV0gdG8gYHNob3J0TGlzdGBcbnNob3J0TGlzdC5hcHBlbmQoWzQsIDVdKVxuXG4jIFVzZSB0aGUgcHJpbnQoKSBtZXRob2QgdG8gc2hvdyBzaG9ydExpc3RcbnByaW50KF9fX18pXG5cbiMgRXh0ZW5kIGBsb25nZXJMaXN0YCB3aXRoIFs0LDVdXG5sb25nZXJMaXN0LmV4dGVuZChbNCwgNV0pXG5cbiMgVXNlIHRoZSBwcmludCgpIG1ldGhvZCB0byBzZWUgbG9uZ2VyTGlzdFxucHJpbnQoX19fXykiLCJzb2x1dGlvbiI6IiMgQXBwZW5kIFs0LDVdIHRvIGBzaG9ydExpc3RgXG5zaG9ydExpc3QuYXBwZW5kKFs0LCA1XSlcblxuIyBVc2UgdGhlIGBwcmludCgpYCBtZXRob2QgdG8gc2hvdyBgc2hvcnRMaXN0YFxucHJpbnQoc2hvcnRMaXN0KVxuXG4jIEV4dGVuZCBgbG9uZ2VyTGlzdGAgd2l0aCBbNCw1XVxubG9uZ2VyTGlzdC5leHRlbmQoWzQsIDVdKVxuXG4jIFVzZSB0aGUgYHByaW50KClgIG1ldGhvZCB0byBzZWUgYGxvbmdlckxpc3RgXG5wcmludChsb25nZXJMaXN0KSIsInNjdCI6InByZWRlZl9tc2cgPSBcIkRpZCB5b3UgcGFzcyBgc2hvcnRMaXN0YCBhbmQgYGxvbmdlckxpc3RgIHRvIHRoZSBgcHJpbnQoKWAgZnVuY3Rpb24/XCJcbmxpc3RfcHJpbnRfbXNnID0gXCJEaWQgeW91IHB1dCBgc2hvcnRMaXN0YCBpbiBgcHJpbnQoKWA/XCJcbiMgVGVzdCBwcmludCBzaG9ydExpc3RcbnRlc3RfZnVuY3Rpb24oXG4gICAgXCJwcmludFwiLFxuICAgIG5vdF9jYWxsZWRfbXNnPXByZWRlZl9tc2csXG4gICAgaW5jb3JyZWN0X21zZz1saXN0X3ByaW50X21zZyxcbiAgICBkb19ldmFsPUZhbHNlXG4pXG4jIFRlc3Q6IFByaW50IGxvbmdlckxpc3QgY29udGVudHNcbmxpc3RfcHJpbnRfbXNnMiA9IFwiRGlkIHlvdSBwdXQgYGxvbmdlckxpc3RgIGluIGBwcmludCgpYD9cIlxudGVzdF9mdW5jdGlvbihcbiAgICBcInByaW50XCIsXG4gICAgbm90X2NhbGxlZF9tc2c9cHJlZGVmX21zZyxcbiAgICBpbmNvcnJlY3RfbXNnPWxpc3RfcHJpbnRfbXNnMixcbiAgICBkb19ldmFsPUZhbHNlXG4pXG5zdWNjZXNzX21zZyhcImBhcHBlbmQoKWAgYW5kIGBleHRlbmQoKWAgaG9sZCBubyBzZWNyZXRzIGZvciB5b3UhXCIpIn0=

आप देख सकते हैं कि extend() कई बार append() कॉल करने की तुलना में ज़्यादा कुशल है।

6. Python में Lists को जोड़ना (concatenate) कैसे करें

Lists को concatenate करने के लिए आप + ऑपरेटर का उपयोग करते हैं। यह आपको एक नई सूची देता है, जो आपकी दोनों सूचियों का संयोजन होती है, और मूल सूचियों को नहीं बदलता।

नोट: concatenating और appending में भ्रम हो सकता है। append() + ऑपरेटर से अलग है; और + ऑपरेटर extend() से मिलता-जुलता है, पर बिल्कुल वही नहीं... append() और extend() के साथ, आप मूल सूची बदलते हैं, जबकि + ऑपरेटर से आप दूसरी सूची वैरिएबल बना सकते हैं।

खुद आज़माएँ और पिछले कोड टुकड़े के उदाहरणों से तुलना करें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoic2hvcnRMaXN0ID0gWzEsIDIsIDNdIiwic2FtcGxlIjoiIyBDb25jYXRlbmF0ZSBgc2hvcnRMaXN0YCB3aXRoIGBbNCw1XWBcbnBsdXNMaXN0ID0gc2hvcnRMaXN0ICsgWzQsNV1cblxuI1VzZSB0aGUgYHByaW50KClgIG1ldGhvZCB0byBzZWUgYHBsdXNMaXN0YFxucHJpbnQoX19fXykiLCJzb2x1dGlvbiI6IiMgQ29uY2F0ZW5hdGUgYHNob3J0TGlzdGAgd2l0aCBgWzQsNV1gXG5wbHVzTGlzdCA9IHNob3J0TGlzdCArIFs0LDVdXG5cbiNVc2UgdGhlIGBwcmludCgpYCBtZXRob2QgdG8gc2VlIGBwbHVzTGlzdGBcbnByaW50KHBsdXNMaXN0KSIsInNjdCI6InByZWRlZl9tc2cgPSBcIkRpZCB5b3UgcGFzcyBgcGx1c0xpc3RgIHRvIHRoZSBgcHJpbnQoKWAgZnVuY3Rpb24/XCJcbnBsdXNfcHJpbnRfbXNnID0gXCJEaWQgeW91IHB1dCBgcGx1c0xpc3RgIGluIGBwcmludCgpYD9cIlxuIyBUZXN0IHByaW50IHBsdXNMaXN0XG50ZXN0X2Z1bmN0aW9uKFxuICAgIFwicHJpbnRcIixcbiAgICBub3RfY2FsbGVkX21zZz1wcmVkZWZfbXNnLFxuICAgIGluY29ycmVjdF9tc2c9cGx1c19wcmludF9tc2csXG4gICAgZG9fZXZhbD1GYWxzZVxuKVxuc3VjY2Vzc19tc2coXCJFYXN5IHBlYXN5IVwiKSJ9

7. Python में List को sort कैसे करें

अपनी सूची के मानों को आरोही या अवरोही क्रम में लाने के दो आसान तरीके हैं:

sort() मेथड का उपयोग करें
या sorted() फ़ंक्शन का उपयोग करें और सूची पास करें

sorted() फ़ंक्शन किसी भी Iterable ऑब्जेक्ट पर लागू किया जा सकता है—यानी यह strings, sets, dictionaries आदि को भी स्वीकार करता है!

टिप: खुद आज़माएँ! हमने पहले से दो सूचियाँ rooms और orders बना दी हैं, जिन्हें आप ऊपर दिए दोनों तरीकों से sort कर सकते हैं :)

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoicm9vbXMgPSBbMzk3LCA4NywgMjk4LCA1MDMsIDQwMl1cbm9yZGVycyA9IFs3NiwgMywgNCwgNV0iLCJzYW1wbGUiOiIjIFVzZSBzb3J0KCkgb24gdGhlIHJvb21zIGxpc3Rcbl9fX18uc29ydCgpXG5cbiMgUHJpbnQgb3V0IHJvb21zIHRvIHNlZSB0aGUgcmVzdWx0XG5wcmludChfX19fKVxuXG4jIE5vdyB1c2UgdGhlIHNvcnRlZCgpIGZ1bmN0aW9uIG9uIG9yZGVyc1xuc29ydGVkKF9fX18pXG5cbiMgUHJpbnQgb3V0IG9yZGVyc1xucHJpbnQoX19fXykiLCJzb2x1dGlvbiI6IiMgVXNlIGBzb3J0KClgIG9uIHRoZSBgcm9vbXNgIGxpc3RcbnJvb21zLnNvcnQoKVxuXG4jIFByaW50IG91dCBgcm9vbXNgIHRvIHNlZSB0aGUgcmVzdWx0XG5wcmludChyb29tcylcblxuIyBOb3cgdXNlIHRoZSBgc29ydGVkKClgIGZ1bmN0aW9uIG9uIHRoZSBgb3JkZXJzYCBsaXN0XG5zb3J0ZWQob3JkZXJzKVxuXG4jIFByaW50IG91dCBvcmRlcnNcbnByaW50KG9yZGVycykiLCJzY3QiOiJwcmVkZWZfbXNnID0gXCJQdXQgaW4gYHJvb21zLnNvcnQoKWAsIHByaW50IGByb29tc2AgYW5kIHRoZW4gdXNlIGBzb3J0ZWQob3JkZXJzKWAgdG8gc29ydCB0aGUgb3JkZXJzIGFnYWluLlwiXG4jIFRlc3Qgc29ydCByb29tcyB3aXRoIHNvcnQoKVxudGVzdF9mdW5jdGlvbihcInJvb21zLnNvcnRcIiwgbm90X2NhbGxlZF9tc2c9XCJNYWtlIHN1cmUgdG8gc29ydCB0aGUgYHJvb21zYCBsaXN0LlwiKVxuIyBUZXN0OiBQcmludCBmaWxlIGNvbnRlbnRzXG5wcmludF9yb29tc19tc2cgPSBcIkRpZCB5b3UgcHV0IGByb29tc2AgaW4gYHByaW50KClgP1wiXG50ZXN0X2Z1bmN0aW9uKFxuICAgIFwicHJpbnRcIixcbiAgICBub3RfY2FsbGVkX21zZz1wcmVkZWZfbXNnLFxuICAgIGluY29ycmVjdF9tc2c9cHJpbnRfcm9vbXNfbXNnLFxuICAgIGRvX2V2YWw9RmFsc2VcbilcbnRlc3RfZnVuY3Rpb24oXCJzb3J0ZWRcIiwgbm90X2NhbGxlZF9tc2c9XCJNYWtlIHN1cmUgdG8gcGFzcyB0aGUgYG9yZGVyc2AgbGlzdCB0byBgc29ydGVkKClgLlwiKVxuc3VjY2Vzc19tc2coXCJHcmVhdCBqb2IhXCIpIn0=

नोट: sorting के बाद आपकी मूल सूची बदल जाती है। इसे तभी उपयोग करें जब मूल सूची की अब आवश्यकता न हो।

8. Python में किसी सूची को Clone या Copy कैसे करें

एक सूची को क्लोन या कॉपी करने के कई तरीके हैं:

आप अपनी मूल सूची को स्लाइस करके एक नए वेरिएबल में स्टोर कर सकते हैं: newList = oldList[:]
आप बिल्ट-इन list() फ़ंक्शन का उपयोग कर सकते हैं: newList = list(oldList)
आप copy लाइब्रेरी का उपयोग कर सकते हैं:
- copy() मेथड के साथ: newList = copy.copy(oldList)
- यदि आपकी सूची में ऑब्जेक्ट्स हैं और आप उन्हें भी कॉपी करना चाहते हैं, तो आप copy.deepcopy() का उपयोग कर सकते हैं: copy.deepcopy(oldList)

नीचे आज़माएँ! हमने आपके लिए एक groceries सूची पहले ही बना दी है जिसे आप कॉपी करके अपने दोस्तों के साथ साझा कर सकते हैं।

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

ध्यान दें कि जब आप ‘साधारण’ कॉपी विधियों का उपयोग करते हैं, तो आपकी मूल सूचियाँ संशोधित हो जाएँगी। हालाँकि, यदि आप deepcopy() मेथड का उपयोग करते हैं, तो यह रोका जाएगा। नीचे का कोड चलाकर देखें क्या होता है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgVGhpcyBpcyB5b3VyIGxpc3Rcbm9iamVjdExpc3QgPSBbJ2EnLCdiJyxbJ2FiJywnYmEnXV1cblxuIyBDb3B5IHRoZSBgb2JqZWN0TGlzdGBcbmNvcGllZExpc3QgPSBvYmplY3RMaXN0WzpdXG5cbiMgQ2hhbmdlIHRoZSBmaXJzdCBsaXN0IGVsZW1lbnQgb2YgYGNvcGllZExpc3RgXG5jb3BpZWRMaXN0WzBdID0gJ2MnXG5cbiMgR28gdG8gdGhlIHRoaXJkIGVsZW1lbnQgKHRoZSBuZXN0ZWQgbGlzdCkgYW5kIGNoYW5nZSB0aGUgc2Vjb25kIGVsZW1lbnRcbmNvcGllZExpc3RbMl1bMV0gPSAnZCdcblxuIyBQcmludCBvdXQgdGhlIG9yaWdpbmFsIGxpc3QgdG8gc2VlIHdoYXQgaGFwcGVuZWQgdG8gaXRcbnByaW50KG9iamVjdExpc3QpIn0=

आपमें से जिन्होंने Python में सूचियों को पहले से ही अगले स्तर तक ले लिया है, उनके लिए अगला खंड आपकी जटिल शंकाओं के सरल जवाब पेश करता है।

लेकिन, जो यह सोच रहे हैं कि सूचियों के परे क्या है, या बिल्ट-इन सूची संरचना की बजाय लाइब्रेरियाँ क्या फायदे दे सकती हैं, उनके लिए अगला खंड निश्चित तौर पर उपयोगी रहेगा।

और जानने के लिए पढ़ते रहें!

9. Python में List Comprehension कैसे काम करता है?

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

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6Ilt4KioyIGZvciB4IGluIHJhbmdlKDEwKV0ifQ==

अब, इसका मतलब क्या है? आप 0 से 10 तक के सभी नंबर लेते हैं, जहाँ 10 शामिल नहीं है, और उन सभी नंबरों को 2 से गुणा करते हैं। ऊपर दिया गया कोड चलाकर देखें कि परिणाम आपकी उम्मीदों से मेल खाता है या नहीं।

ज्यादा कठिन नहीं है, है ना? आइए इसे थोड़ा और बढ़ाएँ!

मान लें कि आप पहले जैसी ही सूची बनाना चाहते हैं, पर केवल उन्हीं नंबरों को 2 से गुणा करना चाहते हैं जो 2 से विभाज्य हैं। लिस्ट कॉम्प्रिहेंशन की मदद से यह भी आसान है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6Ilt4KioyIGZvciB4IGluIHJhbmdlKDEwKSBpZiB4JTI9PTBdIn0=

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

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

अगला उदाहरण देखें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6Im15TGlzdCA9IFsxLCAyLCAzLCA0LCA1LCA2LCA3LCA4LCA5LCAxMF1cblsobGFtYmRhIHg6IHgqeCkoeCkgZm9yIHggaW4gbXlMaXN0XSJ9

इस उदाहरण में, आपके पास पहले से एक सूची myList है जिसे आप लिस्ट कॉम्प्रिहेंशन से रूपांतरित कर रहे हैं: आप देखते हैं कि फिर से for x in myList है, यानी myList के प्रत्येक तत्व पर कोई ऑपरेशन होगा।

अगला, आप देखते हैं कि (lambda x: x*x) शामिल है। सरल रखने के लिए, बस यह जान लें कि लैम्ब्डा फ़ंक्शंस गुमनाम फ़ंक्शंस होते हैं जो रनटाइम पर बनाए जाते हैं। क्योंकि वह कोड का हिस्सा आपके लिए संकेत भर दे सकता है, आप इसे अनदेखा कर सकते हैं और x*x पर ध्यान दे सकते हैं।

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

दूसरे शब्दों में, आप ऊपर दिए गए कोड के पूरे दूसरे लाइन को इस तरह लिख सकते हैं:

f = lambda x: x*x
[f(x) for x in range(10)]

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

ध्यान दें कि लिस्ट कॉम्प्रिहेंशन के अलावा सेट और डिक्शनरी कॉम्प्रिहेंशन भी होते हैं।

यह काफी कुछ था, लेकिन लिस्ट कॉम्प्रिहेंशन के बारे में खोजने के लिए और भी बहुत कुछ है।

नेस्टेड लिस्ट कॉम्प्रिहेंशन के बारे में और जानने और यह देखने के लिए कि यह Python प्रोग्रामिंग में आपके लिए क्या कर सकता है, नीचे दिए गए अक्सर पूछे जाने वाले प्रश्न पढ़ते रहें!

10. Python में सूची के किसी आइटम की आवृत्तियाँ कैसे गिनें

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

नीचे आपको दोनों प्रश्नों के उत्तर मिलेंगे!

सूची में एक आइटम की आवृत्तियाँ गिनना

सिर्फ एक सूची आइटम की आवृत्तियाँ गिनने के लिए आप count() मेथड का उपयोग कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgQ291bnQgdGhlIG9jY3VycmVuY2VzIG9mIHRoZSBudW1iZXIgNFxucHJpbnQoWzEsIDIsIDksIDQsIDUsIDQsIDFdLmNvdW50KDQpKVxuXG4jIENvdW50IHRoZSBvY2N1cnJlbmNlcyBvZiB0aGUgbGV0dGVyIFwiYVwiXG5saXN0ID0gW1wiZFwiLCBcImFcIiwgXCJ0XCIsIFwiYVwiLCBcImNcIiwgXCJhXCIsIFwibVwiLCBcInBcIl1cbmxpc3QuY291bnQoXCJhXCIpIn0=

किसी सूची में सभी आइटमों की आवृत्तियाँ गिनना “tallying” या टैली काउंटर बनाना भी कहलाता है।

`count()` के साथ सूची के सभी आइटम गिनना

सूची में आइटमों की आवृत्तियाँ गिनने के लिए, आप लिस्ट कॉम्प्रिहेंशन को count() मेथड के साथ मिलाकर भी उपयोग कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6Imxpc3Q9IFtcImFcIixcImJcIixcImJcIl1cbltbeCxsaXN0LmNvdW50KHgpXSBmb3IgeCBpbiBzZXQobGlzdCldIn0=

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

याद रखें कि सेट्स में केवल यूनिक आइटम होते हैं!

इस मामले में, पहले a को list.count(x) में पास किया जाएगा, और आपकी मूल सूची में a की सभी आवृत्तियाँ गिनी जाएँगी।

`Counter()` के साथ सभी सूची आइटम गिनना

वैकल्पिक रूप से, collections लाइब्रेरी का तेज़ Counter() मेथड मौजूद है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IGBDb3VudGVyYCBmcm9tIHRoZSBgY29sbGVjdGlvbnNgIGxpYnJhcnlcbmZyb20gY29sbGVjdGlvbnMgaW1wb3J0IENvdW50ZXJcblxuIyBUaGlzIGlzIHlvdXIgbGlzdFxubGlzdCA9IFtcImFcIixcImJcIixcImJcIl1cblxuIyBQYXNzIGBsaXN0YCB0byBgQ291bnRlcigpYFxuQ291bnRlcihsaXN0KSJ9

ध्यान दें कि जब आप सभी सूची आइटम गिनना चाहते हैं, तो Counter() आम तौर पर तेज़ होता है।

11. Python सूची को बराबर आकार के हिस्सों में कैसे बाँटें

अपनी सूची को समान आकार के हिस्सों में बाँटने के लिए, आप iter() के साथ मिलाकर zip() फ़ंक्शन का सहारा ले सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgWW91ciBsaXN0IGB4YFxueCA9IFsxLDIsMyw0LDUsNiw3LDgsOV1cblxuIyBTcGxpdCBgeGAgdXAgaW4gY2h1bmtzIG9mIDNcbnkgPSB6aXAoKltpdGVyKHgpXSozKVxuXG4jIFVzZSBgbGlzdCgpYCB0byBwcmludCB0aGUgcmVzdWx0IG9mIGB6aXAoKWBcbmxpc3QoeSkifQ==

ऊपर का कोड इस प्रकार काम करता है:

iter() किसी अनुक्रम पर एक इटरेटर होता है।
[iter(x)] * 3 तीन listiterator ऑब्जेक्ट्स वाली एक सूची बनाता है: प्रत्येक सूची इटरेटर, x का इटरेटर है।
zip() फ़ंक्शन को पहले पास किया गया * अनुक्रम को आर्ग्युमेंट्स में अनपैक करता है ताकि आप वही इटरेटर तीन बार zip() को पास करें, और यह हर बार इटरेटर से एक आइटम खींचे।

रुकिए। आखिरी चरण बिल्कुल स्पष्ट नहीं है।

आइए इसे कदम-दर-कदम समझते हैं:

आपके पास तीन सूची इटरेटर ऑब्जेक्ट होंगे, जिन्हें आप इस तरह सोच सकते हैं:

[1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9]

पहली बार, zip() क्रमवार रूप से सूची का एक-एक तत्व लेगा, जिससे आपके पास यह बचेगा:

[1][2][3]

ध्यान दें कि इटरेटर ऑब्जेक्ट यह ट्रैक रखते हैं कि इटरेशन में अगला तत्व कौन सा है!

दूसरी बार, अभी-अभी बनाई गई तीन सूचियों में तत्व जुड़ेंगे, और आपके पास यह होगा:

[1, 4], [2, 5], [3, 6]

आखिरी बार, आप वही प्रक्रिया दोहराते हैं, और आपके पास यह होगा:

[1, 4, 7], [2, 5, 8], [3, 6, 9]

इन तीन सूचियों को एक साथ ज़िप करने पर आपके पास यह रह जाएगा:

[1, 2, 3], [4, 5, 6], [7, 8, 9]

यदि, हालांकि, आप इस लॉजिक को एक फ़ंक्शन में रखना चाहते हैं, तो आप इस तरीके का पालन कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgTWV0aG9kIHRvIHNwbGl0IHVwIHlvdXIgbGlzdHMgaW50byBjaHVua3NcbmRlZiBjaHVua3MobGlzdCwgY2h1bmtTaXplKTpcbiAgICBcIlwiXCJZaWVsZCBzdWNjZXNzaXZlIGNodW5rU2l6ZS1zaXplZCBjaHVua3MgZnJvbSBsaXN0LlwiXCJcIlxuICAgIGZvciBpIGluIHJhbmdlKDAsIGxlbihsaXN0KSwgY2h1bmtTaXplKTpcbiAgICAgICAgeWllbGQgbGlzdFtpOmkgKyBjaHVua1NpemVdXG5cbiMgVXNlIHlvdXIgYGNodW5rc2AgZnVuY3Rpb24gdG8gcHJpbnQgb3V0IGNodW5rcyBvZiB0aGUgc2FtZSBzaXplXG5pbXBvcnQgcHByaW50XG5wcHJpbnQucHByaW50KGxpc3QoY2h1bmtzKHJhbmdlKDEwLCA3NSksIDEwKSkpIn0=

आपका chunks() फ़ंक्शन इनपुट के रूप में एक सूची और एक chunk आकार लेता है। यह तब प्रिंट करेगा: “Yield successive (आपके chunk आकार)-आकार के chunks from list” (यानी वह सूची जो आप chunks() मेथड को देते हैं)।

फिर, आप range(0, len(list), chunkSize) देखते हैं: यह सूची 0 से शुरू होती है और आपकी सूची की लंबाई तक जाती है। स्टेप वैल्यू वही है जो आप chunks() को chunkSize के रूप में पास करते हैं।

range() द्वारा निर्मित इस सूची के प्रत्येक तत्व के लिए, आप मूल सूची का एक chunk देते हैं, जो दिए गए इंडेक्स से शुरू होकर दिए गए इंडेक्स + chunk आकार तक होता है।

उदाहरण के लिए, यदि इंडेक्स 0 for लूप से गुजरता है, तो [0:2] की सूची दी जाएगी। अगली इटरेशन में, इंडेक्स 2 for लूप से गुजरता है (स्टेप वैल्यू याद रखें!), और आपकी मूल सूची का chunk [2:4] आउटपुट होगा।

ध्यान दें कि आप अपना परिणाम प्रिंट करने के लिए pprint() या pretty print का उपयोग करते हैं।

आप फ़ंक्शन लिखने की बजाय सीधे लिस्ट कॉम्प्रिहेंशन भी इस्तेमाल कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgU2V0IHVwIHlvdXIgbGlzdCBhbmQgY2h1bmsgc2l6ZVxubGlzdCA9IHJhbmdlKDAsIDUwKVxuY2h1bmsgPSA1XG5cbiMgU3BsaXQgdXAgeW91ciBsaXN0IGludG8gY2h1bmtzXG5bbGlzdFtpOmkgKyBjaHVua10gZm9yIGkgaW4gcmFuZ2UoMCwgbGVuKGxpc3QpLCBjaHVuayldIn0=

12. Python में किसी सूची पर लूप कैसे करें

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

Python में for लूप कुछ इस तरह दिखता है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgVGhpcyBpcyB5b3VyIGxpc3Rcbm15bGlzdCA9IFtbMSwyLDNdLFs0LDUsNiw3XSxbOCw5LDEwXV1cblxuIyBMb29wIG92ZXIgeW91ciBsaXN0IGFuZCBwcmludCBhbGwgZWxlbWVudHMgdGhhdCBhcmUgb2Ygc2l6ZSAzXG5mb3IgeCBpbiBteWxpc3Q6XG4gICAgICBpZiBsZW4oeCk9PTM6XG4gICAgICAgIHByaW50KHgpIn0=

आपके पास mylist नाम की एक सूची है, और आप Python को बताते हैं कि प्रत्येक सूची-तत्व की लंबाई 3 के बराबर है या नहीं, जाँचे। क्योंकि हमारी सूची में दो ऐसी सूचियाँ हैं जिनमें प्रत्येक में तीन-तीन तत्व हैं, यानी [1,2,3] और [8, 9,10], केवल इन्हीं को प्रिंट किया जाएगा।

ध्यान दें कि ऊपर दिए गए कोड में x को आप element, listElement या अपनी पसंद के किसी भी नाम से बदल सकते हैं। कंसोल में आज़माएँ!

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

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgVGhpcyBpcyB5b3VyIGxpc3Rcbm15TGlzdCA9IFszLDQsNSw2XVxuXG4jIExvb3Agb3ZlciBgbXlMaXN0YCBhbmQgcHJpbnQgdHVwbGVzIG9mIGFsbCBpbmRpY2VzIGFuZCB2YWx1ZXMgXG5mb3IgaSwgdmFsIGluIGVudW1lcmF0ZShteUxpc3QpOlxuICAgICBwcmludChpLCB2YWwpIn0=

क्योंकि आप न केवल सूची-तत्व बल्कि उनका इंडेक्स भी प्रिंट करना चाहते हैं, इसलिए आपको अपने for लूप में इसे दिखाना होगा। इसी वजह से हम enumerate(myList) का उपयोग करते हैं, जो एक इंडेक्स और एक मान लौटाता है। स्वाभाविक है, हमें इसे for स्टेटमेंट की शुरुआत में भी दिखाना होता है: आप i, val देखते हैं ताकि स्पष्ट हो कि हम परिणाम में इंडेक्स और मान की अपेक्षा कर रहे हैं।

ध्यान दें कि आप लिस्ट कॉम्प्रिहेंशन का उपयोग करके भी किसी सूची पर लूप कर सकते हैं। यहाँ परिणाम बिना print() पास किए ही प्रिंट हो जाते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoibXlMaXN0ID0gW1sxLDIsM10sWzQsNSw2LDddLFs4LDksMTBdXSIsInNhbXBsZSI6Ilt4IGZvciB4IGluIG15TGlzdCBpZiBsZW4oeCk9PTNdIn0=

13. सूचियों से फ्लैट सूची कैसे बनाएँ

सूचियों की सूची से एक साधारण सूची बनाने के लिए, आप sum() फ़ंक्शन का उपयोग कर सकते हैं। बस अपनी सूची और एक खाली सूची इसे पास करना न भूलें:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgWW91ciBpbml0aWFsIGxpc3Qgb2YgbGlzdHNcbmxpc3QgPSBbWzEsMl0sWzMsNF0sWzUsNl1dXG5cbiMgRmxhdHRlbiBvdXQgeW91ciBvcmlnaW5hbCBsaXN0IG9mIGxpc3RzIHdpdGggYHN1bSgpYFxuc3VtKGxpc3QsIFtdKSJ9

आप अपनी सूचियों को फ्लैट करने के लिए दो और तरीकों का भी उपयोग कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoibGlzdE9mTGlzdHMgPSBbWzEsMl0sWzMsNF0sWzUsNl1dIiwic2FtcGxlIjoiIyBZb3UgY2FuIHJlZHVjZSB0aGUgbGlzdHMgb2YgbGlzdHMgb2YgbGlzdHMgbGlrZSB0aGlzXG5mcm9tIGZ1bmN0b29scyBpbXBvcnQgcmVkdWNlXG5wcmludChyZWR1Y2UobGFtYmRhIHgseTogeCt5LGxpc3RPZkxpc3RzKSlcblxuIyBPciB5b3UgY2FuIHVzZSBsaXN0IGNvbXByZWhlbnNpb25cbnByaW50KFtpdGVtIGZvciBzdWJsaXN0IGluIGxpc3RPZkxpc3RzIGZvciBpdGVtIGluIHN1Ymxpc3RdKSJ9

आप reduce() मेथड का उपयोग करते हैं, जिसे आप एक लैम्ब्डा फ़ंक्शन पास करते हैं। अब, reduce() मेथड यह सुनिश्चित करता है कि आपका iterable एक एकल मान में “रिड्यूस” हो जाए। यह कैसे रिड्यूस होगा, यह आप उस फ़ंक्शन से तय करते हैं जिसे आप पास करते हैं। यहाँ आप कहते हैं कि आप तत्वों को संचयी रूप से जोड़ना चाहते हैं: होता यह है कि [1,2] को [3,4] में जोड़ा जाता है और यह परिणाम [5,6] में जोड़ा जाता है। दृश्य रूप में, यह ऐसे दिखता है:

([1,2]+[3,4])+[5,6]

याद रखें कि + ऑपरेटर सूचियों को concatenate करता है।

सूचियों की सूची से फ्लैट सूची बनाने का दूसरा विकल्प लिस्ट कॉम्प्रिहेंशन का उपयोग करना है। यह नेस्टेड for लूप स्टेटमेंट आसान नहीं लगता। बात इतनी सी है कि आप पहले लेते हैं sublist in list यानी [1, 2], [3, 4], [5, 6] और फिर item for item in sublist पर विचार करते हैं, जिससे उपसूची के प्रत्येक आइटम को प्रिंट किया जाता है।

इस नेस्टेड लिस्ट कॉम्प्रिहेंशन को देखने का एक और तरीका इसे रेगुलर for लूप के रूप में लिखना है:

list1 = []

for sublist in list:
  for item in sublist:
    list1.append(item)

14. दो Python सूचियों का इंटरसेक्शन कैसे प्राप्त करें

लिस्ट कॉम्प्रिहेंशन का उपयोग करके सूची का इंटरसेक्शन

यदि आप दो सूचियों का इंटरसेक्शन प्राप्त करना चाहते हैं, तो आप filter() फ़ंक्शन का उपयोग कर सकते हैं।

यह नीचे दिए गए अभ्यास में दिखाया गया है। हमने आपके लिए पहले से दो सूचियाँ बना दी हैं, list1 और list2। यदि आप सूचियों की सामग्री जाँचना चाहते हैं तो IPython शेल का उपयोग करें।

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoibGlzdDEgPSBbMSwgNiwgNywgMTAsIDEzLCAyOCwgMzIsIDQxLCA1OCwgNjNdXG5saXN0MiA9IFtbMTMsIDE3LCAxOCwgMjEsIDMyXSwgWzcsIDExLCAxMywgMTQsIDI4XSwgWzEsIDUsIDYsIDgsIDE1LCAxNl1dIiwic2FtcGxlIjoiIyBJbnRlcnNlY3QgYm90aCBsaXN0cyB3aXRoIGxpc3QgY29tcHJlaGVuc2lvblxuaW50ZXJzZWN0aW9uID0gW2xpc3QoZmlsdGVyKGxhbWJkYSB4OiB4IGluIGxpc3QxLCBzdWJsaXN0KSkgZm9yIHN1Ymxpc3QgaW4gbGlzdDJdXG5cbiMgUHJpbnQgdGhlIHJlc3VsdCBvZiB0aGUgaW50ZXJzZWN0aW9uXG5wcmludChfX19fKSIsInNvbHV0aW9uIjoiIyBJbnRlcnNlY3QgYm90aCBsaXN0cyB3aXRoIGxpc3QgY29tcHJlaGVuc2lvblxuaW50ZXJzZWN0aW9uID0gW2xpc3QoZmlsdGVyKGxhbWJkYSB4OiB4IGluIGxpc3QxLCBzdWJsaXN0KSkgZm9yIHN1Ymxpc3QgaW4gbGlzdDJdXG5cbiMgUHJpbnQgdGhlIHJlc3VsdCBvZiB0aGUgaW50ZXJzZWN0aW9uXG5wcmludChpbnRlcnNlY3Rpb24pIiwic2N0IjoicHJlZGVmX21zZyA9IFwiZGlkIHlvdSBwYXNzIGBpbnRlcnNlY3Rpb25gIHRvIHRoZSBgcHJpbnQoKWAgZnVuY3Rpb24/XCJcbiMgVGVzdCBgcHJpbnRgXG50ZXN0X2Z1bmN0aW9uKFxuICAgIFwicHJpbnRcIixcbiAgICBub3RfY2FsbGVkX21zZz1wcmVkZWZfbXNnLFxuICAgIGluY29ycmVjdF9tc2c9cHJlZGVmX21zZyxcbiAgICBkb19ldmFsPUZhbHNlXG4pXG5zdWNjZXNzX21zZyA9IFwiV2F5IHRvIGdvIVwiIn0=

ऊपर दिए गए कोड में, filter() भाग प्रत्येक उपसूची के आइटम को लेता है और जाँचता है कि क्या वह स्रोत सूची list1 में है। लिस्ट कॉम्प्रिहेंशन list2 की प्रत्येक उपसूची के लिए निष्पादित होता है।

ध्यान दें कि चूँकि filter() एक iterable लौटाता है, सूची नहीं, इसलिए आपको जो भी filter() में डालते हैं उसे list() से लपेटना होगा। इसे हटाकर खुद टेस्ट करें!

बेहतर पठनीयता के लिए, आप नेस्टेड लिस्ट कॉम्प्रिहेंशन के साथ भी काम कर सकते हैं:

`set()` के साथ सूचियों का इंटरसेक्शन

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

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoibGlzdDEgPSBbMSwgNiwgNywgMTAsIDEzLCAyOCwgMzIsIDQxLCA1OCwgNjNdXG5saXN0MiA9IFsxMywgMTcsIDE4LCAyMSwgMzIsIDcsIDExLCAxMywgMTQsIDI4LCAxLCA1LCA2LCA4LCAxNSwgMTZdIiwic2FtcGxlIjoiIyBNYWtlIHVzZSBvZiB0aGUgbGlzdCBhbmQgc2V0IGRhdGEgc3RydWN0dXJlc1xucHJpbnQobGlzdChzZXQobGlzdDEpICYgc2V0KGxpc3QyKSkpXG5cbiMgVXNlIGBpbnRlcnNlY3Rpb24oKWBcbnByaW50KGxpc3Qoc2V0KGxpc3QxKS5pbnRlcnNlY3Rpb24obGlzdDIpKSkifQ==

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

ध्यान दें कि इन दोनों तरीकों के काम करने के लिए, आपकी सूची में अन्य सूचियाँ नहीं होनी चाहिए। यही कारण है कि list2 अलग दिखती है। सुनिश्चित करने के लिए इसे प्रिंट करें!

15. Python में सूची से डुप्लिकेट्स कैसे हटाएँ

जैसा कि इस ब्लॉग पोस्ट के पहले खंड में बताया गया है, यदि आप बिना क्रम के यूनिक आइटमों का संग्रह स्टोर करना चाहते हैं, तो सेट चुनना सबसे अच्छा है।

किसी भी iterable से सेट बनाने के लिए, आप बस उसे बिल्ट-इन set() फ़ंक्शन को पास कर सकते हैं। यदि बाद में आपको फिर से एक वास्तविक सूची चाहिए, तो आप उसी तरह सेट को list() फ़ंक्शन को पास कर सकते हैं।

याद रखें कि iterable एक सूची, डिक्शनरी, … हो सकता है। यह जाँचने के लिए कि कोई वेरिएबल iterable है या नहीं, उस पर .__iter__ लागू करें।

निम्न उदाहरण स्पष्ट रूप से आपकी सूची से सभी डुप्लिकेट्स हटाने के लिए set() के उपयोग को दर्शाता है:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgWW91ciBsaXN0IHdpdGggZHVwbGljYXRlIHZhbHVlc1xuZHVwbGljYXRlcyA9IFsxLCAyLCAzLCAxLCAyLCA1LCA2LCA3LCA4XVxuXG4jIFByaW50IHRoZSB1bmlxdWUgYGR1cGxpY2F0ZXNgIGxpc3RcbnByaW50KGxpc3Qoc2V0KGR1cGxpY2F0ZXMpKSlcblxuIyBBIGxpc3Qgd2l0aCBzbWFsbCBudW1iZXJzIFxuc21hbGxOdW1iZXJzID0gWzEsIDIsIDNdXG5cbiMgUHJpbnQgdGhlIHVuaXF1ZSBgZHVwbGljYXRlc2AgbGlzdCB3aXRob3V0IHRoZSBzbWFsbCBudW1iZXJzXG5saXN0KHNldChkdXBsaWNhdGVzKSAtIHNldChzbWFsbE51bWJlcnMpKSJ9

जैसा कि आप अंतिम परिणाम से देख सकते हैं, smallNumbers के सेट तत्वों को घटाने के बाद आपकी सूची का मूल क्रम बरकरार नहीं रहता। अब तक आप जानते हैं, सेट स्वयं अनऑर्डर्ड कलेक्शन होते हैं, इसलिए आपकी सूची में जो भी क्रम था, वह खो जाता है। जब आप सेट को फिर से सूची में बदलते हैं, तो आपके लिए एक मनमाना क्रम बनाया जाता है।

यदि आपके तत्वों का क्रम आपके लिए महत्वपूर्ण है, तो आपको एक अलग तंत्र का उपयोग करना होगा। यह पेज उस विषय को अधिक विस्तार से कवर करता है।

16. Python सूचियों की बजाय NumPy क्यों?

आम तौर पर, चार कारण दिखाई देते हैं जिनकी वजह से Python प्रोग्रामर सूचियों की बजाय NumPy arrays को प्राथमिकता देते हैं:

क्योंकि NumPy arrays सूचियों की तुलना में अधिक कॉम्पैक्ट होते हैं।
क्योंकि आइटमों को पढ़ने और लिखने में NumPy के साथ एक्सेस तेज़ होता है।
क्योंकि NumPy के साथ काम करना अधिक सुविधाजनक हो सकता है, क्योंकि आपको वेक्टर और मैट्रिक्स ऑपरेशन्स की भरमार मुफ्त में मिलती है।
क्योंकि NumPy के साथ काम करना अधिक दक्ष हो सकता है, क्योंकि इनका इम्प्लीमेंटेशन अधिक कुशल है।

17. खाली NumPy arrays कैसे बनाएँ

यदि आप केवल एक खाली NumPy array बनाना चाहते हैं, तो आप निम्नलिखित चला सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImltcG9ydCBudW1weVxubnVtcHkuYXJyYXkoW10pIn0=

हालाँकि, यदि आपका उद्देश्य एक NumPy array को इनिशियलाइज़ करना है, तो आप निम्न में से किसी एक तरीके का पालन कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IG51bXB5Iiwic2FtcGxlIjoiIyBNYWtlIGEgTnVtUHkgYXJyYXkgb2YgZm91ciByb3dzIGFuZCB0d28gY29sdW1ucyBhbmQgZmlsbGVkIHdpdGggMFxubnVtcHkuemVyb3Moc2hhcGU9KDQsMikpXG5cbiMgTWFrZSBhIE51bVB5IGFycmF5IG9mIDEgdmFsdWVzIG9mIHRocmVlIGNvbHVtbnNcbm51bXB5Lm9uZXMoMylcblxuIyBNYWtlIGFuIGVtcHR5IE51bVB5IGFycmF5XG5udW1weS5lbXB0eShzaGFwZT0oMCwwKSkifQ==

यदि आप अपने NumPy array को इनिशियलाइज़ करने के अन्य तरीकों की तलाश कर रहे हैं, तो इस डॉक्यूमेंटेशन को अवश्य देखें।

18. Python में सूचियों के साथ गणित कैसे करें

अक्सर हम सूचियों का उपयोग मानों के संग्रह को स्टोर करने के अलावा उन पर कुछ गणितीय क्रियाएँ करने के लिए भी करते हैं। यह खंड सूचियों के साथ गणित करने पर कुछ अक्सर पूछे जाने वाले प्रश्नों को कवर करेगा।

किसी सूची का भारित औसत कैसे निकालें

भारित औसत साधारण औसत जैसा ही है, लेकिन थोड़ा अलग: भारित औसत ऐसा संख्या लौटाता है जो मान और भार दोनों पर निर्भर करती है।

यह परिभाषा पहले थोड़ा भारी लग सकती है। एक उदाहरण देख लेते हैं:

cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413]
cases = [10, 20, 30, 40, 50]

आप निम्नलिखित कोड से आसानी से भारित औसत निकाल सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiY29zdCA9IFswLjQyNCwgMC40MjIxLCAwLjQxODUsIDAuNDEzMiwgMC40MTNdXG5jYXNlcyA9IFsxMCwgMjAsIDMwLCA0MCwgNTBdIiwic2FtcGxlIjoiZm9yIGMgaW4gcmFuZ2UobGVuKGNvc3QpKTpcbiAgIGNvc3RbY10gPSAoY29zdFtjXSAqIGNhc2VzW2NdIC8gc3VtKGNhc2VzKSlcbmNvc3QgPSBzdW0oY29zdClcbnByaW50KGNvc3QpIn0=

लेकिन, आप इन दो अन्य तरीकों में से किसी एक को भी अपना सकते हैं। पहले, आप यह इस्तेमाल कर सकते हैं:

या आप यह वाला इस्तेमाल कर सकते हैं:

अंत में, आप zip() फ़ंक्शन की मदद से भी अपनी सूची का भारित औसत निकाल सकते हैं।

टिप: एक costAndCases वेरिएबल बनाएँ, जिसमें आप बस zip() फ़ंक्शन को cost और case वेरिएबल्स के साथ असाइन कर दें। आप देखेंगे कि केवल ट्यूपल्स वाली एक और सूची बनती है। प्रत्येक ट्यूपल का पहला मान लागत दर्शाता है, जबकि दूसरा तत्व उस कीमत पर खरीदे जा सकने वाले केस दर्शाता है।

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiY29zdCA9IFswLjQyNCwgMC40MjIxLCAwLjQxODUsIDAuNDEzMiwgMC40MTNdXG5jYXNlcyA9IFsxMCwgMjAsIDMwLCA0MCwgNTBdIiwic2FtcGxlIjoiIyBTZWUgd2hhdCBgemlwKClgIGRvZXMgdG8geW91ciBgY29zdGAgYW5kIGBjYXNlc2BcbnByaW50KGxpc3QoemlwKF9fX18sIF9fX18pKSlcblxuIyBDYWxjdWxhdGUgdGhlIHdlaWdodGVkIGF2ZXJhZ2VcbnByaW50KHN1bShbeCAqIHkgZm9yIHgsIHkgaW4gemlwKGNvc3QsIGNhc2VzKV0pIC8gc3VtKGNhc2VzKSkiLCJzb2x1dGlvbiI6IiMgU2VlIHdoYXQgYHppcCgpYCBkb2VzIHRvIHlvdXIgbGlzdHNcbnByaW50KGxpc3QoemlwKGNvc3QsIGNhc2VzKSkpXG5cbiMgQ2FsY3VsYXRlIHRoZSB3ZWlnaHRlZCBhdmVyYWdlXG5wcmludChzdW0oW3ggKiB5IGZvciB4LCB5IGluIHppcChjb3N0LCBjYXNlcyldKSAvIHN1bShjYXNlcykpIiwic2N0IjoicHJlZGVmX21zZyA9IFwiRG9uJ3QgZm9yZ2V0IHRvIGFkZCB0aGUgYHppcCgpYCBmdW5jdGlvbiBhbmQgdG8gcGFzcyBgY29zdGAgYW5kIGBjYXNlYCB0byBpdCFcIlxuIyBUZXN0IG9iamVjdCBjb3N0QW5kQ2FzZXNcbnRlc3RfZnVuY3Rpb24oXCJ6aXBcIiwgXG4gICAgICAgICAgICAgIG5vdF9jYWxsZWRfbXNnID0gXCJIYXZlIHlvdSBjcmVhdGVkIHRoZSBjb3N0QW5kQ2FzZXMgdmFyaWFibGU/IERvbid0IGZvcmdldCB0byBwYXNzIGBjb3N0YCBhbmQgYGNhc2VzYCB0byBgemlwKClgIHRvIGNyZWF0ZSBpdCFcIixcbiAgICAgICAgICAgICAgaW5jb3JyZWN0X21zZz1wcmVkZWZfbXNnLCBcbiAgICAgICAgICAgICAgZG9fZXZhbD1GYWxzZSlcbnN1Y2Nlc3NfbXNnKFwiQXdlc29tZSB3b3JrIVwiKSJ9

याद रखें कि zip() आपकी सूचियों के साथ क्या करता है? आसान है, यह आपकी सूचियों को सचमुच “ज़िप” कर देता है। उदाहरण के लिए, zip(cost, cases) का आउटपुट होगा [(0.424, 10), (0.4221, 20), (0.4185, 30), (0.4132, 40), (0.413, 50)]।

Python में किसी सूची का क्वांटाइल कैसे निकालें

क्वांटाइल्स आपके डेटा सेट का सारांश बनाने में आवश्यक होते हैं, आपके सेट के न्यूनतम और अधिकतम के साथ। आपके पास 25वाँ, 50वाँ और 75वाँ परसेंटाइल भी होते हैं, जिन्हें क्रमशः पहला क्वार्टाइल, माध्यिका और तीसरा क्वार्टाइल भी कहते हैं।

इसका मतलब यह है कि पूरे डेटा सेट का सारांश बनाने के लिए आपको कुल पाँच संख्याएँ चाहिए: न्यूनतम, अधिकतम, माध्यिका और दो क्वार्टाइल्स।

आपके डेटा सेट के न्यूनतम और अधिकतम को खोजना आसान है, लेकिन उन परसेंटाइल्स का क्या?

यह आसान है। मान लीजिए आपके डेटा सेट में 25 अवलोकन हैं, जिन्हें कम से अधिक के क्रम में सजाया गया है:

25वाँ परसेंटाइल या पहला क्वार्टाइल 0.25 को 25 से गुणा करके निकाला जाता है। प्राप्त संख्या 6.25, यानी ऊपर की ओर राउंड करने पर 7, यह बताती है कि 25वाँ परसेंटाइल कौन सी संख्या है: आपकी सॉर्टेड सूची में 7वाँ तत्व।
तीसरा क्वार्टाइल या 75वाँ परसेंटाइल 0.75 को 25 से गुणा करके निकाला जाता है। प्राप्त संख्या 18.75, यानी राउंड अप करने पर 19, बताती है कि आपकी सॉर्टेड सूची का 19वाँ तत्व तीसरा परसेंटाइल है।
आपके डेटा सेट की माध्यिका 0.5 को 25 से गुणा करके निकाली जाती है। 12.5 को राउंड अप करने पर 13 आता है, इसलिए 13वीं संख्या माध्यिका होगी।

लेकिन आप इसे अपनी सूची पर कैसे प्रोग्राम करें?

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

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IG51bXB5IGFzIG5wXG5pbXBvcnQgX19fXyBhcyBfX1xuXG4jIE1ha2UgYSBOdW1QeSBhcnJheVxuYSA9IG5wLmFycmF5KFsxLDIsMyw0LDVdKVxuXG4jIFJldHVybiB0aGUgNTB0aCBwZXJjZW50aWxlIG9mIG91ciBOdW1QeSBhcnJheVxucCA9IG5wLnBlcmNlbnRpbGUoYSwgNTApXG5cbiNQcmludCB0aGUgcmVzdWx0XG5wcmludChfX19fKSIsInNvbHV0aW9uIjoiIyBJbXBvcnQgbnVtcHkgYXMgbnBcbmltcG9ydCBudW1weSBhcyBucFxuXG4jIE1ha2UgYSBOdW1QeSBhcnJheVxuYSA9IG5wLmFycmF5KFsxLDIsMyw0LDVdKVxuXG4jIFJldHVybiB0aGUgNTB0aCBwZXJjZW50aWxlIG9mIG91ciBOdW1QeSBhcnJheVxucCA9IG5wLnBlcmNlbnRpbGUoYSwgNTApXG5cbiNQcmludCB0aGUgcmVzdWx0XG5wcmludChwKSIsInNjdCI6InByZWRlZl9tc2cgPSBcIkhhdmUgeW91IGltcG9ydGVkIG51bXB5IGFuZCBwcmludGVkIG91dCB0aGUgcGVyY2VudGlsZSByZXN1bHQ/XCJcbnF1YW50aWxlX3ByaW50X21zZyA9IFwiRG9uJ3QgZm9yZ2V0IHRvIHBhc3MgYHBgIHRvIGBwcmludCgpYCFcIlxuaW1wb3J0X21zZyA9IFwiSGF2ZSB5b3UgaW1wb3J0ZWQgbnVtcHk/XCJcbnRlc3RfZnVuY3Rpb24oXG4gICAgXCJwcmludFwiLFxuICAgIG5vdF9jYWxsZWRfbXNnPXByZWRlZl9tc2csXG4gICAgaW5jb3JyZWN0X21zZz1xdWFudGlsZV9wcmludF9tc2csXG4gICAgZG9fZXZhbD1GYWxzZVxuKVxuIyBUZXN0IGltcG9ydCBgbnVtcHlgXG50ZXN0X2ltcG9ydChcIm51bXB5XCIsIHNhbWVfYXMgPSBUcnVlLCBub3RfaW1wb3J0ZWRfbXNnID0gaW1wb3J0X21zZywgaW5jb3JyZWN0X2FzX21zZyA9IHByZWRlZl9tc2cpXG5zdWNjZXNzX21zZyhcIkZhbnRhc3RpYyFcIikifQ==

सूचियों का तत्-तत् (element-wise) योग कैसे करें

मान लें आपके पास दो सूचियाँ हैं:

list1=[1, 2, 3]
list2=[4, 5, 6]

और आप यह सुनिश्चित करना चाहते हैं कि सूची-तत्वों का तत्व-वार योग हो; यानी 1 को 4 से, 2 को 5 से और 3 को 6 से जोड़ा जाए। इसे पूरा करने के दो तरीके हैं।

और जानने के लिए पढ़ते रहें!

… बेसिक Python के साथ

आप तत्व-वार जोड़ करने के लिए operator.add के साथ map का उपयोग कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoibGlzdDE9WzEsIDIsIDNdXG5saXN0Mj1bNCwgNSwgNl0iLCJzYW1wbGUiOiJmcm9tIG9wZXJhdG9yIGltcG9ydCBhZGRcbmxpc3QobWFwKGFkZCwgbGlzdDEsIGxpc3QyKSkifQ==

इसका परिणाम एक सूची [5, 7, 9] होगा।

ध्यान दें कि map() फ़ंक्शन के परिणाम को प्रिंट करने के लिए आपको list() का उपयोग करना होगा।

या आप zip() फ़ंक्शन को लिस्ट कॉम्प्रिहेंशन के साथ उपयोग कर सकते हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoibGlzdDE9WzEsIDIsIDNdXG5saXN0Mj1bNCwgNSwgNl0iLCJzYW1wbGUiOiJbc3VtKHgpIGZvciB4IGluIHppcChsaXN0MSwgbGlzdDIpXSJ9

… NumPy के साथ

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

तब आपको सुनिश्चित करना चाहिए कि आप numpy लाइब्रेरी इम्पोर्ट करते हैं और आपकी सूचियाँ NumPy arrays में बदली जाती हैं:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IG51bXB5IGFzIG5wXG5pbXBvcnQgX19fXyBhcyBfX1xuXG4jIE1ha2UgeW91ciBsaXN0cyBpbnRvIE51bVB5IGFycmF5c1xudmVjdG9yMSA9IG5wLmFycmF5KFsxLCAyLCAzXSlcbnZlY3RvcjIgPSBucC5hcnJheShbNCwgNSwgNl0pXG5cbiMgRWxlbWVudC13aXNlIGFkZGl0aW9uXG5zdW1fdmVjdG9yID0gdmVjdG9yMSArIHZlY3RvcjIgXG5cbiMgUHJpbnQgdGhlIHJlc3VsdFxucHJpbnQoX19fXykiLCJzb2x1dGlvbiI6IiMgSW1wb3J0IG51bXB5IGFzIG5wXG5pbXBvcnQgbnVtcHkgYXMgbnBcblxuIyBNYWtlIHlvdXIgbGlzdHMgaW50byBOdW1QeSBhcnJheXNcbnZlY3RvcjEgPSBucC5hcnJheShbMSwgMiwgM10pXG52ZWN0b3IyID0gbnAuYXJyYXkoWzQsIDUsIDZdKVxuXG4jIEVsZW1lbnQtd2lzZSBhZGRpdGlvblxuc3VtX3ZlY3RvciA9IHZlY3RvcjEgKyB2ZWN0b3IyIFxuXG4jIFByaW50IHRoZSByZXN1bHRcbnByaW50KHN1bV92ZWN0b3IpIiwic2N0IjoicHJlZGVmX21zZyA9IFwiRGlkIHlvdSBpbXBvcnQgbnVtcHkgYW5kIHByaW50IHRoZSByZXN1bHQ/XCJcbnByaW50X21zZz0gXCJEaWQgeW91IHBhc3MgYHN1bV92ZWN0b3JgIGB0byBwcmludCgpYFwiXG5pbXBvcnRfbXNnPVwiRG9uJ3QgZm9yZ2V0IHRvIGltcG9ydCBudW1weSBhcyBucCFcIlxudGVzdF9mdW5jdGlvbihcbiAgICBcInByaW50XCIsXG4gICAgbm90X2NhbGxlZF9tc2c9cHJlZGVmX21zZyxcbiAgICBpbmNvcnJlY3RfbXNnPXByaW50X21zZyxcbiAgICBkb19ldmFsPUZhbHNlXG4pXG50ZXN0X2ltcG9ydChcIm51bXB5XCIsIHNhbWVfYXMgPSBUcnVlLCBub3RfaW1wb3J0ZWRfbXNnID0gaW1wb3J0X21zZywgaW5jb3JyZWN0X2FzX21zZyA9IHByZWRlZl9tc2cpXG5zdWNjZXNzX21zZyA9IFwiWW91J3JlIG9mZmljaWFsbHkgYSBQeXRob24gbGlzdCBleHBlcnQhXCIifQ==

Python के साथ आपकी डेटा साइंस यात्रा में आगे क्या?

आप Python में सूचियों पर हमारे इंटरैक्टिव ट्यूटोरियल के अंत तक पहुँच गए हैं। यह काफ़ी कुछ था और अच्छा-ख़ासा काम भी, लेकिन आपने कर दिखाया!

सूचियाँ आपकी Python के साथ डेटा साइंस यात्रा का छोटा लेकिन आवश्यक हिस्सा हैं। और भी बहुत कुछ खोजने को है! हमारा इंटरैक्टिव Intro to Python for Data Science कोर्स उन लोगों के लिए बिल्कुल उपयुक्त है जो Python और डेटा साइंस में इसके उपयोग के बारे में अधिक सीखना चाहते हैं: यह Python की बिल्कुल बुनियाद से शुरू होकर धीरे-धीरे और सहजता से आपको एक मध्यवर्ती स्तर तक ले जाएगा और NumPy से परिचित करवाएगा। (Python) प्रोग्रामिंग में कम अनुभव रखने वालों के लिए एकदम सही!

यदि, हालांकि, आप पहले से ही अधिक उन्नत Python उपयोगकर्ता हैं, तो आप हमारे Intermediate Python For Data Science कोर्स पर नज़र डाल सकते हैं, जो उन लोगों के लिए बनाया गया है जो अपनी डेटा साइंस और Python कौशल को अगले स्तर पर ले जाने के लिए तैयार हैं। यह कोर्स निश्चित रूप से आपको आपकी डेटा साइंस लर्निंग में और आगे ले जाएगा! कोर्स आपको matplotlib और pandas जैसी और लाइब्रेरीज़, और logic, control flow, और filtering जैसे कॉन्सेप्ट्स से परिचित कराता है, और आपकी कौशल को मजबूत करने के लिए एक डेटा साइंस केस स्टडी शामिल करता है।

क्या आप पहले से ही डेटा साइंस के लिए Python का उपयोग कर रहे हैं लेकिन और आगे जाना चाहते हैं? तो आप हमारे Importing Data Into Python कोर्स में रुचि ले सकते हैं या हमारी The importance of preprocessing in data science and the machine learning pipeline ट्यूटोरियल श्रृंखला पढ़ने पर विचार कर सकते हैं!

विषय

Python

डेटा विश्लेषण