Understanding how Python handles variables and function arguments is essential for writing predictable and bug-free code. Many developers coming from languages like C++ or Java often wonder whether Python uses call by value or call by reference. The answer is: neither exactly. Python uses a model often called pass by object reference or call by sharing. Let us delve into understanding how passing by object reference works in Python.<\/p>\n
Before diving into Python\u2019s behavior, it is important to understand the two traditional models of passing arguments to functions: call by value<\/a> and call by reference<\/a>. These concepts originate from languages like C, C++, and Java, and they help establish the foundation for understanding how Python behaves differently.<\/p>\n In the call by value model, a function receives a copy<\/em> of the variable\u2019s value rather than the original variable itself. This means that any changes made inside the function are applied only to the copied value and do not affect the original variable outside the function. This approach ensures data safety, as the original variable remains unchanged regardless of what happens inside the function.<\/p>\n The variable In the call by reference model, instead of passing a copy, the function receives a reference (or address) to the original variable. This allows the function to directly modify the original data stored in memory. Any changes made inside the function are reflected outside the function because both the caller and the function refer to the same memory location.<\/p>\n The parameter Python does not strictly use call by value or call by reference. Instead, it employs a model often called pass by object reference<\/a> (or call by sharing). This means that when you pass a variable to a function, Python passes a reference to the object, not the actual value itself, but how the object behaves depends on its mutability.<\/p>\n Understanding this distinction is crucial. It explains why immutable types behave like “call by value” (the original is unaffected) while mutable types behave like “call by reference” (the original can change). Once you internalize that Python always passes object references, the behavior of functions becomes predictable and intuitive.<\/p>\n The following example demonstrates how Python handles immutable and mutable objects when passed to a function.<\/p>\n This program demonstrates Python\u2019s pass-by-object-reference behavior using both immutable and mutable objects. The function 1.1 Call by Value: Working with Copies<\/h3>\n
\ndef modify(x):\n x = x + 10\n print(\"Inside function:\", x)\n\na = 5\nmodify(a)\nprint(\"Outside function:\", a) # Output: 5\n<\/pre>\n
a<\/code> is passed to the function modify()<\/code>, where a separate copy of its value (5<\/code>) is created and assigned to x<\/code>. The operation x = x + 10<\/code> modifies only this local copy, and as a result, the original variable a<\/code> remains unchanged after the function call. This is why the output shows that the value of a<\/code> is still 5<\/code> outside the function.<\/p>\n1.2 Call by Reference: Working with Original Data<\/h3>\n
\n# Conceptual example of call by reference (Python does not use &):\ndef modify(x):\n x.append(10) # works for mutable objects like lists\n<\/pre>\n
x<\/code> acts as a reference to the original variable, meaning no separate copy is created and both names point to the same memory location. As a result, updating x<\/code> directly modifies the original variable. This is why, in languages that support call by reference, the original value is modified after the function call.1.3 How Python Actually Passes Arguments<\/h3>\n
\n
1.3.1 Understanding Mutability and Its Effect<\/h4>\n
\n
int<\/code>, float<\/code>, str<\/code>, tuple<\/code>): cannot be changed in place. Any operation that seems to modify them actually creates a new object, leaving the original unchanged.<\/li>\nlist<\/code>, dict<\/code>, set<\/code>): can be modified in place. Changes inside the function affect the original object outside the function.<\/li>\n<\/ul>\n<\/a>2. Python in Action: Passing Objects to Functions<\/h2>\n
\ndef modify_immutable(num):\n \"\"\"\n Demonstrates call by value-like behavior using an immutable object (int).\n Changes inside the function do NOT affect the original variable.\n \"\"\"\n print(\"Inside modify_immutable (before):\", num)\n num = num + 10 # Creates a new integer object\n print(\"Inside modify_immutable (after):\", num)\n\n\ndef modify_mutable(items):\n \"\"\"\n Demonstrates call by reference-like behavior using a mutable object (list).\n Changes inside the function affect the original object.\n \"\"\"\n print(\"Inside modify_mutable (before):\", items)\n items.append(4) # Modifies the same list object\n print(\"Inside modify_mutable (after):\", items)\n\n\ndef main():\n # Immutable object\n number = 5\n print(\"Before calling modify_immutable:\")\n print(\"number:\", number)\n modify_immutable(number)\n print(\"After calling modify_immutable:\")\n print(\"number:\", number) # Remains unchanged\n\n print(\"\\n-----------------------------\\n\")\n\n # Mutable object\n my_list = [1, 2, 3]\n print(\"Before calling modify_mutable:\")\n print(\"my_list:\", my_list)\n modify_mutable(my_list)\n print(\"After calling modify_mutable:\")\n print(\"my_list:\", my_list) # Gets updated\n\n\n# Entry point\nif __name__ == \"__main__\":\n main()\n<\/pre>\n
2.1 Code Explanation<\/h3>\n
modify_immutable()<\/code> takes an integer num<\/code>, prints its initial value, adds 10, and prints it again; since integers are immutable, this operation creates a new object and does not change the original number<\/code> variable in main()<\/code>. In contrast, modify_mutable()<\/code> takes a list items<\/code>, prints its initial value, appends 4 to the list, and prints it again; because lists are mutable, this modifies the same object in memory, so changes are reflected in my_list<\/code> outside the function. The main()<\/code> function calls both functions and prints the state of the variables before and after the calls, clearly illustrating the difference between how Python handles immutable versus mutable objects when passed to functions.<\/p>\n2.2 Code Output<\/h3>\n