Yapısal desen eşleme: match-case

Python 3.10 ile gelen `match`/`case`: sabit, yakalama ve joker desenler, dizi, sözlük ve sınıf desenleri, VEYA desenleri, `as` ve koruma koşulları; bir metin komutu ayrıştırıcısı ve bir JSON olay dağıtıcısı üzerinde.

  • İleri
  • 22 dk
  • 12 soru
  • Ders 22 / 66

Bu derste öğreneceklerin

  • match/case yapısının nasıl çalıştığını açıklamak: yukarıdan aşağı denetim, ilk eşleşen kazanır, yakalama ile karşılaştırma farkı
  • Metin komutlarını dizi desenleriyle ayrıştırmak
  • JSON verilerini sözlük ve sınıf desenleriyle denetlemek ve parçalarına ayırmak
  • Koruma koşullarını, VEYA desenlerini ve as anahtar sözcüğünü yerinde kullanmak

Küçük bir oyun botuna go north, take lamp key, quit gibi komutlar gelir; bir çevrim içi mağaza ise {"type": "payment", "amount": 16.5} gibi JSON olayları alır. Böyle verileri if/elif ile denetlemek karmaşıklaşır: önce uzunluğu, sonra türü, sonra anahtarları denetler, ardından gereken parçaları ayrı değişkenlere kopyalarsın. Python 3.10’dan (Ekim 2021) beri dilde yapısal desen eşleme vardır: match verinin biçimini denetler ve parçalarını tek adımda çıkarır.

match, case ve desenTanım

match subject: incelenecek değeri (özne) alır, her case pattern: ise bir desendir, yani verinin nasıl görünmesi gerektiğinin tarifi. Durumlar yukarıdan aşağı denenir; eşleşen ilk case bloğu çalışır ve match biter. Hiçbiri eşleşmezse hiçbir şey olmaz.

Sabitler, VEYA ve joker desen

En basit desen bir sabittir: case 404: özne == 404 olduğunda çalışır. | birkaç seçeneği birleştirir, _ ise her şeyle eşleşir ve genellikle sona “diğer bütün durumlar” olarak yazılır. C ya da JavaScript’teki switch yapısının aksine break gerekmez ve çalışma hiçbir zaman bir sonraki case bloğuna geçmez.

Python
def http_status(code):
    match code:
        case 200:
            return 'OK'
        case 301 | 302:
            return 'Redirect'
        case 401 | 403:
            return 'No access'
        case 404:
            return 'Not Found'
        case _:
            return f'Unknown code {code}'


for c in (200, 302, 403, 404, 418):
    print(c, http_status(c))
Beklenen çıktı
200 OK
302 Redirect
403 No access
404 Not Found
418 Unknown code 418
  1. Özne

    match sözcüğünden sonraki ifade bir kez hesaplanır.

  2. Sırayla durumlar

    Desenler yukarıdan aşağı denenir: biçim ve değerler uyuyor mu?

  3. Adlar bağlanır

    Eşleşen desen yakalama adlarına değer atar.

  4. Koruma koşulu

    if varsa doğru olmalıdır; değilse sonraki case denenir.

  5. Blok

    İlk başarılı case bloğu çalışır ve match biter.

DesenÖrnekNe zaman eşleşir
sabitcase 404: case 'quit':özne == değer (None, True, False için is)
yakalamacase x:her zaman; özneyi x adına bağlar
jokercase _:her zaman; hiçbir şey bağlamaz
değer (noktalı ad)case Cmd.QUIT:özne == sabit
ORcase 401 | 403:seçeneklerden biri eşleşir
dizicase [x, y, *rest]:uygun uzunlukta liste ya da demet
sözlükcase {'type': t}:bu anahtarları olan sözlük (diğerleri yok sayılır)
sınıfcase Point(x=0):isinstance + öznitelikler eşleşir
AScase [_, _] as pair:iç desen eşleşir; değerin tamamını bağlar
koruma (guard)case x if x > 0:desen eşleşir ve koşul doğrudur

Yalın bir ad (case x:) asla bir karşılaştırma değildir: her değerle eşleşen ve onu o ada atayan bir yakalama desenidir. Bu yüzden bir sabit case QUIT: diye yazılamaz; bu, QUIT değerini denetlemez, üzerine yazar. Bir sabitle karşılaştırmak için noktalı bir ad gerekir: Cmd.QUIT, config.LIMIT, Color.RED (Enum).

Python
QUIT = 'quit'


def handle(command):
    match command:
        case QUIT:                 # a capture pattern, not a comparison!
            return f'quitting... (QUIT is now {QUIT!r})'


class Cmd:
    QUIT = 'quit'
    HELP = 'help'


