> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python Value Pattern
A value pattern in Python's structural pattern matching evaluates whether a subject is equal to the value of a specific named attribute. Defined strictly by Python's formal grammar (PEP 634), a value pattern must be expressed as a **dotted name** (e.g., `Constants.TARGET` or `HttpStatus.OK`). This syntactic requirement distinguishes value patterns from **literal patterns** (which match raw literals like `200` or `None`) and **capture patterns** (which bind the subject to a bare identifier).
## Syntax and Mechanics
A value pattern requires at least one dot (`.`) in the identifier name. This typically involves referencing an enumeration, a class attribute, or a module-level constant.
```python theme={"dark"}
from enum import IntEnum
import math
class HttpStatus(IntEnum):
OK = 200
NOT_FOUND = 404
class Config:
MAX_RETRIES = 3
subject = 200
match subject:
case HttpStatus.OK: # Value pattern (resolves to IntEnum member, 200 == 200)
pass
case Config.MAX_RETRIES: # Value pattern (resolves to class attribute)
pass
case math.pi: # Value pattern (resolves to module attribute)
pass
```
## Evaluation Semantics
When the Python interpreter evaluates a value pattern, it performs the following steps:
1. It resolves the dotted name to its underlying object.
2. It compares the resolved object to the subject using the equality operator (`==`).
3. The pattern succeeds if `subject == resolved_value` evaluates to `True`.
Because the comparison relies on `==`, standard type equality rules apply. In the example above, `HttpStatus` must inherit from `IntEnum` for the integer `200` to evaluate as equal to the enum member `HttpStatus.OK`. If a standard `Enum` were used, `200 == HttpStatus.OK` would evaluate to `False`, and the pattern would fail to match.
## The Dotted Name Requirement
A critical technical distinction in Python's pattern matching grammar is how it differentiates between a **value pattern** (which compares) and a **capture pattern** (which assigns).
To match against a pre-defined constant or variable, the pattern **must** be a dotted name. If a bare identifier is used, Python's compiler interprets it as a capture pattern. A capture pattern unconditionally binds the subject to that variable name and succeeds. Because `match`/`case` blocks do not create a new scope, using a bare identifier overwrites (rebinds) any existing variable with that name in the current scope.
```python theme={"dark"}
class Constants:
TARGET = 42
TARGET = 42
subject = 99
match subject:
# VALUE PATTERN: Requires a dotted name.
# Compares subject == Constants.TARGET (evaluates to False).
case Constants.TARGET:
print("Matched the constant value.")
# CAPTURE PATTERN: Uses a bare identifier.
# This does NOT compare subject == 42. It unconditionally succeeds
# and rebinds the local variable 'TARGET' to 99.
case TARGET:
print(f"Captured subject into variable TARGET: {TARGET}")
```
## Value Patterns vs. Literal Patterns
While both pattern types are used to match specific values, Python's grammar classifies them as distinct entities based on their syntax:
* **Value Pattern:** Requires attribute access via a dot (`.`). The value is resolved dynamically at runtime (e.g., `Color.RED`, `settings.DEFAULT_TIMEOUT`).
* **Literal Pattern:** Uses hardcoded literal values directly in the syntax. This includes numbers (`42`), strings (`"success"`), and singletons (`None`, `True`, `False`). Literal patterns matching singletons use object identity (`is`) rather than equality (`==`).
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
