Python関数は参照によって呼び出されます

一部の言語では、refやvalなどの特別な予約語を使用して、参照または値でパラメーターを渡すことができます。Python関数にパラメーターを渡すと、関数を離れるときにパラメーターの値が変更されることはありません。これを行う唯一の方法は、グローバル予約語を使用することです（または現在理解しているとおりです）。

例1：

k = 2

def foo (n):
     n = n * n     #clarity regarding comment below
     square = n
     return square

j = foo(k)
print j
print k

表示されます

>>4
>>2

kが変更されていないことを示す

この例では、変数nは変更されません。

例2：

n = 0
def foo():
    global n
    n = n * n
    return n

この例では、変数nが変更されています

Pythonで関数を呼び出し、パラメーターがグローバルを使用する代わりに値または参照パラメーターのいずれかであることをPythonに通知する方法はありますか？

次に、Aレベルのケンブリッジ試験では、関数は単一の値を返すのに対し、プロシージャは複数の値を返すと言われています。80年代に、関数にはreturnステートメントがあり、プロシージャにはないことを教えられました。なぜこれが正しくないのですか？

Pythonの関数内で、strやなどの不変オブジェクトを変更することはできませんが、次のようなtupleことはできます。

def foo(y):
  y[0] = y[0]**2

x = [5]
foo(x)
print x[0]  # prints 25

ただし、配列内の特定の要素を常に2乗する必要がない限り、これは奇妙な方法です。

Pythonでは、複数の値を返すこともできるため、参照渡しのユースケースのいくつかはそれほど重要ではないことに注意してください。

def foo(x, y):
   return x**2, y**2

a = 2
b = 3
a, b = foo(a, b)  # a == 4; b == 9

このような値を返すと、タプルとして返され、次にアンパックされます。

編集： これについて考える別の方法は、Pythonで参照によって変数を明示的に渡すことはできませんが、渡されたオブジェクトのプロパティを変更できることです。私の例（およびその他）では、リストのメンバーを変更できます。渡されました。ただし、渡された変数を完全に再割り当てすることはできません。たとえば、次の2つのコードは、似たようなことをするように見えますが、結果は異なります。

def clear_a(x):
  x = []

def clear_b(x):
  while x: x.pop()

z = [1,2,3]
clear_a(z) # z will not be changed
clear_b(z) # z will be emptied

「関数呼び出し」には基本的に3種類あります。

• 値渡し
• 参照渡し
• オブジェクト参照を渡す

PythonはPASS-BY-OBJECT-REFERENCEプログラミング言語です。

まず、変数と変数（オブジェクト）の値は2つの別個のものであることを理解することが重要です。変数 'は'オブジェクトを指します。変数はオブジェクトではありません。再び：

変数は目的ではありません

例：次のコード行：

>>> x = []

[]は空のリストであり、空のリストxを指す変数ですが、xそれ自体は空のリストではありません。

変数（x上記の場合は）をボックスと見なし、変数（[]）の「値」をボックス内のオブジェクトと見なします。

PASS BY OBJECT REFERENCE（Pythonの場合）：

ここでは、「オブジェクト参照は値によって渡されます」。

def append_one(li):
    li.append(1)
x = [0]
append_one(x)
print x

ここで、ステートメントx = [0]はxオブジェクトを指す変数（ボックス）を作成します[0]。

呼び出される関数で、新しいボックスliが作成されます。の内容はli箱の中身と同じxです。両方のボックスに同じオブジェクトが含まれています。つまり、両方の変数がメモリ内の同じオブジェクトを指しています。したがって、が指すオブジェクトへの変更は、が指すオブジェクトliにも反映されますx。

結論として、上記のプログラムの出力は次のようになります。

[0, 1]

注意：

変数liが関数で再割り当てされると、liはメモリ内の別のオブジェクトを指します。xただし、以前にポイントしていたメモリ内の同じオブジェクトを引き続きポイントします。

例：

def append_one(li):
    li = [0, 1]
x = [0]
append_one(x)
print x

プログラムの出力は次のようになります。

[0]

参照渡し：

呼び出し元の関数からのボックスは、呼び出された関数に渡されます。暗黙的に、ボックスの内容（変数の値）は呼び出された関数に渡されます。したがって、呼び出された関数のボックスの内容に対する変更は、呼び出し元の関数に反映されます。

値渡し：

呼び出された関数に新しいボックスが作成され、呼び出し元の関数からのボックスの内容のコピーが新しいボックスに格納されます。

お役に立てれば。

OK、これを刺します。Pythonはオブジェクト参照を渡します。これは、通常「参照による」または「値による」と考えるものとは異なります。この例を見てください：

