文章来自《Python cookbook》.

翻译仅仅是为了个人学习,其它商业版权纠纷与此无关!

-- 61.182.251.99 [DateTime(2004-09-23T16:58:36Z)] TableOfContents

描述

Reading Lines with Continuation Characters 读取含有行连接字符的文件行

问题 Problem

You have a file that includes long logical lines split over two or more physical lines, with backslashes to indicate that a continuation line follows. You want to process a sequence of logical lines, rejoining those split lines.

文件含有逻辑上很长的行，分隔在2个或者更多的物理文件行上，行尾使用'\'符号标记下一行仍然是逻辑上的同一行。需要处理逻辑行的序列，将分开的各物理行合并连接起来。

解决 Solution

As usual, a class is the right way to wrap this functionality in Python 2.1:

Python 2.1中，正确方法仍是使用封装类： 

   1 class LogicalLines:
   2 
   3     def _ _init_ _(self, fileobj):
   4 
   5         # Ensure that we get a line-reading sequence in the best way possible:
   6         import xreadlines
   7         try:
   8             # Check if the file-like object has an xreadlines method
   9             self.seq = fileobj.xreadlines(  )
  10         except AttributeError:
  11             # No, so fall back to the xreadlines module's implementation
  12             self.seq = xreadlines.xreadlines(fileobj)
  13 
  14         self.phys_num = 0  # current index into self.seq (physical line number)
  15         self.logi_num = 0  # current index into self (logical line number)
  16 
  17     def _ _getitem_ _(self, index):
  18         if index != self.logi_num:
  19             raise TypeError, "Only sequential access supported"
  20         self.logi_num += 1
  21         result = []
  22         while 1:
  23             # Intercept IndexError, since we may have a last line to return
  24             try: 
  25                 # Let's see if there's at least one more line in self.seq
  26                 line = self.seq[self.phys_num]
  27             except IndexError:
  28                 # self.seq is finished, so break the loop if we have any
  29                 # more data to return; else, reraise the exception, because
  30                 # if we have no further data to return, we're finished too
  31                 if result: break
  32                 else: raise
  33             self.phys_num += 1
  34             if line.endswith('\\\n'):
  35                 result.append(line[:-2])
  36             else:
  37                 result.append(line)
  38                 break
  39         return ''.join(result)
  40 
  41 # Here's an example function, showing off usage:
  42 def show_logicals(fileob, numlines=5):
  43     ll = LogicalLines(fileob)
  44     for l in ll:
  45         print "Log#%d, phys# %d: %s" % (
  46             ll.logi_num, ll.phys_num, repr(l))
  47         if ll.logi_num>numlines: break
  48 
  49 if _ _name_ _=='_ _main_ _':
  50     from cStringIO import StringIO
  51     ff = StringIO(
  52 r"""prima \
  53 seconda \
  54 terza
  55 quarta \
  56 quinta
  57 sesta
  58 settima \
  59 ottava
  60 """)
  61     show_logicals( ff )

讨论 Discussion

This is another sequence-bunching problem, like Recipe 4.9. In Python 2.1, a class wrapper is the most natural approach to getting reusable code for sequence-bunching tasks. We need to support the sequence protocol ourselves and handle the sequence protocol in the sequence we wrap. In Python 2.1 and earlier, the sequence protocol is as follows: a sequence must be indexable by successively larger integers (0, 1, 2, ...), and it must raise an IndexError as soon as an integer that is too large is used as its index. So, if we need to work with Python 2.1 and earlier, we must behave this way ourselves and be prepared for just such behavior from the sequence we are wrapping.

In Python 2.2, thanks to iterators, the sequence protocol is much simpler. A call to the next method of an iterator yields its next item, and the iterator raises a StopIteration when it's done. Combined with a simple generator function that returns an iterator, this makes sequence bunching and similar tasks far easier:

from _ _future_ _ import generators

def logical_lines(fileobj):

参考 See Also