Python Dict और फ़ाइल

Dict हैश टेबल

Python के बेहतर कीवर्ड/वैल्यू हैश टेबल स्ट्रक्चर को "डिकशनरी" कहा जाता है. कोडिंग के कॉन्टेंट को ब्रैकेट { } में, कुंजी:वैल्यू पेयर की सीरीज़ के तौर पर लिखा जा सकता है. उदाहरण के लिए, dict = {key1:value1, key2:value2, ... }. "खाली शब्दकोश", कर्ली ब्रैकेट {} का सिर्फ़ एक खाली जोड़ा है.

किसी डायक्शनरी में वैल्यू देखने या सेट करने के लिए, स्क्वेयर ब्रैकेट का इस्तेमाल किया जाता है. उदाहरण के लिए, dict['foo'], 'foo' कुंजी के नीचे मौजूद वैल्यू को खोजता है. स्ट्रिंग, संख्याएं, और ट्यूपल, कुंजियों की तरह काम करते हैं और इनका कोई भी टाइप, वैल्यू हो सकता है. हो सकता है कि अन्य टाइप, की के तौर पर ठीक से काम करें या न करें. स्ट्रिंग और ट्यूपल, की के तौर पर आसानी से काम करते हैं, क्योंकि वे बदलाव के लायक नहीं होते. जो वैल्यू दी गई में नहीं है उसे देखने पर KeyError दिखता है. "in" का इस्तेमाल करके यह पता लगाया जा सकता है कि ऐक्सेस कोड में कुंजी मौजूद है या नहीं. इसके अलावा, dict.get(key) का इस्तेमाल करके, वैल्यू दिखाई जा सकती है या कोई वैल्यू न होने पर, get(key, not-found) का इस्तेमाल किया जा सकता है.

  ## Can build up a dict by starting with the empty dict {}
  ## and storing key/value pairs into the dict like this:
  ## dict[key] = value-for-that-key
  dict = {}
  dict['a'] = 'alpha'
  dict['g'] = 'gamma'
  dict['o'] = 'omega'

  print(dict) ## {'a': 'alpha', 'o': 'omega', 'g': 'gamma'}

  print(dict['a'])     ## Simple lookup, returns 'alpha'
  dict['a'] = 6       ## Put new key/value into dict
  'a' in dict         ## True
  ## print(dict['z'])                  ## Throws KeyError
  if 'z' in dict: print(dict['z'])     ## Avoid KeyError
  print(dict.get('z'))  ## None (instead of KeyError)

किसी डिक्शनरी पर for लूप, डिफ़ॉल्ट रूप से उसकी कुंजियों पर दोहराता है. कुंजियां, मनचाहे क्रम में दिखेंगी. dict.keys() और dict.values() तरीके, साफ़ तौर पर कुंजियों या वैल्यू की सूचियां दिखाते हैं. items() फ़ंक्शन भी है, जो (key, value) टपल की सूची दिखाता है. यह डिक्शनरी में मौजूद सभी कीवर्ड वैल्यू डेटा की जांच करने का सबसे असरदार तरीका है. इन सभी सूचियों को sorted() फ़ंक्शन में पास किया जा सकता है.

  ## By default, iterating over a dict iterates over its keys.
  ## Note that the keys are in a random order.
  for key in dict:
    print(key)
  ## prints a g o

  ## Exactly the same as above
  for key in dict.keys():
    print(key)

  ## Get the .keys() list:
  print(dict.keys())  ## dict_keys(['a', 'o', 'g'])

  ## Likewise, there's a .values() list of values
  print(dict.values())  ## dict_values(['alpha', 'omega', 'gamma'])

  ## Common case -- loop over the keys in sorted order,
  ## accessing each key/value
  for key in sorted(dict.keys()):
    print(key, dict[key])

  ## .items() is the dict expressed as (key, value) tuples
  print(dict.items())  ##  dict_items([('a', 'alpha'), ('o', 'omega'), ('g', 'gamma')])

  ## This loop syntax accesses the whole dict by looping
  ## over the .items() tuple list, accessing one (key, value)
  ## pair on each iteration.
  for k, v in dict.items(): print(k, '>', v)
  ## a > alpha    o > omega     g > gamma

