Comment puis-je passer une variable par référence?

Arguments sont transmis par cession. La justification de cette est double:

1. le paramètre transmis est en fait un référence à un objet (mais la référence est passée par valeur)
2. certains types de données sont mutables, mais d'autres ne sont pas

Donc:

• Si vous passez un mutable objet dans une méthode, la méthode renvoie une référence à ce même objet et vous pouvez les transformer à votre guise, mais si vous réassocier la référence à la méthode, à l'extérieur de la portée ne sait rien sur elle, et après vous avez terminé, la référence externe sera toujours le point à l'objet d'origine.

• Si vous passez un immuable objet à une méthode, vous ne pouvez pas relier la référence externe, et vous ne pouvez même pas la mutation de l'objet.

Pour le rendre encore plus clair, nous allons donner quelques exemples.

La liste - une mutable type

Essayons de modifier la liste qui a été transmis à une méthode:

def try_to_change_list_contents(the_list):
    print('got', the_list)
    the_list.append('four')
    print('changed to', the_list)

outer_list = ['one', 'two', 'three']

print('before, outer_list =', outer_list)
try_to_change_list_contents(outer_list)
print('after, outer_list =', outer_list)

De sortie:

before, outer_list = ['one', 'two', 'three']
got ['one', 'two', 'three']
changed to ['one', 'two', 'three', 'four']
after, outer_list = ['one', 'two', 'three', 'four']

Depuis le paramètre transmis est une référence à outer_list, pas une copie de celui-ci, nous pouvons utiliser la mutation de la liste des méthodes pour changer et avoir des changements indiqués dans l'extérieur de la portée.

Maintenant, nous allons voir ce qui se passe quand on essaie de changer la référence qui a été transmis en tant que paramètre:

def try_to_change_list_reference(the_list):
    print('got', the_list)
    the_list = ['and', 'we', 'can', 'not', 'lie']
    print('set to', the_list)

outer_list = ['we', 'like', 'proper', 'English']

print('before, outer_list =', outer_list)
try_to_change_list_reference(outer_list)
print('after, outer_list =', outer_list)

De sortie:

before, outer_list = ['we', 'like', 'proper', 'English']
got ['we', 'like', 'proper', 'English']
set to ['and', 'we', 'can', 'not', 'lie']
after, outer_list = ['we', 'like', 'proper', 'English']

Depuis le the_list paramètre est passé par valeur, l'attribution d'une nouvelle liste, il n'a eu aucun effet que le code en dehors de la méthode pouvait voir. Le the_list était une copie de la outer_list de référence, et nous avons eu the_list point à une nouvelle liste, mais il n'y avait aucun moyen de changer de où outer_list pointu.

Chaîne immuable type

Il est immuable, donc il n'y a rien que nous pouvons faire pour changer le contenu de la chaîne

Maintenant, essayons de changer la référence

def try_to_change_string_reference(the_string):
    print('got', the_string)
    the_string = 'In a kingdom by the sea'
    print('set to', the_string)

outer_string = 'It was many and many a year ago'

print('before, outer_string =', outer_string)
try_to_change_string_reference(outer_string)
print('after, outer_string =', outer_string)

De sortie:

before, outer_string = It was many and many a year ago
got It was many and many a year ago
set to In a kingdom by the sea
after, outer_string = It was many and many a year ago

De nouveau, depuis le the_string paramètre est passé par valeur, l'attribution d'une nouvelle chaîne, il n'a eu aucun effet que le code en dehors de la méthode pouvait voir. Le the_string était une copie de la outer_string de référence, et nous avons eu the_string point d'une nouvelle chaîne, mais il n'y avait aucun moyen de changer de où outer_string pointu.

J'espère que cela efface les choses un peu.

EDIT: Il a été noté que ce n'est pas répondre à la question que @David initialement demandé, "Est-il quelque chose que je peux faire pour passer la variable par référence réel?". Nous allons travailler sur.

Comment contourner ce problème?

@Andrea réponse de la montre, vous pourriez revenir à la nouvelle valeur. Cela ne change pas la façon dont les choses se sont passées, mais ne vous permettent d'obtenir l'information que vous voulez de retour:

