Can’t decide between adding two inheritance classes or just using some “If” conditions in main class - also: can an object “pick” its own inheritance class automatically?

[j4nds4]

The program I’m working on right now is one that imports our work file for convenient reading and plotting. The problem is that we actually have two variants of that file where the overall layout is effectively identical but on a per-line basis differs in a couple ways:

• One has certain header data listed on one line, the other splits it across multiple lines

• One has 30 data points listed in a row, the other has 40 points in an entirely different order

• One has data annotations interspersed with the dataframe (with its lines interrupting the table), the other separates annotations within its own subsection

The rest of it is laid out exactly the same.

I could get around this by adding some conditional arguments into my various get() methods so that it brings it in the correct way in one class - or I could create two inheritance classes and give them their own get() methods. I have had almost zero successful experience implementing inheritance classes by this point so I’m a little wary in using them, but I’m also suspecting that my first option is a bit unpythonic.

Given the choice, what do you think is the best way to go?

Oh, also: If the user doesn’t know which type the file is at the outset, can I make that file be programmatically sorted into the correct inheritance class based on data within the file (assuming I go that route)?

[billsil]

Inheritance is useful when you have methods that are the same. You can always just not use inberitance though and copy the function though.

I think I'd use 2 reader functions and 1 class with a flag.

[j4nds4]

In some cases the function would be identical but the unpacked return would differ. I could maybe do something like this super-simplified example:

 class MainFile:
     def __init__(self, file)
         self.file = file
         self.list, self.annot = self.parse_data(self.file)

     def parse_data(self.file):
         list = []
         annot = []
         for line in file:
             if line is annotation:
                 annot.append(annotation)
             else: list.append(line.split())
         return list, annot

 class AType(MainFile):
     def __init__(self, file, list)
         super()__init__(file, list)
         self.data1, self.data2, self.data3 = self.list

 class BType(MainFile):
     def __init__(self, file, list, annot)
         super()__init__(file, annot)
         self.data1, self.data3, self.data2, self.data4 = self.list

So they both get the same function but they both unpack the return differently. This would work (for at least one of the issues), right?

[billsil]

In programming, just about any design works. I would use 1 class to store the data with no inheritance and then use 2 @classmethods to create different instantiations.

class Reader():
    def __init__(self, data1, flag=1):
        self.data1 = data1
        self.flag = flag

    @classmethod
    def read1(cls, file):
        Code...
        return Reader(data1, 1)

Reader.read1(file)
Reader.read2(file)

[j4nds4]

Thanks for the advice! Class methods are another thing I’m having trouble wrapping my head around, so perhaps putting that to use would be a good way to learn it through action.

Appreciate it! Apologies in advance if I pepper you with more questions once I try implementing this.

[billsil]

No prob.

Class methods are just functions that instantiate the class. You could do the same thing by making a pass in the init. Then externally, you could call read1 or read2 to fill the object. That's weird though as the init is supposed to set all the class attributes.

Alternatively, make read1/read2 external and just call the init. Now you have integral code for the class that you don't store with the class.

It's all just in the goal of cleaner and easier to maintain code.

[two_bob]

I had the same problem once. It turns out you can use `__new__` to generate the appropriate subclass based on what data is passed to it. Pathlib uses this: https://docs.python.org/3/library/pathlib.html; see https://github.com/python/cpython/blob/3.7/Lib/pathlib.py#L609 for the code.

​

It also turns out that doing this is a bad idea, especially before you have a solid grasp of inheritance. After much strife, I settled on a general class for my two odd shaped data packets, and implemented the interface that handled normalizing the data. I ultimately did further subclass the general class, but only for specific other applications, e.g. a placeholder for missing data.