1

我正在实现二进制文件格式（约 15 种不同的结构）读取器/写入器，但我有点纠结应该使用哪种设计模式。

  1. 每个结构都包含打包/解包的方法：

    class Struct1:  
    def pack():
        struct.pack(self.foo)
        ...
    def unpack():  
        self.foo = struct.unpack()
        ...
class Struct2:  
    def pack():
        struct.pack(self.foo)
        ...
    def unpack():  
        self.foo = struct.unpack()
        ...
...

    对比

  2. 每个结构都有带有读/写方法的 Reader/Writer 类：

    class Reader:
    def read_struct1():
        s = Struct1()
        s.foo = struct.unpack()
        ...
        return s
    def read_struct2():
        s = Struct2()
        s.foo = struct.unpack()
        ...
        return s
    ...
class Writer:
    def write_struct1(s):
        struct.pack(s.foo)
        ...
    def write_struct2(s):
        struct.pack(s.foo)
        ...
    ...
4

4 回答 4

2

编写单独的 Reader/Writer 类的目的是支持不同的输出处理——写入控制台、写入字节、写入 JSON 字符串等等。重要的是每个类 Struct1、Struct2 等都知道哪些属性对于保存它们的状态很重要。这是 pickle 模块使用的理念。

class Struct1(object):
    fields = ('a','b','c')
    ...

class Struct2(object):
    fields = ('foo', 'bar', 'baz')
    ...

现在可以使用此元数据编写各种编写器类，而无需编写特定于类的代码：

class StructWriter(object):
    packTypeMap = {int:'i', float:'f', str:'s'}

    def write(self, obj):
        fields = obj.fields
        packstring = ''.join(packTypeMap[type(f)] for f in fields)
        packargs = (getattr(obj,f) for f in fields)
        return struct.pack(packstring, *packargs)

class DictWriter(object):
    def write(self, obj):
        return dict((f, getattr(obj,f)) for f in obj.fields)

class JSONWriter(object):
    jsonTypeMap = {str:lambda s:"'"+s+"'"}
    defaultJsonFunc = lambda x:str(x)
    def write(self, obj):
        # not really recommended to roll your own strings, but for illustration...
        fields = obj.fields
        outargs = (getattr(obj,f) for f in fields)
        outvals = (jsonTypeMap.get(type(arg),defaultJsonFunc)(arg) 
                       for arg in outargs)
        return ('{' +
            ','.join("'%s':%s" % field_val for field_val in zip(fields, outvals))
            '}')

class ZipJSONWriter(JSONWriter):
    def write(self, obj):
        import zlib
        return zlib.compress(super(ZipJSONWriter,self).write(obj))        

class HTMLTableWriter(object):
    def write(self, obj):
        out = "<table>"
        for field in obj.fields:
            out += "<tr><td>%s</td><td>%s</td></tr>" % (field, getattr(obj,field))
        out += "</table>"
        return out
于 2012-12-27T14:59:51.207 回答
1

前者似乎更有意义——结构就是事物，因此将它们表示为对象更有意义。我认为第二种方法没有真正的优势。

于 2012-12-27T14:02:38.500 回答
0

它们必须是对象吗？出于管理目的，我很想考虑将pack/unpack字符串放入dict（以（命名）元组作为值）中，并将其放在单独的模块中......

some_file.py：

structs = {
    'struct1': ('unpack', 'pack'),
    'struct2': ('other unpack', 'other pack')
...
}

如果需要有一个PackerUnPacker可以接受并使用它的类......

于 2012-12-27T14:23:20.273 回答
0

重点应该是如何充分利用类继承来避免代码重复？我会尝试为常见的pack/unpack方法定义一个抽象类：

class PackUnpack(object):  
    def pack(self):
        struct.pack(self.foo)
        ...
    def unpack(self):  
        self.foo = struct.unpack()
        ...

class Struct1(object, PackUnpack):
    ...

class Struct2(object, PackUnpack):
    ...

但即使这不可能（或实施起来太麻烦），第一选择似乎更自然并且更容易维护。

于 2012-12-27T14:34:55.830 回答