रणनीति के हिसाब से नोट: परफ़ॉर्मेंस के लिहाज़ से डिक्शनरी आपके लिए एक बेहतरीन टूल है. इसलिए, आपको अपने डेटा को व्यवस्थित तरीके से रखने के लिए, इसका इस्तेमाल करना चाहिए. उदाहरण के लिए, एक लॉग फ़ाइल पढ़ी जा सकती है जिसमें हर लाइन किसी आईपी पते से शुरू होती है. साथ ही, आईपी पते को कुंजी के तौर पर इस्तेमाल करके, डेटा को लिखवाने की सुविधा में स्टोर किया जा सकता है. साथ ही, वैल्यू के तौर पर दिखने वाली लाइनों की सूची दी जा सकती है. पूरी फ़ाइल पढ़ने के बाद, किसी भी आईपी पते को खोजा जा सकता है और उसकी लाइनों की सूची तुरंत देखी जा सकती है. डिक्शनरी स्कैटर डेटा को इकट्ठा करके, उसमें मौजूद चीज़ों को आसान बनाती है.

बोलकर लिखवाने की सुविधा के लिए फ़ॉर्मैटिंग

% ऑपरेटर, किसी डायक्शनरी की वैल्यू को नाम के हिसाब से स्ट्रिंग में बदलने के लिए आसानी से काम करता है:

  h = {}
  h['word'] = 'garfield'
  h['count'] = 42
  s = 'I want %(count)d copies of %(word)s' % h  # %d for int, %s for string
  # 'I want 42 copies of garfield'

  # You can also use str.format().
  s = 'I want {count:d} copies of {word}'.format(h)

Del

"del" ऑपरेटर कुछ डेटा को मिटाता है. आसान शब्दों में, यह किसी वैरिएबल की डेफ़िनिशन को हटा सकता है, जैसे कि उस वैरिएबल की डेफ़िनिशन न दी गई हो. सूची के उस हिस्से को मिटाने और शब्दकोश से एंट्री मिटाने के लिए, सूची के एलिमेंट या स्लाइस पर भी Del का इस्तेमाल किया जा सकता है.

  var = 6
  del var  # var no more!

  list = ['a', 'b', 'c', 'd']
  del list[0]     ## Delete first element
  del list[-2:]   ## Delete last two elements
  print(list)      ## ['b']

  dict = {'a':1, 'b':2, 'c':3}
  del dict['b']   ## Delete 'b' entry
  print(dict)      ## {'a':1, 'c':3}

फ़ाइलें

Open() फ़ंक्शन खुलता है और एक फ़ाइल हैंडल दिखाता है, जिसका इस्तेमाल सामान्य तरीके से फ़ाइल को पढ़ने या लिखने के लिए किया जा सकता है. कोड f = open('name', 'r') फ़ाइल को वैरिएबल f में खोलता है, जो पढ़ने के लिए तैयार है, और पूरा हो जाने पर f.close() का इस्तेमाल करें. लिखने के लिए, 'r' के बजाय 'w' और जोड़ने के लिए 'a' का इस्तेमाल करें. स्टैंडर्ड for-loop, टेक्स्ट फ़ाइलों के लिए काम करता है. यह फ़ाइल की लाइनों को दोहराता है. यह सिर्फ़ टेक्स्ट फ़ाइलों के लिए काम करता है, बाइनरी फ़ाइलों के लिए नहीं. किसी टेक्स्ट फ़ाइल की सभी लाइनों को देखने का आसान और असरदार तरीका, for-loop तकनीक है:

  # Echo the contents of a text file
  f = open('foo.txt', 'rt', encoding='utf-8')
  for line in f:   ## iterates over the lines of the file
    print(line, end='')    ## end='' so print does not add an end-of-line char
                           ## since 'line' already includes the end-of-line.
  f.close()

