क्या प्रत्येक पंक्ति को एक पंक्ति में पढ़ने के लिए इसे लाइन द्वारा संसाधित करने का एक मुहावरेदार तरीका है?

Question

पायथन में, मैं एक फ़ाइल लाइन को लाइन से संसाधित करने के लिए निम्न कार्य करूँगा:

with open(infile) as f:
    for line in f:
        process(line)

यह देखने की कोशिश की जा रही है कि कैसे (फ़ाइलों के बजाय बफ़र्स के साथ) में समान करने के लिए, मुझे कोई स्पष्ट तरीका नहीं मिला।

(जो मैं समाप्त करना चाहता हूं, वह दो क्रमबद्ध डेटास्ट्रक्चर की रेखाएं हैं, एक सभी लाइनों के साथ एक रेग्क्स मेल खाता है, दूसरा जो मेल नहीं खाता है।)

Answer 1

इसे करने के विभिन्न तरीके हैं। कौशल के रास्ते को थोड़ा और अधिक कुशल बनाया जा सकता है:

(goto-char (point-min))
(while (not (eobp))
  (let ((line (buffer-substring (point)
                                (progn (forward-line 1) (point)))))
    ...))

लेकिन Emacs में यह स्ट्रिंग्स के बजाय बफर पर काम करने के लिए बहुत अधिक प्रथागत है। तो स्ट्रिंग निकालने के बजाय और फिर उस पर काम करें, आप बस करेंगे:

(goto-char (point-min))
(while (not (eobp))
  ...
  (forward-line 1))

इसके अलावा, यदि आप पूरे बफ़र के बजाय किसी क्षेत्र पर काम करना चाहते हैं, और यदि आपके "संचालित" में बफ़र को संशोधित करना शामिल है, तो इसे बार-बार पीछे करना है (ताकि आप इस तथ्य से काट न लें कि "अंत" "आपके क्षेत्र की स्थिति हर बार जब आप बफर को बदलते हैं):

(goto-char end)
(while (> (point) start)
  ...
  (forward-line -1))

Comments

उन अनुकूलन सुझावों के लिए धन्यवाद! आपसे सीखने के लिए हमेशा अच्छा है।

— कौशल मोदी

आखिरी स्निपेट के बारे में, क्या यह इस तरह से होना चाहिए (let ((start (point))) (goto-char (point-max)) (while (> (point) start) ... (forward-line -1))):?

— कौशल मोदी

नहीं है, पिछले टुकड़ा सिर्फ इतना है कि मान लिया गया है startऔर endचर जो इस क्षेत्र जिस पर हम काम करना चाहते परिसीमित मौजूदा कर रहे हैं।

— स्टीफन

Answer 2

मैं किसी भी मुहावरेदार तरीके के बारे में नहीं जानता लेकिन मैं इसके साथ आया हूँ:

(defun my/walk-line-by-line ()
  "Process each line in the buffer one by one."
  (interactive)
  (save-excursion
    (goto-char (point-min))
    (while (not (eobp))
      (let* ((lb (line-beginning-position))
             (le (line-end-position))
             (ln (buffer-substring-no-properties lb le)))
        (message ">> %s" ln) ; Replace this with any processing function you like
        (forward-line 1)))))

Answer 3

मुझे लगता है कि निम्नलिखित मुहावरेदार है क्योंकि यह प्राप्त कर सकता है:

(dolist (line (split-string (buffer-string) "\n")) 
  ... process line here ...
  )

संपादित करें: यहां एक और समाधान दिया loopगया है dolist, और यह भी कि वे आपकी नियमित अभिव्यक्ति से मेल खाते हैं या नहीं, के अनुसार रेखाओं को वर्गीकृत करता है:

(loop for line in (split-string (buffer-string) "\n")
  if (string-match "your-regexp" line)
    collect line into matching
  else
    collect line into nonmatching
  finally return (cons matching nonmatching)
  )

यदि आप इस फ़ंक्शन के आउटपुट के लिए एक चर सेट करते हैं, कहते हैं (setq x (loop ...)), तो मिलान लाइनों की वांछित सूची में पाया जाएगा (car x), नॉनमैचिंग लाइनों की सूची के साथ (cdr x)।