DEV Community: Samiksha Srivastav

global and nonlocal in Python (The Concept That Finally Made Scope Click for Me)

Samiksha Srivastav — Thu, 21 May 2026 16:07:08 +0000

While learning Python scopes and closures, I reached two keywords that looked very similar initially:

global
nonlocal

At first, both felt like:
"Okay... both are just used to access outer variables."

But once I understand how Python internally handles variable assignment and scope, the difference became much clearer.

So here's my attempt to explain them in the simplest way possible.

First, Why Does This Error Happen?

Let's start with this example:

This gives:

UnboundLocalError

At first, this feels confusing because: x already exists globally.
So why is Python complaining?

What Python Internally Thinks

Whenever Python sees:

x = something
inside a function, it automatically assumes:

So internally this becomes:
local x = local x + 1

And now the problem becomes obvious:

the local x does not exist yet
but Python is trying to use it first

Hence: UnboundLocalError

Enter global

Now look at this:

Output:
11

What Did global Actually Do?

global x tells Python:

Do not create a local variable.
Use the global one instead.

So now the actual global variable gets modified.

Important Thing Most Beginners Miss

You do NOT need global to READ a global variable.

This works perfectly fine:

**x = 10

def test():
print(x)**

But:
the moment you MODIFY it,
Python tries creating a local variable.

That’s where global becomes necessary.

Now Comes nonlocal

This one confused me even more initially
Because it looks similar to global, but works differently.

Example

Again: UnboundLocalError

Same reason:
Python thinks x is local to inner().

Enter nonlocal

Output: 11

What nonlocal Actually Means

nonlocal x tells Python:

This variable belongs to the enclosing function scope.
Do not create a local copy.

So instead of creating a new local variable:
- Python modifies the outer function’s variable directly.

The Core Difference

global Targets: global scope
nonlocal Targets: enclosing function scope

Visual Understanding

x = "global"

def outer():

y = "outer"

def inner():

    z = "inner"

Here:

x --> global scope
y --> enclosing scope
z --> local scope

So:

global works with x
nonlocal works with y

Why nonlocal Matters So Much

Because closures depend on it.

Example:

def counter():

count = 0

def increment():

    nonlocal count

    count += 1

    return count

return increment

Now:

c = counter()

print(c())
print(c())
print(c())

Output:

1
2
3

The inner function keeps remembering and modifying the outer variable.

That’s where closures and nonlocal connect beautifully.

One-Line Understanding

global --> modifies global scope variable
nonlocal --> modifies enclosing function variable

Final Thoughts

Initially, both keywords looked almost identical to me.

But once I understood:

- how Python creates local variables,
- how assignment works internally,
- and how scopes are connected,

the difference became much more intuitive.

And honestly, understanding these concepts made closures and Python scopes feel way less “magical” and much more logical.

Understanding Scope and Closures in Python

Samiksha Srivastav — Thu, 14 May 2026 14:28:40 +0000

I was comfortable with Python scopes pretty quickly.

But when I reached closures, my first reaction was:
“How is this even possible?”

An inner function remembering variables after the outer function has already finished execution felt really confusing at first.

But after understanding how Python handles memory and scope internally, closures finally became much easier to understand.

So here’s the explanation that helped me the most.

First, What is Scope?

Scope simply means:

“Where can a variable be accessed from?”

Python mainly works with different scopes like:

Global scope
Local scope
Enclosing scope

Let’s see a simple example:

Here:

x can be accessed almost everywhere because it is global
y only exists inside the function

Once the function finishes execution, y disappears from memory.

That part is straightforward.

Now Comes Closures

Closures become interesting when:

a function exists inside another function
and the inner function uses variables from the outer function

Example:

At first glance, this might look normal.

But something very important is happening here.

What happens?

outer() starts execution
x = 10 is created
inner() function is created
inner gets returned

Normally, after a function finishes execution, its local variables should disappear.

So technically: x should have been destroyed.

the inner() function is still using x
So instead of deleting it, Python preserves that variable in memory.
Even though outer() has already finished execution.

How?

Because the inner function remembered the variable from its outer function.

And this is exactly what a closure is.

Simple Definition of Closure

A closure is:

A function that remembers variables from its outer scope even after the outer function has finished execution.

Or even more simply:

Closure = Function + Remembered Environment

Why This Feels Special

Normally, local variables disappear after function execution ends.

But in closures:

Python keeps those variables alive
because another function still needs them

That’s the “magic” behind closures.

Let's take a real example - Counter
This example can make closures finally click for us:

and output is:
1
2
3

What’s Happening Here?

Every time increment() runs:

it still remembers the old value of count
even though counter() already finished execution long ago

That remembered state is preserved because of closure.

And: nonlocal allows us to modify that outer variable.

Important Confusion

Not every nested function is a closure.

A closure only exists when:
the inner function remembers variables from the outer function.

Why Closures Matter

Closures are heavily used in:

decorators
callbacks
state management
function factories

Even many advanced Python features internally depend on this concept.

End Game

At first, closures looked very confusing to me because the outer function had already finished execution.

But once I understood that Python preserves variables in memory when inner functions still need them, the concept became much clearer.

It’s one of those topics that feels “magical” initially, but very logical once broken down step by step.