def return_a_whole_new_string(the_string):
    new_string = something_to_do_with_the_old_string(the_string)
    return new_string

# then you could call it like
my_string = return_a_whole_new_string(my_string)

Si tu voulais vraiment éviter d'utiliser une valeur de retour, vous pouvez créer une classe afin de conserver votre valeur et la passer dans la fonction ou l'utilisation d'une classe existante, comme une liste:

def use_a_wrapper_to_simulate_pass_by_reference(stuff_to_change):
    new_string = something_to_do_with_the_old_string(stuff_to_change[0])
    stuff_to_change[0] = new_string

# then you could call it like
wrapper = [my_string]
use_a_wrapper_to_simulate_pass_by_reference(wrapper)

do_something_with(wrapper[0])

Bien que cela semble un peu lourd.

OriginalL'auteur Blair Conrad

J'ai trouvé les autres réponses, plutôt long et compliqué, j'ai donc créé ce schéma simple pour expliquer la façon Python traite des variables et des paramètres.

OriginalL'auteur Zenadix

Penser à des trucs d'être passé par cession plutôt que par référence/par valeur. De cette façon, il est toujours clair, ce qui se passe tant que vous comprenez ce qui se passe pendant le fonctionnement normal de l'affectation.

Donc, lors du passage d'une liste à une fonction/méthode, la liste est attribué le nom du paramètre. L'ajout à la liste de résultat dans la liste en cours de modification. Réassigner la liste à l'intérieur de la fonction ne changera pas la liste d'origine, depuis:

a = [1, 2, 3]
b = a
b.append(4)
b = ['a', 'b']
print a, b      # prints [1, 2, 3, 4] ['a', 'b']

Depuis immuable types ne peuvent pas être modifiés, ils semblent comme être passé par valeur - passage d'un int dans une fonction signifie que l'attribution de l'int pour les fonctions de paramètre. Vous ne pouvez jamais réaffecter, mais il ne changera pas le originial variables de valeur.

OriginalL'auteur Daren Thomas

Techniquement, Python utilise toujours passer par des valeurs de référence. Je vais répéter mon autre réponse à l'appui de mon affirmation.

Python utilise toujours passer par des valeurs de référence. Il n'y a pas d'exception. Toute affectation de variable signifie copie de la valeur de référence. Pas d'exception. Toute variable est le nom lié à la valeur de référence. Toujours.

Vous pouvez penser à une valeur de référence, comme l'adresse de l'objet cible. L'adresse est automatiquement déréférencé. De cette façon, en travaillant avec la valeur de référence, il semble que vous travaillez directement avec l'objet cible. Mais il y a toujours une référence entre les deux, un pas de plus pour passer à la cible.

Voici l'exemple qui prouve que Python utilise le passage par référence:

Si l'argument est passé par valeur, à l'extérieur lst ne peut pas être modifiée. Le vert sont les objets cibles (le noir est la valeur stockée à l'intérieur, le rouge est le type d'objet), le jaune est la mémoire avec la valeur de référence à l'intérieur, tirés comme la flèche. Le bleu solide flèche correspond à la valeur de référence a été passé à la fonction (par l'intermédiaire de la flèche bleue en pointillés). Le vilain jaune foncé est le dictionnaire interne. (En fait, il pourrait être attiré comme une ellipse verte. La couleur et la forme ne dit qu'il est interne.)

Vous pouvez utiliser le id() fonction intégrée d'apprendre ce que la valeur de référence (c'est l'adresse de l'objet cible).

Dans les langages compilés, une variable est un espace de mémoire qui est capable de capturer la valeur du type. En Python, une variable est un nom (capturé en interne comme une chaîne de caractères) lié à la référence de la variable qui contient la valeur de référence vers l'objet cible. Le nom de la variable est la clé dans le dictionnaire interne, la valeur de la partie de l'article de dictionnaire des magasins de la valeur de référence de la cible.

