How to use classes derived from Python's list class

Question

This is a followup to question 912526 - http://stackoverflow.com/questions/912526/how-do-i-pass-lots-of-variables-to-and-from-a-function-in-python.

There are lots of variables that need to get passed around in the program I'm writing, and from my previous question I understand that I should put these variables into classes, and then pass around the classes.

Some of these variables come in repetetive sets - for a thin film calculation I need to track the optical properties (index of refraction, absorption, thickness, etc) for a number of layers.

Is the best way to store variables like this to create a class derived from a Python list to store the set of classes which each hold the variables for a single layer? And then put the functions that deal with the set of layers in class derived from the list, and the functions that deal with a specific layer in that class? Is there a better way to do this with a single class?

Using the two class approach in the following example, I'm able to set things up so that I can access variables using statments like

n1 = layers[5].n

This is the best way to do this, right?

#Test passing values to and from functions

class Layers(list):

    def add(self,n,k,comment):
        self.append( OneLayer(n,k,comment) )

    def input_string(self):
        input_string = []
        for layer in self:
            vars = layer.input_string()
            for var in vars:
                input_string.append( var )
        return input_string

    def set_layers(self,results):
        for layer,i in enumerate(self):
            j = i*layer.num_var
            layer.set_layer( *results[j:j+2] )

class OneLayer(object):

    def __init__(self,n,k,comment):
        self.n = n
        self.k = k
        self.comment = comment

    def input_string(self):
        return [['f','Index of Refraction',self.n], ['f','Absorption',self.k],['s','Comment',self.comment]]

    def set_layer(self,n,k,comment):
        self.n = n; self.k=k; self.comment = comment

    def num_var(self):
        return 3

if __name__ == '__main__':
    layers = Layers()

    layers.add(1.0,0.0,'This vacuum sucks')
    layers.add(1.5,0.0,'BK 7 Glass')

    print layers[0].n
    print layers.input_string()
    layers[1].set_layer(1.77,0.0,'Sapphire')
    print layers.input_string()

I get the following output from this test program:

1.0
[['f', 'Index of Refraction', 1.0], ['f', 'Absorption', 0.0], ['s', 'Comment', 'This vacuum sucks'], ['f', 'Index of Refraction', 1.5], ['f', 'Absorption', 0.0], ['s', 'Comment', 'BK 7 Glass']]
[['f', 'Index of Refraction', 1.0], ['f', 'Absorption', 0.0], ['s', 'Comment', 'This vacuum sucks'], ['f', 'Index of Refraction', 1.77], ['f', 'Absorption', 0.0], ['s', 'Comment', 'Sapphire']]

Answer 1

There are several issues in your code:

1.If you make any list operation the result will be a native list:

layers1 = Layers()
layers2 = Layers()
layers1 + layers2 -> the result will be a native list

2.Why define input_string when you can override __repr__ or __str__

3.Why do you even have to derive from list in this case? You only need to derive from list if you want your class to behave exactly like a list. But in your case you seem to be looking for a container. All you need to do to get your class to behave similar to a list is to override some special python methods http://docs.python.org/reference/datamodel.html#emulating-container-types

class Layers(object):
    def __init__(self, container=[]):
        self.container = container

    def add(self,n,k,comment):
        self.container.append([n,k,comment])

    def __str__(self):
        return str(self.container)

    def __repr__(self):
        return str(self.container)

    def __getitem__(self, key):
        return Layers(self.container[key])

    def __len__(self):
        return len(self.container)

>>> l = Layers()
>>> l.add(1, 2, 'test')
>>> l.add(1, 2, 'test')
>>> l
[[1, 2, 'test'], [1, 2, 'test']]
>>> l[0]
[1, 2, 'test']
>>> len(l)
2