Je suis tombé sur quelque chose comme ça dans un projet open source. Les méthodes qui modifient les attributs d'instance renvoient une référence à l'instance. Quel est le but de cette construction?

class Foo(object):

  def __init__(self):
    self.myattr = 0

  def bar(self):
    self.myattr += 1
    return self

C'est pour permettre l'enchaînement.

Par exemple:

var Car = function () {
    return {
        gas : 0,
        miles : 0,
        drive : function (d) {
            this.miles += d;
            this.gas -= d;
            return this;
        },
        fill : function (g) {
            this.gas += g;
            return this;
        },
    };
}

Maintenant vous pouvez dire:

var c = Car();
c.fill(100).drive(50);
c.miles => 50;
c.gas => 50;

Comme le mentionnent @Lie Ryan et @Frank Shearar, cela s'appelle une "interface fluide", mais ce modèle existe depuis très longtemps.

La partie controversée de ce modèle est que dans OO, vous avez un état mutable, ainsi une méthode void a une sorte de valeur de retour implicite this, c'est-à-dire que l'objet avec l'état updated est une sorte de valeur de retour.

Donc, dans un langage OO avec un état mutable, ces deux sont plus ou moins équivalents:

a.doA()
a.doB()
a.doC()

... par opposition à

a.doA().doB().doC()

J'ai donc entendu des personnes dans le passé résister à des interfaces fluides parce qu'elles aiment la première forme. Un autre nom que j'ai entendu pour "interface fluide" est "épave de train";)

Je dis "plus ou moins équivalent", cependant, parce que les interfaces fluentes ajoutent une ride. Ils n'ont pas à "rendre ça". Ils peuvent "retourner de nouveau". C'est une façon d'atteindre des objets immuables dans OO.

Donc, vous pourriez avoir une classe A qui fait (pseudocode)

function doA():
    return new A(value + 1)

function doB():
    return new A(value * 2)

function doC():
    return new A(sqrt(value))

Désormais, chaque méthode retourne un nouvel objet, en laissant l’objet initial inchangé. Et c'est une façon de pénétrer dans des objets immuables sans vraiment changer votre code.

La plupart des langues sont conscientes de l'idiome 'return self' et l'ignorent si elles ne sont pas utilisées dans une ligne. Cependant, il est à noter qu'en Python, les fonctions sont retournées Nonepar défaut.

Quand j'étais à l'école CS, mon instructeur a énormément parlé de la différence entre les fonctions, les procédures, les routines et les méthodes; beaucoup de questions de dissertation à la main ont été corrigées avec des crayons mécaniques qui me brûlaient les mains à propos de tout ça.

Je me contenterai de dire que le retour à soi-même est la méthode OO définitive pour créer des méthodes de classe, mais Python autorise plusieurs valeurs de retour, tuples, listes, objets, primitives ou Aucune.

Le chaînage, comme ils le disent, met simplement la réponse à la dernière opération dans la suivante, et l'exécution de Python peut optimiser ce genre de chose. Les compréhensions de liste en sont une forme intégrée. (Très puissant!)

Donc, en Python, il n’est pas très important que chaque méthode ou fonction retourne des éléments, raison pour laquelle la valeur par défaut est None.

Il existe une école de pensée selon laquelle chaque action d'un programme devrait rendre compte de son succès, de son échec ou de ses résultats en fonction de son contexte ou de son objet invoquant, mais ne parlait pas des exigences du DOD ADA ici. Si vous avez besoin d'obtenir des commentaires d'une méthode, continuez ou pas, mais essayez d'être cohérent à ce sujet.

Si une méthode peut échouer, elle devrait renvoyer succès ou échec ou générer une exception à gérer.

Un inconvénient est que si vous utilisez l'idiome de self return, Python vous permettra d'affecter toutes vos méthodes à des variables et vous penserez peut-être que vous obtenez un résultat de données ou une liste lorsque vous obtenez réellement l'objet.

Les langages qui restreignent le type crient et crient et se cassent lorsque vous essayez de faire cela, mais ceux interprétés (Python, Lua, Lisp) sont beaucoup plus dynamiques.

Dans Smalltalk, chaque méthode qui ne retourne pas explicitement quelque chose a un "return self" implicite.

Cela est dû au fait que (a) le fait que chaque méthode retourne quelque chose rend le modèle informatique plus uniforme et (b) il est très utile que les méthodes se retournent. Josh K donne un bel exemple.

Avantages de retourner un objet ( return self)

• Exemple:

  print(foo.modify1().modify2())
  
  # instaed of
  foo.modify1()
  foo.modify2()
  print(foo)
  

• Style plus populaire dans la communauté de programmation (je pense).

Avantages de la mutation d'un objet (non return self)

• Capacité à utiliser returnà d'autres fins.
• Guido van Rossum approuve ce style (je suis en désaccord avec son argument).
• Style plus populaire dans la communauté Python (je pense).
• Par défaut (moins de code source).