DEV Community: Kailas Warade

Python Variables: Why y = x Sometimes Changes Both Variables

Kailas Warade — Fri, 18 Sep 2026 06:17:31 +0000

Python: Why Changing "y" Can Sometimes Change "x" Too

You write:

x = 10
y = x

Then you change "y".

Sometimes "x" stays the same.

Sometimes "x" changes too.

That sounds strange until you understand what "=" actually does in Python.

First, look at this example

x = 10
y = x

x = 20

print(x)
print(y)

Output:

20
10

Changing "x" did not change "y".

Now look at this:

x = [10, 20, 30]
y = x

y.append(40)

print(x)
print(y)

Output:

[10, 20, 30, 40]
[10, 20, 30, 40]

This time, changing "y" also changed what we see through "x".

Why?

The answer is mutation and reassignment.

"y = x" does not create a copy

When you write:

x = [10, 20, 30]
y = x

Python does not create another list containing the same values.

Both names refer to the same list object.

So when you do:

y.append(40)

you are changing that list.

Since "x" also refers to that same list, "x" now shows:

[10, 20, 30, 40]

A simple way to remember it:

Reassignment → changes what a name refers to.

Mutation → changes the object itself.

Reassignment vs mutation

Consider this:

x = 10
y = x

x = 20

Here, "x" is reassigned.

It now refers to "20".

"y" still refers to "10".

But with a list:

x = [10, 20]
y = x

y.append(30)

"y.append(30)" changes the existing list.

So both "x" and "y" show:

[10, 20, 30]

This difference is one of those small Python concepts that becomes very important when working with real programs.

Mutable and immutable objects

This is where another Python concept becomes useful.

Some objects can be changed after they are created.

These are called mutable objects.

Common examples:

"list"
"dict"
"set"

Some objects cannot be changed in place.

These are called immutable objects.

Common examples:

"int"
"float"
"str"
"tuple"

For example:

numbers = [10, 20, 30]
numbers.append(40)

The existing list is modified.

But:

x = 10
x = 20

does not modify the integer "10".

The name "x" is simply reassigned.

Here is another example that can confuse you

Predict the output before running this:

numbers = [10, 20, 30]

other_numbers = numbers

numbers = [100, 200, 300]

other_numbers.append(40)

print(numbers)
print(other_numbers)

The output is:

[100, 200, 300]
[10, 20, 30, 40]

Why?

Initially:

numbers = [10, 20, 30]
other_numbers = numbers

Both names refer to the first list.

Then:

numbers = [100, 200, 300]

This does not change the old list.

It makes "numbers" refer to a new list.

"other_numbers" is still referring to the original list.

So:

other_numbers.append(40)

changes only the original list.

One more Python variable trap: "input()"

There is another small thing that often causes confusion.

Look at this:

age = input("Enter your age: ")

print(type(age))

If you enter:

the result is:

Even though you entered a number.

"input()" returns a string.

If you actually need an integer:

age = int(input("Enter your age: "))

Now:

print(type(age))

gives:

This matters when you start doing calculations.

For example:

age = input("Enter your age: ")

print(age + 5)

This will not work as expected because "age" is a string.

Instead:

age = int(input("Enter your age: "))

print(age + 5)

Don't confuse "=" with "=="

Another basic mistake is confusing these two operators.

"=" means assignment:

age = 25

"==" means comparison:

age == 25

For example:

age = 25

if age == 25:
print("Age is 25")

A simple rule:

"=" → assign

"==" → compare

Python is dynamically typed

Python variables do not need a type declaration like some other programming languages.

You can write:

age = 25

and later:

age = "25"

The same name can refer to objects of different types at different times.

You can check the current type with:

print(type(age))

This is called dynamic typing.

Choose variable names that explain the value

Technically, this works:

a = 45000
b = 12
c = a / b

But this is easier to understand:

annual_salary = 45000
months = 12
monthly_salary = annual_salary / months

Good variable names make code easier to read, debug, and maintain.

Especially when you come back to your code after a few weeks.

Try these before you run them

Don't run these immediately.

Predict the output first.

Question 1

x = [1, 2, 3]
y = x

y.append(4)

print(x)

What will it print?

Question 2

x = 10
y = x

y = 20

print(x)
print(y)

What will it print?

Question 3

x = [1, 2, 3]
y = x

x = [10, 20, 30]

y.append(4)

print(x)
print(y)

Can you predict both outputs?

If you can explain why the answers are different, you understand the important part.

Want the Python Variable Basics in One Place?

If you're preparing for Python interviews or want a reference for Python syntax, variable naming rules, data types, dynamic typing, multiple assignment, scope, "input()", and related questions, I've collected those topics here:

Python Syntax and Variables Interview Q&A

https://www.sankalandtech.com/Tutorials/Python/interview-questions/python-syntax-variables-tutorial.html

Use it as a reference when you want to revise the broader Python syntax and variable concepts.

Final challenge

What will this program print?

items = ["SQL", "Python"]

copy_of_items = items

items = ["Python", "GCP"]

copy_of_items.append("BigQuery")

print(items)
print(copy_of_items)

Will ""BigQuery"" appear in both lists?

Don't run it immediately.

Think about these three things first:

What object does "items" refer to initially?
What happens when "items" is reassigned?
Which object does "copy_of_items" still refer to?

That's the part of Python variables that is easy to miss when you're just learning the syntax.

10 Python Variable Mistakes Developers Still Make (And How to Fix Them)

Kailas Warade — Wed, 16 Sep 2026 06:40:06 +0000

When you first start writing Python, variables seem pretty simple.

You write something like:

name = "Rahul"
age = 25

and move on.

But as your programs become larger, small mistakes around variable names, data types, input, assignment, and scope can lead to confusing errors.

Most of these mistakes are easy to fix once you understand what is happening.

Here are 10 common Python variable mistakes that are worth knowing.

1. Starting a variable name with a number

A Python variable name cannot start with a number.

This is invalid:

2name = "Python"

Python will raise a "SyntaxError".

Numbers can be used inside a variable name or at the end:

name2 = "Python"
student2 = "Rahul"

You can also start a variable name with an underscore:

_name = "Python"

A simple rule:

Start a variable name with a letter or an underscore.

2. Putting spaces in variable names

Spaces are not allowed inside Python variable names.

This will not work:

student name = "Rahul"

If you want to combine multiple words, use an underscore:

student_name = "Rahul"
first_name = "Rahul"
last_name = "Patil"

This naming style is commonly called snake_case.

Compare:

studentname = "Rahul"

with:

student_name = "Rahul"

The second version is easier to read, especially when variable names become longer.

*3. Using Python keywords as variable names
*
Python has reserved keywords that are used by the language itself.

Some examples are:

if
else
for
while
class
def
return
import
try
except

You should not use these keywords as variable names.

For example:

class = "Python"

This produces a syntax error.

Instead, choose a different name:

class_name = "Python"

If you want to check the keywords available in your Python version, you can use:

import keyword

print(keyword.kwlist)

This is a useful little trick when you are unsure whether a word can be used as an identifier.

*4. Forgetting that Python is case-sensitive
*
Python treats uppercase and lowercase names as different.

For example:

name = "Rahul"

print(Name)

This produces a "NameError" because "name" and "Name" are different identifiers.

You can actually create both:

name = "Rahul"
Name = "Python"

print(name)
print(Name)

Output:

Rahul
Python

There is nothing technically wrong with this, but using names that differ only by capitalization can make code difficult to understand.

For example:

customer = "Rahul"
Customer = "Amit"

Someone reading this code can easily confuse the two.

Be consistent with capitalization.

*5. Mixing up "=" and "=="
*
This is one of the easiest mistakes to make when learning Python.

The "=" operator is used for assignment.

age = 25

Here, the value "25" is assigned to "age".

The "==" operator is used for comparison.

age == 25

For example:

age = 25

if age == 25:
print("Age is 25")

A simple way to remember:

= -> assign a value
== -> compare values

The difference is small when you look at it, but it is very important when writing conditions.

*6. Forgetting that "input()" returns a string
*
This is a very common problem in beginner Python programs.

Consider:

age = input("Enter your age: ")

print(age + 1)

Suppose the user enters:

It may look like Python received the number "25".

Actually, "input()" returns the value as a string:

"25"

So Python cannot add the integer "1" directly to it.

You will get a "TypeError".

If you need an integer, convert the input:

age = int(input("Enter your age: "))

print(age + 1)

For a decimal value:

price = float(input("Enter price: "))

This is an important concept to understand because user input is very common in Python programs.