एक समय में एक पंक्ति पढ़ने की गुणवत्ता अच्छी है, जो सभी फ़ाइलों को एक समय में मेमोरी में फ़िट करने की आवश्यकता नहीं होती -- यह तब आसान है जब आप 10 गीगाबाइट्स मेमोरी का उपयोग किए बिना किसी 10 गीगाबाइट फ़ाइल की प्रत्येक पंक्ति को देखना चाहें. f.readlines() मेथड, पूरी फ़ाइल को मेमोरी में पढ़ता है और उसके कॉन्टेंट को लाइनों की सूची के तौर पर दिखाता है. f.read() मेथड, पूरी फ़ाइल को एक स्ट्रिंग में पढ़ता है. इससे टेक्स्ट को एक साथ मैनेज करने में मदद मिलती है. जैसे, रेगुलर एक्सप्रेशन की मदद से, जिसे हम बाद में देखेंगे.

लिखने के लिए, किसी खुली आउटपुट फ़ाइल पर डेटा लिखने का सबसे आसान तरीका f.write(string) तरीका है. इसके अलावा, "print" फ़ंक्शन का इस्तेमाल किसी खुली फ़ाइल के साथ भी किया जा सकता है. जैसे, "print(string, file=f)".

Files यूनिकोड

यूनिकोड में बदली गई फ़ाइलों को पढ़ने और लिखने के लिए `'t'` मोड का इस्तेमाल करें. साथ ही, कोड में बदलने के तरीके के बारे में साफ़ तौर पर बताएं:

with open('foo.txt', 'rt', encoding='utf-8') as f:
  for line in f:
    # here line is a *unicode* string

with open('write_test', encoding='utf-8', mode='wt') as f:
    f.write('\u20ACunicode\u20AC\n') #  €unicode€
    # AKA print('\u20ACunicode\u20AC', file=f)  ## which auto-adds end='\n'

एक्सरसाइज़ इंक्रीमेंटल डेवलपमेंट

Python प्रोग्राम बनाते समय, पूरा प्रोग्राम एक ही चरण में न लिखें. इसके बजाय, सिर्फ़ पहले माइलस्टोन की पहचान करें. उदाहरण के लिए, "पहला कदम शब्दों की सूची निकालना है." उस माइलस्टोन तक पहुंचने के लिए कोड लिखें और उस बिंदु पर अपने डेटा स्ट्रक्चर को प्रिंट करें. इसके बाद, sys.exit(0) का इस्तेमाल करें, ताकि प्रोग्राम उन हिस्सों में आगे न चला जाए जो पूरे नहीं हुए हैं. माइलस्टोन कोड काम करने के बाद, अगले माइलस्टोन के लिए कोड पर काम किया जा सकता है. किसी एक स्टेटस में अपने वैरिएबल का प्रिंटआउट देखने से, आपको यह सोचने में मदद मिल सकती है कि अगले स्टेटस पर जाने के लिए, उन वैरिएबल को कैसे बदलना है. Python, इस पैटर्न को तुरंत इस्तेमाल कर लेता है. इससे, आपको अपने हिसाब से थोड़ा बदलाव करने और प्रोग्राम को चलाने की सुविधा मिलती है, ताकि यह देखा जा सके कि यह कैसे काम करता है. इस सुविधा की मदद से, कम समय में आसानी से अपना प्रोग्राम बनाया जा सकता है.

उदाहरण: wordcount.py

Python के सभी बुनियादी कॉन्टेंट -- स्ट्रिंग, सूचियां, डिक्शनरी, ट्यूपल, फ़ाइलें -- को मिलाकर, बुनियादी एक्सरसाइज़ में मौजूद wordcount.py एक्सरसाइज़ की समरी आज़माएं.