Master Python
matchandcasewith practical examples, structural pattern matching, guards, dictionaries, lists, tuples, classes, and professional coding tricks.
Python’s match statement is one of the most useful features introduced in Python 3.10.
At first glance, it looks similar to switch statements found in other programming languages. But Python’s match is much more powerful because it can match the value, type, structure, and contents of an object.
Instead of writing long if/elif chains, you can often express the same logic more clearly with:
match value:
case pattern:
...
Python’s official specification calls this structural pattern matching. A case can match literals, sequences, mappings, classes, OR patterns, wildcard patterns, and more.
1. Basic match Syntax
The basic structure is:
match value:
case pattern1:
# code
case pattern2:
# code
case _:
# default case
Example:
status = 200
match status:
case 200:
print("OK")
case 404:
print("Not Found")
case 500:
print("Server Error")
case _:
print("Unknown Status")
Output:
OK
The _ shortcut
The underscore is the wildcard pattern.
case _:
means:
Match anything that has not already matched a previous case.
It is similar to the else part of an if/elif/else structure.
2. Trick: Replace Long if/elif Chains
Instead of:
command = "start"
if command == "start":
print("Starting...")
elif command == "stop":
print("Stopping...")
elif command == "restart":
print("Restarting...")
else:
print("Unknown command")
Use:
match command:
case "start":
print("Starting...")
case "stop":
print("Stopping...")
case "restart":
print("Restarting...")
case _:
print("Unknown command")
This is easier to scan when you’re dealing with many discrete cases.
3. Trick: Match Multiple Values with |
Python allows OR patterns.
command = "quit"
match command:
case "quit" | "exit" | "close":
print("Closing program")
case "start" | "run":
print("Starting program")
case _:
print("Unknown command")
The | means:
Match any one of these patterns.
This is particularly useful when several inputs should trigger the same behavior.
The patterns in an OR pattern must bind the same set of names.
Shortcut
Instead of:
case "yes":
...
case "y":
...
case "Y":
...
you can write:
case "yes" | "y" | "Y":
...
4. Trick: Capture a Value with a Variable
A case can capture the matched value.
value = 42
match value:
case number:
print(f"Got: {number}")
Output:
Got: 42
Important warning
A bare variable name in a pattern is a capture pattern, not a comparison.
For example:
case number:
matches essentially anything and assigns it to number.
This is one of the most important match rules to understand. A capture pattern always succeeds.
So don’t write:
case status:
if you intended to compare against an existing variable named status.
For fixed constants, use literals or a qualified constant:
case Status.SUCCESS:
5. Trick: Add Conditions with if Guards
A pattern can have an additional condition called a guard.
age = 25
match age:
case n if n >= 18:
print("Adult")
case n:
print("Minor")
The pattern first captures the value as n.
Then:
if n >= 18
checks the additional condition.
The general syntax is:
case pattern if condition:
Python evaluates the guard after the pattern succeeds.
6. Trick: Combine Structure + Condition
This is where match becomes much more powerful.
user = ("Divesh", 21)
match user:
case (name, age) if age >= 18:
print(f"{name} is an adult")
case (name, age):
print(f"{name} is a minor")
Here Python performs two operations:
- Checks whether the value has the expected structure.
- Checks the condition.
This is much cleaner than manually indexing the tuple.
7. Trick: Match Lists and Tuples
You can match sequences directly.
point = [10, 20]
match point:
case [x, y]:
print(f"X={x}, Y={y}")
case _:
print("Invalid point")
Output:
X=10, Y=20
This is called a sequence pattern.
Python can match sequence structures and capture individual elements.
8. Trick: Use * to Capture the Remaining Items
This is one of the best match shortcuts.
numbers = [10, 20, 30, 40, 50]
match numbers:
case [first, *middle, last]:
print(first)
print(middle)
print(last)
Output:
10
[20, 30, 40]
50
The *middle captures the remaining elements as a list.
You can also use:
case [first, *rest]:
Example:
items = ["Python", "JavaScript", "C++", "Java"]
match items:
case [first, *rest]:
print("First:", first)
print("Remaining:", rest)
9. Trick: Match a Specific List Shape
You can require a specific structure.
data = [10, 20, 30]
match data:
case [10, 20, 30]:
print("Exact match")
case _:
print("Different data")
You can also combine literals and variables:
data = [10, 20, 30]
match data:
case [10, x, 30]:
print("Middle value:", x)
Output:
Middle value: 20
This is much more expressive than checking:
if len(data) == 3 and data[0] == 10 and data[2] == 30:
10. Trick: Match Dictionaries Directly
Dictionary matching is extremely useful when working with JSON-like data.
user = {
"name": "Divesh",
"role": "admin"
}
match user:
case {"role": "admin"}:
print("Administrator")
case {"role": "user"}:
print("Regular user")
case _:
print("Unknown role")
A mapping pattern checks whether the required keys exist and whether their associated values match the patterns.
11. Trick: Extract Dictionary Values While Matching
You can capture values from a dictionary.
user = {
"name": "Divesh",
"age": 21
}
match user:
case {"name": name, "age": age}:
print(f"{name} is {age} years old")
Output:
Divesh is 21 years old
This is excellent for processing structured API responses.
12. Trick: Capture Remaining Dictionary Data with **
You can capture the remaining keys.
data = {
"name": "Divesh",
"age": 21,
"city": "Delhi"
}
match data:
case {"name": name, **extra}:
print("Name:", name)
print("Extra:", extra)
Output:
Name: Divesh
Extra: {'age': 21, 'city': 'Delhi'}
This is a powerful technique when you know some important keys but want to preserve everything else.
13. Trick: Match Nested Data
You can combine patterns.
response = {
"status": "success",
"data": {
"id": 101,
"name": "Python"
}
}
match response:
case {
"status": "success",
"data": {"id": item_id, "name": name}
}:
print(item_id, name)
case {"status": "error"}:
print("Request failed")
case _:
print("Unknown response")
This is particularly useful for nested JSON-style structures.
Instead of repeatedly writing:
response["data"]["id"]
the pattern can extract the values directly.
14. Trick: Match Different Data Shapes
One of the biggest advantages of structural pattern matching is that you can handle completely different shapes.
value = ("Python", 3.14)
match value:
case [name, version]:
print(f"List: {name}, {version}")
case {"name": name, "version": version}:
print(f"Dictionary: {name}, {version}")
case str(text):
print(f"String: {text}")
case _:
print("Unknown structure")
The same match statement can describe several possible forms of input.
15. Trick: Match Built-in Types
You can use class patterns with built-in types.
value = "Python"
match value:
case str(text):
print("String:", text)
case int(number):
print("Integer:", number)
case float(number):
print("Float:", number)
case _:
print("Other type")
Output:
String: Python
This is more expressive than combining many separate isinstance() checks.
16. Trick: Match Custom Classes
Pattern matching also works with user-defined classes.
class User:
def __init__(self, name, age):
self.name = name
self.age = age
user = User("Divesh", 21)
match user:
case User(name, age):
print(f"{name} is {age}")
Output:
Divesh is 21
Class patterns can match an instance and extract selected attributes. Python uses __match_args__ to determine how positional class patterns map to attributes.
17. Trick: Use Dataclasses with match
Dataclasses work particularly nicely with pattern matching.
from dataclasses import dataclass
@dataclass
class Product:
name: str
price: float
product = Product("Laptop", 75000)
match product:
case Product(name, price):
print(name, price)
Output:
Laptop 75000
Dataclasses automatically provide a suitable __match_args__ based on their fields, making positional matching convenient.
18. Trick: Build a Clean Command Router
A practical application is command handling.
def handle_command(command):
match command.split():
case ["start"]:
return "Starting..."
case ["stop"]:
return "Stopping..."
case ["user", username]:
return f"Loading user: {username}"
case ["search", *terms]:
return f"Searching for: {' '.join(terms)}"
case _:
return "Unknown command"
print(handle_command("user Divesh"))
print(handle_command("search python match tutorial"))
Possible output:
Loading user: Divesh
Searching for: python match tutorial
Notice how the command is split into a list and then matched structurally.
This is a great example of where match can be much more expressive than a long collection of string comparisons.
19. Trick: Match HTTP-Style Responses
You can use matching for structured application responses.
response = {
"status": 200,
"data": ["Python", "JavaScript"]
}
match response:
case {"status": 200, "data": data}:
print("Success:", data)
case {"status": 404}:
print("Not found")
case {"status": status} if status >= 500:
print("Server error")
case _:
print("Unexpected response")
This combines:
- Dictionary matching
- Value matching
- Variable capture
- Guards
- Wildcards
That combination is where match becomes especially powerful.
20. Trick: Use as to Capture the Entire Matched Value
You can capture a larger pattern as a whole.
data = [1, 2, 3]
match data:
case [1, *rest] as original:
print("Original:", original)
print("Rest:", rest)
Output:
Original: [1, 2, 3]
Rest: [2, 3]
The as pattern lets you match a structure while also keeping the complete subject available.
21. Trick: Create a Mini State Machine
match is excellent for small state machines.
state = ("logged_in", "admin")
match state:
case ("logged_out", _):
print("Show login page")
case ("logged_in", "admin"):
print("Show admin dashboard")
case ("logged_in", "user"):
print("Show user dashboard")
case _:
print("Unknown state")
Instead of nested conditions, the state and its structure are described directly.
22. Trick: Match Enums Safely
For constants, qualified names are useful.
from enum import Enum
class Status(Enum):
SUCCESS = 1
ERROR = 2
status = Status.SUCCESS
match status:
case Status.SUCCESS:
print("Success")
case Status.ERROR:
print("Error")
This is preferable to accidentally writing a bare variable as a capture pattern.
Remember:
case Status.SUCCESS:
is a value pattern, while:
case status:
is a capture pattern.
23. Trick: Combine | with Guards
You can combine alternatives and conditions.
value = 15
match value:
case int(n) if n < 0:
print("Negative integer")
case int(n) if n == 0:
print("Zero")
case int(n) if n > 0:
print("Positive integer")
case _:
print("Not an integer")
Another useful example:
command = "YES"
match command.lower():
case "yes" | "y":
print("Confirmed")
case "no" | "n":
print("Cancelled")
case _:
print("Invalid response")
24. Professional Trick: Keep Cases Ordered from Specific to General
This is one of the most important rules.
Bad ordering:
value = 10
match value:
case n:
print("Anything")
case 10:
print("Ten")
The first case captures everything, so the 10 case can never be selected.
Better:
match value:
case 10:
print("Ten")
case n:
print("Other value:", n)
The general case should normally come last.
Python’s specification requires an irrefutable case such as a wildcard or unrestricted capture to be last.
25. Professional Trick: Use _ When You Don’t Need the Value
Suppose you only care about the structure.
Instead of:
match point:
case [x, y]:
print("Valid point")
if you don’t need either value, use:
match point:
case [_, _]:
print("Valid point")
The _ wildcard does not bind a variable.
This communicates your intention clearly.
26. match vs if/elif
Traditional approach
if command == "start":
...
elif command == "stop":
...
elif command == "restart":
...
else:
...
Modern approach
match command:
case "start":
...
case "stop":
...
case "restart":
...
case _:
...
But match isn’t automatically better for every situation.
Use if when you have primarily arbitrary Boolean conditions:
if score >= 90:
...
elif score >= 75:
...
Use match when you’re describing specific values or structures:
match result:
case {"status": "success", "data": data}:
...
case {"status": "error", "message": message}:
...
27. Ultimate Python match Cheat Sheet
| Pattern | Meaning |
|---|---|
case 10: | Match the value 10 |
case "Python": | Match a string |
case True: | Match True |
case None: | Match None |
case _: | Match anything |
case x: | Capture the value into x |
case 1 | 2: | Match 1 OR 2 |
case [x, y]: | Match a 2-item sequence |
case [first, *rest]: | Capture first + remaining items |
case {"name": name}: | Match dictionary key and capture value |
case {"name": name, **extra}: | Capture remaining dictionary entries |
case int(x): | Match an integer and capture it |
case User(name, age): | Match a User object |
case pattern if condition: | Pattern + additional condition |
case pattern as value: | Match pattern and capture whole value |
These patterns correspond to Python’s structural pattern-matching system, which includes literal, capture, wildcard, OR, sequence, mapping, and class patterns.
28. The 10 Best match Shortcuts to Memorize
Shortcut 1 — Default case
case _:
Shortcut 2 — Multiple values
case "yes" | "y":
Shortcut 3 — Extract sequence values
case [x, y]:
Shortcut 4 — Capture remaining sequence
case [first, *rest]:
Shortcut 5 — Match dictionary keys
case {"id": id}:
Shortcut 6 — Capture extra dictionary data
case {"id": id, **extra}:
Shortcut 7 — Add conditions
case n if n > 100:
Shortcut 8 — Match a type
case str(text):
Shortcut 9 — Match a class
case User(name, age):
Shortcut 10 — Preserve the entire value
case [x, y] as point:
29. Real-World Example: A Modern Event Handler
Here’s a compact example combining several techniques:
def handle_event(event):
match event:
case {"type": "login", "user": user}:
return f"{user} logged in"
case {"type": "logout", "user": user}:
return f"{user} logged out"
case {"type": "message", "from": sender, "text": text}:
return f"{sender}: {text}"
case {"type": "error", "code": code} if code >= 500:
return "Server error"
case {"type": "error", "code": code}:
return f"Client error: {code}"
case _:
return "Unknown event"
event = {
"type": "message",
"from": "Divesh",
"text": "Hello Python"
}
print(handle_event(event))
Output:
Divesh: Hello Python
This style is particularly clean for event-driven applications where different events have different structures.
30. Important Mistakes to Avoid
Mistake 1: Treating a variable as a constant
Don’t assume:
case status:
means:
value == status
It is a capture pattern.
Use a literal or qualified constant instead.
Mistake 2: Putting _ too early
Avoid:
match value:
case _:
print("Anything")
case 10:
print("Ten")
The 10 case will never be reached.
Use:
match value:
case 10:
print("Ten")
case _:
print("Anything else")
Mistake 3: Using match for everything
Don’t replace every if statement with match.
For example:
if temperature > 30:
print("Hot")
is perfectly readable.
match shines when the input has recognizable values or structures.
31. Modern Python Pattern-Matching Formula
A useful mental model is:
match
↓
What is the input?
↓
case
↓
Does its value or structure match?
↓
Optional guard
↓
Run the selected block
Think of match as:
“Look at this value and tell me which known shape it has.”
That mindset makes structural pattern matching much easier to understand.
Conclusion
Python’s match statement is much more than a traditional switch statement.
It can match:
- Values
- Multiple alternatives
- Lists
- Tuples
- Nested structures
- Dictionaries
- Dictionary contents
- Built-in types
- Custom classes
- Dataclasses
- Conditions
- Extracted variables
- Remaining sequence items
- Remaining mapping items
The biggest advantage is that it lets you express data structure and decision logic together.
If you’re using Python 3.10 or newer, learning match is worth it—especially for command parsers, JSON-like data, event handlers, state machines, AST processing, and applications with multiple structured input types. Python’s official documentation confirms that the match statement was added in Python 3.10.
Quick rule to remember
match value:
case specific_pattern:
...
case another_pattern:
...
case _:
...
Specific first. General last.
Master that principle, then add:
|
*
**
if
as
and you’ll have the core toolkit for modern Python structural pattern matching.
