Python यूटिलिटी

इस सेक्शन में, हम सामान्य समस्याओं को हल करने के लिए Python के कुछ स्टैंडर्ड यूटिलिटी मॉड्यूल पर नज़र डालेंगे.

फ़ाइल सिस्टम -- os, os.path, सिग्नल

*os* और *os.path* मॉड्यूल में, फ़ाइल सिस्टम से इंटरैक्ट करने के लिए कई फ़ंक्शन होते हैं. *shutil* मॉड्यूल, फ़ाइलों को कॉपी कर सकता है.

• ओएस मॉड्यूल दस्तावेज़
• filenames = os.listdirect(direct) -- उस डायरेक्ट्री पाथ में मौजूद फ़ाइल नामों की सूची (इसमें . और ..). फ़ाइल नाम सिर्फ़ डायरेक्ट्री में मौजूद नाम हैं, उनके पूरे पाथ नहीं.
• os.path.join(direct, filename) -- ऊपर दी गई सूची में से फ़ाइल का नाम दिया गया है. इसलिए, पाथ बनाने के लिए, डायरेक्ट्री और फ़ाइल नाम को एक साथ रखें
• os.path.abspath(path) -- दिया गया, कोई पाथ दिया गया, जिसकी पूरी जानकारी नहीं दी गई है, जैसे कि /home/Nicol/foo/bar.html
• os.path.dername(path), os.path.basename(path) -- दिए गए direct/foo/bar.html पर, Dirname "direct/foo" और basename "bar.html" दें
• os.path.exists(path) -- मौजूद होने पर सही है
• os.mkdia(direct_path) -- एक डायर बनाता है, os.makeDRs(direct_path) इस पाथ के लिए ज़रूरी सभी दिशा बनाता है
• shortcuts.copy(source-path, dest-path) -- कोई फ़ाइल कॉपी करें (डेस्टिनेशन पाथ की डायरेक्ट्री मौजूद होनी चाहिए)

## Example pulls filenames from a dir, prints their relative and absolute paths
def printdir(dir):
  filenames = os.listdir(dir)
  for filename in filenames:
    print(filename)  ## foo.txt
    print(os.path.join(dir, filename)) ## dir/foo.txt (relative to current dir)
    print(os.path.abspath(os.path.join(dir, filename))) ## /home/nick/dir/foo.txt

मॉड्यूल का पता लगाने के लिए, पहले से मौजूद python help() और der() फ़ंक्शन का इस्तेमाल किया जा सकता है. इंटरप्रेटर में, "ओएस इंपोर्ट करें" करें. इसके बाद, इन निर्देशों का इस्तेमाल करके देखें कि मॉड्यूल में क्या उपलब्ध है: direct(os), help(os.list पढ़कर), der(os.path), help(os.path.dername).

बाहरी प्रोसेस चलाना -- सब-प्रोसेस

*सबप्रोसेस* मॉड्यूल किसी बाहरी कमांड को चलाने और उसके आउटपुट को कैप्चर करने का एक आसान तरीका है.

• सबप्रोसेस मॉड्यूल दस्तावेज़
• आउटपुट = subprocessing.check_ मेहमानों(cmd, stderr=subprocessor.STDOUT) -- कमांड को चलाता है, इसके बाहर निकलने का इंतज़ार करता है, और आउटपुट टेक्स्ट दिखाता है. कमांड को इसके स्टैंडर्ड आउटपुट और स्टैंडर्ड गड़बड़ी के साथ एक आउटपुट टेक्स्ट में चलाया जाता है. अगर यह काम नहीं करता, तो CalledProcessError.
• अगर आपको सब-प्रोसेस को चलाने पर ज़्यादा कंट्रोल चाहिए, तो subprocessor.popen क्लास देखें
• इसमें एक आसान subप्रोसेस.call(cmd) भी है, जो कमांड को चलाता है और अपने आउटपुट को आपके आउटपुट में डालता है. साथ ही, अपना गड़बड़ी कोड दिखाता है. यह तब काम करता है जब आपको कमांड रन करना हो, लेकिन उसके आउटपुट को अपने Python डेटा स्ट्रक्चर में कैप्चर करने की ज़रूरत न हो.

import subprocess

## Given a dir path, run an external 'ls -l' on it --
## shows how to call an external program
def listdir(dir):
  cmd = 'ls -l ' + dir
  print("Command to run:", cmd)   ## good to debug cmd before actually running it
  (status, output) = subprocess.getstatusoutput(cmd)
  if status:    ## Error case, print the command's output to stderr and exit
    sys.stderr.write(output)
    sys.exit(status)
  print(output)  ## Otherwise do something with the command's output

अपवाद

अपवाद, रन-टाइम गड़बड़ी को दिखाता है, जो किसी खास लाइन पर सामान्य एक्ज़ीक्यूशन को रोकती है और कंट्रोल को गड़बड़ी हैंडलिंग कोड में ट्रांसफ़र कर देती है. इस सेक्शन में, अपवादों के बुनियादी इस्तेमाल के बारे में बताया गया है. उदाहरण के लिए, रन-टाइम गड़बड़ी का मतलब यह हो सकता है कि प्रोग्राम में इस्तेमाल किए गए किसी वैरिएबल में कोई वैल्यू (ValueError .. आपने शायद कई बार देखा हो) न हो या फ़ाइल मौजूद न होने की वजह से, फ़ाइल खोलने की कार्रवाई में कोई गड़बड़ी हुई हो (IOError). अपवाद के ट्यूटोरियल में ज़्यादा जानें और अपवाद की पूरी सूची देखें.

