Python Variables & Data Types

Creating a variable in Python takes exactly one step: assign a value to a name using the = operator. There is no "declare" step, no type keyword, and no semicolon needed.

name = "Alice"       # str — text inside quotes
age = 28             # int — whole number
height = 1.68        # float — decimal number
is_student = True    # bool — True or False

print(name)
print(age)
print(height)
print(is_student)

Python reads the right side of =, determines the type from the value, and stores both the value and its type in memory under the name you chose. The equals sign here is the assignment operator, not a mathematical equality check.

You can also assign multiple variables on one line using Python's tuple unpacking shorthand:

# Assign multiple variables at once
x, y, z = 10, 20, 30
print(x, y, z)  # 10 20 30

# Assign the same value to multiple names
a = b = c = 0
print(a, b, c)  # 0 0 0

Python has four built-in primitive data types that you'll use in virtually every program you write. Understanding them deeply is essential before moving to lists, dictionaries, and objects.

2.1 int — Whole Numbers

int stores whole numbers of any size — positive, negative, or zero. Python integers are not limited to 32 or 64 bits like in C or Java; they can grow to any size your RAM allows.

population = 8_000_000_000   # underscores improve readability
negative = -42
big_num = 999999999999999999999  # Python handles any size!

print(population)
print(type(population))   # <class 'int'>

2.2 float — Decimal Numbers

float stores numbers with a fractional part. Internally, Python uses 64-bit double-precision floating-point (IEEE 754), which gives you about 15–17 significant decimal digits of accuracy.

pi = 3.14159265358979
temperature = -7.5
small = 0.000_001        # scientific-style

print(pi)
print(type(pi))          # <class 'float'>

# Beware of floating-point precision:
print(0.1 + 0.2)         # 0.30000000000000004 ← expected in IEEE 754

2.3 str — Text Strings

str stores any sequence of characters — letters, digits, spaces, emoji, or symbols. Strings can be wrapped in single quotes, double quotes, or triple quotes for multiline text.

greeting = "Hello, World!"
city = 'Hyderabad'
multiline = """Line one
Line two
Line three"""

# f-strings let you embed variables directly
name = "Balaji"
message = f"Welcome, {name}! You are learning Python."
print(message)

2.4 bool — True or False

bool has exactly two possible values: True and False (capital T and F — Python is case-sensitive). Booleans are the foundation of all conditional logic and are technically a subtype of int in Python (True == 1 and False == 0).

is_logged_in = True
has_premium = False

print(is_logged_in)             # True
print(type(has_premium))        # <class 'bool'>

# Booleans are ints under the hood:
print(True + True)              # 2
print(True * 10)                # 10
print(int(False))               # 0

The built-in type() function tells you the exact data type of any variable or value. This is invaluable for debugging, especially because Python can silently change what type a variable holds.

print(type(42))          # <class 'int'>
print(type(3.14))        # <class 'float'>
print(type("hello"))     # <class 'str'>
print(type(True))        # <class 'bool'>
print(type(None))        # <class 'NoneType'>

# isinstance() — better for conditional checks:
x = 100
if isinstance(x, int):
    print("x is an integer!")

Use this table as a quick cheat sheet whenever you need to compare the core Python types:

Python enforces some rules for variable names (your code will crash if you break them) and has conventions that are best practices (your code still runs, but it looks unprofessional).

x = 42          # meaningless
a1 = "Alice"    # cryptic
MyVar = True    # camelCase (not Pythonic)
class = "math"  # reserved word → crashes!

student_age = 42
student_name = "Alice"
is_enrolled = True
MAX_STUDENTS = 30  # constant

Python does not automatically convert between types the way JavaScript does. If you want to combine an integer with a string, you must explicitly convert first. This explicit approach prevents many hidden bugs.

age = 25
score = 97.8
user_input = "42"   # comes in as string from input()

# str() — convert to string for concatenation
print("Age: " + str(age))        # "Age: 25"

# int() — convert string or float to integer
print(int(user_input) + 8)       # 50
print(int(score))                 # 97 (truncates, no rounding!)

# float() — convert int or string to float
print(float("3.14"))             # 3.14
print(float(10))                 # 10.0

# bool() — falsy vs truthy
print(bool(0))        # False   ← zero is falsy
print(bool(""))       # False   ← empty string is falsy
print(bool("hello"))  # True    ← any non-empty string is truthy
print(bool(42))       # True    ← any non-zero number is truthy

# WRONG — this crashes with TypeError
age = input("Enter your age: ")
print(age + 5)                   # TypeError: can only concatenate str (not "int") to str

# CORRECT — convert first
age = int(input("Enter your age: "))
print(age + 5)                   # works perfectly!

Python has no built-in const keyword. Instead, the community convention (PEP 8) is to write constants in UPPER_CASE_WITH_UNDERSCORES at the top of your file. This signals to other developers: "don't change this value."

# Constants — by convention, UPPER_CASE
MAX_LOGIN_ATTEMPTS = 5
PI = 3.14159265358979
APP_VERSION = "2.1.0"
DATABASE_URL = "postgresql://localhost/mydb"

# Usage in code
attempts = 0
while attempts < MAX_LOGIN_ATTEMPTS:
    print(f"Attempt {attempts + 1} of {MAX_LOGIN_ATTEMPTS}")
    attempts += 1

If you need truly immutable constants in a serious project, Python developers typically use the Final type hint from Python 3.8+: from typing import Final; MAX: Final = 100. This doesn't prevent reassignment at runtime but causes static type checkers like mypy to flag it as an error.