Python Variables Guide: Learn How to Use Variables in Python

Variables are the foundation of any Python program. They act as containers that hold information your code can use, modify, and display. Whether you're storing a user’s name, calculating totals, or building AI models — variables are how Python handles and tracks data.

This beginner-friendly guide walks you through Python variables in detail, with examples and best practices at every step.

How to Declare Variables in Python

Python makes variable creation incredibly simple. You don’t need to declare a data type or use special keywords — just assign a value to a name, and Python creates the variable for you.

1name = 'Alice'
2age = 30
3height = 5.6

Python automatically assigns a type behind the scenes based on the value. This is called dynamic typing, and it's one of the reasons Python is so beginner-friendly.

Type Conversion with Casting

Sometimes, you’ll want to convert a variable from one type to another — for example, changing a string to a number before doing math. This is known as type casting.

Python provides simple functions to do this:

1x = int('7')      # '7' becomes 7
2y = float(3)      # 3 becomes 3.0
3z = str(100)      # 100 becomes '100'

This is especially useful when dealing with input from users or external sources like files and APIs, which often provide data as strings.

Check a Variable’s Type

If you’re unsure what type a variable holds, use the

1type()

function:

1price = 19.99
2print(type(price))  # Output: <class 'float'>

This is helpful for debugging or confirming the result of type casting or calculations.

Using Single or Double Quotes for Strings

Python lets you define strings using either single (') or double (") quotes. Functionally, there’s no difference.

1first_name = 'Alice'
2last_name = "Smith"

Use the one that avoids escaping characters:

1quote = "It's a sunny day"
2dialogue = 'He said, "Python is awesome!"'

This flexibility keeps code clean and easy to read.

Case Sensitivity in Variable Names

Python is case-sensitive, which means age, Age, and AGE are all considered different variables.

1name = 'Alice'
2Name = 'Bob'
3NAME = 'Charlie'

Be careful — inconsistent casing can lead to bugs that are hard to spot.

Python Variable Naming Rules

To keep your code clean and error-free, Python enforces some rules for naming variables:

Must begin with a letter (a–z or A–Z) or underscore (_)
Can contain letters, numbers, and underscores
Cannot start with a number
Cannot contain spaces or special characters like %, $, -
Cannot be one of Python’s reserved keywords, like if, class, def, return, etc.

Valid names:

1user_name = 'Alice'
2_total = 50
3email2 = 'hello@example.com'

Invalid names:

12name = 'wrong'        # Starts with a number
2user-name = 'invalid'  # Hyphen not allowed
3return = 'error'       # Reserved keyword

Writing Clear Multi-Word Variable Names

When a variable name includes more than one word, it’s important to format it in a way that keeps it readable. There are several naming styles — and each has a specific use case in Python.

1. Snake Case (Recommended)

Words are lowercase and separated by underscores.

1user_name = 'Alice'
2item_price = 19.99

This is the official Python style, as recommended by PEP 8.

2. Camel Case

Each word after the first starts with a capital letter, no underscores.

1userName = 'Alice'
2itemPrice = 19.99

This is more common in JavaScript and Java, but still used occasionally in Python (often in APIs or frameworks).

3. Pascal Case

Every word starts with a capital letter. This is typically used for class names in Python, not variables — but it's worth knowing.

1UserName = 'Alice'
2ItemPrice = 19.99

4. Uppercase Snake Case

Used for constants — values that should not change.

1MAX_USERS = 100
2DEFAULT_TIMEOUT = 60

Using consistent naming makes your code easier to read, understand, and maintain.

Variables Can Change Their Type

Since Python uses dynamic typing, a variable can be reassigned to hold a value of a completely different type later in your program.

1info = 'Welcome'   # Initially a string
2info = 42          # Now an integer
3info = [1, 2, 3]   # Now a list

This gives you flexibility — but also requires discipline. Avoid changing a variable’s type unless necessary, and always use clear names that reflect the current use.

Python Doesn’t Have True Constants (But You Can Fake Them)

Python doesn’t enforce constants — but by convention, we write constant values in all uppercase letters with underscores.

1PI = 3.14159
2API_KEY = 'abc123'

This signals to other developers that these values are meant to stay fixed. Python won’t stop you from changing them, but you shouldn’t.

Variable Scope: Where Your Variables Live

Scope determines where a variable is accessible in your code.

Global Variables

Defined outside any function, accessible everywhere.

1site_name = 'TxtNode'

Local Variables

Defined inside a function, only available there.

1def greet():
2    message = 'Hello'
3    print(message)

Trying to access

1message

outside the function will cause an error.

Example:

1count = 10  # Global
2
3def show_count():
4    count = 5  # Local version
5    print(count)
6
7show_count()  # 5
8print(count)  # 10

Python resolves variable names using the LEGB rule:

Local (inside a function)
Enclosing (in nested functions)
Global (at the top level of the file)
Built-in (Python keywords and functions)

Summary and Key Takeaways

Let’s quickly review what you’ve learned:

✅ Python lets you create variables easily using assignment
✅ You can change a variable’s type at any time
✅ Naming conventions matter — use snake_case for variables
✅ Strings can use single or double quotes
✅ Variable names are case-sensitive
✅ Avoid reserved keywords in variable names
✅ Use clear styles for multi-word variables (snake_case, camelCase, PascalCase)
✅ Constants are written in UPPERCASE
✅ Scope matters: local vs global

Mastering Python Variables: A Beginner's Guide to Dynamic Data