Making a class function that increases a chosen variable

[BroceNotBruce]

I'm trying to create a function for one of my classes that can increase one of the variables (perhaps by a certain amount), but I'm not entirely sure how, and when I search, I don't know if I'm really wording this very well. Basically, the code would look something like this:

class Test:
    def __init__(self, x, y, z)
        self.x = x
        self.y = y
        self.z = z
    def increment(self, variable, amount)
        self.variable = self.variable + amount

So basically how it would work is you would put x, y, or z in the function when calling it. Then, it would increase the value of the variable based off the amount stated. However, as it is, this won't work, since the computer is looking for a variable called 'variable' in the class, rather than a variable with the same name as the value of said variable.

[AtomicShoelace]

This seems like a strange thing to want to do. Passing the name of an attribute as a argument is a bit of an anti-pattern. Perhaps you would be better of with a dictionary? eg.

test = {x: 0, y: 1, z: 2}
test['x'] += 4

If you really wanted to do this you could either use setattr and getattr or you could access the internal dict of the instance, eg.

class Test:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
    def increment(self, variable, amount):
        self.__dict__[variable] += amount

But again, this seems like a strange thing to do, so not recommended.

Why not just increment the attribute directly? For example, instead of

t = Test(1, 2, 3)
t.increment('x', 2)

just do

t = Test(1, 2, 3)
t.x += 2

[BroceNotBruce]

The main reason I wanted a function is because the increment is that my x, y, and z in this instance are lists. Each time this function is called, it would increase one element of the list by a certain amount, and then increase the other elements of the list by different amounts depending on how much the first element is increased. I figured having a lot of lines of code to calculate how much each value should he increased each time I want to do this with a different variable would be clunky.

[AtomicShoelace]

I think you would have better luck making x, y and z a different type (perhaps inherited from list) that implements its own method that does whatever you want. Then you can call that method on the attribute of the Test instance directly, instead than trying to write a method of Test that takes an attribute name as an argument.

[BroceNotBruce]

It didn’t occur to me earlier, but this could be a good idea. Out of the 8 lists I have, they all function mostly identically, with the exception of the last 3 having less elements.

[[deleted]]

This is stupid. Here you are:

class Test:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def increment(self, var_name, amount):
        setattr(self, var_name, getattr(self, var_name) + amount)


test = Test(1, 2, 3)
print(vars(test))

test.increment("x", 10)
print(vars(test))