Read Structured Data with match and case

Select a timestamp to watch that moment on YouTube.

1. 00:00

   Programs often receive small dictionaries that represent different kinds of events. A message has a type and some text. A movement has a type and coordinates. A third event might not fit either form. Python's match statement lets us describe those shapes directly and capture the values we need. It is more than a switch on a single constant: a pattern can inspect a mapping, a sequence, or an object. Python checks cases from top to bottom and runs the first one that matches. That ordering gives us a clear place for specific cases and a final fallback. In this video we will build an event formatter, deliberately write a case that captures everything by mistake, and fix it with quoted literals and a guard.

2. 00:46

   We will also see why matching a shape is not always the same as validating content. A text field can be a string yet still contain only spaces. The companion lesson on PythonLessonLab includes runnable examples, a browser console, a checked task, typical errors, and a short quiz. This syntax requires Python 3.10 or newer. Before we type code, predict the desired results: a nonblank message should show its trimmed text, a movement should display two integers, and anything else should become Unknown event. That fallback is useful because malformed input remains visible instead of silently producing None.

3. 01:27

   Both inputs enter the message branch. That is not because move equals message; it is because a bare name in a pattern is usually a capture. The pattern assigns the subject to a new name called message and succeeds. It is a powerful feature when we want to extract data, but a bug when we intended a fixed value. To compare with the literal word message, put it in quotes. This is one of the most important syntax differences to remember when learning match. In an if statement, writing `kind == message` would compare with an existing variable. In a case pattern, an unqualified bare name does something else.

4. 02:07

   Python will even reject a later case after an unconditional capture because it would be unreachable. That compiler error is helpful, but if the broad case is your only case, the wrong behavior can still look plausible. Let's repair the code by using `case "message":` and then a wildcard `case _:` for other kinds. The wildcard is also broad, so it belongs last. We will apply the same discipline to dictionary event patterns: quote the exact type string, capture only the fields that should vary, and make a final fallback explicit. A pattern match is not a conversion. The string "3" will not turn into integer 3 just because the move pattern expects an integer coordinate.

5. 02:52

   The first event matches even though it has an extra id key. A mapping pattern requires the keys it lists, but additional keys are permitted. The type value must equal the quoted string message. The text value must match the str class pattern, and the captured value becomes the local name text. Then the guard checks that some content remains after stripping spaces. The first event passes every step and returns Hi. The second has the right keys and a string value, but the guard fails because the string is blank after stripping. The third has an integer text field, so it fails the str pattern before the guard even runs.

6. 03:32

   This layered reading is useful: shape first, content rule second, result last. Do not confuse a guard with a general exception handler. If your case body contains another operation that can fail, matching does not magically catch it. The final wildcard gives us a deliberate result for the shapes we do not support. In production code you might raise a domain-specific error instead, especially if malformed input should stop processing. For this teaching exercise, Unknown event makes every path easy to see in the console and easy to verify. Try removing the guard mentally. Whitespace-only text would then become a visible but empty message line, which is not the behavior we promised.

7. 04:18

   The first case describes a message and trims its text. The second describes a movement and captures two integer coordinates. The third case catches whatever did not fit. Notice that the pattern does not modify the dictionary. It reads values and returns a new string. The string coordinate "3" does not match `int(x)`, so the fallback handles it. We could choose to convert numeric text, but that would be a separate policy, not an automatic behavior of match. Cases are checked in order, and the first match wins. A general two-key mapping pattern placed before a more specific one might take an event too early.

8. 04:58

   Keep the shapes narrow and place any broad fallback last. There is also a subtle Python detail: bool is considered a subclass of int, so an int class pattern can match True. If a real event API must reject booleans for coordinates, add a guard such as `type(x) is int and type(y) is int`. The exercise's contract uses normal integer coordinates, so we do not complicate the first version with that rule. Pattern matching is powerful, but it should make your intent clearer, not encourage clever cases that are hard to debug. If a simple if statement is clearer for a one-condition decision, use it.

9. 05:38

   Here the two dictionary shapes make match a readable fit. These checks cover the promise we made before writing code. A message with an extra id field still matches; its original dictionary remains unchanged. Blank text is rejected by the guard. A movement with a negative coordinate is valid, but a string coordinate is not silently converted. An unknown event reaches the fallback. The assertions do not prove that every possible mapping is safe for every real application. They do show that our two supported shapes and failure path behave consistently. Open the companion lesson and fill in the match cases yourself.

10. 06:19

    Start with quoted type literals, then capture the fields, then add the message guard, and keep the wildcard last. Run the practical checker and inspect any failing case before moving to the quiz. If you see a surprising branch, ask whether you wrote a literal or a capture pattern. If a dictionary with extra keys succeeds, remember that mapping patterns specify required keys rather than an exact complete schema. If blank text succeeds, the structure matched but the content rule is missing. This distinction between shape and guard is a useful way to read more complex match statements later. You can extend the function with another event type once these basics are solid, but keep branch order and fallback behavior explicit.

11. 07:05

    The goal is not to use match everywhere. It is to make structured alternatives easy for the next reader to understand.