wispy tundra
Hello, consider this code:
def greet(message):
print(message)
message = "New message"
anotherMessage = "def"
message = "Hello World"
anotherMessage = "abcd"
greet(message)
print(message)
print(anotherMessage)
I was testing if it was possible to produce side effects by modifying other global variables but it seem we can't? Can someone explain why please.
Do we have parameters pass by ref and pass by value in python?
waxen fernBOT
Hello, consider this code:
```py
def greet(message):
print(message)
message...
@wispy tundra
Python help channel opened
plain crypt
you can do it by using the global and nonlocal keywords
without them, any assignment to a variable inside a function makes it create a local variable
"pass by ref and pass by value" does not make sense, a language only uses 1 calling convention, and for python neither of those accurately describe the behavior
its more like "pass by value, where the value is a reference", and whats important is that name = expression is reassignment of the reference, not rewriting the object at that reference if there already is a name variable
signal ice
you can always freely mutate globals without a special declaration, but you cannot reassign
modest dune
Hello, consider this code:
```py
def greet(message):
print(message)
message...
You already got a thorough answer to this like an hour ago. What else is confusing you?
empty onyx
wispy tundra
previous post: https://discord.com/channels/267624335836053506/14222704202493503...
from dataclasses import dataclass
@dataclass
class Container:
x: int
def modify_x(container: Container):
container.x += 1
c = Container(0)
print(c)
modify_x(c)
print(c)
Can you explain how this work pls, why can't we use global here for e.g?
signal ice
that's a mutation
empty onyx
You can, that was just an example of how, in your original message, you were passing message in to be mutated
signal ice
it's modifying an attribute of an object
tawny valve
@wispy tundra note that many of pythons data types such as bool, int, float, string, tuple and frozenset (to name some of those i can name on top of my head) are not internally mutable, so all you can do to "change" such a variable is to reassign it to a new object (because all data types in python are objects)
wispy tundra
yep I see, so in python , we don't really have the concept of pass by ref or pass by value? Even though we say everything are objects, we don't use references of the objects? Like for e.g when I try to mutate message for e.g
tawny valve
yep I see, so in python , we don't really have the concept of pass by ref or pas...
think of variables as a label that points to the address that stores the object data, and when you assign to a variable you move that label to point to another address to another object
modest dune
yep I see, so in python , we don't really have the concept of pass by ref or pas...
If you're coming from C++, the word "reference" is used a bit differently. Imagine that in Python, everything is passed as a pointer to an object, and the pointer self-dereferences on use. Reassigning a pointer within the function doesn't affect anything outside of the function.
tawny valve
if you instead pass in an object that is internally mutable such as a list, set or a dict for example you can mutate its content as normal within other scopes, or even access such a global variable without declaring it as global and still mutate it internally as normal as long as you don't try to assign directly to the variable
wispy tundra
yepp, I see, will read a bit and came back, but I have an overview now, ty !
For the Container, the idea is instead of using an immutable object, like a number, create a class and from that class, the objects will be mutable objects, like container.x is a mutable obj compared with just something like x = 10?
tawny valve
For the `Container`, the idea is instead of using an immutable object, like a nu...
yes, you are creating an internally mutable object that will hold attributes that you can mutate as you wish
the variable is just pointing to the address of the class instance (object), as long as you don't assing to the variable holing it you'll be fine
wispy tundra
yupp I see, thanks !
sorry once more for the post earlier, didn't saw it was close 😭 , I understand things a bit more now, thanks !
modest dune
sorry once more for the post earlier, didn't saw it was close 😭 , I understand ...
Sorry if my tone was negative when I pointed that out. It's not uncommon for people to post questions, and then ignore all replies.
wispy tundra
Sorry if my tone was negative when I pointed that out. It's not uncommon for peo...
nan no worries, I will try to be more attentive next time, what matters is I have an overview of how immutable and mutable objects now work in python :c
By the way quick question, we did say something is immutable, but when we use global, we are just creating another label/reference to that variable?
Under the hood it's behaving like the container?
tawny valve
remember that there aren't any primitive data types in python, every variable is a reference to an object (and as Carcigenicate so well described it above, you can view it as if they are always automatically self-dereferencing)
wispy tundra
yupp I see
modest dune
By the way quick question, we did say something is immutable, but when we use `g...
global affects how the function is compiled. Without a global statement, if there's an assignment in the function to a variable, all reads and assignments to the variable are compiled as local variable operations. If you include a global statement to the name, reads/assignments are compiled as instructions that also look the name up in the global scope. So, it doesn't create a new name, but changes how names are looked up.
On second read, I'm not sure if I interpreted your question correctly.
wispy tundra
nope, it was the answer I was looking, how global works, I understand now, with global keyword, we just change the rules of how the interpreter sees things ?
modest dune
!e
from dis import dis
a_name = 1
def no_global():
a_name = 2
print(a_name)
def with_global():
global a_name
a_name = 2
print(a_name)
dis(no_global)
dis(with_global)
You can actually see this if you want to investigate
waxen fernBOT
!e
```python
from dis import dis
a_name = 1
def no_global():
a_name = 2
...
:white_check_mark: Your 3.13 eval job has completed with return code 0.
001 | 5 RESUME 0
002 |
003 | 6 LOAD_CONST 1 (2)
004 | STORE_FAST 0 (a_name)
005 |
006 | 7 LOAD_GLOBAL 1 (print + NULL)
007 | LOAD_FAST 0 (a_name)
008 | CALL 1
009 | POP_TOP
010 | RETURN_CONST 0 (None)
... (truncated - too many lines)
Full output: https://paste.pythondiscord.com/AHKXGMQD7LGAEFBUVNVG2B3CGA
tawny valve
oh, and if you have a global statement in the function for a variable it affects variable assignments even before that line inside that scope
modest dune
dis compiles and then disassembles the Python to human-readable bytecode. LOAD_FAST is a lookup of local variables, while LOAD_GLOBAL is, as the name implies, a global lookup.
waxen fernBOT
Python help channel closed for inactivity