Question

我是Python的新手，并且编写了一个可以从二进制文件读写的代码。

我决定为将包含在文件中的每种类型的数据创建类，并为了保持它们的组织，我创建了一个他们都将继承的类，称为InteriorIO。我希望每个类都有一个读写方法，可以读/写文件中的数据。然而，在继承InteriorIO的同时，我希望它们的行为类似于str或int，因为它们返回它们包含的值，因此我会根据它们最接近的内容修改__str__或__int__像。

class InteriorIO(object):
    __metaclass__ = ABCMeta

    @abstractmethod
    def read(this, f):
        pass

    @abstractmethod
    def write(this, f):
        pass

class byteIO(InteriorIO):
    def __init__(this, value=None):
        this.value = value

    def read(this, f):
        this.value = struct.unpack("B", f.read(1))[0]

    def __str__:
        return value;

class U16IO(InteriorIO):
    def __init__(this, value=None):
        this.value = value

    def read(this, f):
        this.value = struct.unpack("<H", f.read(2))[0]

    def __int__:
        return value;

# how I'd like it to work
f.open("C:/some/path/file.bin")
# In the file, the fileVersion is a U16
fileVersion = U16IO()
# We read the value from the file, storing it in fileVersion
fileVersion.read(f)
# writes the fileVersion that was just read from the file
print(str(fileVersion))
# now let's say we want to write the number 35 to the file in the form of a U16, so we store the value 35 in valueToWrite
valueToWrite = U16IO(35)
# prints the value 35
print(valueToWrite)
# writes the number 35 to the file
valueToWrite.write(f)
f.close()

底部的代码有效，但是这些类感觉不对，而且模糊不清。我正在设置this.value，这是我想出的随机名称，对于每个对象都是一种“主”值，然后将所述值作为我想要的类型返回。

组织我的类最干净的方法是什么，它们都继承自InteriorIO，但它们的行为类似于str或int，因为它们返回了它们的值？

Answer 1

我认为在这种情况下，您可能需要考虑Factory Design Pattern。

这是一个简单的例子来解释这个想法：

class Cup:
    color = ""

    # This is the factory method
    @staticmethod
    def getCup(cupColor, value):
        if (cupColor == "red"):
            return RedCup(value)
        elif (cupColor == "blue"):
            return BlueCup(value)
        else:
            return None

class RedCup(Cup):
    color = "Red"

    def __init__(self, value):
        self.value = value


class BlueCup(Cup):
    color = "Blue"

    def __init__(self, value):
        self.value = value

# A little testing
redCup = Cup.getCup("red", 10)
print("{} ({})".format(redCup.color, redCup.__class__.__name__))

blueCup = Cup.getCup("blue", 20)
print("{} ({})".format(blueCup.color, blueCup.__class__.__name__))

所以你有一个工厂Cup，它包含一个给定值的静态方法getCup，将决定“生成”哪个对象，因此标题为“工厂”。

然后在您的代码中，您只需要调用工厂的getCup方法，这将返回适当的类来处理。

他们处理__int__和__str__的方式我认为在您缺少的类中，只需实现它并返回None。因此，您的U16IO应该实现返回__str__的{{1}}方法，并且您的byteIO应该实现同样返回None的{{1}}。

Answer 2

为什么你甚至在这里使用课程？这似乎太复杂了。

您可以定义两个函数read和write;

def bread(format, binaryfile):
    return struct.unpack(format, binaryfile.read(format.calcsize()))

def bwrite(format, binaryfile, *args):
    binaryfile.write(struct.pack(format, *args))

Python类“主要”值

2 个答案: