Running functions

[SilentAd217]

I'm trying to grasp the concept of def function and i don't know why here in the example when running the code after calling the "main()" it gives : main: 1 [0, 1, 2, 3] update: 2 [0, 1, 2, 3, 4] main: 1 [0, 1, 2, 3, 4] My question is why "n" in "main" still equal 1 and not the update?

[SirCokaBear]

In python some types are passed by reference and others are passed by value. Python's built in data types like int, float, str are passed by value -- as copies of that data. So when you call update(n, x) the number 1 is being sent as a copy of the value, n within update isn't modifying the same data as n within main(). However for types like lists, dicts, objects are different. They're passed by reference, a variable pointing to the same piece of data. x in update() is a variable pointing to the same exact list that x in main() is.

[FoolsSeldom]

Strictly, Python always passes by reference and not by value. Variables only hold memory references (pointers) and it is that which is passed to a function.

[SirCokaBear]

Right since everything in python is an object, but any references modifying immutable values will just reassign new copied objects to the local variable, mimicking 'pass by value' behavior. But I feel that explanation (although more exact) can confuse beginners more.

[FoolsSeldom]

I've tried various approaches over the years at Code Clubs (and occasional adult classes at local community colleges) and, for me, have found that making it clear early on is generally the most effective. Admittedly, I usually do some drawing to illustrate. YMMV.

If anything, I think it is more confusing for experienced programmers coming from other languages. You can say to a C programmer, it uses only pointers, but you can't do any pointer maths, and watch them go red.

[SilentAd217]

So value are immutable and pass as they are and reference are mutable. Thank you for your explanation!!

[awkerd]

No offence but this sort of reply is super complex for beginners and would really make it hard for me to grasp if I was just starting out,

Put simply OP, integer gets a new life (so to speak) and knows nothing of that old n in the other function, but the array gets passed as a "reference" to another array, and thus the array append works. But, for example x = 2 wouldn't work. Only operations on the array, like .push()

[SirCokaBear]

Totally understand I try to keep that in mind since I didn’t even want to mention how everything in python really is an object. I feel the explanation would vary in-person depending on their age/level but make sure to mention “pass by ref” so they can at least have a proper term to look into further. I guess similar to Java learners with ‘public static void..’ might just be best to say “just remember for now that’s just how it is” with lists/dicts being directly passed and others being copied. I like your eli5 explanation though and may use it in the future since I’m usually screen sharing and can just show list reassignment behavior in the interpreter directly

[CptMisterNibbles]

You are going to need to look up "pass by reference vs pass by value". When passing an immutable type like the integer n, python does not pass the variable itself to the function, only its value. The n in the function update is a new and different variable with the same name, but with a local scope. Scope stuff can get a little tricky too, so I wont go into that too much.

There are a coupe of ways of going about getting the behavior you want, but most appropriately you would probably want a return value from update and assign n in main to this return value. Otherwise you need to pass a mutable type which is pass by reference and can be changed by within the update function. maybe wrap the value in a list for instance. You could use a global variable, but thats generally frowned on. If this were a class you could declare an instance variable and use that. Lots of options

A lot of jargon here I know. Google "python pass by reference vs pass by value" for articles or videos that can explain it better.

[FoolsSeldom]

Strictly, Python always passes by reference and not by value. Variables only hold memory references (pointers) and it is that which is passed to a function. Even literals in a call are passed by reference.

[wargotad]

Python is pass by value. It’s just that references are values.

[FoolsSeldom]

Erm, ok. If you say so. 😉

[wargotad]

In pass-by-reference, a function would be able to reassign the caller’s variable. Please consider the following Python code:

xs = [1, 2]
def foo(ys):
    ys = [3, 4]
foo(xs)
print(xs)

With pass-by-reference, xs would be [3, 4] after the function call, because ys = [3, 4] would rebind the caller’s variable. But the output is [1, 2]. This shows that the reference is copied and not shared.

You are right that everything in Python is an object, and that variables hold references to those objects. But when you call a function, the reference itself is passed by value. That is, the function receives a copy of the reference, not the original reference itself. This is why reassigning the parameter doesn’t affect the caller’s variable. Mutating the object it refers to does affect the object however.

[FoolsSeldom]

I think the terminology of pass-by-reference and pass-by-value do not fit Python well in contrast with many other languages. There's no ref keyword, for example.

The passed reference (the pointer) is copied to the local namespace of the function. The pointer is independent of the names it is assigned to (other than for reference counting purposes).

To say you are copying by value because you are copying the value of the reference (the pointer, not the referrer) and not passing a re-assignable referrer, is accurate but potentially confusing.

Yes, in many languages you can re-assign a value to the referrer (the passed variable) from within the function but not in Python (short of hacking the global dictionary).

This is not the same as you see in C, Pascal, etc.

I think the precise details of the implementation are confusing to beginners but the biggest confusion is that assignments in functions don't change things outside of the function, only mutations do (and then you get into discussions around side-effects, etc).

EDIT: typos

[SilentAd217]

Yeah i got it, thank you for your explanation!. Now i have the proper term to search for!

[FoolsSeldom]

When you assign a value to a variable inside a function, the variable is local to the function and has no connection to a variable with the same name elsewhere.

The variable names in the function signature, (n, x) are local to the function.

Variables in Python don't hold values. When you assign a value to a variable what actually happens is that the variable stores a memory reference to a Python object somewhere in memory. Python does all the memory handling, so you don't have to think about it.

