Python函数通过引用调用

Question 1

在某些语言中，可以使用特殊的保留字（例如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该参数是值还是引用参数，而不是使用global？

其次，在A级剑桥考试，他们现在说一个函数返回一个值，而过程返回不止一个值。在80年代，我被告知一个函数具有return语句，而过程没有。为什么现在不正确？

Question 2

您无法在Python函数中更改不可变的对象（例如str或）tuple，但可以执行以下操作：

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

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

但是，这是一种怪异的解决方法，除非您需要始终将数组中的某些元素平方。

请注意，在Python中，您还可以返回多个值，从而使得通过引用传递的一些用例不那么重要：

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

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

当您返回这样的值时，它们将作为元组返回，而元组又将解压缩。

编辑： 另一种思考方式是，虽然您无法在Python中通过引用显式传递变量，但可以修改传入的对象的属性。在我的示例（和其他示例）中，您可以修改列表的成员但是，您将无法完全重新分配传入的变量。例如，请看下面的两段代码，看起来它们可能会做类似的事情，但最终结果不同：

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

Question 3

本质上有三种“函数调用”：

传递价值
通过参考
通过对象引用

Python是一种PASS-BY-OBJECT-REFERENCE编程语言。

首先，重要的是要了解变量和变量（对象）的值是两个分开的东西。变量“指向”对象。变量不是对象。再次：

变量不是对象

示例：在下面的代码行中：

>>> x = []

[]是空列表，x是一个指向空列表的变量，但x本身不是空列表。

将变量（x在上述情况下）视为一个框，并将变量（[]）的“值”作为该框内的对象。

通过对象引用（在python中为例）：

此处，“对象引用按值传递”。

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

在这里，该语句生成x = [0]一个x指向object的变量（框）[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]

通过引用：

来自调用函数的框将传递给被调用函数。隐式地，将框的内容（变量的值）传递给被调用的函数。因此，对被调用函数中框内容的任何更改都将反映在调用函数中。

通过值：

在被调用函数中创建一个新框，并将来自调用函数的框内容副本存储到新框中。

希望这可以帮助。

Question 4

好吧，我将对此采取行动。Python通过对象引用传递，这与您通常认为的“按引用”或“按值”不同。举个例子：

def foo(x):
    print x

bar = 'some value'
foo(bar)

因此，您要创建一个值为'some value'的字符串对象，并将其“绑定”到名为的变量bar。在C语言中，这类似于bar指向“某个值”的指针。

当您致电时foo(bar)，您bar本身并没有传递。您要传递bar的值：指向“某个值”的指针。那时，同一字符串对象有两个“指针”。

现在将其与：

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

bar = 'some value'
foo(bar)

这就是区别所在。在该行中：

x = 'another value'

您实际上并没有更改的内容x。实际上，这甚至是不可能的。相反，您正在创建一个值为“另一个值”的新字符串对象。那个赋值运算符？这并不是说“x用新值覆盖正在指向的东西”。它说的是“更新x以指向新对象”。在该行之后，有两个字符串对象：“某个值”（bar指向它）和“另一个值”（x指向它）。

这并不笨拙。当您了解它是如何工作的时，它就是一个优美而高效的系统。

Question 5

希望下面的描述能很好地总结一下：

这里有两件事要考虑-变量和对象。

如果要传递变量，则按值传递，这意味着对该函数内的变量所做的更改是该函数的局部变量，因此不会在全局范围内反映出来。这更多的是类似于“ 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

如果要传递打包在可变对象（如列表）中的变量，则只要不重新分配对象，对对象所做的更改就会全局反映。

例：

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

现在考虑重新分配对象的情况。在这种情况下，对象指的是新存储位置，该位置在发生此功能的函数中是本地的，因此不会全局反映。

例：

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]

Question 6

Python既不是值传递也不是引用传递。它更多的“对象引用是按值传递”的描述在这里：

这就是为什么它不按值传递。 因为

def append(list):
    list.append(1)

list = [0]
reassign(list)
append(list)

返回[0,1]，表明已明确传递了某种引用，因为按值传递完全不允许函数更改父范围。

看起来像是通过引用吧？不。

这就是为什么它不通过引用传递的原因。因为

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

Question 7

从技术上讲，python不会通过值传递参数：全部通过引用传递。但是...由于python有两种类型的对象：不可变和可变的，因此发生了以下情况：

不可变参数有效地通过值传递：字符串，整数，元组都是不可变对象类型。尽管它们在技术上是“通过引用传递”的（就像所有参数一样），但是由于您无法在函数内部就地更改它们，因此它的外观/行为似乎就像是通过值传递一样。
可变参数通过引用有效地传递：列表或字典通过其指针传递。函数内部的任何就地更改（如附加或删除）都会影响原始对象。

这就是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'}

Question 8

所以这有点微妙，因为Python仅按值传递变量，而Python中的每个变量都是引用。如果您希望能够通过函数调用更改值，则需要一个可变对象。例如：

l = [0]

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

set_3(l)
print(l[0])

在上面的代码中，该函数修改了List对象的内容（可变的），因此输出为3而不是0。

我写这个答案只是为了说明“按值”在Python中的含义。上面的代码风格不好，如果您真的想更改值，则应编写一个类并在该类中调用方法，如MPX所建议的那样。

Question 9

给出的答案是

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相比，它似乎很笨拙。这是我们拥有的最好的方法吗？

它不仅笨拙，还涉及以某种方式手动更改原始参数，例如通过将原始参数更改为列表：或将其复制到另一个列表，而不仅仅是说：“使用此参数作为值”或“使用此参数”作为参考”。简单的答案可能没有保留字，但这是很好的解决方法吗？

Question 10

考虑该变量是一个框，它指向的值是框内的“事物”：

1.通过引用：函数共享同一框，从而也包含其中的东西。

2.按值传递：函数创建一个新盒子，一个旧盒子的副本，包括其中任何东西的副本。例如。Java-函数会创建盒子及其内部事物的副本，该副本可以是：基本体/对对象的引用。（请注意，在新框中复制的引用和原始引用都仍然指向同一对象，这里引用是框中的东西，而不是它指向的对象）

3.通过对象引用传递：该函数创建一个框，但是它与初始框所包含的内容相同。因此在Python中：

a）如果所述盒子中的东西是易变的，所做的更改将反映在原始盒子中（例如列表）

b）如果事物是不可变的（例如python字符串和数字类型），则函数内部的框将保留相同的事物，直到您尝试更改其值。一旦更改，与原始功能相比，功能框中的内容是全新的。因此，该盒子的id（）现在将给出它所包围的新事物的标识。

Question 11

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)

Question 12

在Python中，按引用或按值传递必须与要传递的实际对象有关。因此，例如，如果要传递列表，则实际上是按引用传递，因为列表是可变对象。因此，您将传递一个指向函数的指针，并且可以在函数主体中修改对象（列表）。

当传递字符串时，该传递是通过值完成的，因此将创建一个新的字符串对象，并且在函数终止时将其销毁。因此，所有这些都与可变和不可变的对象有关。

Question 13

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