Python for Beginners — Part 2: Variables, Data Types & Numbers

Part 2 of a beginner-friendly series on learning Python from scratch.

In Part 1, we installed Python, wrote our first program, and learned the syntax rules that hold everything together. Now it's time to start storing and working with information — which means variables and data types.

What is a Variable?

A variable is a name that points to a value stored in memory. Think of it as a labeled container you can put something into, and refer back to later by name.

name = "Ramesh"
age = 25

Unlike many other languages, Python doesn't need you to declare a variable's type ahead of time. You just assign a value with =, and Python figures out the type on its own. This is called dynamic typing.

x = 5        # x is an integer
x = "hello"  # now x is a string — totally legal in Python

This flexibility is convenient, but it also means you need to be a little more careful — Python won't stop you from changing a variable's type halfway through your program, even if that wasn't your intention.

Variable Naming Rules

Python is strict about how variable names can look:

• Must start with a letter or an underscore (_) — never a number.
• Can only contain letters, numbers, and underscores.
• Cannot be a Python keyword (class, for, if, etc.).
• Are case-sensitive — age, Age, and AGE are three different variables.

age = 25        # valid
_age = 25       # valid
age2 = 25       # valid
2age = 25       # invalid — cannot start with a number
my-age = 25     # invalid — hyphens aren't allowed

Naming conventions

Python's style guide (PEP 8) recommends snake_case for variable names — lowercase words separated by underscores:

first_name = "Ramesh"
total_score = 95

Assigning Multiple Variables

Python lets you assign several variables in a single line, which keeps code compact and readable.

# One value to multiple variables
x = y = z = 10

# Multiple values to multiple variables
name, age, city = "Ramesh", 25, "Chennai"

Data Types in Python

Every value in Python belongs to a data type, which determines what kind of operations you can perform on it. Here are the core built-in types you'll use constantly:

Type	Example	Description
str	"hello"	Text
int	25	Whole numbers
float	3.14	Decimal numbers
bool	True / False	Logical values
list	[1, 2, 3]	Ordered, changeable collection
tuple	(1, 2, 3)	Ordered, unchangeable collection
dict	{"a": 1}	Key-value pairs
set	{1, 2, 3}	Unordered, unique values
NoneType	None	Represents "no value"

We'll dive deep into collections (list, tuple, dict, set) in Part 5. For now, let's focus on the basics — strings, numbers, and booleans.

Checking a variable's type

Use the built-in type() function any time you want to confirm what you're working with:

x = 25
print(type(x))     # <class 'int'>

y = "hello"
print(type(y))     # <class 'str'>

This is one of the most useful debugging habits you can build early on.

Numbers in Python

Python has three numeric types you'll run into regularly:

• int — whole numbers, positive or negative, with no limit on size: 10, -45, 1000000
• float — numbers with a decimal point: 3.14, -0.5, 2.0
• complex — numbers with an imaginary part, written with a j: 3 + 4j (rare for beginners, but good to know it exists)

x = 10        # int
y = 3.14      # float
z = 3 + 4j    # complex

print(type(x), type(y), type(z))

Basic arithmetic

Python supports all the math operations you'd expect:

a = 10
b = 3

print(a + b)   # 13  → addition
print(a - b)   # 7   → subtraction
print(a * b)   # 30  → multiplication
print(a / b)   # 3.333... → division (always returns a float)
print(a // b)  # 3   → floor division (drops the decimal)
print(a % b)   # 1   → modulus (remainder)
print(a ** b)  # 1000 → exponent (a to the power of b)

Note that / always returns a float, even if the result is a whole number:

print(10 / 2)   # 5.0, not 5

Type Casting

Sometimes you need to convert a value from one type to another — this is called casting. Python gives you simple functions for this:

x = "25"
y = int(x)      # converts string "25" to integer 25

a = 25
b = str(a)      # converts integer 25 to string "25"

c = "3.14"
d = float(c)    # converts string "3.14" to float 3.14

This comes up constantly in real programs — for example, when you take user input (which always arrives as a string) and need to do math with it:

user_input = input("Enter your age: ")  # this is a string, even if you type "25"
age = int(user_input)                   # now it's a usable integer
print(age + 5)

If you try to do math directly on the unconverted string, Python will raise a TypeError — so casting isn't optional here, it's required.

Why This Matters

Dynamic typing is one of the reasons Python feels fast to write in — you spend less time declaring types and more time solving the actual problem. But that same flexibility is also where beginners get tripped up: a variable that started as a number can quietly become a string somewhere in your code, and the bug only shows up when you try to do math on it. Getting comfortable with type() and casting early will save you a lot of confusion later.

What's Next

In Part 3, we'll cover strings and booleans — how to slice and format text, the most useful string methods, and how Python handles True/False logic.

---

This is Part 2 of an 8-part beginner Python series. Catch up on Part 1: Getting Started & Syntax, or continue to Part 3 once it's live.