Update

I condensed this answer into a python package to make matching as easy as pip install regex-spm,

import regex_spm

match regex_spm.fullmatch_in("abracadabra"):
  case r"\d+": print("It's all digits")
  case r"\D+": print("There are no digits in the search string")
  case _: print("It's something else")

Original answer

As Patrick Artner correctly points out in the other answer, there is currently no official way to do this. Hopefully the feature will be introduced in a future Python version and this question can be retired. Until then:

PEP 634 specifies that Structural Pattern Matching uses the == operator for evaluating a match. We can override that.

import re
from dataclasses import dataclass

# noinspection PyPep8Naming
@dataclass
class regex_in:
    string: str

    def __eq__(self, other: str | re.Pattern):
        if isinstance(other, str):
            other = re.compile(other)
        assert isinstance(other, re.Pattern)
        # TODO extend for search and match variants
        return other.fullmatch(self.string) is not None

Now you can do something like:

match regex_in(validated_string):
    case r'\d+':
        print('Digits')
    case r'\s+':
        print('Whitespaces')
    case _:
        print('Something else')

Caveat #1 is that you can't pass re.compile'd patterns to the case directly, because then Python wants to match based on class. You have to save the pattern somewhere first.

Caveat #2 is that you can't actually use local variables either, because Python then interprets it as a name for capturing the match subject. You need to use a dotted name, e.g. putting the pattern into a class or enum:

class MyPatterns:
    DIGITS = re.compile('\d+')

match regex_in(validated_string):
    case MyPatterns.DIGITS:
        print('This works, it\'s all digits')

Groups

This could be extended even further to provide an easy way to access the re.Match object and the groups.

# noinspection PyPep8Naming
@dataclass
class regex_in:
    string: str
    match: re.Match = None

    def __eq__(self, other: str | re.Pattern):
        if isinstance(other, str):
            other = re.compile(other)
        assert isinstance(other, re.Pattern)
        # TODO extend for search and match variants
        self.match = other.fullmatch(self.string)
        return self.match is not None

    def __getitem__(self, group):
        return self.match[group]

# Note the `as m` in in the case specification
match regex_in(validated_string):
    case r'\d(\d)' as m:
        print(f'The second digit is {m[1]}')
        print(f'The whole match is {m.match}')

Clean solution

There is a clean solution to this problem. Just hoist the regexes out of the case-clauses where they aren't supported and into the match-clause which supports any Python object.

The combined regex will also give you better efficiency than could be had by having a series of separate regex tests. Also, the regex can be precompiled for maximum efficiency during the match process.

Example

Here's a worked out example for a simple tokenizer:

pattern = re.compile(r'(\d+\.\d+)|(\d+)|(\w+)|(".*)"')
Token = namedtuple('Token', ('kind', 'value', 'position'))
env = {'x': 'hello', 'y': 10}

for s in ['123', '123.45', 'x', 'y', '"goodbye"']:
    mo = pattern.fullmatch(s)
    match mo.lastindex:
        case 1:
            tok = Token('NUM', float(s), mo.span())
        case 2:
            tok = Token('NUM', int(s), mo.span())
        case 3:
            tok = Token('VAR', env[s], mo.span())
        case 4:
            tok = Token('TEXT', s[1:-1], mo.span())
        case _:
            raise ValueError(f'Unknown pattern for {s!r}')
    print(tok) 

This outputs:

Token(kind='NUM', value=123, position=(0, 3))
Token(kind='NUM', value=123.45, position=(0, 6))
Token(kind='VAR', value='hello', position=(0, 1))
Token(kind='VAR', value=10, position=(0, 1))
Token(kind='TEXT', value='goodbye', position=(0, 9))

Better Example

The code can be improved by writing the combined regex in verbose format for intelligibility and ease of adding more cases. It can be further improved by naming the regex sub patterns:

pattern = re.compile(r"""(?x)
    (?P<float>\d+\.\d+) |
    (?P<int>\d+) |
    (?P<variable>\w+) |
    (?P<string>".*")
""")

That can be used in a match/case statement like this:

for s in ['123', '123.45', 'x', 'y', '"goodbye"']:
    mo = pattern.fullmatch(s)
    match mo.lastgroup:
        case 'float':
            tok = Token('NUM', float(s), mo.span())
        case 'int':
            tok = Token('NUM', int(s), mo.span())
        case 'variable':
            tok = Token('VAR', env[s], mo.span())
        case 'string':
            tok = Token('TEXT', s[1:-1], mo.span())
        case _:
            raise ValueError(f'Unknown pattern for {s!r}')
    print(tok)

