Python Match Case

match compares one value against a list of patterns and runs the block for the first pattern that fits. It is Python’s answer to the switch statement found in other languages, and it can also pull values out of lists and dictionaries.

Your first match statement

match was added in Python 3.10. Each case is a pattern. _ is the wildcard: it matches anything, so it works like else.

status_code = 404 match status_code:    case 200:        print("OK")    case 404:        print("Not found")    case 500:        print("Server error")    case _:        print("Unknown status")

Not found

Only the first matching case runs. Unlike C or Java, there is no fall-through and no break needed.

Several values in one case

Use | to mean “or”:

def day_type(day):    match day.lower():        case "saturday" | "sunday":            return "weekend"        case "monday" | "tuesday" | "wednesday" | "thursday" | "friday":            return "weekday"        case _:            return "not a day" for d in ["Sunday", "wednesday", "Funday"]:    print(d, "->", day_type(d))

Sunday -> weekend
wednesday -> weekday
Funday -> not a day

Capture a value and add a guard

A bare name in a pattern captures the value. An if after the pattern is a guard: the case matches only if the guard is true.

def grade(score):    match score:        case n if n >= 90:            return "A"        case n if n >= 75:            return "B"        case n if n >= 0:            return "C or below"        case _:            return "invalid" print(grade(95), grade(80), grade(40), grade(-5))

A B C or below invalid

Match sequences

Patterns can describe lists and tuples. Names in the pattern are filled from the matching positions, and *rest collects the remaining items.

def run(command):    match command.split():        case ["quit"]:            return "Bye"        case ["go", direction]:            return f"Going {direction}"        case ["take", first, *others]:            return f"Taking {first} and {len(others)} more"        case []:            return "Say something"        case _:            return f"Unknown command: {command!r}" for c in ["go north", "take key lamp rope", "quit", "", "dance"]:    print(run(c))

Going north
Taking key and 2 more
Bye
Say something
Unknown command: 'dance'

Match dictionaries

A mapping pattern checks that certain keys exist and captures their values. Extra keys are ignored, which makes this ideal for JSON from an API.

events = [    {"type": "click", "x": 10, "y": 20},    {"type": "key", "key": "Enter"},    {"type": "scroll"},] for event in events:    match event:        case {"type": "click", "x": x, "y": y}:            print(f"click at ({x}, {y})")        case {"type": "key", "key": key}:            print(f"key {key} pressed")        case {"type": other}:            print(f"unhandled event {other}")

click at (10, 20)
key Enter pressed
unhandled event scroll

Match by type

int(), str() and other class names in a pattern check the type:

def describe(value):    match value:        case bool():            return "a boolean"        case int() | float():            return "a number"        case str() if value == "":            return "an empty string"        case str():            return "a string"        case list():            return f"a list of {len(value)}"        case _:            return "something else" for v in [True, 3, 2.5, "", "hi", [1, 2], None]:    print(repr(v), "is", describe(v))

True is a boolean
3 is a number
2.5 is a number
'' is an empty string
'hi' is a string
[1, 2] is a list of 2
None is something else

Check your understanding

point = (0, 5)match point:    case (0, 0):        print("origin")    case (0, y):        print(f"on the y axis at {y}")    case (x, 0):        print(f"on the x axis at {x}")    case _:        print("somewhere else")

on the y axis at 5

calc(6, "*", 7), calc(9, "/", 0), calc(9, "/", 3), calc(1, "^", 2)

42 cannot divide by zero 3.0 unknown operator

def calc(a, op, b):    match op:        case "+":            return a + b        case "-":            return a - b        case "*":            return a * b        case "/" if b == 0:            return "cannot divide by zero"        case "/":            return a / b        case _:            return "unknown operator" print(calc(6, "*", 7), calc(9, "/", 0), calc(9, "/", 3), calc(1, "^", 2))

42 cannot divide by zero 3.0 unknown operator

Program Practice

The if-else programs are a great place to practise match: try rewriting a few solutions with it.

Python match case FAQ

Python Operators & Booleans

Operators are the symbols that do the work in an expression: they add numbers, compare values and combine conditions. This lesson covers all seven groups of Python operators and the booleans they produce.

Arithmetic operators

