Comment passer une variable par référence ?

Contenu de la question

J'ai écrit ce cours à des fins de test :

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

    def change(self, var):
        var = 'Changed'

Lorsque j'essaie de créer une instance, le résultat est original。所以python中的参数似乎是按值传递的。那是对的吗？如何修改代码才能达到引用传递的效果，使得输出为changed ?

_{Parfois, les gens sont surpris par la syntaxe x = 1 这样的代码（其中 x 是参数名称）不会影响调用者的参数，但像 x[0] = 1 这样的代码却会影响调用者的参数。发生这种情况是因为尽管有 = comme , mais l'affectation d'éléments et l'affectation de tranches sont des méthodes de mutation} d'objets existants, plutôt que de réaffectation de variables. Voir Pourquoi une fonction peut-elle modifier certains paramètres tels que perçus par l'appelant, mais pas d'autres ? Apprendre encore plus.

Voir aussi Quelle est la différence entre passer par référence et passer par valeur ? Pour des discussions terminologiques importantes et indépendantes de la langue.

La bonne réponse

les paramètres sont passés par devoir

. Il y a deux raisons à cela :

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

Donc :

• Si vous transmettez un objet mutable

  à une méthode, la méthode obtiendra une référence au même objet et vous pourrez le modifier comme vous le souhaitez, mais si vous êtes à l'intérieur de la méthode, la portée externe ne sait rien à ce sujet. Ensuite, la référence externe pointera toujours vers l'objet d'origine.

• Si vous transmettez un objet immuable

  à une méthode, vous ne pouvez toujours pas relier la référence externe ni même modifier l'objet.

Pour illustrer cela plus clairement, donnons quelques exemples.

Liste - type mutable

Essayons de modifier la liste passée à la 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)

Sortie :

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

outer_listÉtant donné que le paramètre transmis est une référence à

et non une copie de celui-ci, nous pouvons utiliser la méthode de liste de mutations pour le modifier et refléter les modifications dans la portée externe.

Voyons maintenant ce qui se passe lorsque l'on essaie de changer la référence passée en 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)

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

the_list 参数是按值传递的，因此为其分配新列表不会对方法外部的代码产生任何影响。 the_list 是 outer_list 引用的副本，我们让 the_list 指向一个新列表，但无法更改 outer_listLe paramètre the_list étant passé par valeur, lui attribuer une nouvelle liste n'aura aucun impact sur le code en dehors de la méthode. the_list est une copie de ce à quoi

fait référence, nous faisons pointer the_list vers une nouvelle liste, mais nous ne pouvons pas changer l'endroit vers lequel

pointe.

String - type immuable

Il est immuable donc nous ne pouvons pas 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)

Sortie : the_string 参数是按值传递的，因此为其分配新字符串不会对方法外部的代码看到任何影响。 the_string 是 outer_string 引用的副本，我们让 the_string 指向一个新字符串，但无法更改 outer_string

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

Encore une fois, à cause des points où

.

J'espère que cela rend les choses plus claires.

EDIT :

Quelqu'un a souligné que cela ne répondait pas à la question initiale de @david : "Puis-je faire quelque chose pour transmettre la variable par référence réelle ?". Travaillons dur.

Comment résoudre ce problème ?

Comme le montre la réponse de @andrea, vous pouvez renvoyer de nouvelles valeurs. Cela ne change pas la façon dont le contenu est transmis, mais cela vous permet d'obtenir les informations souhaitées :

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 vous voulez vraiment éviter d'utiliser la valeur de retour, vous pouvez créer une classe pour contenir votre valeur et la transmettre à la fonction ou utiliser 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 gênant. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!