J'ai une classe avec une __init__fonction.

Comment puis-je renvoyer une valeur entière à partir de cette fonction lorsqu'un objet est créé?

J'ai écrit un programme, d'où l' __init__analyse de la ligne de commande et j'ai besoin d'un jeu de valeurs. Est-il correct de le définir dans une variable globale et de l'utiliser dans d'autres fonctions membres? Si oui, comment faire cela? Jusqu'à présent, j'ai déclaré une variable hors classe. et la définition d'une fonction ne se reflète pas dans une autre fonction ??

__init__est nécessaire pour renvoyer Aucun. Vous ne pouvez pas (ou du moins ne devriez pas) retourner quelque chose d'autre.

Essayez de créer ce que vous voulez pour renvoyer une variable d'instance (ou une fonction).

>>> 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

Pourquoi voudriez-vous faire ça?

Si vous souhaitez renvoyer un autre objet lorsqu'une classe est appelée, utilisez la __new__()méthode:

class MyClass(object):
    def __init__(self):
        print "never called in this case"
    def __new__(cls):
        return 42

obj = MyClass()
print obj

De la documentation de__init__ :

En tant que contrainte spéciale sur les constructeurs, aucune valeur ne peut être renvoyée; cela entraînera le déclenchement d'une TypeError lors de l'exécution.

Pour preuve, ce code:

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

f = Foo()

Donne cette erreur:

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

Exemple d'utilisation de la matière en question peut être comme:

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)

Je n'ai pas assez de réputation donc je ne peux pas écrire de commentaire, c'est fou! J'aimerais pouvoir le poster comme commentaire sur weronika

La __init__méthode, comme les autres méthodes et fonctions, retourne None par défaut en l'absence d'une instruction return, vous pouvez donc l'écrire comme l'une des deux:

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

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

Mais bien sûr, ajouter le return Nonene vous achète rien.

Je ne sais pas trop ce que vous recherchez, mais l'un de ceux-ci pourrait vous intéresser:

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

f=Foo()
print f.value
print f

imprime:

42
42

__init__ne renvoie rien et doit toujours revenir None.

Vous pouvez simplement le définir sur une variable de classe et le lire à partir du programme principal:

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

Je voulais juste ajouter, vous pouvez renvoyer des classes dans __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

La méthode ci-dessus vous aide à implémenter une action spécifique sur une exception dans votre test

init () ne renvoie aucune valeur parfaitement résolue

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)

sortie: ma vitesse est de 21 kmh

Eh bien, si vous ne vous souciez plus de l'instance d'objet ... vous pouvez simplement la remplacer!

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

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