def handle_fixed(command):
    match command:
        case Cmd.QUIT:             # a dotted name is compared with ==
            return 'bye'
        case Cmd.HELP:
            return 'commands: help, quit'
        case _:
            return f'unknown command {command!r}'


print(handle('hello'))
print(handle_fixed('hello'), '|', handle_fixed('quit'))
Beklenen çıktı
quitting... (QUIT is now 'hello')
unknown command 'hello' | bye
case QUIT: 'hello' ile de eşleşti ve yerel QUIT değerini 'hello' yaptı. Cmd.QUIT ise == ile karşılaştırılır.

Okumaya devam etmek için ücretsiz kaydol

Dersin geri kalan bölümleri, test ve notlar Educora hesabıyla açılır. Kayıt bir dakika sürer; ilerlemen tüm cihazlarında saklanır.

Dizi desenleri: bir komut ayrıştırıcısı

command.split() dizeyi bir sözcük listesine çevirir, match ise bu listenin biçimini denetler: ['go', direction] tam iki sözcük, ilki go; ['take', *items] take ve istenen sayıda sözcük (bunlar items listesine düşer); ['quit' | 'exit'] tek sözcük, iki seçenekten biri. Desenin içindeki adlar eşleşen parçaları yakalar.

Python
DIRECTIONS = {'north', 'south', 'east', 'west'}


def handle(command):
    match command.split():
        case []:
            return 'Say something'
        case ['go', direction] if direction in DIRECTIONS:
            return f'You go {direction}'
        case ['go', _]:
            return 'You cannot go there'
        case ['take']:
            return 'Take what?'
        case ['take', *items]:
            return 'You take ' + ', '.join(items)
        case ['look'] | ['l']:
            return 'A dark room. There is a lamp.'
        case ['quit' | 'exit']:
            return 'Bye!'
        case [verb, *_]:
            return f'I do not know how to {verb!r}'


for line in ['go north', 'go up', 'take lamp key', 'take', 'l', 'exit', 'dance now', '']:
    print(f'{line!r:15} -> {handle(line)}')
Beklenen çıktı
'go north'      -> You go north
'go up'         -> You cannot go there
'take lamp key' -> You take lamp, key
'take'          -> Take what?
'l'             -> A dark room. There is a lamp.
'exit'          -> Bye!
'dance now'     -> I do not know how to 'dance'
''              -> Say something
go up için ilk go deseni eşleşti ama koruma koşulu (if direction in DIRECTIONS) yanlış çıktı; bu yüzden denetim bir sonraki case durumuna geçti. Boş dize boş bir liste verir: case [].

if/elif ile

words = command.split()
if len(words) == 2 and words[0] == 'go':
    move(words[1])
elif len(words) >= 2 and words[0] == 'take':
    take(words[1:])
elif words in (['quit'], ['exit']):
    stop()

match ile

match command.split():
    case ['go', direction]:
        move(direction)
    case ['take', *items] if items:
        take(items)
    case ['quit' | 'exit']:
        stop()
Aynı mantık: match uzunluğu ve indisleri kendisi denetler ve parçalara ad verir.

Bir dizi deseni listelerle, demetlerle, range ve diğer dizilerle eşleşir, ama dizelerle, bytes ve sözlüklerle eşleşmez; yoksa her dize harflerine ayrılırdı. Yıldızsız desen tam uzunluk ister, *name ise istenen sayıda elemanı liste olarak yakalar (bir desende yalnızca bir yıldız olabilir).

Python
def describe(value):
    match value:
        case []:
            return 'empty sequence'
        case [x]:
            return f'one item: {x}'
        case [x, y]:
            return f'pair: {x}, {y}'
        case [first, *middle, last]:
            return f'from {first} to {last}, {len(middle)} in between'
        case str():
            return f'a string: {value!r}'
        case _:
            return f'something else: {type(value).__name__}'


for v in [[], (7,), [1, 2], range(5), 'ab', {'a': 1}]:
    print(describe(v))
Beklenen çıktı
empty sequence
one item: 7
pair: 1, 2
from 0 to 4, 3 in between
a string: 'ab'
something else: dict
(7,) bir demettir ama [x] deseniyle eşleşir: köşeli ya da yuvarlak parantez fark etmez. range(5) için middle [1, 2, 3] oldu.

Örnekler: hangi case çalışır?

Problem

1) match (3, 4): → case [x, 0]: print('zero'), case [x, y]: print(x * y)
2) match [1]: → case [x, y, *rest]: print('long'), case _: print('short')
3) match ['take']: → case ['take', *items] if items: print('A'), case ['take', *items]: print(len(items))

Çözümü gösterÇözümü gizle

Çözüm

