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

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

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

# These list elements are all of the same type
zoo = ['bear', 'lion', 'panda', 'zebra']
print(zoo)

# But these list elements are not
biggerZoo = ['bear', 'lion', 'panda', 'zebra', ['chimpanzees', 'gorillas', 'orangutans', 'gibbons']]
print(biggerZoo)

आप देखेंगे कि दूसरी वैरिएबल 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 प्रकार के बीच चुनाव उतना साफ नहीं रहता।

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

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

# Import the `collections` library
____ ____

# Check if a dictionary is hashable
print(isinstance({}, collections.Hashable))

# Check if a float is hashable
print(isinstance(0.125, collections.Hashable))

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

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

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

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

# Select the first list element
oneZooAnimal = biggerZoo[0]

# Print `oneZooAnimal`
print(____)

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

# Pass -1 to the index operator on `biggerZoo`
monkeys = ___
print(monkeys)

# Pass -2 to the index operator on `biggerZoo`
zebra = ___
print(zebra)

# Run this code to trigger an "Index Out Of Range" Error
biggerZoo[6]

# Use the slice notation like this
someZooAnimals = biggerZoo[2: ]

# Print to see what you exactly select from `biggerZoo`
print(someZooAnimals)

# Try putting 2 on the other side of the colon
otherZooAnimals = biggerZoo[____]

# Print to see what you're getting back
print(otherZooAnimals)

# 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]संचालित द्वारा

# start through not past end, by step
a[start:end:step]संचालित द्वारा

# Print to see how the step value influences your result
print(biggerZoo[2::2])
print(biggerZoo[1::3])

# Import `choice` from the `random` library
from ____ import ____

# Construct your `list` variable with a list of the first 4 letters of the alphabet
list = ['_','_','_','_']

# Print your random 'list' element
print(choice(list))

# Import `randrange` from the `random` library
from ____ import ____

# Construct your `randomLetters` variable with a list of the first 4 letters of the alphabet
randomLetters = ['_','_', '_', '_']

# Select a random index from 'randomLetters`
randomIndex = randrange(0,len(randomLetters))

# Print your random element from `random`
print(randomLetters[randomIndex])

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

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

# List of Strings to a String
listOfStrings = ['One', 'Two', 'Three']
strOfStrings = ''.join(listOfStrings)
print(strOfStrings)

# List Of Integers to a String
listOfNumbers = [1, 2, 3]
strOfNumbers = ''.join(str(n) for n in listOfNumbers)
print(strOfNumbers)

# Pass your list to `tuple()`
tuple(___)

# Transform your list into a set
set(___)

helloWorld = ['hello','world','1','2']संचालित द्वारा

list(zip(helloWorld))

# Convert to a dictionary
helloWorldDictionary = dict(zip(helloWorld[0::2], helloWorld[1::2]))

# Print out the result
print(helloWorldDictionary)

a = [1, 2, 3, 4, 5]

# Create a list iterator object
i = iter(a)

# Zip and create a dictionary
print(dict(zip(i, i)))

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

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

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

# Pass `justAList` to `len()`
len(____)

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

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

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

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

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

# This is your list
list = [5, 6, 7, 8, 9]

# Check whether it's iterable
list.__iter__

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

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

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

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

# Append [4,5] to `shortList`
shortList.append([4, 5])

# Use the print() method to show shortList
print(____)

# Extend `longerList` with [4,5]
longerList.extend([4, 5])

# Use the print() method to see longerList
print(____)

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

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

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

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

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

# Concatenate `shortList` with `[4,5]`
plusList = shortList + [4,5]

#Use the `print()` method to see `plusList`
print(____)

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

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

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

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

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

# Use sort() on the rooms list
____.sort()

# Print out rooms to see the result
print(____)

# Now use the sorted() function on orders
sorted(____)

# Print out orders
print(____)

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

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

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

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

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

# Copy the grocery list by slicing and store it in the `newGroceries` variable
newGroceries = groceries[__]

# Copy the grocery list with the `list()` function and store it in a `groceriesForFriends` variable
groceriesForFriends = list(____)

# Import the copy library as c
import ____ as __

# Create a `groceriesForFamily` variable and assign the copied grocery list to it
groceriesForFamily =  c.copy(____)

# Use `deepcopy()` and assign the copied list to a `groceriesForKids` variable
groceriesForKids= c.deepcopy(____)

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

# This is your list
objectList = ['a','b',['ab','ba']]

# Copy the `objectList`
copiedList = objectList[:]

# Change the first list element of `copiedList`
copiedList[0] = 'c'

# Go to the third element (the nested list) and change the second element
copiedList[2][1] = 'd'

# Print out the original list to see what happened to it
print(objectList)

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

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

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

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

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

[x**2 for x in range(10)]

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

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

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

[x**2 for x in range(10) if x%2==0]

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

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

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

myList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[(lambda x: x*x)(x) for x in myList]

