如何编写一个行为与另一个动态确定的类完全相同的类？ （Python）

Question

我想创建一个“File”对象，在调用 ReadLine() 方法时返回“Line”对象，而不仅仅是字符串。我还希望能够使用包含文本文档绝对路径的字符串或字符串列表来初始化 File 对象，并让生成的实例在任何一种情况下都具有相同的行为。我能弄清楚如何执行此操作的唯一方法是根据输入类型将 File 对象包装在 FileDoc 或 FileList 对象周围。这是迄今为止我所拥有的解决方案的缩写版本：

class Line(object):
    def __init__(self, line, count, fpath):
        self.text = line
        self.count = count
        self.fname = fpath.split('/')[-1]

class FileBase(object):
    def __init__(self):
        pass

    def Open(self):
        self.count = 0

    def Readline(self):
        pass

    def Get_count(self):
        return self.count

    def Set_count(self, val):
        self.count = val

class FileList(FileBase):
    def __init__(self, lines):
        self.lines = lines
        self.Open()

    def ReadLine(self):
        self.count += 1
        try:
            return Line(line=self.lines[self.count - 1], count=self.count - 1, fpath='list')
        except IndexError:
            raise StopIteration

class FileDoc(FileBase):
    def __init__(self, fpath):
        self.fpath = fpath
        self.Open()

    def Open(self):
        self.count = 0
        self.file = open(self.fpath, 'r')

    def ReadLine(self):
        self.count += 1
        return Line(line=self.file.next(), count=self.count - 1, fpath=self.fpath)

class File(FileBase):
    def __init__(self, input):
        if type(input) == type(''):
            self.actual = FileDoc(input)
        elif type(input) == type([]):
            self.actual = FileList(input)
        else:
            raise NonRecognizedInputError

    def Open(self):
        self.actual.Open()

    def ReadLine(self):
        return self.actual.ReadLine()

    def Get_count(self):
        return self.actual.count

    def Set_count(self, val):
        self.actual.count = val

但是，这看起来很笨重且非 Pythonic，因为我必须使用 Get_count() 和 Set_count() 方法来访问 File 对象的 .count 成员，而不仅仅是能够通过instance.count直接访问它。是否有一种更优雅的解决方案，允许我以成员身份访问 .count 成员，而不是使用 getter 和 setter？

另外，为了加分，我仍在试图弄清楚整个继承问题。有没有更好的方法来构建类之间的关系？

Answer 1

要简化 count 属性，请使用 property 装饰器：

@property
def count(self):
    return self._count  # or return self.actual.count

@count.setter
def count(self, value):
    self._count = value  # or self.actual.count = value

或者如果您不希望它成为装饰器：

count = property(Get_count, Set_count)

至于您的继承方案，我认为还可以；由于您使用 File 隐藏大部分详细信息，因此以后如果需要的话更改它应该不会太难。 @MannyD 的评论是重组的好主意；请注意，例如，file 对象是可迭代的，就像列表一样。

顺便说一句，FileLine 作为 collections.namedtuple 可能会更好（只是说）：

Line = collections.namedtuple('Line', 'line count path')

Answer 2

我个人认为你的类层次结构太复杂了。我不确定您如何在代码中使用它，但“文件”一词似乎被过度使用了。字符串列表根本不是文件，因此我创建了类似 LineReader 的东西，以便能够从不同的源读取数据，然后使用文件或列表迭代器为其提供数据。

考虑下面的代码：

class Line(object):
    def __init__(self, line, count, fpath):
        self.text = line
        self.count = count
        self.fname = fpath

class LineReader(object):
    def __init__(self, iterator, fname):
        self.iterator = iterator
        self.fname = fname
        self.count = 0

    def ReadLine(self):
        line = Line(self.iterator.next(), self.count, self.fname)
        self.count += 1        
        return line

class LineSource(object):
    def __init__(self, input):
        if type(input) == type(''):
            self.reader = LineReader(open(input), input.split('/')[-1])
        elif type(input) == type([]):
            self.reader = LineReader(iter(input), 'list')
        else:
            raise NonRecognizedInputError

    def ReadLine(self):
        return self.reader.ReadLine()

对我来说看起来不那么复杂并且可以完成工作。我不知道为什么您需要访问计数器，因为它已写入 Line 对象。您可以按照 @li.davidm 的建议使用属性，但前提是您确实有理由在读取行时更改文件读取器的内部计数器。

Answer 3

除非有理由强制执行继承层次结构，否则我会考虑使用工厂模式并利用 Python 是动态类型的事实：

def FileFactory(input):
    if isinstance(input, types.StringTypes):
        return FileDoc(input)
    if isinstance(input, (types.ListType, types.TupleType)):
        return FileList(input)
    raise NonRecognizedInputError()

不需要 File() 类，因为它不提供任何超出基础的内容类，因此在这种情况下，只需维护额外的代码。此外，通常最好使用 isinstance(object, type) 来处理派生类，而不是比较特定类型。

顺便说一句，我建议遵循 PEP 8 风格指南它将使您的代码更容易被其他人阅读。