Python FAQ:

Do Variables in Python hold the actual data or the reference to that data?

In Python, a variable is essentially a named reference to a location in memory where a specific piece of data is stored.

This means that when you create a variable, you are not actually storing the data itself in the variable, but rather a reference to that data.

To illustrate this, let's say you create a variable `x` and assign it the value `10`.

In reality, what's happening is that Python creates an integer object containing the value `10` somewhere in memory, and then assigns the memory address of that object to the variable `x`.

So when you later refer to the variable `x`, Python will use the memory address stored in `x` to locate the integer object containing the value `10`.

This approach has several benefits.

For one, it makes Python memory-efficient, since you can have multiple variables referencing the same piece of data without having to duplicate that data in memory.

It also means that you can easily modify the data by changing what a variable reference.

For example, you could write:

x = 10
y = x
x = 20

In this case, `y` will still reference the integer object containing the value `10`, while `x` now references a different integer object containing the value `20`.

It's important to understand that different data types in Python have different memory requirements.

So the way that variables reference data can affect memory usage.

For example, when you create a list in Python, the list itself is an object that contains references to other objects (i.e. the elements of the list).

For example:

original_list = [1, 2, 3]
copy_list = original_list

print(original_list == copy_list) # True
print(original_list is copy_list) # True

Both are True here.

We can check the id also:

print(id(original_list))
print(id(copy_list))

# Output:
139906917792512
139906917792512

Therefore, If you create a copy of a list by simply assigning it to a new variable, both variables will reference the same list object and its elements.

This can lead to unexpected behaviour if you're not careful.

We will check out this in the next Python FAQ "What is the difference between Deep Copy and Shallow Copy In Pyhton"

In summary, variables in Python hold references to data rather than the actual data itself.

This makes Python memory-efficient and flexible, but it's important to understand how references work when dealing with complex data structures like lists.

That's all for this thread.

Hi, I am RS Punia from India🇮🇳. I tweet daily about Python fundamentals, Software Development, Django & Machine Learning 🐍🚀

If you enjoy reading this:

✅ Follow @CodingMantras
✅ Like & Retweet

Happy Coding ⚡️Keep Improving