Valeurs de référence sont cachés dans Python. Il n'y a pas de manière explicite le type d'utilisateur pour le stockage de la valeur de référence. Toutefois, vous pouvez utiliser un élément de la liste (ou d'un élément dans tout autre type de conteneur) comme variable de référence, parce que tous les conteneurs ne stocker les éléments que les références à des objets cibles. En d'autres termes, les éléments ne sont pas réellement contenue à l'intérieur du conteneur -- uniquement les références aux éléments.

OriginalL'auteur pepr

(modifier - Blair a mis à jour sa très populaire réponse de sorte qu'il est maintenant exacte)

Je pense qu'il est important de noter que le courant post avec le plus de votes (par Blair Conrad), tout en étant correcte par rapport à son résultat, est trompeuse et est à la limite incorrecte repose sur ses définitions. Bien qu'il existe de nombreux langages (comme C) qui permettent à l'utilisateur de passer soit par référence ou le passage par valeur, Python n'est pas l'un d'eux.

David Cournapeau la réponse de points à la réponse réelle et explique pourquoi le comportement de Blair Conrad post semble être correct, tandis que les définitions ne sont pas.

Dans la mesure où Python est le passage par valeur, toutes les langues sont le passage par valeur depuis quelques morceau de données (que ce soit une "valeur" ou "de référence") doit être envoyé. Toutefois, cela ne signifie pas que Python est le passage par valeur dans le sens où un programmeur C pensons de lui.

Si vous voulez le comportement, Blair Conrad réponse est fine. Mais si vous voulez savoir les écrous et les boulons de pourquoi Python est ni le passage par valeur ou passage par référence, lire David Cournapeau de réponse.

OriginalL'auteur KobeJohn

Vous avez obtenu quelques bonnes réponses ici.

x = [ 2, 4, 4, 5, 5 ]
print x  # 2, 4, 4, 5, 5

def go( li ) :
  li = [ 5, 6, 7, 8 ]  # re-assigning what li POINTS TO, does not
  # change the value of the ORIGINAL variable x

go( x ) 
print x  # 2, 4, 4, 5, 5  [ STILL! ]


raw_input( 'press any key to continue' )

OriginalL'auteur bobobobo

Python-passer-par-assignation de schéma n'est pas tout à fait la même qu'en C++de référence des paramètres de l'option, mais il s'avère être très similaire à l'argument de passage de modèle du langage C (et autres) dans la pratique:

• Immuable arguments sont effectivement passé “en valeur.” Des objets comme des entiers et des chaînes sont passés par référence d'objet au lieu de la copie, mais parce que vous ne pouvez pas modifier des objets immuables en place de toute façon, l'effet est un peu comme faire une copie.
• Mutable arguments sont effectivement passé “par pointeur.” Des objets tels que des listes
  et les dictionnaires sont également passés par référence d'objet, qui est similaire à la façon dont C
  passe tableaux—pointeurs mutable objets peuvent être modifiés en place dans la fonction,
  comme C des tableaux.

OriginalL'auteur ajknzhol

Beaucoup de points de vue dans les réponses ici, mais je pense que d'un point supplémentaire n'est pas clairement mentionné ici explicitement. Citant la documentation python https://docs.python.org/2/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python

"En Python, les variables qui ne sont référencés à l'intérieur d'une fonction sont implicitement mondiale. Si une variable est affectée d'une valeur de n'importe où au sein de la fonction du corps, il est supposé pour être un local. Si une variable est jamais assigner une nouvelle valeur à l'intérieur de la fonction, la variable est implicitement local, et vous avez besoin de l'indiquer explicitement que "global".
Bien qu'un peu surprenant au premier abord, un moment de explique cet. D'une part, exigeant mondial pour les variables assignées fournit un bar à l'encontre des effets secondaires indésirables. D'autre part, si le mondial était nécessaire pour que toutes les références globales, vous seriez en utilisant mondiale de tous les temps. Vous devez déclarer comme mondiales chaque référence à une fonction intégrée ou à un composant d'un module importé. Ce désordre à l'encontre de l'utilité de la déclaration mondiale pour l'identification des effets secondaires."

Même lors du passage d'un objet mutable à une fonction cela s'applique toujours. Et m'explique clairement la raison de la différence de comportement entre l'affectation de l'objet et de l'exploitation sur l'objet dans la fonction.

def test(l):
    print "Received", l , id(l)
    l = [0, 0, 0]
    print "Changed to", l, id(l)  # New local object created, breaking link to global l

l= [1,2,3]
print "Original", l, id(l)
test(l)
print "After", l, id(l)

donne:

Original [1, 2, 3] 4454645632
Received [1, 2, 3] 4454645632
Changed to [0, 0, 0] 4474591928
After [1, 2, 3] 4454645632

L'affectation à une variable globale qui n'est pas déclaré mondiale crée donc un nouvel objet local et rompt le lien à l'objet original.

OriginalL'auteur Joop

En dehors de toutes les grandes explications sur comment ça fonctionne en Python, je ne vois pas une simple suggestion pour le problème. Comme vous semblez le faire créer des objets et des instances, la pythonic de manipulation des variables d'instance, et la modification est la suivante:

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.Change()
        print self.variable

    def Change(self):
        self.variable = 'Changed'

Dans les méthodes d'instance, vous normalement, reportez-vous à self pour accéder aux attributs d'instance. Il est normal pour définir les attributs d'instance dans __init__ et de les lire ou de les changer dans les méthodes d'instance. C'est aussi pourquoi vous passez self la sla, le premier argument def Change.

Une autre solution serait de créer une méthode statique comme ceci:

class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.variable = PassByReference.Change(self.variable)
        print self.variable

    @staticmethod
    def Change(var):
        var = 'Changed'
        return var

OriginalL'auteur Dolf Andringa

J'ai utilisé la méthode suivante pour convertir rapidement un couple de Fortran codes de Python. Vrai, c'est de ne pas passer par référence que la question initiale a été posée, mais c'est un travail simple dans certains cas.

a=0
b=0
c=0
def myfunc(a,b,c):
    a=1
    b=2
    c=3
    return a,b,c

a,b,c = myfunc(a,b,c)
print a,b,c

OriginalL'auteur Brad Porter

compte tenu de la façon python gère des valeurs et des références pour eux, la seule façon vous pouvez faire référence à un arbitraire instance attribut par son nom:

class PassByReferenceIsh:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print self.variable

    def change(self, var):
        self.__dict__[var] = 'Changed'

dans le code réel, vous, bien sûr, ajouter la vérification des erreurs sur le dict de recherche.

OriginalL'auteur mARK bLOORE

Par Référence en Python est tout à fait différente de la notion de passage par référence en C++/Java.

• Java: Tout est passé par référence, donc toutes les modifications apportées dans le paramètre dans la fonction appelée sont visibles à l'appelant.
• C++: à la Fois par référence ou par valeur sont autorisés. Si un paramètre est passé par référence, vous pouvez le modifier ou non, selon que le paramètre est passé comme const ou non. Cependant, const ou non, le paramètre maintient la référence à l'objet et la référence ne peut pas être attribué à point à un autre objet à l'intérieur de la fonction appelée.
• Python:
  Python est “passe-par-objet de référence”, dont il est souvent dit: “les références de l'Objet sont passés par valeur.”[Lire ici]Un. À la fois l'appelant et la fonction se référer au même objet, mais le paramètre de la fonction est une nouvelle variable qui est juste en maintenant une copie de l'objet en l'appelant. Comme C++, un paramètre peut être modifié ou non, en fonction dépend du type de l'objet passé. par exemple; Un immuable type d'objet ne peut pas être modifié dans la fonction appelée alors qu'un objet mutable peuvent être mises à jour ou ré-initialisé. Une différence cruciale entre la mise à jour ou ré-affectation/re-initialisation de la mutable variable est mise à jour de la valeur est renvoyée dans la fonction appelée alors que la réinitialisation de la valeur n'est pas. La portée de la cession de nouveau l'objet d'une mutable variable est locale à la fonction en python. Les exemples fournis par @blair-conrad sont grands pour comprendre cela.

OriginalL'auteur Alok Garg