What is the problem with shadowing names defined in outer scopes?

The currently most up-voted and accepted answer and most answers here miss the point.

It doesn't matter how long your function is, or how you name your variable descriptively (to hopefully minimize the chance of potential name collision).

The fact that your function's local variable or its parameter happens to share a name in the global scope is completely irrelevant. And in fact, no matter how carefully you choose you local variable name, your function can never foresee "whether my cool name yadda will also be used as a global variable in future?". The solution? Simply don't worry about that! The correct mindset is to design your function to consume input from and only from its parameters in signature. That way you don't need to care what is (or will be) in global scope, and then shadowing becomes not an issue at all.

In other words, the shadowing problem only matters when your function need to use the same name local variable and the global variable. But you should avoid such design in the first place. The OP's code does not really have such design problem. It is just that PyCharm is not smart enough and it gives out a warning just in case. So, just to make PyCharm happy, and also make our code clean, see this solution quoting from silyevsk's answer to remove the global variable completely.

def print_data(data): print data def main(): data = [4, 5, 6] print_data(data) main() 

This is the proper way to "solve" this problem, by fixing/removing your global thing, not adjusting your current local function.

A good workaround in some cases may be to move the variables and code to another function:

def print_data(data): print data def main(): data = [4, 5, 6] print_data(data) main() 

It depends how long the function is. The longer the function, the greater the chance that someone modifying it in future will write data thinking that it means the global. In fact, it means the local, but because the function is so long, it's not obvious to them that there exists a local with that name.

For your example function, I think that shadowing the global is not bad at all.

I think this rule doesn't help much. I simply disabled it by going to Settings -> Editor -> Inspections and then checking off this rule: Shadowing names from outer scope

I like to see a green tick in the top right corner in PyCharm. I append the variable names with an underscore just to clear this warning so I can focus on the important warnings.

data = [4, 5, 6] def print_data(data_): print(data_) print_data(data) 

It looks like it is 100% a pytest code pattern.

See:

pytest fixtures: explicit, modular, scalable

I had the same problem with it, and this is why I found this post ;)

# ./tests/test_twitter1.py import os import pytest from mylib import db # ... @pytest.fixture def twitter(): twitter_ = db.Twitter() twitter_._debug = True return twitter_ @pytest.mark.parametrize("query,expected", [ ("BANCO PROVINCIAL", 8), ("name", 6), ("castlabs", 42), ]) def test_search(twitter: db.Twitter, query: str, expected: int): for query in queries: res = twitter.search(query) print(res) assert res 

And it will warn with This inspection detects shadowing names defined in outer scopes.

To fix that, just move your twitter fixture into ./tests/conftest.py

# ./tests/conftest.py import pytest from syntropy import db @pytest.fixture def twitter(): twitter_ = db.Twitter() twitter_._debug = True return twitter_ 

And remove the twitter fixture, like in ./tests/test_twitter2.py:

# ./tests/test_twitter2.py import os import pytest from mylib import db # ... @pytest.mark.parametrize("query,expected", [ ("BANCO PROVINCIAL", 8), ("name", 6), ("castlabs", 42), ]) def test_search(twitter: db.Twitter, query: str, expected: int): for query in queries: res = twitter.search(query) print(res) assert res 

This will be make happy for QA, PyCharm and everyone.

data = [4, 5, 6] # Your global variable def print_data(data): # <-- Pass in a parameter called "data" print data # <-- Note: You can access global variable inside your function, BUT for now, which is which? the parameter or the global variable? Confused, huh? print_data(data) 

To ignore the warning, as Chistopher said in a comment, you can comment above it

# noinspection PyShadowingNames 

Do this:

data = [4, 5, 6] def print_data(): global data print(data) print_data() 

It may also be a subtle warning that your function is being defined as in internal function to another, and you did not intend this. Perhaps it's because of bad indenting, which is in turn caused by a lack of caffeine. In other words, you could see this message as reading " your scope is not what you think it is, young Padawan"

In your code, the warning "Shadows 'data' from outer scope" is indicating that the parameter data in the function print_data has the same name as the global variable data. This can potentially lead to confusion or errors in more complex programs, as it's not immediately clear which data is being referred to inside the function.

To resolve this warning, you can simply rename the parameter in the function to something else, like data_list:

data = [4, 5, 6]

def print_data(data_list): print(data_list)

print_data(data)

Now, there's no ambiguity between the global variable data and the parameter data_list within the function.