Python Dict और फ़ाइल

डिक्ट हैश टेबल

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

डिक्शनरी में किसी वैल्यू को देखने या उसे सेट करने के लिए, स्क्वेयर ब्रैकेट का इस्तेमाल किया जाता है. जैसे, delete['foo'], 'foo' कुंजी के तहत वैल्यू दिखाता है. स्ट्रिंग, संख्याएं, और ट्यूपल कुंजी की तरह काम करते हैं. इनमें से किसी भी टाइप की वैल्यू हो सकती है. अन्य टाइप सही तरीके से काम कर भी सकते हैं और नहीं भी कर सकते हैं, क्योंकि स्ट्रिंग और ट्यूपल सही तरीके से काम करते हैं, क्योंकि इन्हें बदला नहीं जा सकता. डिक्शनरी में नहीं है, तो ऐसी वैल्यू खोजने से KeyError होती है -- यह देखने के लिए "in" का इस्तेमाल करें कि क्या कुंजी डिक्शनरी में है या डिक्ट.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)

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

  ## 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}

Files

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

  # 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(string, file=f)" जैसी किसी खुली फ़ाइल के साथ "प्रिंट करें" का इस्तेमाल किया जा सकता है.

फ़ाइलों का यूनिकोड

कोड में बदली गई फ़ाइलों को पढ़ने और लिखने के लिए, `'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 कसरत का जवाब दें.