https://pypi.org/project/pampy/
santinic/pampy: Pampy: The Pattern Matching for Python you always dreamed of. (github.com)
All the things you can match
As Pattern you can use any Python type, any class, or any Python value.
The operator _
and built-in types like int
or str
, extract variables that are passed to functions.
Types and Classes are matched via instanceof(value, pattern)
.
Iterable
Patterns match recursively through all their elements. The same goes for dictionaries.
Pattern Example | What it means | Matched Example | Arguments Passed to function | NOT Matched Example |
---|---|---|---|---|
"hello" |
only the string "hello" matches |
"hello" |
nothing | any other value |
None |
only None |
None |
nothing | any other value |
int |
Any integer | 42 |
42 |
any other value |
float |
Any float number | 2.35 |
2.35 |
any other value |
str |
Any string | "hello" |
"hello" |
any other value |
tuple |
Any tuple | (1, 2) |
(1, 2) |
any other value |
list |
Any list | [1, 2] |
[1, 2] |
any other value |
MyClass |
Any instance of MyClass. And any object that extends MyClass. | MyClass() |
that instance | any other object |
_ |
Any object (even None) | that value | ||
ANY |
The same as _ |
that value | ||
(int, int) |
A tuple made of any two integers | (1, 2) |
1 and 2 |
(True, False) |
[1, 2, _] |
A list that starts with 1, 2 and ends with any value | [1, 2, 3] |
3 |
[1, 2, 3, 4] |
[1, 2, TAIL] |
A list that start with 1, 2 and ends with any sequence | [1, 2, 3, 4] |
[3, 4] |
[1, 7, 7, 7] |
{'type':'dog', age: _ } |
Any dict with type: "dog" and with an age |
{"type":"dog", "age": 3} |
3 |
{"type":"cat", "age":2} |
{'type':'dog', age: int } |
Any dict with type: "dog" and with an int age |
{"type":"dog", "age": 3} |
3 |
{"type":"dog", "age":2.3} |
re.compile('(\w+)-(\w+)-cat$') |
Any string that matches that regular expression expr | "my-fuffy-cat" |
"my" and "puffy" |
"fuffy-dog" |
Pet(name=_, age=7) |
Any Pet dataclass with age == 7 |
Pet('rover', 7) |
['rover'] |
Pet('rover', 8) |
Any |
The same as _ |
that value | ||
Union[int, float, None] |
Any integer or float number or None | 2.35 |
2.35 |
any other value |
Optional[int] |
The same as Union[int, None] |
2 |
2 |
any other value |
Type[MyClass] |
Any subclass of MyClass. And any class that extends MyClass. | MyClass |
that class | any other object |
Callable[[int], float] |
Any callable with exactly that signature | def a(q:int) -> float: ... |
that function | def a(q) -> float: ... |
Tuple[MyClass, int, float] |
The same as (MyClass, int, float) |
|||
Mapping[str, int] Any subtype of Mapping acceptable too |
any mapping or subtype of mapping with string keys and integer values | {'a': 2, 'b': 3} |
that dict | {'a': 'b', 'b': 'c'} |
Iterable[int] Any subtype of Iterable acceptable too |
any iterable or subtype of iterable with integer values | range(10) and [1, 2, 3] |
that iterable | ['a', 'b', 'v'] |
Using default
By default match()
is strict. If no pattern matches, it raises a MatchError
.
You can instead provide a fallback value using default
to be used when nothing matches.
>>> match([1, 2], [1, 2, 3], "whatever")
MatchError: '_' not provided. This case is not handled: [1, 2]
>>> match([1, 2], [1, 2, 3], "whatever", default=False)
False
Using Regular Expressions
Pampy supports Python's Regex. You can pass a compiled regex as pattern, and Pampy is going to run pattern.search()
, and then pass to the action function the result of .groups()
.
def what_is(pet): return match(pet, re.compile('(\w+)-(\w+)-cat$'), lambda name, my: 'cat '+name, re.compile('(\w+)-(\w+)-dog$'), lambda name, my: 'dog '+name, _, "something else" ) what_is('fuffy-my-dog') # => 'dog fuffy' what_is('puffy-her-dog') # => 'dog puffy' what_is('carla-your-cat') # => 'cat carla' what_is('roger-my-hamster') # => 'something else'标签:Pampy,Python,dog,value,Any,int,other,any,模式匹配 From: https://www.cnblogs.com/sinferwu/p/17012057.html