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] मिलता है (यह स्ट्रिंग के साथ + की तरह ही होता है).

For और IN

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 -- यह जांच करता है कि वैल्यू, कलेक्शन में है या नहीं. इससे, सही/गलत वैल्यू मिलती है.

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

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

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

रेंज

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

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

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

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

Python में 'टाइम-लूप' का स्टैंडर्ड भी होता है और *break* और *Continue* स्टेटमेंट, 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), list2 के एलिमेंट को सूची के आखिर में जोड़ता है. किसी सूची में + या += का इस्तेमाल करना, एक्सपैंशन() का इस्तेमाल करने जैसा ही है.
• list.index(elem) -- सूची की शुरुआत से दिए गए एलिमेंट को खोजता है और उसका इंडेक्स दिखाता है. अगर एलिमेंट नहीं दिखता है, तो यह ValueError देता है (ValueError के बिना जांच करने के लिए "in" का इस्तेमाल करें).
• list.remove(elem) -- दिए गए एलिमेंट के पहले इंस्टेंस को खोजता है और उसे हटा देता है (अगर मौजूद नहीं है, तो ValueError देता है)
• सूची.sort() -- स्थान पर सूची को सॉर्ट करता है (इसे लौटाता है). (बाद में दिखाए जाने वाले क्रमित() फ़ंक्शन को प्राथमिकता दी जाती है.)
• list.reverse() -- पहले से मौजूद सूची को रिवर्स कर देता है (इसे रिटर्न नहीं करता है)
• list.पॉप(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]

सूची तैयार करना

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

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