Structural Pattern Matching in Python

Structural Pattern Matching
Haim Michael
September 20th
, 2022
All logos, trade marks and brand names used in this presentation belong
to the respective owners.
https://youtu.be/xgRYrs_jy5E
life michael

© 2021 Haim Michael All Rights Reserved 2
Introduction
 As of Python 3.10 we can use patterns matching. There are
three PEPs (Python Enhancement Proposals) describing this
feature:
PEP 634: The Specification
https://www.python.org/dev/peps/pep-0634
PEP 635: Motivation and Rationale
PEP 636: Patterns Matching Tutorial

Switch Statement on Steroids
 We can consider patterns matching as a switch statement on
steroids.

Matching Specific Values
 The simplest form of patterns matching in Python would be a
simple use case similar to switch statement.
command = "+"
match command:
case '+':
print('plus...')
case '-':
print('minus')
case '*':
print('multiply')
case '/':
print('divide')

The _ Wildcard
 We can use the _ character as a wild card. We shall place the
wild card as the last case possibility. If none of the other
cases matches, the wild card will.
command = "%"
match command:
case '+':
print('plus...')
case '-':
print('minus')
case '/':
print('divide')
case _:
print('soething else')

Matching Sequences
 We can match a sequence with possible sequences
composed of literals or variables.
operation = ("deposit",1200,123222)
operation = ("transfer",800,123222,101888)
match operation:
case operation,sum,account_id:
print("%s %f %d" % (operation,sum,account_id))
case operation, sum, from_id, to_id:
print("%s %f from %d to %d" % (operation, sum, from_id, to_id))

Matching Sequences
operation = ["playing","pacman"]
match operation:
case ["eat",food]:
print("eating %s is great" % (food,))
case ["watching",show]:
print("enjoy watching %s" % (show,))
case ["playing",game]:
print("playing %s is awesome" % (game,))
case _:
print("your operation cannot be recognized")

Matching Multiple Values
 We can use the packing capability similarly to the way we use
it in assignments.

Matching Multiple Values
operation = ("delete","Hello.py","Calcu.py","Demo.py")
match operation:
case "delete",*files:
print("the following files will be deleted:")
for file in files:
print(file)
case "makedir",*directories:
print("the following directories will be created:")
for directory in directories:
print(directory)
case _:
print("the requesed operation is not recognized")

Composing Patters
 We can compose new patterns composed from others.
Patterns that don't include other patterns can be any of the
following: capture patterns, literal patterns, and the wildcard
pattern _.

Composing Patters
operation = ("update_mark",("mosh",234234),103444,88)
match operation:
case "register_course",student,course_id:
print("registering to course")
print(student)
print(course_id)
case "update_mark",(student_name,student_id),course_id,mark:
print("updating mark in specific course")
print("student name: %s", student_name)
print("student id: %d" % (student_id,))
print("course id: %d" % (course_id,))
print("mark: %.2f" % (mark,))

Or Patterns
 We can use the | operator (AKA the or operator) in order to
create a case that includes more than one pattern. Matching
any of the patterns will be considered as matching the entire
case.

Or Patterns
command = ("del","temp.txt")
match command:
case ("delete",file) | ("remove",file) | ("del",file):
print("deleting file %s" % (file,))
case ("copy",file,newfile):
print("copying file %s to %s" % (file,newfile))

The as Pattern
 We can use the or operator for creating a sub pattern
composed of multiple possibilities. We can use the as pattern
for finding which is the exact possibility that match.

The as Pattern
data = ("del","temp.txt")
match data:
case (("delete" | "remove" | "del") as command, file):
print("command=%s" % (command,))

Adding Conditions
 We can add a condition to specific cases. The condition
includes the use of the if keyword followed by expression that
its value is of the type bool.

Adding Conditions
data = ("del","temp.txt")
files = ["readme.txt", "temp.txt", "index.txt"]
match data:
case (("delete" | "remove" | "del") as command, file) if file in files:
print("command=%s" % (command,))
case (("delete" | "remove" | "del") as command, file) if file not in files:
print("the file %s cannot be deleted" % file)

Matching Objects Types
 When having an object we need to examine its type and its
attributes we can avoid the use of isinstance() and we
can avoid checking its attributes.

class Dog:
def hau(self):
return "hau hau"
class Cat:
def __init__(self,predator):
self.predator = predator
def miaou(self):
return "miaou miaou"
class Cow:
def moo(self):
return "moo moo"
ob = Cat(True)

