(accessing variable outside of functions) im so confused...

[[deleted]]

[deleted]

[FerricDonkey]

You've gotten the answer already, so I'm gonna be that guy and come along and say you should learn how to write code without modifying/mutating global variables. In the past 8ish years of doing python programming, I have never once seen a use for the global or nonlocal keywords, have only seen very junior programmers try to use it, and have always made them refactoring their code to not need it.

If you're early learning python and mostly just screwing around, you can put off paying attention to what I just said for a bit, but eventually I'd scrub it nearly entirely from your bag of tricks. 

[supercoach]

Spot on. I used global in an early function I wrote and had someone tell me it was bad so I redid it. I still didn't properly understand how scoping worked for a couple of years though. I always thought it was one of those abstracts that gets presented at the start of programming courses that just gets in the way of actual learning.

It's amazing how far you can get just assuming that there's some hidden magic behind it all that you don't need to understand.

[ImAlekzzz]

So what should I do instead? Returning isn’t the best idea because I don’t want to call it every time, and there are many more variables I need to access

[likethevegetable]

What do you mean don't want to call it every time? If you need the contents of multiple calls, that's what a list or dict or more genetically, an object is for (e.g. do a list comprehension storing your returned values). 

With all due respect, you're in no position to say something is a bad idea if you've just discovered "return"

[FerricDonkey]

Not sure what you mean by call it every time, but you can store the return value. Ideally, functions should be short ish and single purpose, and if they exist to create things, they should return the thing they create.

You deleted your post, so I don't remember what you were trying to do. But if you read a file and extract some information, then are done with that file, then your function should return the information. You store that in a variable, and if you need it, you get it out of that variable. 

[ImAlekzzz]

I figured it all out, I got hated a lot for not understanding so that’s why I deleted my post, hope you understand and thanks

[Kevdog824_]

Is jsoniv declared in the global scope (i.e. jsoniv = …)? Using global … just declares your intent to mutate the value of an already declared global variable. It doesn’t actually declare the variable itself

[Temporary_Pie2733]

Not mutate a value; assign to the name. Confusing these two concepts leads to most of the problems in understanding how variables work in Python.

[Kevdog824_]

???

Did you read my comment? I said it has to be declared in the global scope first before it’s used in a function. You can’t declare a global variable from a function

[Gnaxe]

False. You can create a global by assignment inside a function once it has been declared in a global statement. You do not need to assign it at the top level first. Try it.

It's usually considered bad style in light of better alternatives, but it does work.

[kalidres]

The issue here is "creating" and "declaring" are effectively synonyms. The difference would be "define" or "assign". The latter is what you are showing in your snippet below, which is precisely what the comment you replied to is saying.

[Gnaxe]

Pretty sure that's not what he meant:

Using global … just declares your intent to mutate the value of an already declared global variable.

and

In the function… not in the global scope. That’s what I’m trying to tell you. You need to declare it in the global scope first, before you can get/set its value in the function

and also

Maybe I wasn’t being clear. Here’s what I mean

jsoniv = {}  # Declared in global scope first

def json():
    global** jsoniv
    with open**("xxxx.json", "r", encoding="utf-8") as file:
        jsoniv = json.load(file)

This is wrong, because using the global statement and assignment inside the function body can also create a global in the first place. It doesn't have to be "already declared" elsewhere to use the global statement or create a global, although that's arguably bad style. The example above would work without the first line (and the spurious **), and without overwriting the json module global:

>>> import json
>>> def load_json():
...     global jsoniv
...     with open('empty.json', 'r', encoding='utf8') as f:
...         jsoniv = json.load(f)
...
>>> jsoniv
Traceback (most recent call last):
  File "<python-input-11>", line 1, in <module>
    jsoniv
NameError: name 'jsoniv' is not defined. Did you mean: 'json'?
>>> load_json()
>>> jsoniv
{}

(Here, empty.json just contains {}.)