किसी गड़बड़ी प्रबंधन कोड के बिना (जैसा कि हम अब तक कर रहे हैं), रन-टाइम अपवाद की वजह से प्रोग्राम सिर्फ़ एक गड़बड़ी के मैसेज के साथ रुक जाता है. यह एक अच्छा डिफ़ॉल्ट व्यवहार है और आपने इसे कई बार देखा है. अपवादों को हैंडल करने के लिए, अपने कोड में "आज़माएं/अपवाद" स्ट्रक्चर जोड़ें, जैसे:

  try:
    ## Either of these two lines could throw an IOError, say
    ## if the file does not exist or the read() encounters a low level error.
    f = open(filename, 'rb')
    data = f.read()
    f.close()
  except IOError:
    ## Control jumps directly to here if any of the above lines throws IOError.
    sys.stderr.write('problem reading:' + filename)
  ## In any case, the code then continues with the line after the try/except

'को आज़माएं:' सेक्शन में कोड शामिल होता है, जिसकी वजह से कोई अपवाद हो सकता है. अपवाद: सेक्शन में किसी अपवाद की स्थिति में कोड होता है, ताकि उसे चलाया जा सके. अगर कोई अपवाद नहीं है, तो ' छोड़कर': सेक्शन को छोड़ दिया जाता है. इसका मतलब है कि यह कोड सिर्फ़ गड़बड़ी से निपटने के लिए है, न कि कोड के "सामान्य" मामले के लिए. "IOError for e: .." को छोड़कर, सिंटैक्स का इस्तेमाल करके अपवाद ऑब्जेक्ट के लिए एक पॉइंटर लिया जा सकता है. (e, अपवाद ऑब्जेक्ट की ओर इशारा करता है).

एचटीटीपी -- urllib और urlparse

मॉड्यूल *urllib.request* यूआरएल फ़ेच करने की सुविधा देता है -- जिससे यूआरएल, ऐसी फ़ाइल जैसा दिखता है जिससे उसे पढ़ा जा सकता है. *urlparse* मॉड्यूल अलग-अलग हो सकता है और यूआरएल को एक साथ रख सकता है.

• urllib.request मॉड्यूल दस्तावेज़
• ufile = urllib.request.urlopen(url) -- उस यूआरएल के लिए ऑब्जेक्ट जैसी फ़ाइल लौटाता है
• text = ufile.read() -- इससे इसे फ़ाइल की तरह पढ़ा जा सकता है (readlines() वगैरह. भी काम करता है)
• जानकारी = ufile.info() -- उस अनुरोध की मेटा जानकारी. info.gettype() माइम टाइप है, उदाहरण के लिए 'टेक्स्ट/html'
• baseurl = ufile.geturl() -- को अनुरोध के लिए "base" url देता है, जो रीडायरेक्ट की वजह से मूल से अलग हो सकता है
• urllib.request.urlretrieve(url, filename) -- दिए गए फ़ाइल पाथ से यूआरएल डेटा डाउनलोड करता है
• urllib.parse.urljoin(baseurl, url) -- पूरा यूआरएल देने या न करने वाले यूआरएल और जिस पेज से यह आता है उसके Baseurl से, पूरा यूआरएल दिखाएं. बेस यूआरएल देने के लिए, ऊपर दिए गए geturl() का इस्तेमाल करें.

सभी अपवाद urllib.error में हैं.

from urllib.request import urlopen

## Given a url, try to retrieve it. If it's text/html,
## print its base url and its text.
def wget(url):
  ufile = urlopen(url)  ## get file-like object for url
  info = ufile.info()   ## meta-info about the url content
  if info.get_content_type() == 'text/html':
    print('base url:' + ufile.geturl())
    text = ufile.read()  ## read all its text
    print(text)

ऊपर दिया गया कोड ठीक से काम करता है. हालांकि, अगर कोई यूआरएल किसी वजह से काम नहीं करता है, तो उसमें गड़बड़ी को ठीक किया जा सकता है. यहां फ़ंक्शन का एक वर्शन दिया गया है, जो यूआरएल कार्रवाई फ़ेल होने पर, गड़बड़ी का मैसेज प्रिंट करने के लिए 'कोशिश करें'/'अपवाद' लॉजिक जोड़ता है.

अगर urlopen() हैंग होता हुआ लगता है, तो हो सकता है कि आपका सिस्टम कुछ एचटीटीपी पतों को सीधे ऐक्सेस करने की अनुमति न दे. इस बात की पुष्टि करने के लिए, wget या curl का इस्तेमाल करके, यूआरएल को फ़ेच करने की कोशिश करें. अगर ये प्रोग्राम भी काम नहीं करते, तो आपको प्रॉक्सी सेवा के ज़रिए एचटीटीपी कॉन्टेंट फ़ेच करना होगा. प्रॉक्सी ऐक्सेस को कॉन्फ़िगर करना इस ट्यूटोरियल में शामिल नहीं है.

## Version that uses try/except to print an error message if the
## urlopen() fails.
def wget2(url):
  try:
    ufile = urlopen(url)
    if ufile.info().get_content_type() == 'text/html':
      print(ufile.read())
  except IOError:
    print('problem reading url:', url)

ड्रिल

फ़ाइल सिस्टम और बाहरी कमांड मटीरियल का अभ्यास करने के लिए, खास अभ्यास को कॉपी करें देखें. urllib सामग्री का अभ्यास करने के लिए, लॉग पहेली व्यायाम देखें.