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
- How can I pass an integer into a function by reference?
- What are the best practices?
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 = 3 x =  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
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
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
nonlocalwas introduced in python 3
- If the enclosing scope is the global one, use
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
 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
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
@staticmethod), you still don’t want to use it in most Python programs just because you’d use it in Java.
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.
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=x*3 a=np.array() triple_var_by_ref(a) print(a+1)
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
class PassByReference: def Change(self, var): self.a = var print(self.a) s=PassByReference() s.Change(5)