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

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'

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)

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

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

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

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)

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

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

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)

Using __new__ is the best option, as mentioned in other answers.

Just to add a use case for why. The company I work for asked me to update our internal system from python 3.8 to 3.10 which runs on Flask, and with us still being on the 1.x.x version, I updated to 2.x.x, and that initially led to upgrading SQLAlchemy to version 2, but that created incompatibility issues around the use of db.engine.execute() calls that were all over the place still.

To fix this, I first tried a wrapper function to just replace the calls with the correct context-based engine calls, but that won't work for calls like:

db.engine.execute(sql).scalar()

because a function can't have a member function of it's own. So the solution was to create a class that could be called using both forms:

DBEngineClass(sql)

and

DBEngineClass(sql).scalar()

Where DBEngineClass has the __new__ member function defined to return the pure ResultProxy from the engine call, whereas there is also a scalar() and fetchall() member function that relies on the __init__ member function to execute the sql query and then set a result member variable to the ResultProxy, which can then be mutated and returned by the scalar() and fetchall() member functions.

So that way it reduces the overall time that we need to spend on refactoring, by making the process as simple as adding a new import statement into the affected python files, and then doing a simple find and replace to keep the same functionality, as well as make the system compatible with the newer version of SQLAlchemy.

Thanks for readind :-)