在Python中通过引用传递整数

问题:在Python中通过引用传递整数

如何在Python中通过引用传递整数?

我想修改传递给函数的变量的值。我读过Python中的所有内容都是按值传递的,但是必须有一个简单的技巧。例如,在Java中,你可以通过引用类型的IntegerLong等等。

  1. 如何通过引用将整数传递给函数?
  2. 最佳做法是什么?

How can I pass an integer by reference in Python?

I want to modify the value of a variable that I am passing to the function. I have read that everything in Python is pass by value, but there has to be an easy trick. For example, in Java you could pass the reference types of Integer, Long, etc.

  1. How can I pass an integer into a function by reference?
  2. What are the best practices?

回答 0

在Python中,这种方式不太有效。Python将引用传递给对象。在函数内部,您有一个对象-您可以随意更改该对象(如果可能)。但是,整数是不可变的。一种解决方法是在可以更改的容器中传递整数:

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

x = [1]
change(x)
print x

这充其量是丑陋的/笨拙的,但是您不会在Python中做得更好。原因是因为在Python中,赋值(=)接受右侧对象结果的任何对象,并将其绑定到左侧对象*(或将其传递给适当的函数)。

了解了这一点,我们可以看到为什么无法更改函数内部不可变对象的值的原因-您不能更改其任何属性,因为它是不可变的,并且您不能仅给新的“变量”赋值值,因为您实际上是在创建一个新对象(与旧对象不同),并为其赋予旧对象在本地命名空间中的名称。

通常,解决方法是简单地返回所需的对象:

def multiply_by_2(x):
    return 2*x

x = 1
x = multiply_by_2(x)

*在上述第一个示例中,3实际上传递给x.__setitem__

It doesn’t quite work that way in Python. Python passes references to objects. Inside your function you have an object — You’re free to mutate that object (if possible). However, integers are immutable. One workaround is to pass the integer in a container which can be mutated:

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

x = [1]
change(x)
print x

This is ugly/clumsy at best, but you’re not going to do any better in Python. The reason is because in Python, assignment (=) takes whatever object is the result of the right hand side and binds it to whatever is on the left hand side *(or passes it to the appropriate function).

Understanding this, we can see why there is no way to change the value of an immutable object inside a function — you can’t change any of its attributes because it’s immutable, and you can’t just assign the “variable” a new value because then you’re actually creating a new object (which is distinct from the old one) and giving it the name that the old object had in the local namespace.

Usually the workaround is to simply return the object that you want:

def multiply_by_2(x):
    return 2*x

x = 1
x = multiply_by_2(x)

*In the first example case above, 3 actually gets passed to x.__setitem__.


回答 1

您需要通过引用传递的大多数情况是,您需要将多个值返回给调用方。“最佳实践”是使用多个返回值,这在Python中比在Java等语言中要容易得多。

这是一个简单的例子:

def RectToPolar(x, y):
    r = (x ** 2 + y ** 2) ** 0.5
    theta = math.atan2(y, x)
    return r, theta # return 2 things at once

r, theta = RectToPolar(3, 4) # assign 2 things at once

Most cases where you would need to pass by reference are where you need to return more than one value back to the caller. A “best practice” is to use multiple return values, which is much easier to do in Python than in languages like Java.

Here’s a simple example:

def RectToPolar(x, y):
    r = (x ** 2 + y ** 2) ** 0.5
    theta = math.atan2(y, x)
    return r, theta # return 2 things at once

r, theta = RectToPolar(3, 4) # assign 2 things at once

回答 2

不完全直接传递值,而是像传递值一样使用它。

x = 7
def my_method():
    nonlocal x
    x += 1
my_method()
print(x) # 8

注意事项:

  • nonlocal 在python 3中引入
  • 如果封闭范围是全局范围,请使用global代替nonlocal

Not exactly passing a value directly, but using it as if it was passed.

x = 7
def my_method():
    nonlocal x
    x += 1
my_method()
print(x) # 8

Caveats:

  • nonlocal was introduced in python 3
  • If the enclosing scope is the global one, use global instead of nonlocal.

回答 3

确实,最佳做法是退后一步,然后询问您是否真的需要这样做。为什么要修改传递给函数的变量的值?

如果您需要快速破解,最快的方法是传递一个list整数,并粘贴[0]如mgilson的答案所示,在每次使用时使用。