Comparison to if/elif/else

Here is the equivalent code written using an if-elif-else chain:

for s in ['123', '123.45', 'x', 'y', '"goodbye"']:
    if (mo := re.fullmatch('\d+\.\d+', s)):
        tok = Token('NUM', float(s), mo.span())
    elif (mo := re.fullmatch('\d+', s)):
        tok = Token('NUM', int(s), mo.span())
    elif (mo := re.fullmatch('\w+', s)):
        tok = Token('VAR', env[s], mo.span())
    elif (mo := re.fullmatch('".*"', s)):
        tok = Token('TEXT', s[1:-1], mo.span())
    else:
        raise ValueError(f'Unknown pattern for {s!r}')
    print(tok)

Compared to the match/case, the if-elif-else chain is slower because it runs multiple regex matches and because there is no precompilation. Also, it is less maintainable without the case names.

Because all the regexes are separate we have to capture all the match objects separately with repeated use of assignment expressions with the walrus operator. This is awkward compared to the match/case example where we only make a single assignment.

The following example is based on R. Hettinger's talk discussing an approach similar to @ahoff's post.

Given

import re


class RegexEqual(str):
    def __eq__(self, pattern):
        return bool(re.search(pattern, self))

Code

def validate(s):
    """A naive string validator."""
    match RegexEqual(s):
        case r"\d+":
            return "Number found"
        case r"\w+":
            return "Letter found"
        case _:
            return "Unknown"

Demo

validate("123")
# 'Number found'
validate("hi")
# 'Letter found'
validate("...")
# 'Unknown'

Details

RegexEqual is a direct subclass of str that simply overrides the == operator.

RegexEqual("hello") == "h...o"
# True

See Also

• R. Hettinger's toolkit on common match-case workarounds.

It's a little obvious and not at all fancy, but pretty readable -- just put it in the guard.

import re, logging
logger = logging.getLogger(__name__)
def singularize(plural:str) -> str:
    '''
    If I can make a reaonable guess at a singular form, return it

    :param plural: Candidate plural like 'Philadelphia 76ers'
    :return: Singular form if calculated, or argument
    '''
    match plural:
        case ies if form := re.fullmatch(r'(?i)(\w+)ies', ies):
            # gravies
            singular = f"{form.group(1)}y"
        case oes if form := re.fullmatch(r'(?i)(\w+o)es', oes):
            # potatoes
            singular = form.group(1)
        case xim if form := re.fullmatch(r'(?i)(\w+)im', xim):
            # chaverim
            singular = form.group(1)
        case xes if form := re.fullmatch(r'(?i)(\w+)es', xes):
            #glasses
            singular = form.group(1)
        case xxs if form := re.fullmatch(r'(?i)(\w*[A-RT-Z]s)', xxs):
            # books
            singular = form.group(1)
        case ata if form := re.fullmatch(r'(?i)(\w+at)a', ata):
            # data
            singular = f"{form.group(1)}um"
        case xxi if form := re.fullmatch(r'(?i)(\w+)i', xxi):
            # illuminati
            singular = f"{form.group(1)}us"
        case xae if form := re.fullmatch(r'(?i)(\w+a)e', xae):
            # alumnae
            singular = form.group(1)
        case default:
            # all sorts of plural forms not covered, but I'm really just trying to convert labels to label
            singular = default
    logger.debug(f"{singular} singularized from {plural}")
    return singular

Just a small snippet from some WIP of mine. Works like a charm.

pattern = re.compile(r"""
(?P<empty>^$)|                      # empty line
(?P<bigcomment>^(\#\#\#))|          # comment block
(?P<comment>^(\#))                  # single line comment
(?P<newdoc>^((\=\=\=)|(\-\-\-)))|   # new document
(?P<catchall>.*)
""",
re.VERBOSE,
)
for line in lines.splitlines():
    mo = pattern.search(line)  # Match object
    assert mo is not None, f"Line: {line}"  # otherwise the typechecker complains that mo could be None (which logically can't happen with the catchall)

    match mo.lastgroup:
        case "empty":continue
        case "bigcomment": ...

Although the OP asked for a solution using structural pattern matching, actually one can be looking for just a neat code or one in a funcional style. In that case:

patterns = ['^hof.*', r'a\w+c.*', '^[1-3].*']

def search(str):
  return 'found' if any([re.search(p, str) is not None for p in patterns]) else 'not found'

Usage:

search('hof!')      #found
search('abc')       #found
search('1234')      #found
search('spaghetti') #not found