Variables and Data Types - Python Mastery

Variables in Python

A variable is a name that refers to a value in memory. Python uses dynamic typing — you don't declare types, and a variable can hold any type at any time.

# Variable assignment — no type declaration needed
x = 42
name = "Alice"
price = 9.99
is_active = True

# Python infers the type automatically
print(type(x))         # <class 'int'>
print(type(name))      # <class 'str'>
print(type(price))     # <class 'float'>
print(type(is_active)) # <class 'bool'>

# Multiple assignment
a = b = c = 0          # All three point to 0
x, y, z = 1, 2, 3      # Unpack tuple
first, *rest = [1, 2, 3, 4]  # first=1, rest=[2,3,4]

Naming Rules

Letters, numbers, underscores — no spaces, no hyphens
Cannot start with a number: 2fast is invalid, fast2 is fine
Case-sensitive: name, Name, and NAME are three different variables
Convention: use snake_case for variables and functions (user_name not userName)
Avoid reserved words: if, else, while, for, def, class, True, False, None, import, return, and, or, not...

The Core Data Types

Integers (int)

Whole numbers, positive or negative. Python integers have no size limit — they can be arbitrarily large.

age = 25
temperature = -10
big_number = 1_000_000     # Underscores for readability (Python 3.6+)
factorial_20 = 2432902008176640000  # No overflow!
hex_color = 0xFF5733       # Hexadecimal literal
binary = 0b1010            # Binary literal (= 10)
octal = 0o17               # Octal literal (= 15)

Floats (float)

Decimal numbers. Python uses 64-bit double precision — the same as C's double.

pi = 3.14159265358979
price = 9.99
scientific = 1.5e10   # 15,000,000,000.0
tiny = 2.5e-4         # 0.00025

# The famous floating point gotcha (affects ALL languages)
print(0.1 + 0.2)      # 0.30000000000000004 — not a Python bug!

# Solutions:
print(round(0.1 + 0.2, 2))  # 0.3 — for display

from decimal import Decimal  # For financial calculations
result = Decimal("0.1") + Decimal("0.2")
print(result)  # 0.3 — exact!

Strings (str)

Text data. Python strings are immutable sequences of Unicode characters — they support any language, emoji, and special characters.

greeting = "Hello"
name = 'World'          # Single or double quotes — your choice
multiline = """This is a
multiline string"""

# Common string operations
s = "Python"
print(s[0])       # 'P' — indexing (0-based)
print(s[-1])      # 'n' — negative indexing from end
print(s[1:4])     # 'yth' — slicing [start:end] (end exclusive)
print(len(s))     # 6
print(s.upper())  # 'PYTHON'
print(s.lower())  # 'python'
print(s + " 3")   # 'Python 3' — concatenation (use f-strings in practice)
print("py" in s)  # False (case-sensitive)

Booleans (bool)

Only two values: True and False. Note the capital first letter — Python is case-sensitive.

is_logged_in = True
has_permission = False

# Boolean operations
print(True and False)   # False
print(True or False)    # True
print(not True)         # False

# Comparison operators return booleans
print(5 > 3)     # True
print(5 == 5)    # True
print(5 != 3)    # True

# Truthiness — many values evaluate to False:
bool(0)      # False — zero integer
bool(0.0)    # False — zero float
bool("")     # False — empty string
bool([])     # False — empty list
bool({})     # False — empty dict
bool(None)   # False — None

# Everything else is truthy
bool(1)      # True
bool("hi")   # True
bool([0])    # True — list with one element (even if that element is 0!)

None — The Absence of Value

None represents "no value" or "not set". It's Python's equivalent of null in other languages.

result = None
print(result)           # None
print(result is None)   # True — use 'is', not '=='
print(result == None)   # True — works but not Pythonic

# Common uses
def find_user(id):
    # Returns None if not found
    return None  # No explicit return also gives None

user = find_user(999)
if user is None:
    print("User not found")

Type Conversion

# int() — convert to integer
int("42")        # 42
int(3.9)         # 3 (truncates, doesn't round!)
int(True)        # 1
int(False)       # 0

# float() — convert to float
float("3.14")    # 3.14
float(42)        # 42.0

# str() — convert to string
str(100)         # "100"
str(3.14)        # "3.14"
str(True)        # "True"

# bool() — convert to boolean
bool(0)          # False
bool(1)          # True
bool("")         # False
bool("hello")    # True

# Safe conversion — handle errors
user_input = "not a number"
try:
    number = int(user_input)
except ValueError:
    print(f"'{user_input}' is not a valid integer")

Key Takeaways

Dynamic typing: Python infers types — no declarations needed
Core types: int, float, str, bool, None — know them cold
Floating point: 0.1 + 0.2 != 0.3 — use round() or Decimal for money
None check: use x is None, not x == None
Type conversion: int(), float(), str(), bool() — wrap in try/except for user input

Practice Exercises

Create variables for your name, age, height (meters), and whether you enjoy coding. Print each with type().
What is bool("")? What about bool("False")? Run it and explain why.
Write code that converts "3.14" to a float, then to an int. What value do you get?
Given price = 19.99 and quantity = 3, calculate and print the total formatted to 2 decimal places.
Use multiple assignment to swap two variables a = 5 and b = 10 in one line.

← The REPL and First Script Strings in Depth →