如果您需要做一些更重要的事情,请写一个 class具有int作为属性的,以便您可以对其进行设置。当然,这会迫使您为类和属性命名,如果您什么都没想到,请返回并再次阅读该句子几次,然后使用list

更一般而言,如果您尝试将某些Java习惯用法直接移植到Python,那么您做错了。即使有直接对应的内容(如static/ @staticmethod),您仍然不想在大多数Python程序中使用它,只是因为您要在Java中使用它。

Really, the best practice is to step back and ask whether you really need to do this. Why do you want to modify the value of a variable that you’re passing in to the function?

If you need to do it for a quick hack, the quickest way is to pass a list holding the integer, and stick a [0] around every use of it, as mgilson’s answer demonstrates.

If you need to do it for something more significant, write a class that has an int as an attribute, so you can just set it. Of course this forces you to come up with a good name for the class, and for the attribute—if you can’t think of anything, go back and read the sentence again a few times, and then use the list.

More generally, if you’re trying to port some Java idiom directly to Python, you’re doing it wrong. Even when there is something directly corresponding (as with static/@staticmethod), you still don’t want to use it in most Python programs just because you’d use it in Java.


回答 4

在Python中,每个值都是引用(指向对象的指针),就像Java中的非基本体一样。另外,像Java一样,Python仅按值传递。因此,从语义上讲,它们几乎是相同的。

既然您在问题中提到Java,那么我想看看您如何实现Java的目标。如果您可以用Java展示它,那么我可以向您展示如何用Python完全等效地展示它。

In Python, every value is a reference (a pointer to an object), just like non-primitives in Java. Also, like Java, Python only has pass by value. So, semantically, they are pretty much the same.

Since you mention Java in your question, I would like to see how you achieve what you want in Java. If you can show it in Java, I can show you how to do it exactly equivalently in Python.


回答 5

numpy的单元素数组是可变的,但对于大多数用途,它可以被就好像它是一个数值蟒变量进行评价。因此,它比单元素列表更方便使用按引用编号的容器。

    import numpy as np
    def triple_var_by_ref(x):
        x[0]=x[0]*3
    a=np.array([2])
    triple_var_by_ref(a)
    print(a+1)

输出:

3

A numpy single-element array is mutable and yet for most purposes, it can be evaluated as if it was a numerical python variable. Therefore, it’s a more convenient by-reference number container than a single-element list.

    import numpy as np
    def triple_var_by_ref(x):
        x[0]=x[0]*3
    a=np.array([2])
    triple_var_by_ref(a)
    print(a+1)

output:

3

回答 6

class PassByReference:
    def Change(self, var):
        self.a = var
        print(self.a)
s=PassByReference()
s.Change(5)     
class PassByReference:
    def Change(self, var):
        self.a = var
        print(self.a)
s=PassByReference()
s.Change(5)     

回答 7

也许这不是pythonic的方式,但是您可以这样做

import ctypes

def incr(a):
    a += 1

x = ctypes.c_int(1) # create c-var
incr(ctypes.ctypes.byref(x)) # passing by ref

Maybe it’s not pythonic way, but you can do this

import ctypes

def incr(a):
    a += 1

x = ctypes.c_int(1) # create c-var
incr(ctypes.ctypes.byref(x)) # passing by ref

回答 8

可能比length-1列表技巧更能自我记录的是旧的空类型技巧:

def inc_i(v):
    v.i += 1

x = type('', (), {})()
x.i = 7
inc_i(x)
print(x.i)

Maybe slightly more self-documenting than the list-of-length-1 trick is the old empty type trick:

def inc_i(v):
    v.i += 1

x = type('', (), {})()
x.i = 7
inc_i(x)
print(x.i)

回答 9

在Python中,所有内容均按值传递,但如果要修改某些状态,则可以更改传递给方法的列表或对象内的整数值。

In Python, everything is passed by value, but if you want to modify some state, you can change the value of an integer inside a list or object that’s passed to a method.


回答 10

正确的答案是使用一个类,然后将值放入该类中,这使您可以完全按需传递引用。

class Thing:
  def __init__(self,a):
    self.a = a
def dosomething(ref)
  ref.a += 1

t = Thing(3)
dosomething(t)
print("T is now",t.a)

The correct answer, is to use a class and put the value inside the class, this lets you pass by reference exactly as you desire.

class Thing:
  def __init__(self,a):
    self.a = a
def dosomething(ref)
  ref.a += 1

t = Thing(3)
dosomething(t)
print("T is now",t.a)