1) 12: ilk desen ikinci eleman olarak 0 ister (4 ≠ 0), ikincisi x = 3, y = 4 verir.
2) short: [x, y, *rest] en az 2 eleman ister.
3) 0: ilk desen eşleşir ama items == [] olduğu için koruma koşulu yanlıştır; ikinci case items listesini boş liste olarak yakalar.

Sözlük desenleri: JSON ve API yanıtları

Bir sözlük deseni {'anahtar': desen} bu anahtarların var olmasını ve değerlerinin iç desenlerle eşleşmesini ister. Dizilerin aksine fazla anahtarlar yok sayılır; JSON’daki yeni alanlar kodu bozmaz. Kalan anahtarlar gerekiyorsa **rest onları ayrı bir sözlükte toplar. Türü denetlemek için sınıf desenini doğrudan içine yaz: str(city) “dizeyse city adına bağla”, int() | float() as t “sayıysa t adına bağla” demektir.

Python
def read_weather(response):
    match response:
        case {'status': 'ok', 'data': {'city': str(city), 'temp': int() | float() as t}}:
            return f'{city}: {t} °C'
        case {'status': 'error', 'message': str(msg)}:
            return 'error: ' + msg
        case {'status': status}:
            return f'unexpected response with status {status!r}'
        case _:
            return 'not a response'


print(read_weather({'status': 'ok', 'data': {'city': 'Baku', 'temp': 23.5}, 'time': '12:00'}))
print(read_weather({'status': 'error', 'message': 'city not found'}))
print(read_weather({'status': 'ok', 'data': {'city': 'Quba', 'temp': 'warm'}}))
print(read_weather(['ok', 23]))
Beklenen çıktı
Baku: 23.5 °C
error: city not found
unexpected response with status 'ok'
not a response
İlk yanıtta fazla 'time' anahtarı engel olmadı. Üçüncüde 'temp' bir sayı değil; bu yüzden ilk desen eşleşmedi ve yanıt genel {'status': status} desenine düştü. Bir liste sözlük desenleriyle eşleşmez.

Sınıf desenleri ve koruma koşulları