def foo(x):
    print x

bar = 'some value'
foo(bar)

したがって、値が「some value」の文字列オブジェクトを作成し、それをbar。という名前の変数に「バインド」します。Cでは、これはbar「ある値」へのポインタに似ています。

あなたが電話するときfoo(bar)、あなたはbarそれ自体を通過していません。bar's value：' somevalue 'へのポインタを渡しています。その時点で、同じ文字列オブジェクトへの2つの「ポインタ」があります。

今それを比較してください：

def foo(x):
    x = 'another value'
    print x

bar = 'some value'
foo(bar)

ここに違いがあります。行で：

x = 'another value'

実際にはの内容を変更しているわけではありませんx。実際、それは不可能ですらあります。代わりに、値 'anothervalue'を使用して新しい文字列オブジェクトを作成しています。その代入演算子？「x指しているものを新しい値で上書きする」と言っているのではありません。「x代わりに新しいオブジェクトを指すように更新する」と言っています。その行の後に、2つの文字列オブジェクトがあります。「ある値」（それをbar指している）と「別の値」（それをx指している）です。

これは不器用ではありません。それがどのように機能するかを理解すると、それは美しくエレガントで効率的なシステムです。

次の説明がそれをうまく要約していることを願っています：

ここで考慮すべきことが2つあります。変数とオブジェクトです。

1. 変数を渡す場合は、値で渡します。つまり、関数内で変数に加えられた変更はその関数に対してローカルであるため、グローバルに反映されません。これは、「C」のような動作です。

例：

def changeval( myvar ):
   myvar = 20; 
   print "values inside the function: ", myvar
   return

myvar = 10;
changeval( myvar );
print "values outside the function: ", myvar

O / P：

values inside the function:  20 
values outside the function:  10

2. リストなどの可変オブジェクト内にパックされた変数を渡す場合、オブジェクトに加えられた変更は、オブジェクトが再割り当てされない限り、グローバルに反映されます。

例：

def changelist( mylist ):
   mylist2=['a'];
   mylist.append(mylist2);
   print "values inside the function: ", mylist
   return

mylist = [1,2,3];
changelist( mylist );
print "values outside the function: ", mylist

O / P：

values inside the function:  [1, 2, 3, ['a']]
values outside the function:  [1, 2, 3, ['a']]

3. ここで、オブジェクトが再割り当てされた場合を考えてみましょう。この場合、オブジェクトは、これが発生する関数に対してローカルであるため、グローバルに反映されない新しいメモリ位置を参照します。

例：

def changelist( mylist ):
   mylist=['a'];
   print "values inside the function: ", mylist
   return

mylist = [1,2,3];
changelist( mylist );
print "values outside the function: ", mylist

O / P：

values inside the function:  ['a']
values outside the function:  [1, 2, 3]

Pythonは、値渡しでも参照渡しでもありません。ここで説明するように、これは「オブジェクト参照は値によって渡される」ということです。

1. これが、値渡しではない理由です。 なぜなら

   def append(list):
       list.append(1)
   
   list = [0]
   reassign(list)
   append(list)
   

[0,1]を返します。これは、値渡しによって関数が親スコープをまったく変更できないため、ある種の参照が明確に渡されたことを示しています。

それでは、参照渡しのように見えますね。いいえ。

2. これが、参照渡しではない理由です。なぜなら

   def reassign(list):
     list = [0, 1]
   
   list = [0]
   reassign(list)
   print list
   

リストが再割り当てされたときに元の参照が破棄されたことを示す[0]を返します。 参照渡しは[0,1]を返します。

詳細については、こちらをご覧ください：

関数がスコープ外を操作しないようにする場合は、新しいオブジェクトを作成する入力パラメーターのコピーを作成する必要があります。

from copy import copy

def append(list):
  list2 = copy(list)
  list2.append(1)
  print list2

list = [0]
append(list)
print list

技術的には、Pythonは引数を値で渡しません。すべて参照で渡します。しかし... Pythonには不変と可変の2種類のオブジェクトがあるため、次のようになります。

• 不変の引数は値によって効果的に渡されます。文字列、整数、タプルはすべて不変のオブジェクトタイプです。これらは技術的には（すべてのパラメーターと同様に）「参照によって渡されます」が、関数内でその場で変更できないため、値によって渡されたかのように見えます。

• 可変引数は参照によって効果的に渡されます。リストまたは辞書はそのポインターによって渡されます。（appendまたはdel）のような関数内でのインプレース変更は、元のオブジェクトに影響します。

これがPythonの設計方法です。コピーはなく、すべてが参照によって渡されます。明示的にコピーを渡すことができます。

