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, चलने के दौरान इस टाइप के संकेत का इस्तेमाल नहीं करता आपके प्रोग्राम में शामिल न हो. इनका इस्तेमाल IDEs (इंटिग्रेट किए गए डेवलपमेंट एनवायरमेंट) जैसे दूसरे प्रोग्राम और यह पुष्टि करने के लिए कि आपके फ़ंक्शन को कॉल किया जाता है या नहीं, लिंटर/टाइप चेकर जैसे स्टैटिक विश्लेषण टूल के साथ काम करने वाले आर्ग्युमेंट इस्तेमाल किए जा सकते हैं.)

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

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

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

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

सीमा

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

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

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

लूप में चलाते समय

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

  ## 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 के एलिमेंट को सूची के आखिर में जोड़ता है. किसी सूची में + या += का इस्तेमाल करना, एक्सपैंशन() का इस्तेमाल करने जैसा ही है.
• list.index(elem) -- सूची की शुरुआत से दिए गए एलिमेंट को खोजता है और उसका इंडेक्स दिखाता है. अगर एलिमेंट नहीं दिखता है, तो ValueError देता है (ValueError के बिना जांच करने के लिए "in" का इस्तेमाल करें).
• list.remove(elem) -- दिए गए एलिमेंट का पहला इंस्टेंस खोजता है और उसे हटा देता है (मौजूद न होने पर, ValueError देता है)
• list.sort() -- सूची को अपनी जगह पर क्रम से लगाता है (इसे नहीं दिखाता है). (बाद में दिखाया गया क्रम से लगाया गया() फ़ंक्शन पसंद किया जाता है.)
• list.reverse() -- सूची को उलटा कर देता है (इसे नहीं दिखाता है)
• list.pop(index) -- दिए गए इंडेक्स से एलीमेंट को हटाता है और लौटाता है. इंडेक्स को छोड़ देने पर सबसे दाईं ओर का एलिमेंट दिखाता है (अपेंड() के उलट).

ध्यान दें कि ये लिस्ट ऑब्जेक्ट पर *मेथड* हैं. वहीं, 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 में उन सवालों को आज़माएं जो क्रम से लगाने की सुविधा का इस्तेमाल नहीं करते (बेसिक एक्सरसाइज़ में).