How to distinguish between a tuple and a list in Python's structural pattern matching?

Question

I want to use Python's structural pattern matching to distinguish between a tuple (e.g. representing a point) and a list of tuples.

The straightforward approach does not work though:

def fn(p):
    match p:
        case (x, y):
            print(f"single point: ({x}, {y})")
        case [*points]:
            print("list of points:")
            for x, y in points:
                print(f"({x}, {y})")

fn((1, 1))
fn([(1, 1), (2, 2)])

which outputs:

single point: (1, 1)
single point: ((1, 1), (2, 2))

whereas I want it to output:

single point: (1, 1)
list of points:
(1, 1)
(2, 2)

Switching the order of the case statements also does not help here.

What is a good way to solve this with pattern matching?

*points is a list, so can you just use `case *points:`? Or put it before (above) the other case? — DisappointedByUnaccountableMod, Nov 19 '21 at 11:45
Your first case could explicitly match on a tuple containing two integers - `case (int(x), int(y)):`? — Iain Shelvington, Nov 19 '21 at 11:47
@balmy that would be a syntax error. The problem seems to be that python treats all sequences the same — mihi, Nov 19 '21 at 11:50
@IainShelvington that does indeed work! But is there also a more general approach, like when the tuple contents are arbitrary? — mihi, Nov 19 '21 at 11:50
@mihi yes, I added an answer below with an example of how to match a tuple or list — Iain Shelvington, Nov 19 '21 at 11:57

score 6 · Accepted Answer · answered Nov 19 '21 at 11:56

Use tuple(foo) for matching a tuple and list(foo) for matching a list

def fn(p):
    match p:
        case tuple(contents):
            print(f"tuple: {contents}")
        case list(contents):
            print(f"list: {contents}")

fn((1, 1))  # tuple: (1, 1)
fn([(1, 1), (2, 2)])  # list: [(1, 1), (2, 2)]

How to distinguish between a tuple and a list in Python's structural pattern matching?

1 Answers1