def sort(array):
    # do sort
    return array

data = [1, 2, 3]
sort(data[:]) # here you passed a copy

最後に、関数には独自のスコープがあることを述べておきます。

def do_any_stuff_to_these_objects(a, b): 
    a = a * 2 
    del b['last_name']

number = 1 # immutable
hashmap = {'first_name' : 'john', 'last_name': 'legend'} # mutable
do_any_stuff_to_these_objects(number, hashmap) 
print(number) # 1 , oh  it should be 2 ! no a is changed inisde the function scope
print(hashmap) # {'first_name': 'john'}

Pythonは変数を値で渡すだけですが、Pythonのすべての変数は参照であるため、これは少し微妙な点です。関数呼び出しで値を変更できるようにしたい場合、必要なのは可変オブジェクトです。例えば：

l = [0]

def set_3(x):
    x[0] = 3

set_3(l)
print(l[0])

上記のコードでは、関数はListオブジェクト（可変）の内容を変更するため、出力は0ではなく3になります。

この答えは、Pythonで「値による」が何を意味するかを説明するためだけに書いています。上記のコードは悪いスタイルです。本当に値を変更したい場合は、MPXが示唆するように、クラスを作成し、そのクラス内でメソッドを呼び出す必要があります。

与えられた答えは

def set_4(x):
   y = []
   for i in x:
       y.append(i)
   y[0] = 4
   return y

そして

l = [0]

def set_3(x):
     x[0] = 3

set_3(l)
print(l[0])

それが質問で言うことをする限り、これは最良の答えです。ただし、VBやPascalに比べると非常に不器用な方法のようですが、これが最善の方法ですか？

不器用であるだけでなく、元のパラメータを手動で変更することも含まれます。たとえば、元のパラメータをリストに変更するか、「このパラメータを値として使用する」または「これを使用する」と言うのではなく、別のリストにコピーします。参考として」。簡単な答えは、これに予約語がないということでしょうか？しかし、これらは素晴らしい回避策ですか？

変数がボックスであり、それが指す値がボックス内の「もの」であると考えてください。

1.参照渡し：関数は同じボックスを共有するため、内部のものも共有されます。

2.値渡し：関数は、新しいボックス、古いボックスのレプリカを作成し、その中にあるもののコピーを含めます。例えば。Java-関数は、ボックスとその中にあるもののコピーを作成します。これは、プリミティブ/オブジェクトへの参照です。（新しいボックスにコピーされた参照と元の参照はどちらも同じオブジェクトを指していることに注意してください。ここでは、参照はボックス内のものであり、指しているオブジェクトではありません）

3.オブジェクト参照の受け渡し：関数はボックスを作成しますが、最初のボックスが囲んでいたものと同じものを囲みます。したがって、Pythonでは：

a）上記のボックス内のものが変更可能である場合、行われた変更は元のボックスに反映されます（例：リスト）

b）ものが不変である場合（Python文字列や数値型など）、関数内のボックスは、値を変更しようとするまで同じものを保持します。一度変更すると、関数のボックス内のものは、元のものと比較してまったく新しいものになります。したがって、そのボックスのid（）は、それが囲む新しいもののIDを与えるようになります。

class demoClass:
    x = 4
    y = 3
foo1 = demoClass()
foo1.x = 2
foo2 = demoClass()
foo2.y = 5
def mySquare(myObj):
    myObj.x = myObj.x**2
    myObj.y = myObj.y**2
print('foo1.x =', foo1.x)
print('foo1.y =', foo1.y)
print('foo2.x =', foo2.x)
print('foo2.y =', foo2.y)
mySquare(foo1)
mySquare(foo2)
print('After square:')
print('foo1.x =', foo1.x)
print('foo1.y =', foo1.y)
print('foo2.x =', foo2.x)
print('foo2.y =', foo2.y)

Pythonでは、参照または値による受け渡しは、渡す実際のオブジェクトと関係があります。たとえば、リストを渡す場合、リストは可変オブジェクトであるため、実際には参照による受け渡しを行います。したがって、関数へのポインタを渡しており、関数本体のオブジェクト（リスト）を変更できます。

文字列を渡す場合、この受け渡しは値によって行われるため、新しい文字列オブジェクトが作成され、関数が終了すると破棄されます。つまり、すべては可変オブジェクトと不変オブジェクトに関係しています。

Pythonはすでに参照によって呼び出しています。

例を見てみましょう：

  def foo(var):
      print(hex(id(var)))


  x = 1 # any value
  print(hex(id(x))) # I think the id() give the ref... 
  foo(x)

出力

  0x50d43700 #with you might give another hex number deppend on your memory 
  0x50d43700