使用结构模式匹配来检测可哈希性

Question

使用结构模式匹配，你如何编写一个匹配可哈希对象的案例？

Answer 1

Core problem

All classes start out by being hashable because they inherit from object which defines a __hash__() method based on the object id:

>>> hash(object())
269091997

To become unhashable, classes have to override object and set __hash__ to None :

class UnhashableTuple(tuple):
    __hash__ = None

Structural pattern matching can match cases when the __hash__ attribute is None , but it doesn't provide a direct way to detect when the attribute is not None .

Solution

Build two cases. The first case filters-out unhashable instances. This leaves only hashable instances for the second case.

Example

Here we test a number of objects for hashability:

for obj in [], (), set(), frozenset(), 10, None, dict():
    match obj:
        case object(__hash__=None):
            print('Unhashable type:', type(obj))
        case object(__hash__=_):
            print('Hashable type:  ', type(obj))

This outputs:

Unhashable type: <class 'list'>
Hashable type:   <class 'tuple'>
Unhashable type: <class 'set'>
Hashable type:   <class 'frozenset'>
Hashable type:   <class 'int'>
Hashable type:   <class 'NoneType'>
Unhashable type: <class 'dict'>

Containers

For containers, the above only detects whether the container is hashable. It is possible that the elements in the container are unhashable.

Fortunately, pattern matching can destructure an object and let you test you test the components as well as the container (using the same technique). This is somewhat messy though.

Answer 2

Raymond Hettinger's answer works in limited cases, but it fails on inputs like list , which is hashable even though list.__hash__ is None , and inputs like ([1, 2], [3, 4]) , which is unhashable even though tuple.__hash__ is not None .

The most reliable way to detect whether an object is hashable is always going to be to try to hash it. If you want to do that in a case statement, the easiest way would be to write a guard:

def hashable(x):
    try:
        hash(x)
    except TypeError:
        return False
    else:
        return True

match x:
    case _ if hashable(x):
        ...
    ...

This just directly calls hash(x) and sees whether it works, instead of trying to perform a structural check.

If you need the hash and want to avoid double-computation, you can save the hash(x) result:

def try_hash(x):
    try:
        return hash(x)
    except TypeError:
        return None

match x:
    case _ if (x_hash := try_hash(x)) is not None:
        ...
    ...