类中的 Python 条件语句

Question

What is the best way to achieve having class attributes that change, based on input that has been passed in via a cli argument?

What I've written works perfectly fine, however feels overly messy and bad design. Is there a better way to go about this?

The example below has four different inputs, however as this program grows larger this would become very messy.

Here's some short example code;

class Example(object):

    def __init__(self, var1):
        self.var1 = var1
        self.var2 = None
        self.var3 = None
        self.var4 = None

        if var1 == 'foo':
            self.var2 = 'foo2'
            self.var3 = 'foo3'
            self.var4 = 'foo4'
        elif var1 == 'bar':
            self.var2 = 'bar2'
            self.var3 = 'bar3'
            self.var4 = 'bar4'
        elif var1 == 'foobar':
            self.var2 = 'foobar2'
            self.var3 = 'foobar3'
            self.var4 = 'foobar4'
        elif var1 == 'barfoo':
            self.var2 = 'barfoo2'
            self.var3 = 'barfoo3'
            self.var4 = 'barfoo4'


def main()

    parser = argparse.ArgumentParser()
    parser.add_argument('input')
    args = parser.parse_args()

    example = Example(args.input)

    print(example.var2) # returns 'foo2'

Example of calling with an argument;

python main.py foo

Answer 1

There are many ways to clean this up, as suggested in the comments. For something of the size and scale of your example, I would do something like this:

class Example:
    _DEPENDENT_VALS = {
        'foo': ('foo2', 'foo3', 'foo4'),
        'bar': ('bar2', 'bar3', 'bar4'),
        'foobar': ('foobar2', 'foobar3', 'foobar4'),
        'barfoo': ('barfoo2', 'barfoo3', 'barfoo4')
    }

    def __init__(self, var1):
        self.var1 = var1
        self.var2 = None
        self.var3 = None
        self.var4 = None

        if var1 in Example._DEPENDENT_VALS:
            self.var2, self.var3, self.var4 = Example._DEPENDENT_VALS[var1]

This method might not always be appropriate depending on the number and type of values you're setting but it's one way to go about it.

Answer 2

` ls=['foo','bar','foobar','barfoo'] #add the list of prefixes

if self.var1 in ls:

self.var2= f'{self.var1}2'
self.var3= f'{self.var1}3'
self.var4= f'{self.var1}4'

`

Answer 3

Define a dict mapping prefixes to a tuple of the three modifiers, then use it to initialize them:

class Example:
    _var_suffixes = {'foo': ('1', '2', '3'),
                     'bar': ('1', '2', '3'),
                     'foobar': ('1', '2', '3'),
                     'barfoo': ('1', '2', '3'),
                     }
    def __init__(self, var1):
        self.var1 = var1
        self.var2 = None
        self.var3 = None
        self.var4 = None

        if var1 in self._var_suffixes:
            suf2, suf3, suf4 = self._var_suffixes[var1]
            self.var2 = var1 + suf2
            self.var3 = var1 + suf3
            self.var4 = var1 + suf4

Optionally, this may make more sense to store var2 through var4 as a list (especially if the number of suffixes is variable by key), in which case you'd do something like this, which is even simpler:

class Example:
    _var_suffixes = {'foo': ('1', '2'),
                     'bar': ('1', '2', '3'),
                     'foobar': ('1', '2', '3', '4'),
                     'barfoo': ('1', '2', '3', '4', '5'),
                     }
    def __init__(self, var1):
        self.var1 = var1
        self.varlist = []

        for suf in self._var_suffixes.get(var1, ()):
            self.varlist.append(var1 + suf)

    # Optional property for access by name
    @property
    def var2(self):
        try:
            return self.varlist[0]
        except IndexError:
            return None

Answer 4

The class body is just Python code. It has specific scope rules, but anything goes otherwise. This means you can create functions conditionally:

class C: if some_condition: def optional_method(self): pass or pull methods from elsewhere:

import some_module

class D: method_name = some_module.function_that_accepts_self etc.

Answer 5

One approach is to keep __init__ as "dumb" as possible, define separate class methods for each "style" of object, and push the burden of selecting the right class method to call to the caller.

class Example:

    def __init__(self, var1, var2, var3, var4):
        self.var1 = var1
        self.var2 = var2
        self.var3 = var3
        self.var4 = var4

    @classmethod
    def foo(cls):
        return cls('foo', 'foo2', 'foo3', 'foo4')

    @classmethod
    def bar(cls):
        return cls('bar', 'bar2', 'bar3', 'bar4')

    # etc

# Instead of Example('foo')
e = Example.foo()

The only thing you lose here is the ability to pass an unknown value to Example and get a properly initialized value back, for example,

x = "..."  # Assumed to be foo, bar, foobar, or barfoo
e = Example(x)

However, the caller can always use whatever method you might have hidden in side Element.__init__ to pick the values for var2 et al. to pick which class method to all. For example,

x = "foo"
e = getattr(Example, x)()  # e = Example.foo()

Answer 6

Don't know if the best option but assuming that actual values aren 'foo1' 'foo2' but something else or more complex I would go for updating the self. dict

Two ways (I think the seccond is more clear)

class A():
    def __init__(self,var1):
        self.var1 = var1
        fooDict = {'var2':'foo2','var3':'foo3','var4':'foo4'}
        foovarDict = {'var2':'foovar2','var3':'foovar3','var4':'foovar4'}
        if var1 == 'foo':
            self.__dict__ = {**self.__dict__,**fooDict}
        elif var1 == 'foovar':
            self.__dict__ = {**self.__dict__,**foovarDict}
            
    def getVars(self):
        print(self.var1)
        print(self.var2)
        print(self.var3)
        print(self.var4)



a = A('foo')
a.getVars()

#ouputs
#foo
#foo2
#foo3
#foo4

b = A('foovar')
b.getVars()

#outputs
#foovar
#foovar2
#foovar3
#foovar4

Second way:

class A():
    def __init__(self,var1):
        self.var1 = var1
        fooDict = {'var2':'foo2','var3':'foo3','var4':'foo4'}
        foovarDict = {'var2':'foovar2','var3':'foovar3','var4':'foovar4'}
        if var1 == 'foo':
            self.__dict__.update(fooDict)
        elif var1 == 'foovar':
            self.__dict__.update(foovarDict)

    def getVars(self):
        print(self.var1)
        print(self.var2)
        print(self.var3)
        print(self.var4)

a = A('foo')
a.getVars()


b = A('foovar')
b.getVars()

with same outputs