इस उदाहरण में, आपके पास पहले से एक सूची 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 the occurrences of the number 4
print([1, 2, 9, 4, 5, 4, 1].count(4))

# Count the occurrences of the letter "a"
list = ["d", "a", "t", "a", "c", "a", "m", "p"]
list.count("a")

list= ["a","b","b"]
[[x,list.count(x)] for x in set(list)]

# Import `Counter` from the `collections` library
from collections import Counter

# This is your list
list = ["a","b","b"]

# Pass `list` to `Counter()`
Counter(list)

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

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

# Your list `x`
x = [1,2,3,4,5,6,7,8,9]

# Split `x` up in chunks of 3
y = zip(*[iter(x)]*3)

# Use `list()` to print the result of `zip()`
list(y)

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

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

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

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

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

[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]

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

[1][2][3]

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

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

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

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

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

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

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

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

# Method to split up your lists into chunks
def chunks(list, chunkSize):
    """Yield successive chunkSize-sized chunks from list."""
    for i in range(0, len(list), chunkSize):
        yield list[i:i + chunkSize]

# Use your `chunks` function to print out chunks of the same size
import pprint
pprint.pprint(list(chunks(range(10, 75), 10)))

आपका 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 का उपयोग करते हैं।

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

# Set up your list and chunk size
list = range(0, 50)
chunk = 5

# Split up your list into chunks
[list[i:i + chunk] for i in range(0, len(list), chunk)]

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

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

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

# This is your list
mylist = [[1,2,3],[4,5,6,7],[8,9,10]]

# Loop over your list and print all elements that are of size 3
for x in mylist:
      if len(x)==3:
        print(x)

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

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

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

# This is your list
myList = [3,4,5,6]

# Loop over `myList` and print tuples of all indices and values 
for i, val in enumerate(myList):
     print(i, val)

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

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

[x for x in myList if len(x)==3]

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

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

# Your initial list of lists
list = [[1,2],[3,4],[5,6]]

# Flatten out your original list of lists with `sum()`
sum(list, [])

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

# You can reduce the lists of lists of lists like this
from functools import reduce
print(reduce(lambda x,y: x+y,listOfLists))

# Or you can use list comprehension
print([item for sublist in listOfLists for item in sublist])

• आप 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 सूचियों का इंटरसेक्शन कैसे प्राप्त करें

# Intersect both lists with list comprehension
intersection = [list(filter(lambda x: x in list1, sublist)) for sublist in list2]

# Print the result of the intersection
print(____)

# An intersection of both lists, stored in `intersection`
intersection = [[x for x in sublist if x in list1] for sublist in list2]

# Print the result of the intersection
print(intersection)

# Make use of the list and set data structures
print(list(set(list1) & set(list2)))

# Use `intersection()`
print(list(set(list1).intersection(list2)))

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

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

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

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

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

# Your list with duplicate values
duplicates = [1, 2, 3, 1, 2, 5, 6, 7, 8]

# Print the unique `duplicates` list
print(list(set(duplicates)))

# A list with small numbers 
smallNumbers = [1, 2, 3]

# Print the unique `duplicates` list without the small numbers
list(set(duplicates) - set(smallNumbers))

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

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

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

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

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

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

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

import numpy
numpy.array([])

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

# Make a NumPy array of four rows and two columns and filled with 0
numpy.zeros(shape=(4,2))

# Make a NumPy array of 1 values of three columns
numpy.ones(3)

# Make an empty NumPy array
numpy.empty(shape=(0,0))

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

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

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

cost = [0.424, 0.4221, 0.4185, 0.4132, 0.413]
cases = [10, 20, 30, 40, 50]संचालित द्वारा

for c in range(len(cost)):
   cost[c] = (cost[c] * cases[c] / sum(cases))
cost = sum(cost)
print(cost)

sum(cost[c] * cases[c] / sum(cases) for c in range(len(cost)))

sum(cost[c] * cases[c] for c in range(len(cost))) / sum(cases)

# See what `zip()` does to your `cost` and `cases`
print(list(zip(____, ____)))

# Calculate the weighted average
print(sum([x * y for x, y in zip(cost, cases)]) / sum(cases))

# Import numpy as np
import ____ as __

# Make a NumPy array
a = np.array([1,2,3,4,5])

# Return the 50th percentile of our NumPy array
p = np.percentile(a, 50)

#Print the result
print(____)

list1=[1, 2, 3]
list2=[4, 5, 6]संचालित द्वारा

from operator import add
list(map(add, list1, list2))

[sum(x) for x in zip(list1, list2)]

# Import numpy as np
import ____ as __

# Make your lists into NumPy arrays
vector1 = np.array([1, 2, 3])
vector2 = np.array([4, 5, 6])

# Element-wise addition
sum_vector = vector1 + vector2 

# Print the result
print(____)

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 ट्यूटोरियल श्रृंखला पढ़ने पर विचार कर सकते हैं!