How to understand dynamic scoping using Python code?

Question

I'm a programmer coming from Python background which typically uses lexical scoping and I want to understand dynamic scope. I've researched it on-line, still unclear to me. For example, I've read this page which made things a lot easier to me, especially the code snippets:

#In Dynamic scoping: 
 const int b = 5; 
 int foo() 
 { 
 int a = b + 5;
 return a;
 }
 int bar()
 {
 int b = 2;
 return foo();
 }
 int main()
 {
 foo(); // returns 10
 bar(); // returns 7
 return 0;
 }
#In lexical scoping: 
 const int b = 5; 
 int foo() 
 { 
 int a = b + 5;
 return a;
 }
 int bar()
 {
 int b = 2;
 return foo();
 }
 int main()
 {
 foo(); // returns 10
 bar(); // returns 10
 return 0;
 }

As I understand and as you can see, in the dynamic scoping, bar function returns 7 not 10, which means foo called the b variable which is defined within bar, in other words, foo did not looked for the b variable that's defined in top of the code (the first b variable) but rather it used the b variables that's defined in bar.

Q1: Hence, In dynamic scoping, the function that's being called within another function in this case foo called in bar first looks for variables in the caller function in this case bar and then it looks for top level variables ?

Q2: Could you explain dynamic scoping in Python code ?

• Martijn Pieters: Python uses lexical scoping, there is no dynamic scoping. As such we cannot explain dynamic scoping in Python code.
• Martijn Pieters: The answer for Q1 is: yes.
• GIZ: @MartijnPieters about Q1 is this what all dynamic scoping boils down to or is there anything else ?
• Martijn Pieters: That's what it boils down to, yes. Also see Wikipedia.

Answer 1

There is no dynamic scoping in Python, unless you implement your own stack-based 'namespace'.

And yes, dynamic scoping is that simple; the value of a variable is determined by the closest calling namespace where a value was set. View the calls as a stack, and a value is looked up by searching the current call stack from top to bottom.

So for your dynamic example, the stack is first:

foo
main 
globals -> b = 5

finding b = 5 when searching through the stack, and then the stack changes to

foo
bar -> b = 2
main
globals -> b = 5

so b = 2 is found.

• GIZ: So it's possible to find variables even in main function if for example b variable was assigned in main instead of bar ?
• Martijn Pieters: Yes, all scopes on the call stack are included in the search.
• GIZ: And if I called main or any other function outside functions, it'll only look for globals only, correct me if I'm wrong.
• GIZ: I see the point now why very limited people still relying on dynamic scoping as it's very complicated to comprehend, guess if you have about 100 functions in your program, it's really, really difficult to trace every single var, that being said, you need to build a tree of variable chain to understand where the problem is coming from in case of a bug
• Alexey: Aren't Python's context variables (3.7) just dynamically scoped variables?