Existe-t-il un moyen en Python de retourner une valeur via un paramètre de sortie ?

Question

Certains langages ont la possibilité de retourner des valeurs en utilisant des paramètres, comme le C#. Prenons un exemple :

class OutClass
{
    static void OutMethod(out int age)
    {
        age = 26;
    }
    static void Main()
    {
        int value;
        OutMethod(out value);
        // value is now 26
    }
}

Existe-t-il quelque chose de similaire en Python pour obtenir une valeur en utilisant un paramètre ?

Answer 1

Il n'y a aucune raison de le faire, puisque Python peut renvoyer plusieurs valeurs via un tuple :

def func():
    return 1,2,3

a,b,c = func()

Mais vous pouvez également passer un paramètre mutable et renvoyer des valeurs par mutation de l'objet :

def func(a):
    a.append(1)
    a.append(2)
    a.append(3)

L=[]
func(L)
print(L)   # [1,2,3]

Answer 2

Vous voulez dire comme passer par référence ?

Pour les objets Python, le défaut est de passer par référence. Cependant, je ne pense pas que vous puissiez changer la référence en Python (sinon cela n'affectera pas l'objet original).

Par exemple :

def addToList(theList):   # yes, the caller's list can be appended
    theList.append(3)
    theList.append(4)

def addToNewList(theList):   # no, the caller's list cannot be reassigned
    theList = list()
    theList.append(5)
    theList.append(6)

myList = list()
myList.append(1)
myList.append(2)
addToList(myList)
print(myList)   # [1, 2, 3, 4]
addToNewList(myList)
print(myList)   # [1, 2, 3, 4]

Answer 3

Passez une liste ou quelque chose comme ça et mettez la valeur de retour là-dedans.

Answer 4

En outre, si vous avez envie de lire un peu de code, je pense que pywin32 a un moyen de gérer les paramètres de sortie.

Dans l'API Windows, il est courant de s'appuyer fortement sur les paramètres de sortie, je me suis donc dit qu'ils avaient dû s'en occuper d'une manière ou d'une autre.

Answer 5

Vous pouvez le faire avec des objets mutables, mais dans la plupart des cas, cela n'a pas de sens car vous pouvez renvoyer plusieurs valeurs (ou un dictionnaire si vous voulez modifier la valeur de retour d'une fonction sans rompre les appels existants à celle-ci).

Je ne vois qu'un seul cas où vous pourriez en avoir besoin : le threading, ou plus exactement, le passage d'une valeur entre les threads.

def outer():
    class ReturnValue:
        val = None
    ret = ReturnValue()
    def t():
        # ret = 5 won't work obviously because that will set
        # the local name "ret" in the "t" function. But you
        # can change the attributes of "ret":
        ret.val = 5

    threading.Thread(target = t).start()

    # Later, you can get the return value out of "ret.val" in the outer function