Problème de transfert de valeur de fonction

Regardons d'abord un exemple :

# -*- coding: UTF-8 -*-
def chagne_number( b ):
    b = 1000
b = 1
chagne_number(b)
print( b )

Le résultat final est :

1

Certaines personnes ici peuvent avoir des questions, pourquoi la valeur de b n'est-elle pas modifiée via la fonction chagne_number ? Pourquoi n'y a-t-il aucun changement et le résultat de sortie est toujours 1 ? Ce problème est discuté dans de nombreux langages de programmation et l'explication du principe est similaire.

Il s'agit principalement du transfert de paramètres de fonction, qui sont des objets de type. Les types de données de base en Python ont également été introduits auparavant. Ces objets de type peuvent être divisés en types modifiables et types non modifiables. En Python, les chaînes, les entiers, les types à virgule flottante et les tuples sont des objets non modifiables, tandis que les listes, dicts, etc. sont des objets qui peuvent être modifiés.

Par exemple :

Type non modifiable

 : L'affectation de variable a = 1 génère en fait un objet entier 1, puis la variable a pointe vers 1. Lorsque a = 1000, elle génère en fait un autre objet entier 1000, puis modifie le valeur d'un Pointe vers, ne pointe plus vers l'objet entier 1, mais pointe vers 1000, et le dernier 1 sera rejeté

Type modifiable

: affectation de variable a = [1,2,3,4,5,6 ], qui consiste à générer une liste d'objets, il y a 6 éléments dans la liste, et la variable a pointe vers la liste, a[2] = 5 change la valeur du troisième élément de la liste a. C'est différent de la. ci-dessus. Il ne redirige pas a, mais modifie directement la valeur de l'élément dans la liste.

Cela affectera également la transmission des paramètres dans les fonctions :

Types immuables

 : transmission de valeurs de type C++, telles que des entiers, des chaînes et des tuples. Par exemple, fun(a) transfère uniquement la valeur de a et n'affecte pas l'objet a lui-même. Par exemple, modifier la valeur d'un intérieur fun(a) ne modifie qu'un autre objet copié et n'affecte pas a lui-même.

Types modifiables

 : similaire à la transmission de références C++, comme les listes et les dictionnaires. Par exemple, fun (a), a lui est effectivement transmis. Après modification, un fun extérieur sera également affecté. Par conséquent, dans le premier exemple, b = 1, un objet entier 1 est créé et la variable b pointe vers. Cet objet est obtenu, puis lors du passage de la fonction chagne_number, la variable b est copiée par valeur. Ce qui est passé n'est que la valeur de b, et n'affecte pas b lui-même. Pour plus de détails, vous pouvez consulter l'exemple modifié et avoir une meilleure compréhension grâce aux résultats imprimés.

# -*- coding: UTF-8 -*-
def chagne_number( b ):
    print('函数中一开始 b 的值：{}' .format( b ) )
    b = 1000
    print('函数中 b 赋值后的值：{}' .format( b ) )
b = 1
chagne_number( b )
print( '最后输出 b 的值：{}' .format( b )  )

Résultat imprimé :

函数中一开始 b 的值：1
函数中 b 赋值后的值：1000
最后输出 b 的值：1

Bien sûr, si le paramètre est de type modifiable, alors après avoir appelé cette fonction, la valeur d'origine sera également modifiée. L'exemple spécifique est le suivant :

# -*- coding: UTF-8 -*-
def chagne_list( b ):
    print('函数中一开始 b 的值：{}' .format( b ) )
    b.append(1000)
    print('函数中 b 赋值后的值：{}' .format( b ) )
b = [1,2,3,4,5]
chagne_list( b )
print( '最后输出 b 的值：{}' .format( b )  )

Résultat de sortie :

函数中一开始 b 的值：[1, 2, 3, 4, 5]
函数中 b 赋值后的值：[1, 2, 3, 4, 5, 1000]
最后输出 b 的值：[1, 2, 3, 4, 5, 1000]

.section suivante