Python की सूचियां

Python में, "list" नाम का एक बेहतरीन, पहले से मौजूद सूची टाइप है. सूची की लिटरल वैल्यू, स्क्वेयर ब्रैकेट [ ] के अंदर लिखी जाती हैं. सूचियां, स्ट्रिंग की तरह ही काम करती हैं -- डेटा को ऐक्सेस करने के लिए, Len() फ़ंक्शन और स्क्वेयर ब्रैकेट [ ] का इस्तेमाल करें. पहला एलिमेंट इंडेक्स 0 पर होता है. (python.org की आधिकारिक सूची के दस्तावेज़ देखें.)

  colors = ['red', 'blue', 'green']
  print(colors[0])    ## red
  print(colors[2])    ## green
  print(len(colors))  ## 3

सूचियों में = के साथ असाइनमेंट करने पर, कॉपी नहीं बनती. इसके बजाय, असाइनमेंट से दोनों वैरिएबल, मेमोरी में मौजूद एक सूची पर ले जाते हैं.

  b = colors   ## Does not copy the list

"खाली सूची", ब्रैकेट [ ] का सिर्फ़ एक खाली पेयर होता है. '+', दो सूचियों को जोड़ने के लिए काम करता है. इसलिए, [1, 2] + [3, 4] से [1, 2, 3, 4] मिलता है. यह ठीक वैसा ही है जैसे स्ट्रिंग के साथ +.

CANNOT TRANSLATE

Python के *for* और *in* कंस्ट्रक्ट बहुत काम के हैं. इनका सबसे पहले इस्तेमाल हम सूचियों के साथ करते हैं. *for* कंस्ट्रक्ट -- for var in list -- किसी लिस्ट (या दूसरे कलेक्शन) के हर एलिमेंट को देखने का आसान तरीका है. दोहराए जाने के दौरान, सूची में कोई आइटम न जोड़ें या न हटाएं.

  squares = [1, 4, 9, 16]
  sum = 0
  for num in squares:
    sum += num
  print(sum)  ## 30

अगर आपको पता है कि सूची में किस तरह की चीज़ें हैं, तो लूप में वैरिएबल के ऐसे नाम का इस्तेमाल करें जो उस जानकारी को कैप्चर करता हो. जैसे, "num", "name" या "url". Python कोड में टाइप के बारे में याद दिलाने के लिए कोई दूसरा सिंटैक्स नहीं होता, इसलिए वैरिएबल के नाम की मदद से, चल रही गतिविधियों को आसान बनाया जा सकता है. (यह थोड़ा गुमराह करने वाला है. Python के बारे में ज़्यादा जानने पर, आपको टाइप के सुझाव के रेफ़रंस दिखेंगे. इनकी मदद से, फ़ंक्शन की परिभाषाओं में टाइप करने से जुड़ी जानकारी जोड़ी जा सकती है. Python आपके प्रोग्राम चलाते समय, टाइप के इन हिंट का इस्तेमाल नहीं करता. इनका इस्तेमाल, IDE (इंटिग्रेटेड डेवलपमेंट एनवायरमेंट) जैसे अन्य प्रोग्राम और लिंटर/टाइप चेकर जैसे स्टैटिक विश्लेषण टूल करते हैं. इससे यह पुष्टि की जाती है कि आपके फ़ंक्शन, काम करने वाले आर्ग्युमेंट के साथ कॉल किए गए हैं या नहीं.)

*in* कंस्ट्रक्ट की मदद से, यह आसानी से पता लगाया जा सकता है कि कोई एलिमेंट किसी सूची (या दूसरे कलेक्शन) में मौजूद है या नहीं -- value in collection -- यह जांच करता है कि वैल्यू कलेक्शन में है या नहीं. इसके बाद, True/False दिखाता है.

  list = ['larry', 'curly', 'moe']
  if 'curly' in list:
    print('yay') ## yay

for/in कंस्ट्रक्ट का इस्तेमाल, Python कोड में बहुत आम तौर पर किया जाता है. ये सूची के अलावा, अन्य डेटा टाइप पर भी काम करते हैं. इसलिए, आपको इनका सिंटैक्स याद रखना चाहिए. ऐसा हो सकता है कि आपको अन्य भाषाओं में, किसी कलेक्शन को मैन्युअल तौर पर दोहराना पड़े. Python में, आपको सिर्फ़ in/in का इस्तेमाल करना चाहिए.

किसी स्ट्रिंग पर काम करने के लिए, for/in का भी इस्तेमाल किया जा सकता है. स्ट्रिंग, अपने वर्णों की सूची की तरह काम करती है. इसलिए, for ch in s: print(ch) किसी स्ट्रिंग के सभी वर्णों को प्रिंट करता है.

सीमा

range(n) फ़ंक्शन, 0, 1, ... n-1 जैसी संख्याएं दिखाता है. वहीं, range(a, b) फ़ंक्शन, a, a+1, ... b-1 जैसी संख्याएं दिखाता है. हालांकि, इसमें आखिरी संख्या शामिल नहीं होती. for-loop और range() फ़ंक्शन के कॉम्बिनेशन से, संख्याओं के लिए सामान्य for-loop बनाया जा सकता है:

  ## print the numbers from 0 through 99
  for i in range(100):
    print(i)