case Point(x=0, y=y): önce isinstance(subject, Point) koşulunu, sonra öznitelikleri denetler. Konumsal yazım Point(0, y) sınıfta __match_args__ (özniteliklerin sırası) ister; @dataclass bunu kendiliğinden oluşturur («Tip ipuçları ve dataclass'lar» dersine bak). int(), str(), float(), list(), dict() gibi yerleşik türlerde tek bir konumsal desen değerin tamamını yakalar: str(name). Desenden sonra if ile bir koruma koşulu yazılabilir: desen eşleşse de koşul yanlışsa denetim bir sonraki case durumuna geçer.

Python
from dataclasses import dataclass


@dataclass
class Point:
    x: float
    y: float


@dataclass
class Circle:
    center: Point
    r: float


@dataclass
class Rect:
    corner: Point
    w: float
    h: float


def describe(shape):
    match shape:
        case Circle(Point(0, 0), r):
            return f'circle at the origin, r = {r}'
        case Circle(r=r) if r <= 0:
            return 'invalid circle'
        case Rect(w=w, h=h) if w == h:
            return f'square {w} × {h}'
        case Rect(Point(x, y), w, h):
            return f'rectangle {w} × {h} at ({x}, {y})'
        case _:
            return f'unknown shape: {shape}'


for s in [Circle(Point(0, 0), 5), Circle(Point(2, 3), -1), Rect(Point(1, 1), 4, 4),
          Rect(Point(0, 2), 6, 3), Point(1, 2)]:
    print(describe(s))
print(Rect.__match_args__)
Beklenen çıktı
circle at the origin, r = 5
invalid circle
square 4 × 4
rectangle 6 × 3 at (0, 2)
unknown shape: Point(x=1, y=2)
('corner', 'w', 'h')
Circle(Point(0, 0), r) iç içe bir desendir: merkezi (0, 0) noktasında olan bir çember. Rect(w=w, h=h) if w == h kareyi sıradan dikdörtgenden önce yakalar, çünkü özel durum yukarıda yazılmıştır.

Mini proje: bir olay dağıtıcısı

Bir çevrim içi mağazanın sunucusu bir JSON olay akışı alır. Her olay türüne ve biçimine göre yönlendirilmelidir: girişleri kaydet, siparişlerin tutarını hesapla, boş siparişleri at, geçerli ödemeleri gelire ekle, eksi tutarları reddet, bilinmeyen ve bozuk olayları bildir. Burada dersin bütün desenleri birlikte çalışır: VEYA ve as, **extra, iç içe dizi, tür denetimi ve koruma koşulu.

Python
import json

raw = '''[
  {"type": "login", "user": "aysel"},
  {"type": "order", "user": "aysel", "items": [{"sku": "pen", "qty": 3, "price": 1.5},
                                               {"sku": "book", "qty": 1, "price": 12.0}]},
  {"type": "order", "user": "murad", "items": []},
  {"type": "payment", "user": "aysel", "amount": 16.5, "currency": "AZN"},
  {"type": "payment", "user": "leyla", "amount": -3, "currency": "AZN"},
  {"type": "logout", "user": "aysel", "reason": "timeout"},
  {"type": "upload", "file": "cv.pdf"},
  "garbage"
]'''

revenue = 0
for event in json.loads(raw):
    match event:
        case {'type': 'login' | 'logout' as kind, 'user': str(user), **extra}:
            print(f'{user}: {kind}' + (f' {extra}' if extra else ''))
        case {'type': 'order', 'user': user, 'items': [_, *_] as items}:
            total = sum(item['qty'] * item['price'] for item in items)
            print(f'{user}: order of {len(items)} items, {total:.2f} AZN')
        case {'type': 'order', 'user': user}:
            print(f'{user}: empty order ignored')
        case {'type': 'payment', 'amount': int() | float() as amount, 'currency': 'AZN'} if amount > 0:
            revenue += amount
        case {'type': 'payment', 'user': user, 'amount': amount}:
            print(f'{user}: rejected payment {amount}')
        case {'type': str(kind)}:
            print(f'unknown event type {kind!r}')
        case _:
            print(f'not an event: {event!r}')
print('revenue:', revenue, 'AZN')
Beklenen çıktı
aysel: login
aysel: order of 2 items, 16.50 AZN
murad: empty order ignored
leyla: rejected payment -3
aysel: logout {'reason': 'timeout'}
unknown event type 'upload'
not an event: 'garbage'
revenue: 16.5 AZN
[_, *_] as items “en az bir elemanlı liste” demektir; bu yüzden boş sipariş bir sonraki case durumuna düşer. Ödeme yalnızca koruma koşulu sağlanınca gelire eklenir; eksi tutar bir sonraki, daha genel ödeme deseninde reddedilir.

Alıştırma

classify(value) fonksiyonunu tamamla: bool → 'bool' (zaten yazıldı; ilk sırada olmalı, çünkü True aynı zamanda bir int), 0 → 'zero', pozitif tam sayı → 'positive int', negatif tam sayı → 'negative int', ondalıklı sayı → 'float', boş dize → 'empty string', başka bir dize → 'string', iki elemanlı dizi → 'pair', geri kalan her şey → 'other'.

Alıştırma · Python
def classify(value):
    match value:
        case bool():
            return 'bool'
        # add the other cases here
        case _:
            return 'other'


for v in [0, 42, -7, 3.14, '', 'hi', (1, 2), [1, 2, 3], True, None]:
    print(repr(v), '->', classify(v))
Beklenen çıktı
0 -> zero
42 -> positive int
-7 -> negative int
3.14 -> float
'' -> empty string
'hi' -> string
(1, 2) -> pair
[1, 2, 3] -> other
True -> bool
None -> other

Alıştırma

Komut hesap makinesini dizi desenleriyle tamamla: add a b, mul a b, neg a ve en az bir sayılı sum a b c …. Sayıları float türüne çevir; diğer her şey 'error' döndürmeli.

Alıştırma · Python
def calc(line):
    match line.split():
        case ['add', a, b]:
            return float(a) + float(b)
        # add: mul a b, neg a, sum a b c ... (at least one number)
        case _:
            return 'error'


for line in ['add 2 3', 'mul 4 2.5', 'neg 7', 'sum 1 2 3 4', 'sum', 'add 1']:
    print(line, '=', calc(line))
Beklenen çıktı
add 2 3 = 5.0
mul 4 2.5 = 10.0
neg 7 = -7.0
sum 1 2 3 4 = 10.0
sum = error
add 1 = error

Unutma

  • match durumları yukarıdan aşağı dener; ilk eşleşen çalışır, break gerekmez, bir sonrakine geçiş olmaz.
  • Yalın bir ad her şeyle eşleşen bir yakalama desenidir; sabitleri noktalı adla (Cmd.QUIT) yaz.
  • Dizi desenleri listeler ve demetlerle eşleşir (dizelerle değil); *rest kalan elemanları yakalar.
  • Sözlük desenleri fazla anahtarları yok sayar; **rest kalanları toplar; str(x) ve int() | float() as n türü denetler.
  • Sınıf desenleri isinstance koşulunu ve öznitelikleri denetler (dataclass’ta __match_args__ hazırdır); if koruma koşulu desenden sonra denetlenir.
Bu derste bir hata ya da yanlışlık mı gördün?

Kendini test et

12 soru. Her doğru cevap XP kazandırır.

Soru 1 / 12

Soru 1 / 12. match/case hangi Python sürümünden beri vardır?