a, b = 14, 4print(a + b, a - b, a * b)print(a / b, a // b, a % b, a ** 2)

18 10 56
3.5 3 2 196

+ and * also work on strings and lists:

print("ab" + "cd", "-" * 10)print([1, 2] + [3], [0] * 3)

abcd ----------
[1, 2, 3] [0, 0, 0]

The Numbers & Math lesson explains //, % and rounding in detail.

Assignment operators

Augmented assignment updates a variable using its current value.

balance = 1000balance -= 250      # withdrawalbalance *= 1.05     # 5% interestprint(balance)

787.5

Comparison operators

Comparisons return a boolean: True or False.

score = 72print(score == 72, score != 72)print(score > 50, score <= 60)print("apple" < "banana")     # strings compare alphabeticallyprint(10 == 10.0)             # int and float with the same value are equal

True False
True False
True
True

Python lets you chain comparisons, just like in maths:

age = 25print(18 <= age < 60)

True

Logical operators: and, or, not

has_ticket = Trueis_adult = Falseprint(has_ticket and is_adult)print(has_ticket or is_adult)print(not is_adult)

False
True
True

Short-circuiting

and stops at the first falsy value and or stops at the first truthy value. They return that value itself, not always True/False. This gives two handy idioms:

name = ""display = name or "Guest"          # default when name is emptyprint(display) items = []print(len(items) > 0 and items[0])  # items[0] is never evaluated

Guest
False

Booleans and truthiness

True and False are the two boolean values, and bool is a subclass of int. In an if or while, any value is treated as true or false:

print(True + True, True * 10)for value in [0, 3, "", "text", [], [1], None]:    print(repr(value), "->", "truthy" if value else "falsy")

2 10
0 -> falsy
3 -> truthy
'' -> falsy
'text' -> truthy
[] -> falsy
[1] -> truthy
None -> falsy

Identity operators: is, is not

== asks “do these have the same value?” is asks “are these the very same object?”

a = [1, 2]b = [1, 2]c = aprint(a == b, a is b)print(a is c)

True False
True

Membership operators: in, not in

roles = ["admin", "tester", "viewer"]print("tester" in roles)print("guest" not in roles)print("py" in "python")                  # substring checkprint("id" in {"id": 7, "name": "x"})   # checks dict keys

True
True
True
True

Bitwise operators

Bitwise operators work on the binary digits of integers. You will meet them in permissions, flags and low-level code.

a, b = 6, 3       # 110 and 011 in binaryprint(a & b, a | b, a ^ b)print(~a, a << 1, a >> 1)

2 7 5
-7 12 3

Operator precedence

From highest to lowest (operators on the same row are evaluated left to right, except **):

print(True or False and False)    # and binds tighter: True or (False and False)print(not 1 == 2)                 # not (1 == 2)

True
True

Check your understanding

x = 5print(x > 3 and x < 10, x > 3 or 1 / 0, 0 or "" or "last")

True True last

1900, 2000, 2024, 2026

1900 False
2000 True
2024 True
2026 False

for year in [1900, 2000, 2024, 2026]:    is_leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0    print(year, is_leap)

1900 False
2000 True
2024 True
2026 False

Program Practice

Python operators FAQ

Python Type Casting

Type casting means converting a value from one type to another, such as turning the text “42” from input() into the number 42. Python does some conversions for you, and you do the rest with built-in functions named after the types.

Implicit conversion

When you mix an int and a float in arithmetic, Python converts the int to a float for you, so no precision is lost:

qty = 3          # intprice = 19.5     # floattotal = qty * priceprint(total, type(total).__name__)print(True + True)    # bool is a kind of int: True is 1

58.5 float
2

Python will not guess between text and numbers. Mixing them is an error:

age = 30print("Age: " + age)

Traceback (most recent call last):
  File "main.py", line 2, in <module>
    print("Age: " + age)
          ~~~~~~~~^~~~~
TypeError: can only concatenate str (not "int") to str

Explicit conversion functions

Numbers and strings

age = 30print("Age: " + str(age))        # number to textprint(int("42") + 8)             # text to numberprint(float("3.75") * 2)print(int(9.99), int(-9.99))     # int() truncates towards zeroprint(int("  15\n"))             # surrounding whitespace is ignored

Age: 30
50
7.5
9 -9
15

int() can also read numbers written in other bases:

print(int("ff", 16), int("0b1010", 0), int("777", 8))

255 10 511

Values that cannot be converted

print(int("3.5"))

Traceback (most recent call last):
  File "main.py", line 1, in <module>
    print(int("3.5"))
          ~~~^^^^^^^
ValueError: invalid literal for int() with base 10: '3.5'

int() will not read a decimal string. Convert to float first, or catch the error:

print(int(float("3.5"))) for text in ["12", "4.0", "abc"]:    try:        print(text, "->", int(text))    except ValueError:        print(text, "-> not a whole number")

3
12 -> 12
4.0 -> not a whole number
abc -> not a whole number

Converting to bool

bool() returns False for “empty” or zero values and True for everything else.

for v in [0, 0.0, "", "0", "False", [], [0], None]:    print(f"{v!r:8} -> {bool(v)}")

0        -> False
0.0      -> False
''       -> False
'0'      -> True
'False'  -> True
[]       -> False
[0]      -> True
None     -> False

Between collections

letters = list("banana")print(letters)print(set(letters))                    # duplicates removedprint(tuple(letters[:3]))print("".join(letters))               # list of strings back to one string pairs = [("chrome", 120), ("firefox", 118)]print(dict(pairs))print(list({"x": 1, "y": 2}))          # a dict converts to its keys

['b', 'a', 'n', 'a', 'n', 'a']
{'a', 'b', 'n'}
('b', 'a', 'n')
banana
{'chrome': 120, 'firefox': 118}
['x', 'y']

Check your understanding

print(int("7") + float("2.5"), str(7) + str(2.5), int(True))

9.5 72.5 1

"12, 7.5, 30, 0.5"

[12.0, 7.5, 30.0, 0.5]
Total: 50.0
Average: 12.5

line = "12, 7.5, 30, 0.5"numbers = [float(part) for part in line.split(",")]print(numbers)print("Total:", sum(numbers))print("Average:", sum(numbers) / len(numbers))

[12.0, 7.5, 30.0, 0.5]
Total: 50.0
Average: 12.5

Program Practice

Python type casting FAQ

Python Numbers & Math

Python has three number types and a rich set of tools for working with them. This lesson covers arithmetic, rounding, the float precision trap, the math module and random numbers.

Three number types

count = 42          # int: whole number, any sizeratio = 0.75        # float: decimal numbersignal = 3 + 4j     # complex: real + imaginary part print(type(count).__name__, type(ratio).__name__, type(signal).__name__)print(abs(signal))  # length of the complex number

int float complex
5.0

Large numbers are easier to read with underscores. Python ignores them:

population = 1_428_627_663print(population)print(2 ** 64)

1428627663
18446744073709551616

Arithmetic operators

a, b = 17, 5print(a + b, a - b, a * b)print(a / b, a // b, a % b)print(a ** b)

22 12 85
3.4 3 2
1419857

// and % work as a pair: a == (a // b) * b + a % b. divmod() gives both at once. A classic use is converting seconds:

seconds = 3725minutes, secs = divmod(seconds, 60)hours, minutes = divmod(minutes, 60)print(f"{hours}h {minutes}m {secs}s")

1h 2m 5s

Order of operations

Python follows the usual maths rules: * first, then , /, //, %, then + and -. Use parentheses to make your intent clear.

print(2 + 3 * 4)print((2 + 3) * 4)print(2 ** 3 ** 2)    # ** groups from the right: 2 ** 9print(-2 ** 2)        # ** binds tighter than the minus sign

14
20
512
-4

Rounding

price = 2.675print(round(price, 2))print(round(2.5), round(3.5))     # ties round to the even numberprint(int(7.9), int(-7.9))        # int() cuts off the decimals

2.67
2 4
7 -7

round(2.5) gives 2 because Python uses “banker’s rounding”: a tie goes to the nearest even number. round(2.675, 2) gives 2.67 because 2.675 cannot be stored exactly as a float; it is really slightly less.

Float precision

print(0.1 + 0.2)print(0.1 + 0.2 == 0.3) import mathprint(math.isclose(0.1 + 0.2, 0.3))

0.30000000000000004
False
True

For money, use Decimal with string inputs, which stores decimal digits exactly:

from decimal import Decimal print(Decimal("0.1") + Decimal("0.2"))total = Decimal("19.99") * 3print(total)

0.3
59.97

Useful built-in functions

nums = [4, -9, 15, 2]print(abs(-9), max(nums), min(nums), sum(nums))print(pow(2, 10), pow(2, 10, 1000))   # third argument: remainder

9 15 -9 12
1024 24

The math module

import math print(math.sqrt(144))print(math.floor(4.7), math.ceil(4.2))print(math.pi)print(math.factorial(5))print(math.gcd(48, 36), math.lcm(4, 6))print(round(math.log10(1000)), round(math.hypot(3, 4)))

12.0
4 5
3.141592653589793
120
12 12
3 5

Random numbers

The random module picks pseudo-random values. random.seed() makes the sequence repeatable, which is useful in tests.

import random random.seed(7)print(random.randint(1, 6))           # dice roll: 1 to 6 inclusiveprint(random.choice(["red", "green", "blue"]))print(round(random.random(), 3))      # float from 0.0 up to 1.0

3
red
0.395

Number systems

print(bin(10), oct(10), hex(255))print(int("1010", 2), int("ff", 16))

0b1010 0o12 0xff
10 255

Check your understanding

print(7 // 2, -7 // 2, 7 % 3, -7 % 3)

3 -4 1 2

principal = 15000, rate = 7.5 (% per year), years = 3

Interest: 3375.0
Total: 18375.0

principal = 15000rate = 7.5years = 3 interest = principal * rate * years / 100print("Interest:", round(interest, 2))print("Total:", round(principal + interest, 2))

Interest: 3375.0
Total: 18375.0

Program Practice

Python numbers and math FAQ

Python User Input

input() pauses your program and waits for the user to type something and press Enter. It is the simplest way to make a program interactive, and it is used in many practice programs.

Read text with input()

input() shows an optional prompt, waits for the user and returns what they typed as a string.

name = input("What is your name? ")print("Hello,", name)

What is your name? Asha
Hello, Asha

input() always returns a string

Even if the user types digits, you get a string. Adding two strings joins them instead of adding numbers:

a = input("First number: ")b = input("Second number: ")print(a + b)print(type(a))

First number: 5
Second number: 7
57
<class 'str'>

Convert input to a number

Wrap input() in int() for whole numbers or float() for decimals.

qty = int(input("Quantity: "))price = float(input("Price: "))print("Total:", qty * price)

Quantity: 5
Price: 7.5
Total: 37.5

Several values on one line

split() breaks a string on spaces and returns a list. Combine it with map() to convert every part:

numbers = input("Enter numbers separated by spaces: ").split()print(numbers) values = list(map(int, numbers))print(sum(values))

Enter numbers separated by spaces: 10 20 30
['10', '20', '30']
60

Unpack directly into variables when you know how many values to expect:

width, height = map(int, input("Width and height: ").split())print("Pixels:", width * height)

Width and height: 1920 1080
Pixels: 2073600

Handle invalid input

If the user types abc, int() cannot convert it and raises a ValueError:

age = int(input("Age: "))

Age: abc
Traceback (most recent call last):
  File "main.py", line 1, in <module>
    age = int(input("Age: "))
ValueError: invalid literal for int() with base 10: 'abc'

Catch the error with try / except and ask again. The Exception Handling lesson explains this pattern fully.

while True:    text = input("Age: ")    try:        age = int(text)    except ValueError:        print(f"{text!r} is not a whole number, try again")        continue    if age < 0:        print("Age cannot be negative")        continue    break print("Age saved:", age)

Age: abc
'abc' is not a whole number, try again
Age: -3
Age cannot be negative
Age: 29
Age saved: 29

Check your understanding

4 6

Width and height: 4 6
Area: 24
Perimeter: 20

w, h = map(int, input("Width and height: ").split())print("Area:", w * h)print("Perimeter:", 2 * (w + h))

Width and height: 4 6
Area: 24
Perimeter: 20

Program Practice

Many basic programs read their values with input(). Try changing a solution to ask the user instead of using fixed values.

Python input FAQ

Python Output & Comments

print() is how your program talks to you, and comments are how you talk to the next person who reads your code. Both look simple, but a few options make them far more useful.

The print() function

print() writes text to the screen and then moves to a new line. You can give it any value: text, numbers, lists or the result of a calculation.

print("Hello, Python")print(42)print(3.5 * 2)print([1, 2, 3])print()                 # an empty lineprint("after the blank line")

Hello, Python
42
7.0
[1, 2, 3]

after the blank line

Print several values

Separate values with commas. print() converts each one to text and puts a space between them, so you can mix text and numbers without converting anything.

name = "Asha"tests = 12print("Tester:", name, "ran", tests, "tests")

Tester: Asha ran 12 tests

Change the separator: sep

sep sets what goes between the values. The default is a single space.

print("2026", "11", "02", sep="-")print("a", "b", "c", sep="")print("login", "search", "checkout", sep=" | ")

2026-11-02
abc
login | search | checkout

Change the line ending: end

end sets what is printed after the last value. The default is a newline ("\n"), so each print() starts a new line. Change it to keep printing on the same line.

for step in range(1, 4):    print("step", step, end=" -> ")print("finished")

step 1 -> step 2 -> step 3 -> finished

Print variables with f-strings

An f-string starts with f before the quote. Anything in { } is replaced by its value. This is the clearest way to build output.

item = "keyboard"price = 1499.5qty = 2print(f"{qty} x {item} = {price * qty}")print(f"Price with 2 decimals: {price:.2f}")print(f"{qty=}")

2 x keyboard = 2999.0
Price with 2 decimals: 1499.50
qty=2

Escape characters

A backslash inside a string starts an escape sequence:

print("Name\tScore")print("Asha\t91")print("Line one\nLine two")print("She said \"hi\"")print("C:\\tests\\report.txt")

Name	Score
Asha	91
Line one
Line two
She said "hi"
C:\tests\report.txt

Print to a file

print() can write to a file instead of the screen with the file argument. The File Handling lesson explains open() in detail.

with open("log.txt", "w") as log:    print("test started", file=log)    print("test passed", file=log) print(open("log.txt").read())

test started
test passed

Comments

A comment starts with #. Python ignores everything from # to the end of the line. Use comments to explain why the code does something, not what it obviously does.

# Prices are stored in paise to avoid rounding errors with floatsprice_paise = 149950 discount = 0.10   # 10% festival discount, ends 15 Novfinal = price_paise * (1 - discount)print(final / 100)

1349.55

Multi-line comments

Python has no special multi-line comment. Put # at the start of each line. Most editors do this for a selection with Ctrl+/.

# Step 1: read the users file# Step 2: keep only active users# Step 3: print their namesusers = [("asha", True), ("ravi", False), ("meena", True)]print([name for name, active in users if active])

['asha', 'meena']

Docstrings

A string written as the first line of a function, class or module is a docstring. Unlike a comment, Python keeps it, and help() shows it.

def area(width, height):    """Return the area of a rectangle."""    return width * height print(area(3, 4))print(area.__doc__)

12
Return the area of a rectangle.

Check your understanding

print("a", "b", sep="*", end="!")print("c")

a*b!c

item = "Mouse", qty = 3, price = 349.5

Mouse | 3 | 1048.50

item = "Mouse"qty = 3price = 349.5print(item, qty, f"{qty * price:.2f}", sep=" | ")

Mouse | 3 | 1048.50

Program Practice

Python print and comments FAQ

Python Syntax

Syntax is the set of rules for how Python code must be written. Python’s rules are few, but one of them, indentation, is stricter than in most languages. Learn these rules once and most beginner errors disappear.

Statements and lines

A Python program is a list of statements, normally one per line. Python runs them from top to bottom. No semicolon is needed at the end of a line.

city = "Pune"temperature = 31print(city, temperature)

Pune 31

Indentation defines blocks

Many languages use curly braces { } to group lines. Python uses indentation: the spaces at the start of a line. A line ending in a colon : starts a block, and every line in that block must be indented by the same amount.

score = 82 if score >= 50:    print("Passed")          # inside the if block    print("Well done")       # also insideprint("Report finished")     # outside: runs every time

Passed
Well done
Report finished

Wrong indentation is a syntax error, and Python refuses to run the file:

if True:print("not indented")

  File "main.py", line 2
    print("not indented")
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 1

Indenting a line that should not be indented is also an error:

print("one")    print("two")

  File "main.py", line 2
    print("two")
IndentationError: unexpected indent

Blocks inside blocks

Each new block adds one more level of indentation. Python knows a block has ended when the indentation goes back.

for n in [1, 2, 3, 4]:    if n % 2 == 0:        print(n, "is even")    else:        print(n, "is odd")print("done")

1 is odd
2 is even
3 is odd
4 is even
done

Long lines

Python ends a statement at the end of the line, except inside brackets (), [] or {}. So the easiest way to split a long line is to wrap it in parentheses.

total = (    120    + 80    + 45)names = ["login", "search",         "checkout"]print(total, names)

245 ['login', 'search', 'checkout']

A backslash \ at the end of a line also continues it, but brackets are clearer and are what the PEP 8 style guide recommends.

Several statements on one line

A semicolon lets you put two statements on one line. It works, but it hurts readability, so use it rarely.

a = 1; b = 2; print(a + b)

3

Case sensitivity

Python is case-sensitive: name, Name and NAME are three different variables, and Print is not the same as print.

name = "Asha"Name = "Ravi"print(name, Name)Print("hello")

Asha Ravi
Traceback (most recent call last):
  File "main.py", line 4, in <module>
    Print("hello")
    ^^^^^
NameError: name 'Print' is not defined. Did you mean: 'print'?

Keywords

Keywords are reserved words with a special meaning, such as if, for and def. You cannot use them as variable names. The keyword module lists them:

import keywordprint(len(keyword.kwlist))print(keyword.kwlist)

35
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Check your understanding

x = 5if x > 3:    print("big")print("end")if x > 10:    print("huge")

big
end

print("Even numbers:")for n in range(1, 7):    if n % 2 == 0:        print(n)print("Done")

Even numbers:
2
4
6
Done

Program Practice

Python syntax FAQ