If you want to learn Python syntax and variables in more detail, including related concepts and interview questions, you can use the
*"Python Syntax and Variables guide" *(https://www.sankalandtech.com/Tutorials/Python/interview-questions/python-syntax-variables-tutorial.html) as a reference.

7. Combining strings and numbers incorrectly

Another common mistake is trying to concatenate a string and a number using "+".

For example:

age = 25

print("My age is " + age)

This produces a "TypeError".

Why?

Because ""My age is "" is a string and "age" is an integer.

One solution is to convert the number to a string:

print("My age is " + str(age))

But an f-string is usually cleaner:

age = 25

print(f"My age is {age}")

You can also include multiple variables:

name = "Rahul"
age = 25

print(f"My name is {name} and I am {age} years old.")

F-strings are simple and make formatted output much easier to read.

*8. Losing track of a variable's data type
*
Python is dynamically typed.

You don't have to declare a variable's type before assigning a value.

For example:

value = 100

print(type(value))

Output:

Later, the same variable can refer to a string:

value = "Python"

print(type(value))

Output:

This flexibility is useful, but it can also cause problems if you lose track of what a variable currently contains.

For example:

value = 100
value = "Python"

print(value + 10)

The last line produces a "TypeError" because "value" is currently a string.

So don't just remember that Python is dynamically typed.

Also remember:

Always understand the type of the value your variable currently contains before performing an operation on it.

When debugging, "type()" can be very useful:

print(type(value))

*9. Giving variables vague names
*
Python allows short variable names:

x = 50000
d = 10

There is nothing syntactically wrong with this.

But what do "x" and "d" represent?

Compare them with:

employee_salary = 50000
number_of_days = 10

Now the purpose is much clearer.

Meaningful names become especially important when:

the program becomes larger
several developers work on the same code
you revisit old code
you need to debug a problem
the same type of value is used in several places

A good variable name can often make code easier to understand without adding a comment.

For example:

total_price = 1500

is easier to understand than:

tp = 1500

unless "tp" has a very clear meaning within a small local context.

*10. Getting confused by local and global scope
*
Variable scope determines where a variable can be accessed.

Consider:

name = "Rahul"

def show_name():
name = "Python"
print(name)

show_name()
print(name)

Output:

Python
Rahul

Why are the values different?

The variable created inside "show_name()" is local to that function.

The variable created outside the function is in the global scope.

The local variable does not change the global variable in this example.

This distinction becomes important as programs start using more functions.

When debugging a variable-related problem, ask:

Where was this variable created, and which scope am I currently inside?

Understanding scope can prevent many confusing bugs.

*Quick checklist
*
Before running your Python code, take a moment to check:

Did I start variable names correctly?
Did I accidentally use spaces in a variable name?
Did I avoid Python keywords?
Is my capitalization consistent?
Did I use "=" for assignment and "==" for comparison?
Did I convert "input()" before performing calculations?
Am I combining compatible data types?
Do I know the current type of my variable?
Are my variable names meaningful?
Do I understand the variable's scope?

These are simple checks, but they can prevent a surprising number of beginner-level errors.

Try It Yourself

The best way to understand these concepts is to experiment with the code.

Try this:

age = "25"

print(age + 1)

You will get a type-related error.

Now convert the value:

age = int(age)

print(age + 1)

You should now get:

Try another example:

value = 100
print(type(value))

value = "Python"
print(type(value))

Notice how the type changes.

You can also experiment with variable names, capitalization, and function scope.

Don't be afraid of errors while learning Python. A small error followed by understanding the reason behind it is often more useful than simply memorizing the correct syntax.

Final Thoughts

Python variables are easy to create, but there are several details worth understanding early.

Variable naming rules, assignment, data types, input conversion, meaningful names, and scope all become important as your programs grow.

You don't need to memorize everything at once.

Write a small program, make a change, run it, read the error, and try to understand why it happened.

That habit will help you much more than simply memorizing Python syntax.

Python Basics: 10 Things Every Beginner Should Understand

Kailas Warade — Tue, 15 Sep 2026 15:04:41 +0000

*Python Basics: 10 Things Every Beginner Should Understand
*
When someone starts learning Python, the first question is usually:

“Where should I start?”

There are so many Python tutorials, courses and videos available that it is easy to get confused.

Should you learn variables first? Loops? Functions? Pandas? NumPy?

My suggestion is simple: don't try to learn everything together.

First, understand the basic ideas behind Python and write small programs. The advanced topics will become much easier later.

Here are 10 Python basics that I recommend every beginner understand.

What can you do with Python?

Python is not only for beginners.

You can use it for many different types of work, including:

Data analysis
Data engineering
Automation
Web development
AI and machine learning
Scripting
Scientific computing

For example, even a small program can process a list of numbers:

numbers = [10, 20, 30, 40]

for number in numbers:
print(number)

It is a simple example, but it teaches you something important: how Python code is written and how a loop works.

Python code is easy to read

Look at this example:

name = "John"
age = 25

print(name)
print(age)

You can understand what the program is doing without knowing a lot of programming terminology.

That's helpful when you are learning.

But don't confuse simple syntax with simple programming. As your programs become bigger, you still need to understand good programming practices.

Python does not require you to declare variable types

In some programming languages, you have to specify the type of a variable.

Python usually doesn't require that.

age = 25
name = "John"
salary = 45000.50

Python knows that "age" is an integer, "name" is a string and "salary" is a float.

You can check the type yourself:

age = 25

print(type(age))

Output:

Now consider this:

age = "25"

Here, "age" contains a string, not an integer.

So this will not work as you might expect:

print(age + 5)

You will get a "TypeError".

This is why understanding Python data types is important, even when Python makes variable declaration easy.

Don't ignore indentation

If you are coming from another programming language, Python indentation may take some time to get used to.

For example:

age = 20

if age >= 18:
print("You are an adult")

The spaces before "print()" are important.

They tell Python that the statement belongs to the "if" block.

So in Python, indentation is not just about making your code look clean. It is part of the syntax.

A Python program can be just one file

You don't need a big project to start.

Create a file called "hello.py":

print("Hello, Python!")

Then run it from the command line:

python hello.py

That's it.

As you become comfortable, you can create scripts for real tasks.

For example:

Read a CSV file
Rename files
Generate a report
Check data
Move files from one folder to another

This is where Python starts becoming really useful.

What is PIP?

You will probably hear the word PIP quite often when learning Python.

PIP is used to install Python packages.

For example, if you want to work with Pandas, you can install it using:

pip install pandas

Then you can use it in your program:

import pandas as pd

You don't have to write every feature yourself. Python has a huge collection of packages that you can use in your projects.

Why do we need a virtual environment?

This is something beginners often skip.

Suppose you have two Python projects.

One project needs an older version of a package, while another project needs a newer version.

Installing everything in one common environment can create problems.

A virtual environment keeps the packages for a project separate.

For example:

python -m venv myenv

You can then activate the environment and install the packages needed for that particular project.

You may not need to worry about this for your first small Python program.

But if you start building real projects, learn virtual environments early.

Python is very useful for working with data

If you are interested in data analytics or data engineering, you will come across Python quite often.

For example, Pandas can read a CSV file:

import pandas as pd

df = pd.read_csv("employees.csv")

print(df.head())

Now you have the data in a DataFrame.

You can then clean it, filter it, calculate values and transform it.

Some popular Python libraries for data work are:

NumPy
Pandas
Matplotlib

You don't need to learn all of them on day one.

Start with Python basics first.

Python is great for automation

Think about a simple situation.

You receive 500 CSV files and need to perform the same operation on every file.

Doing it manually would take a lot of time.

A Python script can do the repetitive work for you.

Python can be used to:

Read multiple files
Combine CSV files
Rename files
Create reports
Move files
Check data
Perform repetitive tasks

This is one of the areas where even a small amount of Python knowledge can be useful in day-to-day work.

Don't learn Python only by watching tutorials

This is probably the most important point.

You can watch a two-hour Python tutorial and feel like you understand everything.

Then you open your editor and suddenly don't know what to write.

That's normal.

The solution is to start writing small programs.

For example, try finding the largest number:

numbers = [10, 50, 30, 80, 40]

largest = numbers[0]

for number in numbers:
if number > largest:
largest = number

print(largest)

The answer is "80".

Now change the program yourself.

Try finding:

The smallest number
The second largest number
The sum of all numbers
The average
Numbers greater than 50
Duplicate values

Don't worry if your first attempt gives an error.

The error is part of learning Python.

What should you learn next?

After you are comfortable with these basics, move gradually to:

Strings
Lists
Tuples
Sets
Dictionaries
Conditions
Loops
Functions
Exception handling
File handling
Modules and packages
Object-oriented programming
NumPy
Pandas
Real Python projects

You don't have to finish all of these before writing projects.

In fact, writing small projects while learning is a much better way to remember what you learn.

One more Python resource

If you are learning Python for interviews or want a quick revision of the basics, I have also prepared a separate guide covering 20 common Python programming questions.

It covers topics such as Python installation, Python 2 vs Python 3, PIP, virtual environments, dynamic typing, Python scripts, indentation, data analysis, automation and Python's use in AI.

You can find it here:

"Introduction to Python Programming: Top 20 Questions Explained" (https://www.sankalandtech.com/Tutorials/Python/interview-questions/introduction-to-python-programming.html)

Final thought

Don't try to become an expert in Python in a few days.

Learn one concept.

Write some code.

Make a mistake.

Understand the error.

Try again.

Then move to the next concept.

If you do this regularly, Python will become much more comfortable over time.

And once your basics are strong, you can decide where you want to go next — data analytics, data engineering, automation, AI or machine learning.