How to return a value from __init__ in Python?

Question

I have a class with an __init__ function.

How can I return an integer value from this function when an object is created?

I wrote a program, where __init__ does command line parsing and I need to have some value set. Is it OK set it in global variable and use it in other member functions? If so how to do that? So far, I declared a variable outside class. and setting it one function doesn't reflect in other function ??

Answer 1

If you want to return some other object when a class is called, then use the __new__() method:

class MyClass:
    def __init__(self):
        print("never called in this case")

    def __new__(cls):
        return 42

obj = MyClass()
print(obj)
# Output: 42

Answer 2

__init__ is required to return None. You cannot (or at least shouldn't) return something else.

Try making whatever you want to return an instance variable (or function).

>>> class Foo:
...     def __init__(self):
...         return 42
... 
>>> foo = Foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() should return None

Answer 3

From the documentation of __init__:

As a special constraint on constructors, no value may be returned; doing so will cause a TypeError to be raised at runtime.

As a proof, this code:

class Foo(object):
    def __init__(self):
        return 2

f = Foo()

Gives this error:

Traceback (most recent call last):
  File "test_init.py", line 5, in <module>
    f = Foo()
TypeError: __init__() should return None, not 'int'

Answer 4

Sample Usage of the matter in question can be like:

class SampleObject(object):

    def __new__(cls, item):
        if cls.IsValid(item):
            return super(SampleObject, cls).__new__(cls)
        else:
            return None

    def __init__(self, item):
        self.InitData(item) #large amount of data and very complex calculations

...

ValidObjects = []
for i in data:
    item = SampleObject(i)
    if item:             # in case the i data is valid for the sample object
        ValidObjects.append(item)

Answer 5

The __init__ method, like other methods and functions returns None by default in the absence of a return statement, so you can write it like either of these:

class Foo:
    def __init__(self):
        self.value=42

class Bar:
    def __init__(self):
        self.value=42
        return None

But, of course, adding the return None doesn't buy you anything.

I'm not sure what you are after, but you might be interested in one of these:

class Foo:
    def __init__(self):
        self.value=42
    def __str__(self):
        return str(self.value)

f=Foo()
print f.value
print f

prints:

42
42

Answer 6

__init__ doesn't return anything and should always return None.

Answer 7

You can just set it to a class variable and read it from the main program:

class Foo:
    def __init__(self):
        #Do your stuff here
        self.returncode = 42
bar = Foo()
baz = bar.returncode

Answer 8

We can not return value from init. But we can return value using new.

class Car:
    def __new__(cls, speed, unit):
        return (f"{speed} with unit {unit}")


car = Car(42, "km")
print(car)

Answer 9

init() return none value solved perfectly

class Solve:
def __init__(self,w,d):
    self.value=w
    self.unit=d
def __str__(self):
    return str("my speed is "+str(self.value)+" "+str(self.unit))
ob=Solve(21,'kmh')
print (ob)

output: my speed is 21 kmh

Answer 10

Just wanted to add, you can return classes in __init__

@property
def failureException(self):
    class MyCustomException(AssertionError):
        def __init__(self_, *args, **kwargs):
            *** Your code here ***
            return super().__init__(*args, **kwargs)

    MyCustomException.__name__ = AssertionError.__name__
    return MyCustomException

The above method helps you implement a specific action upon an Exception in your test

Answer 11

Met this case when tried to parse some string data into a recursive data structure, and had a counter to be passed through.

Python does not allow to return anything from __init__, but you may write a factory function, or a class method, or a Parser class, depending on the code structure and complexity of parsing, which will parse your data into data objects.

Global variable is not a good solution, as it may be changed somewhere else, breaking the parsing logic.

Function example:

class MyClass():
    def __init__(self, a, b, c):
        # only assignments here
        self.a = a
        self.b = b
        self.c = c
        # return None


def parse(data):
    # parsing here
    a = ...
    b = ...
    c = ...

    # status, counter, etc.
    i = ...

    # create an object
    my_obj = MyClass(a, b, c)
    
    # return both
    return my_obj, i


# get data and parse
data = ...
my_obj, i = parse(data)

Class method example:

class MyClass():
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c

    @classmethod
    def parse(cls, data):
        a = ...
        b = ...
        c = ...

        i = ...

        obj = cls(a, b, c)
        return obj, i


data = ...
my_obj, i = MyClass.parse(data)

Answer 12

solution here Yes, trying to return from the init method in python returns errors as it is a constructor of the class you can only assign values for the scope of the class but not return a specific value. if you want to return a value but do not wish to create a method, you can use str method

def __init__(self,a):
    self.value=a

   def __str__(self):
    return str("all my return values are possible here")`

Answer 13

Well, if you don't care about the object instance anymore ... you can just replace it!

class MuaHaHa():
def __init__(self, ret):
    self=ret

print MuaHaHa('foo')=='foo'