Global variables not working

[hobbyist]

I have made some global variables. A simplified version of the program (but with the same rationale) is this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

sentence_1 = "hello" sentence_2 = "hello"   class MyClass:     def __init__(self, parent = None):         # do something         function_A()         function_B()           def function_A:             # do something ...             global sentence_1 = "new string 1"           def function_B:             # do something ...             global sentence_2 = "new string 2"

The problem I face is that although I use, or not use the word global, the sentence_1 and sentence_2, they do not change, but the initial strings "hello" remain. Do I miss something here?

[ndc85430]

Why do you want global mutable things in the first place? That leads to code that's hard to follow and maintain.

[hobbyist]

Why do you want global mutable things in the first place? That leads to code that's hard to follow and maintain.

So, you imply return variables of each function?

[buran]

So, you imply return variables of each function?

Let's start by saying you have SyntaxErrors in your code. Then, if it was just functions it's better to take arguments and then return the result.

Because it is a supposedly class (i.e. OOP) you can add and use attributes. But before that you need to fix the structure of your class (e.g. make the functions methods, not nested functions inside __init__() method. And if the functions don't need access to instance or class, you should ask yourself does it really belong to the class.

This makes it easier to debug and test your code, reuse it and so on.

---

Do I miss something here?

Also, what you have here is just the class definition, you never instantiate your class so that it execute (after you fix the multiple problems)

So this work, but it's BAD code and you should not do it:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

sentence_1 = "hello" sentence_2 = "hello"    class MyClass:     def __init__(self, parent = None):         # do something           def function_A():             # do something ...             global sentence_1             sentence_1 = "new string 1"            def function_B():             # do something ...             global sentence_2             sentence_2 = "new string 2"           function_A()         function_B()     spam = MyClass() print(sentence_1) print(sentence_2)

[deanhystad]

Do you understand what global does? Do you understand the concept of scope?

You can think of scope as a kind of dictionary that stores names. When you use a variable Python searches for the name in these scope dictionaries. Every function has a scope. Every module (file) has a scope. Python has a scope. The scopes even have names; Local for the function scope, Global for the module scope, and Built-in for the Python scope. There is an additional scope called Enclosing which occurs if you define functions inside of functions.

When you use a variable in your code Python searches for the variable in these scopes. The order of the search is Local, Enclosing, Global, Built-in. If you read about scope you may see this order referred to as LEGB. This is why ndc85430 asked why you are using the global keyword to use a mutable variable. Global variables are visible for use in any function defined in the module. However ndc85430 is wrong about "sentence_1" being mutable. "sentence_1" is a string, and strings are not mutable in Python.

When you assign a variable in your code Python creates the variable in the current scope. If your function uses the "global" keyword to declare the variable, the assignment creates the variable in the global scope. Your code would work if you got the syntax correct.

1 2 3 4

def function_A:     # do something ...     global sentence_1     sentence_1 = "new string 1"

You would know this if you ever bothered to read the Python documents before using new language features. If all your learning is focused on tutorials or looking at examples you risk never learning about how things work and why they work this way. The Python documents explain how a language feature fits into the Python puzzle. If you start reading the docs not only will you have fewer questions, but you will get a deeper understanding of Python and grow an intuition about why something is not working.

buran's suggestion about using attributes is a good one. In a class not only can you think of a scope as being a dictionary, it is a dictionary in the literal sense. An attribute is a variable defined in the context of the class. You use a special syntax to access these variables. From inside the class you use "self.name" to access the "name" attribute. From outside the class you use "instance.name" where "instance" is the name of a variable that references an instance of the class.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class MyClass:     def __init__(self):         """Use docstring notation instead of # as the header comment"""         self.sentence_1 = "Hello"         self.sentence_2 = "World"        def function_A(self):         # do something ...         self.sentence_1 = "Goodnight"        def function_B(self):         # do something ...         self.sentence_2 = "moon"       def __repr__(self):         return f'{self.sentence_1} {self.sentence_2}!'   a = MyClass() print(a) print(a.sentence_1) print(a.sentence_2) a.sentence_2 = 'sun' print(a) a.function_A() a.function_B() print(a)

The most useful thing about classes is that each instance gets their own namespace that they carry around wherever they go. If I create another instance of MyClass and assigned to the variable "b", I now have two instances of the class that are independent of each other. Changing attributes in "a" does not affect the corresponding attribute in "b". This is something that would be very difficult to do using just functions and modules.

Output:
Hello World!
Hello
World
Hello sun!
Goodnight moon!

[buran]

@deanhysted, in order to make it more versatile, you can pass initial values for attributes in the __init__()

[ndc85430]

No, I'm perfectly aware that strings aren't mutable. I was referring to the fact that variables can be reassigned.

[deanhystad]

Then I am confused by your comment "Why do you want global mutable things in the first place?" The OP contained global strings which are immutable. I thought the mistake odd for you but see no other way to interpret the comment.

[hobbyist]

Do you understand what global does? Do you understand the concept of scope?

You can think of scope as a kind of dictionary that stores names. When you use a variable Python searches for the name in these scope dictionaries. Every function has a scope. Every module (file) has a scope. Python has a scope. The scopes even have names; Local for the function scope, Global for the module scope, and Built-in for the Python scope. There is an additional scope called Enclosing which occurs if you define functions inside of functions.

When you use a variable in your code Python searches for the variable in these scopes. The order of the search is Local, Enclosing, Global, Built-in. If you read about scope you may see this order referred to as LEGB. This is why ndc85430 asked why you are using the global keyword to use a mutable variable. Global variables are visible for use in any function defined in the module. However ndc85430 is wrong about "sentence_1" being mutable. "sentence_1" is a string, and strings are not mutable in Python.

When you assign a variable in your code Python creates the variable in the current scope. If your function uses the "global" keyword to declare the variable, the assignment creates the variable in the global scope. Your code would work if you got the syntax correct.

1 2 3 4

def function_A:     # do something ...     global sentence_1     sentence_1 = "new string 1"

You would know this if you ever bothered to read the Python documents before using new language features. If all your learning is focused on tutorials or looking at examples you risk never learning about how things work and why they work this way. The Python documents explain how a language feature fits into the Python puzzle. If you start reading the docs not only will you have fewer questions, but you will get a deeper understanding of Python and grow an intuition about why something is not working.

buran's suggestion about using attributes is a good one. In a class not only can you think of a scope as being a dictionary, it is a dictionary in the literal sense. An attribute is a variable defined in the context of the class. You use a special syntax to access these variables. From inside the class you use "self.name" to access the "name" attribute. From outside the class you use "instance.name" where "instance" is the name of a variable that references an instance of the class.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class MyClass:     def __init__(self):         """Use docstring notation instead of # as the header comment"""         self.sentence_1 = "Hello"         self.sentence_2 = "World"        def function_A(self):         # do something ...         self.sentence_1 = "Goodnight"        def function_B(self):         # do something ...         self.sentence_2 = "moon"       def __repr__(self):         return f'{self.sentence_1} {self.sentence_2}!'   a = MyClass() print(a) print(a.sentence_1) print(a.sentence_2) a.sentence_2 = 'sun' print(a) a.function_A() a.function_B() print(a)

The most useful thing about classes is that each instance gets their own namespace that they carry around wherever they go. If I create another instance of MyClass and assigned to the variable "b", I now have two instances of the class that are independent of each other. Changing attributes in "a" does not affect the corresponding attribute in "b". This is something that would be very difficult to do using just functions and modules.

Output:
Hello World!
Hello
World
Hello sun!
Goodnight moon!

Many thanks, it finally works!!

Also thanks to everyone else who responded and helped me !!

[jefsummers]

And one thing that has been talked around but not sure if it has been pointed out directly - it is generally a very bad idea for a function in a class to directly access data that is outside of the class. If you were to try to reuse the class by importing into a different file, there could be serious confusion about the errors that arise.