match ob:
case Dog():
print(ob.hau())
case Cat(predator=False):
print(ob.miaou())
case Cat(predator=True):
print("%s grrrrr" % ob.miaou())
case Cow():
print(ob.moo())

Matching Attributes By Position
 When using objects that were instantiated from a class
marked as dataclass we can describe the matched
attributes by position.

Matching Attributes By Position
from dataclasses import dataclass
from math import pow, sqrt
@dataclass
class Point:
x: int
y: int
@dataclass
class Line:
p1: Point
p2: Point
ob = Line(Point(3, 4), Point(6, 8))
match ob:
case Line(p1, p2):
print(sqrt(pow(p2.x - p1.x, 2) + pow(p2.y - p1.y, 2)))
case Point(x, y):
print(sqrt(pow(x, 2) + pow(y, 2)))

The __match_args__ Attribute
 When using objects that were not instantiated from a class
marked as dataclass and were not instantiated from the
tuple type we can still describe the matched attributes by
position if we add the __match_args__ attribute to the
class definition.
 The __match_args__ special attribute defines an explicit
order for the attributes.

from math import pow, sqrt
class Point:
__match_args__ = ("x", "y")
def __init__(self, x, y):
self.x = x
self.y = y
class Line:
__match_args__ = ("p1", "p2")
def __init__(self, p1, p2):
self.p1 = p1
self.p2 = p2
ob = Line(Point(3, 4), Point(6, 8))

match ob:
case Line(p1, p2):
print(sqrt(pow(p2.x - p1.x, 2) + pow(p2.y - p1.y, 2)))
case Point(x, y):
print(sqrt(pow(x, 2) + pow(y, 2)))

Enums Matching
 We can match agains possible values that were defined as
part of an Enum object.
from enum import Enum
class Color(Enum):
BLUE = 1
GREEN = 2
RED = 3
BLACK = 4
WHITE = 5
class Car:
__match_args__ = ("brand", "id", "color")
def __init__(self, brand, id, color):
self.brand = brand
self.id = id
self.color = color

Enums Matching
ob = Car("Mazda 6", 2342343, Color.GREEN)
match ob:
case Car(car_brand, car_id, Color.WHITE):
print("white cars are simpler to handle")
case Car(car_brand, car_id, Color.BLACK):
print("black cars aborb the heat")
case Car(car_brand, car_id, _):
print("colorful cars are more fun")

Mappings Matching
 We can match an expression against a dict object. The
matching will be based on the keys.

Mappings Matching
 We can match an expression against a dict object. The
matching will be based on the keys.
command = {
'action': 'getbalance',
'account': {
'accountid': 204714,
'owners_ids': (24537564, 51634545)
}}

Mappings Matching
match command:
case {'action': 'getbalance', 'account': account}:
print("getting balance")
print("account id: %s" % (account['accountid'],))
print("account owners are:")
print(account['owners_ids'])
case {'action': 'deposit', 'sum': sum, 'account': account}:
print("deposit %f" % sum)
print("account id: %s" % (account,))

Mappings Matching
 We can use the dict packing capability when matching a dict
object with additional key value pairs that don't match any of
the pattern's parts.
command = {
'account': {
'owners_ids': (24537564, 51634545)
},
'date': {'day':12,'month':1,'year':1980},
'time': {'hour': 14, 'minutes': 20}
}

Mappings Matching
match command:
case {'action': 'getbalance', 'account': account, **ob}:
print("getting balance")
print(ob)
case {'action': 'deposit', 'sum': sum, 'account': account, **ob}:
print("deposit %f" % sum)
print("account id: %s" % (account,))
print(ob)

Matching Builtin Types
 We can use builtin types for validating the types of specific
parts in the expression we check.
data = {
'sum':800,
'account': {
'owners_ids': (24537564, 51634545)
}
}

Matching Builtin Types
match data:
case {'action': str() as action, 'account': account}:
print(action)
case _:
print(data)

Questions & Answers
Thanks for Your Time!
Haim Michael
haim.michael@lifemichael.com
+972+3+3726013 ext:700
life
michael

Structural Pattern Matching in Python

More Related Content

Similar to Structural Pattern Matching in Python (20)

More from Haim Michael (20)

Recently uploaded (20)

Structural Pattern Matching in Python