xrange() एक वैरिएंट है, जो परफ़ॉर्मेंस पर असर डालने वाले मामलों के लिए, पूरी सूची बनाने की ज़रूरत को कम करता है. Python 3 में, range() की परफ़ॉर्मेंस अच्छी होगी और xrange() का इस्तेमाल करने की ज़रूरत नहीं होगी.

While लूप

Python में स्टैंडर्ड while-loop भी होता है. साथ ही, *break* और *continue* स्टेटमेंट, C++ और Java की तरह ही काम करते हैं. इनसे सबसे अंदरूनी लूप के कोर्स में बदलाव होता है. ऊपर दिए गए for/in लूप, सूची में हर एलिमेंट को दोहराने के सामान्य मामले को हल करते हैं. हालांकि, while लूप से आपको इंडेक्स नंबर पर पूरा कंट्रोल मिलता है. यहां एक while लूप दिया गया है, जो सूची में हर तीसरे एलिमेंट को ऐक्सेस करता है:

  ## Access every 3rd element in a list
  i = 0
  while i < len(a):
    print(a[i])
    i = i + 3

सूची बनाने के तरीके

यहां सूची के कुछ अन्य सामान्य तरीके दिए गए हैं.

• list.append(elem) -- सूची के आखिर में एक एलिमेंट जोड़ता है. सामान्य गड़बड़ी: नई सूची नहीं दिखाता, सिर्फ़ ओरिजनल सूची में बदलाव करता है.
• list.insert(index, elem) -- एलिमेंट को दिए गए इंडेक्स पर डालता है. साथ ही, एलिमेंट को दाईं ओर शिफ़्ट करता है.
• list.extend(list2) लिस्ट2 के एलिमेंट को सूची के आखिर में जोड़ता है. किसी सूची में + या += का इस्तेमाल करना, extend() का इस्तेमाल करने जैसा ही है.
• list.index(elem) -- यह लिस्ट की शुरुआत से दिए गए एलिमेंट को खोजता है और उसका इंडेक्स दिखाता है. अगर एलिमेंट नहीं दिखता है, तो ValueError देता है (ValueError के बिना जांच करने के लिए "in" का इस्तेमाल करें).
• list.remove(elem) -- दिए गए एलिमेंट का पहला इंस्टेंस खोजता है और उसे हटा देता है (मौजूद न होने पर, ValueError देता है)
• list.sort() -- सूची को उसी जगह पर क्रम से लगाता है (उसे नहीं दिखाता). (बाद में दिखाया गया sorted() फ़ंक्शन बेहतर है.)
• list.reverse() -- सूची को उलटा कर देता है (इसे नहीं दिखाता है)
• list.pop(index) -- दिए गए इंडेक्स से एलीमेंट को हटाता है और लौटाता है. अगर इंडेक्स को छोड़ दिया जाता है, तो सबसे दाईं ओर मौजूद एलिमेंट दिखाता है. यह append() फ़ंक्शन के ठीक उलट काम करता है.

ध्यान दें कि ये लिस्ट ऑब्जेक्ट पर *मेथड* हैं. वहीं, Len() एक ऐसा फ़ंक्शन है जो सूची (या स्ट्रिंग या जो भी हो) को आर्ग्युमेंट के तौर पर लेता है.

  list = ['larry', 'curly', 'moe']
  list.append('shemp')         ## append elem at end
  list.insert(0, 'xxx')        ## insert elem at index 0
  list.extend(['yyy', 'zzz'])  ## add list of elems at end
  print(list)  ## ['xxx', 'larry', 'curly', 'moe', 'shemp', 'yyy', 'zzz']
  print(list.index('curly'))    ## 2

  list.remove('curly')         ## search and remove that element
  list.pop(1)                  ## removes and returns 'larry'
  print(list)  ## ['xxx', 'moe', 'shemp', 'yyy', 'zzz']

आम तौर पर होने वाली गड़बड़ी: ध्यान दें कि ऊपर दिए गए तरीके, बदली गई सूची को *वापस नहीं* लाते. ये सिर्फ़ मूल सूची में बदलाव करते हैं.

  list = [1, 2, 3]
  print(list.append(4))   ## NO, does not work, append() returns None
  ## Correct pattern:
  list.append(4)
  print(list)  ## [1, 2, 3, 4]

सूची का बिल्ड अप

सूची को खाली सूची [] के तौर पर शुरू करना, एक आम पैटर्न है. इसके बाद, उसमें एलिमेंट जोड़ने के लिए जोड़ें (जोड़ें) या एक्सटेंडेड() का इस्तेमाल करें:

  list = []          ## Start as the empty list
  list.append('a')   ## Use append() to add elements
  list.append('b')

सूची के स्लाइस

स्लाइस, स्ट्रिंग की तरह ही सूचियों पर काम करते हैं. इनका इस्तेमाल सूची के सब-पार्ट बदलने के लिए भी किया जा सकता है.

  list = ['a', 'b', 'c', 'd']
  print(list[1:-1])   ## ['b', 'c']
  list[0:2] = 'z'    ## replace ['a', 'b'] with ['z']
  print(list)         ## ['z', 'c', 'd']

कसरत: list1.py

इस सेक्शन में दिए गए कॉन्टेंट का अभ्यास करने के लिए, list1.py में मौजूद वे समस्याएं हल करें जिनमें क्रम से लगाने की सुविधा का इस्तेमाल नहीं किया गया है. ये समस्याएं, बुनियादी एक्सरसाइज़ में मौजूद हैं.