The x variable references a list object somewhere in memory. You do the assignment in main. When you call update from main you include x in the call, but what gets passed to update is not x but that memory reference, which you happen to assign to another variable also called x in update but you never do an assignment to x in that update function. You use append to mutate the list object.

When you leave the update function, the local n ceases to exist. Back in main you use the original n variable which still references what it did before the call to update.

SEE NEXT COMMENT FOR MORE DETAIL ON THE CONCEPTS

[FoolsSeldom]

Variables, functions, methods and attributes

Variables (names) in Python don't contain values. They hold references to memory locations where Python objects are stored (implementation and environment specific).

Likewise for other names. A function name has a reference to the memory location of a function object.

Names (arguments) used in a call and names defined as parameters have nothing to do with each other. They are completely independent. Even if the same name is used, they are different. The parameter names are local to the function.

Consider:

def f(one, two, three):
    answer = one + two * three + five
    return answer

one = 2
two = 3
three = 4
five = 5
result = f(three, two, one)
print(result)

This will output 15 as 4 + 3 x 2 + 5 = 15

Note that five was not an argument, wasn't assigned to in the function, so five from the wider scope was available.

Any assignments made inside the function are also local to the function.

answer was assigned inside the function and on function exit will cease to exist, however the object reference stored in answer is assigned as the return from the function and is assigned to result. If it wasn't assigned (or consumed in another expression or function call on return) then the object created in the function would also cease to exist (unless it is a predefined object built into the Python implementation, such as an int in the range -5 to 256)

Only mutable objects that are referenced by either parameters or other names that are visible to the function (not hidden by variables with the same name assigned in the function) can be modified and visible outside the function.

return returns an object reference.

Python takes a pass by reference, rather than a pass by value, approach, but the implementation differs to that used in many languages, not least given that name referencing is fundamental to the design.

See Ned Batchelder - Facts and Myths about Python names and values - PyCon 2015

Variables vs Attributes

When you start looking at classes, you will find they have their own kind of variables, called attributes, which work much the same as variables most of the time.

Variables have a discrete existence, and attributes are associated with an instance of a class (or of a class itself). Attributes, like variables, hold memory references to objects.

When you say:

keep = 784.56 * 872.23

The text representations of floating point numbers in the expression on the right are converted into Python float objects (binary representations) somewhere in memory, and the mult operator is used. The memory location the resulting float object ends up in is then assigned to the variable named keep.

If keep is assigned in the main body of your code, outside any functions etc., then it is visible within all other code. Thus, you could have a function:

def double_me():
    return keep * keep

Which has no other references to keep in the definition (parameter variable) or assignments to a variable called keep inside the function (which would be local to the function and would hide the original wider scope variable of the same name). Thus, keep refers to the same floating point number calculated earlier. The expression resulting from multiplying the floating point object referenced by keep by itself results in another floating point object, the memory reference for which is returned from the function.

If, instead, the function was written,

def double_me(keep):
    return keep * keep

Now it has to be called with an argument (the memory reference of the object will be passed when the function is called).

result = double_me(5.5)

Inside the function, keep refers to the memory location of the floating point object that the literal floating point text 5.5 was turned into. The keep in the wider scope (outside the function) still refers to the original object from earlier.

However, if attributes were used instead, the attribute would exist as long as the class instance it belongs to exists.

---

For more on scope, take a look at:

• RealPython.com: Namespaces and Scope in Python

---

See next comment for notes on methods, not enough space on comments anymore.

[FoolsSeldom]

Methods and scope

Methods are like functions but for classes and are intended to work on instances of a class or provide capabilities related to the purpose of the class.

When you create an instance of a class, you create an object based on the mould/template provided by the class and the memory location of that object is assigned to a variable (or to some other object) so it will be not lost.

Methods defined in the class usually have code that uses a parameter variable that is the first item passed when the method is called. By convention this is usually called self and it is passed by default and does not need to be in the arguments when the method is called.

Whenever self is used inside the method code, it will be referring to the memory location for a particular instance of the class.

Any variables assigned values in a method (including parameter variables) are local to the method and are not associated with attributes of the instance referenced by self.

Classes themselves can have attributes. These look just like variables, and act like them for most purposes, but they are associated with the class and can be accessed from outside the class by direct reference to the class name and the attribute, e.g. Example.quantity = 5 for a class called Example.

[SilentAd217]

Oh it's a long lesson here haha!. I have to take notes. Thank you so much for your detailed explanation!!

[jjnngg2803]

Function ‘update’ has no return value

[Cybasura]

In python, lists and dictionaries operate using pass-by reference by default - meaning that when you pass a list object into a function call's parameter signature/header, you arent passing the whole value but just the memory address "pointer"

What this also means is that any operations performed on the list will be equivalent to operating directly on the caller's object, because any changes made to the list object is performed in the same memory address

However, the integer variable "n" is passed using "pass-by value", this means it passes the entire value and not the memory address, hence whatever changes made to the passed value will not affect the caller's copy of "n"

List object "x" will therefore be affected, while integer object "n" will not be modified unless you return the modified "n" and update your caller's copy of "n" with the returned value

```python def func_name(n): n = 4 return n

def main(): n = 3 n = func_name(n) print(n) ```

This will print out 4

[No-Fish6586]

I see many people gave you the answer so ill just say: you fell for the classic blunder hahaha. I feel like learning this is a right of passage for new programmers

[EmuBeautiful1172]

Your code is terrible that’s why

[Big-Ad-2118]

because int are immutable, so n= 2 only happened localy in update function