Class error, using __new__ , instead of __init__, trying to return value

Question

Description:

I am trying to return a value from a class when I call it.

I want the result of an object's method call upon creating the object.

I want to get the value of:

A().get_result() 

# by just calling"
A()

My Question:

Why does A.get_result() require the argument self?

Minimal Reproducible Example:

Using the following class definition:

class A():
    _arg_list = None
    
    def __new__(self, my_args):
        self._arg_list = my_args
        return self.get_result()
        
    def get_result(self):
        return self._args_list[0]

Current Result:

A(['arg1','arg2'])


---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[6], line 1
----> 1 A(['arg1','arg2'])

Cell In[5], line 9, in A.__new__(self, my_args)
      5 def __new__(self, my_args):
      7     self._arg_list = my_args
----> 9     return self.get_result()

TypeError: A.get_result() missing 1 required positional argument: 'self'

Desired Result:

A(['arg1','arg2'])
>> 'arg1'

Answer 1

Instance methods operate on, well... instances. In Python, that's made explicit by requiring self as the first parameter of all instance methods (though the exact name can be anything, by convention, it's always self for instance_methods and cls for class methods). Other OO languages make this implicit (where self or this is just a magical keyword), but nonetheless require it.

Even if you don't want an object to hang around, and you just want to call the instance method get_result() once, you still need the instance call the method on. You have 2 options:

1. Change get_result() to not be an instance method (so it doesn't require an instance)
2. Create an instance to call get_result() on.

Here's one possible way to achieve this:

class A():
    _arg_list = None
    
    def __new__(cls, my_args):
        new_instance = super().__new__(cls)
        new_instance._args_list = my_args
        
        return new_instance.get_result()
        
    def get_result(self):
        return self._args_list[0]

print(A(['arg1', 'arg2'])) # => 'arg1'

But really, this is all really weird. Unless you have a really good reason not to, I'd suggest:

1. Circumvent all this headache by just making a function, and getting rid of the class all together:

   # You *could* call it A if you really wanted, but people would expect that to be a class, so don't do that.
   def a(my_args):
       return my_args[0]
   

2. Just use A().get_result(), which is perfectly clear.

Answer 2

Because you defined it to require self, as is normal for methods!

Perhaps the part you are missing is that the first argument to __new__ is actually the class.

So

return self.get_result()

Is equivalent to:

return A.get_result()

And it is important to note, the implicit binding of the first argument only occurs when you call a method on an instance. You don't actually have an instance anywhere in your code!

But the question you really should be asking yourself here is why A is a class at all.