Comment effectuer une correspondance de motifs structurels approximatifs pour les flotteurs et complexes

La clé de la solution consiste à construire un wrapper qui remplace la méthode __ eq __ et le remplace par une correspondance approximative:

0.9999999999999999 sums to about 1.0
3.3000000000000003 sums to about 3.3
0.7071067811865475 is close to sqrt(2) / 2

Il crée des tests d'égalité approximatifs pour Les deux valeurs flottantes et les valeurs complexes:

for x in [sum([0.1] * 10), 1.1 + 2.2, sin(radians(45))]:
    match Approximately(x):
        case 1.0:
            print(x, 'sums to about 1.0')
        case 3.3:
            print(x, 'sums to about 3.3')
        case 0.7071067811865475:
            print(x, 'is close to sqrt(2) / 2')
        case _:
            print('Mismatch')

Voici comment l'utiliser dans une instruction MATCH / Case:

>>> Approximately(1.1 + 2.2) == 3.3
True
>>> Approximately(1.1 + 2.2, abs_tol=0.2) == 3.4
True
>>> Approximately(1.1j + 2.2j) == 0.0 + 3.3j
True

Cela sort:

import cmath

class Approximately(complex):

    def __new__(cls, x, /, **kwargs):
        result = complex.__new__(cls, x)
        result.kwargs = kwargs
        return result

    def __eq__(self, other):
        try:
            return isclose(self, other, **self.kwargs)
        except TypeError:
            return NotImplemented

La réponse de Raymond est très sophistiquée et ergonomique, mais semble être beaucoup de magie pour quelque chose qui pourrait être beaucoup plus simple. Une version plus minimale serait simplement de capturer la valeur calculée et de vérifier explicitement si les choses sont "fermées", par exemple :

from dataclasses import dataclass

@dataclass
class Square:
    size: float

@dataclass
class Rectangle:
    width: float
    height: float

def classify(obj: Square | Rectangle) -> str:
    match obj:
        case Square(size=x) if math.isclose(x, 1):
            return "~unit square"

        case Square(size=x):
            return f"square, size={x}"

        case Rectangle(width=w, height=h) if math.isclose(w, h):
            return "~square rectangle"

        case Rectangle(width=w, height=h):
            return f"rectangle, width={w}, height={h}"

almost_one = 1 + 1e-10
print(classify(Square(almost_one)))
print(classify(Rectangle(1, almost_one)))
print(classify(Rectangle(1, 2)))

Je suggère également d'utiliser cmath.isclose () où / Lorsque vous en avez réellement besoin, en utilisant les types appropriés, vous permet de vous assurer que votre code fait ce que vous attendez.

L'exemple ci-dessus est juste le code minimum utilisé pour démontrer la correspondance et, Comme indiqué dans les commentaires, pourrait être plus facilement implémenté à l'aide d'une instruction IF traditionnelle. Au risque de faire dérailler la question d'origine, il s'agit d'un exemple un peu plus complet:

import math

match 1.1 + 2.2:
    case x if math.isclose(x, 3.3):
        print(f"{x} is close to 3.3")
    case x:
        print(f"{x} wasn't close)

Je ne sais pas si j'utiliserais réellement une instruction Match Ici, mais espérons-le, plus représentatif!