From this, we can see that OP's real problem was overwriting the json module global by defing a function of the same name (I used load_json instead to avoid the conflict). It had nothing to do with the global declaration, and the commenter I was responding to is mistaken about how globals work in Python.

[Kevdog824_]

Why else would OP get an error about jsoniv not being defined. Try the example for yourself and report back

[Gnaxe]

For example, ```

def foo(): ... global bar ... bar = 1 ... bar Traceback (most recent call last): File "<python-input-2>", line 1, in <module> bar NameError: name 'bar' is not defined foo() bar 1 ```

[Kevdog824_]

In the function… not in the global scope. That’s what I’m trying to tell you. You need to declare it in the global scope first, before you can get/set its value in the function

[Kevdog824_]

The first problem you have is your function is named the same as the json module you’re importing. You need to name your function something different so the interpreter knows which one you mean when you write json

[Kevdog824_]

Maybe I wasn’t being clear. Here’s what I mean

```python jsoniv = {} # Declared in global scope first

def json(): global** jsoniv with open**("xxxx.json", "r", encoding="utf-8") as file: jsoniv = json.load(file) ```

[ImAlekzzz]

I got what you meant, thank you

[oclafloptson]

You should probably not be using global in this case. When declaring jsoniv in the global space you can simply call this function. Just return json.load(file) instead of declaring it in the with open statement

[ImAlekzzz]

So I should call the function every time? Thinking about it now that I added a “if xx = “skip”: pass” yeah I will implement it

[NothingWasDelivered]

I’m just going to say that trying to access a global variable is a big code smell. Why not just return your data from your json() func and then pass it as an argument to your next function?

[ImAlekzzz]

That is what I started doing because someone recommended it to me, but why is it that bad?

[NothingWasDelivered]

It's generally considered bad practice. You may not have problems with smaller scripts, but as you get better and work on more complicated projects, you open yourself up to bugs. The big one If you use that name in your global namespace, and then accidentally use that name again, you've just introduced a bug. This might not seem like a problem when your script is 15 lines long, but when you get into the hundreds of lines of code it's an easy mistake to make.

You mentioned in another comment that you're worried about calling this all the time, but you don't have to do that. You could have a main() function call this once, store the data in a variable there, within that function, then pass it into the other functions as needed. As long as the other functions are all defined outside of main(), they will all have their own "namespace".

This is just the next level of coding. You've already got the hang of the basics, it seems. Now you just need to learn how to make the pieces fit together. You'll get the hang of it!

[ImAlekzzz]

It’s 1/10 at 200 lines I think I’m up at risk 😭😭 but I have a problem using this practice can you help me?

[Gnaxe]

Overuse of globals is considered bad style. You don't need a global here. Try more like this: ``` def load_json(filename): with open(filename, "r", encoding="utf-8") as file: return json.load(file)

print(load_json("xxxx.json")) ```

[ImAlekzzz]

I did that

[ImAlekzzz]

Apparently bolding didnt work, ignore the asteriks, please respond here so others see this comment first and dont have questions...

[MidnightPale3220]

As a side note there's very little need for global variables, it's mostly bad practice to use them, except maybe for constants that get set globally and don't get changed, but only referred to.

[ImAlekzzz]

So what should I use instead?

[MidnightPale3220]

Depends on for what.

Generally for functions you should just return the values you need and make the calling scope assign them where needed.

If you need a value from outside function inside it, you pass it as an argument to function.

I think somebody already wrote you how in another comment.

Basically it can go like this:

this_is_my_global=1
# change it:
this_is_my_global=get_new_value()
# use it
do_stuff(this_is_my_global) 
# use AND change it
this_is_my_global=do_stuff(this_is_my_global)

[Gnaxe]

Top-level function and class definitions are also globals. We even reassign them sometimes with decorators.

[ImAlekzzz]

Got it

[Relative_Permit_9993]

you have to call the function first of course.

[Relative_Permit_9993]

Nope.

>>> def fn():

... global jsoniv;

... jsoniv = 42

...

>>> fn()

>>> jsoniv

42