OOP：Python - 方法调用中的重复值

Question

I'm new to OOP python and trying to understand how to handle instances, I have a method:

class Object:

    things = []

    def __init__(self, table):

        self.table = table
        self.things.append(table)

        ( ... )

    def thingy(self):
        return self.db.execute(f"select date, p1, p2 from {self.table}")

    def all_things(self):
        self.things.extend(
            map(lambda t: Object(thing=t + '_thing').thingy(), Constants.THINGS))

        return self.things 

Now how would I call this object, because my thing is driven by a list from Constants.THINGS , IE: THINGS = ["table1", "table2" ... ] , but in order to create the object to call the method all_things() - I must have a thing set - even tho the method sets the thing on call ...

This feels a little backward, so would appreciate what it is I am misunderstanding as I think I need to change the constructor/object

a = Object(end_date="2020-01-05",
           start_date="2020-01-01",
           thing=WHAT_TO_PUT_HERE).all_things()

If I add anything to this thing I get a double output

Any help is appreciated

• UPDATE:

The desired output would be that thing() will fire, based on a list input provided by Constants.THINGS , if we input: THINGS = ["table1", "table2"] we would expect thingy() to execute twice with:

select date, p1, p2 from table1 , select date, p1, p2 from table2

And this would be added to the things class variable, and then when all_things() finishes we should have the content of the two select statements in a list

However,

Object.things

will actually have [WHAT_TO_PUT_HERE, table_1, table2]

Answer 1

So according to your update, this is what I think you're attempting to do.

class Object:
    def __init__(self):
        # do some initialization
        pass

    def thingy(self, table):
        return self.db.execute(f"select date, p1, p2 from {table}")

    # call the method "thingy" on all Constants.THINGS
    def all_things(self):
        map(self.thingy, Constants.THINGS)

Then from outside the class you would call it like this.

my_instance = Object()
my_instance.all_things()

I'm assuming the class will also have some setup and teardown of your db connection. As well as some other things but this is simply a minimalistic attempt at giving an example of how it should work.

Answer 2

Okay, so rather than having a class variable which @Axe319 informed me doesn't get reset with every instance as self.table would. I altered the constructor to just have:

class Object:
    def __init__(self, table):
        self.table = table
        self.things = list()

Then when I call the particular method outside the class:

all_things() I can just pass None into the table as the method builds that for me. ie:

a = Object(thing=None).all_things()

This might be an anti-pattern - again I'm new to OOP, but it's creating something that looks correct.

PS yes I agree, things, thingy, and the thing was a bad choice for variables for this question...

Thanks