str() vs repr() vs print() in Python

Samiksha Srivastav — Mon, 11 May 2026 03:07:53 +0000

While learning Python, I came across three things that look very similar at first:

str()
repr()
print()

Initially, I thought all of them simply display output.
But after exploring deeper, I realized they actually serve different purposes.

The Core Idea

str() ---> user-friendly representation
repr() ---> developer/debugging representation
print() ---> displays output on the screen

Let's understand the things in detail

str() is used when we want output that is clean and readable for humans.

Here, Python gives us a simple readable version of the object.

But, repr() is different.

It tries to show the exact representation of the object - the way Python internally sees it.

Notice something interesting?

Quotes are visible here.

That's because repr() is meant more for developers and debugging.

A Better Example

Now let’s take a string containing a newline character:

But using repr()

What’s Happening Here?

str() shows the readable version
repr() shows the raw/internal representation

That’s why \n is visible inside repr().

So What Does print() Do?

print() is simply used to display output.

If you have noticed....Internally, print() usually uses str() to display objects.

Final Understanding

Function | Purpose
str() | Human-readable output
repr() | Developer/debugging output
print() | Displays output

Final Thoughts

At first, these functions looked almost identical to me.

But understanding the difference between readable output and internal representation made Python behavior much clearer — especially for debugging and understanding objects deeply.

Small concept, but very powerful.

Understanding Mutable and Immutable Objects in Python

Samiksha Srivastav — Wed, 06 May 2026 14:44:48 +0000

Now let's discuss mutable and immutable objects in Python.

First,

Mutable means something that can change
Immutable means something that cannot change

So, any data or object whose value can be changed after creation is called mutable, and those which cannot be changed are called immutable.

It's All About Memory
What does "change" actually mean here?

This concept is all about how values are stored in memory.

Let’s Take an Immutable Data Type (Integer)
Let’s understand this with an example in the Python shell:

But Wait…

We know that integers are immutable,
so how are we able to “change” the value of int_2?

What’s Actually Happening?
When we create int_1 = 5, a value 5 is stored in memory, and int_1 refers to it
When we assign int_2 = int_1, both variables refer to the same memory location (value 5)
But when we do int_2 = 8, we are not modifying 5

Instead, Python creates a new object (8) in memory,
and now int_2 starts referring to this new location

While int_1 still refers to the original value 5

Key Insight

Immutable objects cannot be changed in place.
Any “change” actually creates a new object in memory.

What About Mutable?

Mutable objects (like lists, dictionaries, etc.) can be changed directly without creating a new object.

Final Thought

So, mutable vs immutable is not just about “change” -
it’s about how Python handles memory and references internally.

If you’re learning Python, follow along - I’m sharing my journey step by step.

Day-2 of learning Python | Exploring Python Shell and Module Reloading

Samiksha Srivastav — Tue, 05 May 2026 14:28:45 +0000

While learning python today, I spent some time understanding how the Python shell works and how modules behave inside it.

The Python shell (or REPL) is basically an interactive environment where you can run code line-by-line. It's super useful when you just want to test something quickly instead of running a full script every time.

While experimenting, I tried something interesting. I created a Python file, defined a few functions and variables in it, and then imported that file into the Python shell. everything worked perfectly at first.

But then I made some changes in the file - added few functions and modified a few existing ones - and tried to use them again in the shell. Surprisingly, I started getting errors.

At first, it felt confusing because I had clearly updated the code. But then I learned what was actually happening behind the scenes.

When we import a module in Python, it gets loaded into the memory once. So even if we change the file later and save them, the Python shell doesn't automatically pick up those changes.

To fix this, Python provides a way to reload the module using the importlib module:

import importlib
importlib.reload(module_name)

This forces Python to reload the module and reflect the latest changes.

It was a small thing, but understanding this made the behavior of Python much clearer to me. It also showed me how important it is to know what's happening internally, not just write code.

Getting Started with Python

Samiksha Srivastav — Mon, 04 May 2026 14:45:53 +0000

Today I started learning Python, and I explored some fundamental concepts that helped me understand how Python actually works behind the scenes.

What is Python?

Python is a high-level, interpreted programming language.

Being high-level means it is easy to read and write, as it is closer to human language and abstracts away hardware complexity.
This makes it very different from low-level languages like assembly or machine language, which directly interact with hardware.

Is Python Really Interpreted?

We often hear that Python is an interpreted language, but there is a bit more to it.

Python actually works in two main steps:

Compilation to Bytecode
First, Python converts your code into an intermediate format called bytecode.
Execution using Python Virtual Machine (PVM)
This bytecode is then executed by the Python Virtual Machine (PVM.)

This process is what makes Python both flexible and easy to debug.

What is pycache?

While running Python programs, you might notice a folder named pycache.

It stores compiled bytecode files(.pyc)
These files help Python run faster when the program is executed again
This process is usually automatic and hidden from developers

Key Takeaways

Python is easy to read and beginner-friendly
It is interpreted but internally uses bytecode
Execution happens through the Python Virtual Machine (PVM)
pycache improves performance by storing compiled code

Final Thoughts

Understanding what happens behind the scenes makes learning Python much more interesting. This is just the beginning of my journey, and I'm excited to explore more.

Follow my journey as I continue learning and building in Python!