I want a configurable python callable. Class versus function factory?

user_1305287 0
Viewed 116

I want to write a number of related parse functions, that take text and return objects or raise exceptions, rather like int() and float() do. I do anticipate being able to supply these recursively to higher level parsers. I want to be able to configure these at run time, and have either their docstrings, or some other attribute, settable to report how they've been configured.

Python's 'There should be one—and preferably only one—obvious way to do it' has let me down here.

I appear to be able to do exactly the same thing with either a class with a call method, or a function that returns a function.

For instance, my two attempts at a toy range-constrained number parser are below. 

class Parser():
    def __init__(self, nType=int, nRange=None):
        self.nType = nType
        self.nRange = nRange
        self.__doc__ = 'class - range is {}'.format(str(nRange))

    def __call__(self, inStr):
        x = self.nType(inStr)
        if self.nRange:
            if not self.nRange[0] <= x <= self.nRange[1]:
                raise ValueError('{} is out of range (class)'.format(inStr))
        return x        

def parserFactory(nType=int, nRange=None):
    def parser(inStr):
        x = nType(inStr)
        if nRange:
            if not nRange[0] <= x <= nRange[1]:
                raise ValueError('{} is out of range (factory)'.format(inStr))
        return x
    parser.__doc__ = 'factory - range is {}'.format(str(nRange))
    return parser    

a = Parser()
b = Parser(nRange=(3,6), nType=float)
c = parserFactory(nType=float)
d = parserFactory(nRange=(3, 6))

for string in ['4', '14']:
    for x in [a,b,c,d,int]:
        print(x.__doc__[:35])
        try:
            print(string, x(string))
        except ValueError as error:
            print(error)

Both do what I want. Both have more or less the same complexity, and essentially the same statements, albeit in a different order. The factory is slightly shorter. I don't anticipate needing to use any other class methods. I don't see any clear way to choose which is 'better'.

Is one or the other more pythonic?

Is one or the other more likely to run me into difficulty if (when) I try to modify them in yet unanticipated ways?

What do most people do?

I'm a fairly inexperienced programmer. I've read wikipedia's entry on 'factory method pattern' and the subtleties in it go straight over my head.

(edit) Having read comments, answers and links, I think one of the problems is that neither is a good fit. You would not expect a class to have so few methods, even though it can. You would not expect a function to be carrying an attribute, even though it can. As the syntax is so similar, it probably doesn't matter which I use initially, as I can switch without a change in behaviour. (/edit)

factory class python
1 Answers

You can think of functions as syntactic sugar for classes with only a __init__ and __call__. That would also be true for generators vs classes, context managers vs classes, ...

If you are only passing the parser around and calling it someplace(i.e. doing function things), then you should use the factory. It also allows you to migrate to the class later easily, your factory can simply return the class.

If, besides calling it, you need to inspect or change the values of the parser in other parts of your code, then you should go with classes.

All that said, in this specific case you showed here, I think I would use functools.partial

user_6377540
Related