Strukturlu şablon uyğunluğu: match-case

Python 3.10-dan gələn `match`/`case`: hərfi, tutan və «hər şey» şablonları, ardıcıllıq, lüğət və sinif şablonları, OR-şablonlar, `as` və şərtlər (guard) — mətn əmrlərinin təhlilçisi və JSON hadisələrinin paylayıcısı nümunəsində.

  • İrəli
  • 22 dəq
  • 12 sual
  • 66 dərsdən 22-cisi

Bu dərsdə öyrənəcəksən

  • match/case-in necə işlədiyini izah etmək: yuxarıdan aşağı yoxlama, ilk uyğun gələn qalib gəlir, tutma (capture) və müqayisə fərqi
  • Mətn əmrlərini ardıcıllıq şablonları ilə təhlil etmək
  • JSON verilənlərini lüğət və sinif şablonları ilə yoxlamaq və hissələrə ayırmaq
  • Şərtləri (guard), OR-şablonları və as-ı düzgün yerdə işlətmək

Kiçik oyun bota go north, take lamp key, quit kimi əmrlər göndərilir, onlayn mağaza isə {"type": "payment", "amount": 16.5} kimi JSON hadisələri qəbul edir. if/elif ilə belə verilənləri yoxlamaq çətinləşir: əvvəl uzunluğu, sonra tipi, sonra açarları yoxlayırsan, sonra lazım olan hissələri ayrıca dəyişənlərə köçürürsən. Python 3.10-dan (2021-ci ilin oktyabrı) dildə strukturlu şablon uyğunluğu var: match verilənin formasını yoxlayır və hissələrini bir addımda çıxarır.

match, case və şablonTərif

match subject: yoxlanılan qiyməti (subyekt) götürür, hər case pattern: isə bir şablondur — verilənin necə görünməli olduğunun təsviri. case-lər yuxarıdan aşağı yoxlanılır; uyğun gələn ilk case-in bloku icra olunur və match bitir. Heç biri uyğun gəlmirsə, heç nə baş vermir.

Hərfi şablonlar, OR və «hər şey» şablonu

Ən sadə şablon hərfi qiymətdir: case 404: subyekt == 404 olanda işləyir. | bir neçə variantı birləşdirir, _ isə hər şeyə uyğun gəlir və adətən sonda «qalan bütün hallar» kimi yazılır. C və ya JavaScript-in switch-indən fərqli olaraq break lazım deyil və icra növbəti case-ə «düşmür».

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))
Gözlənilən nəticə
200 OK
302 Redirect
403 No access
404 Not Found
418 Unknown code 418
  1. Subyekt

    match-dən sonrakı ifadə bir dəfə hesablanır.

  2. Case-lər sıra ilə

    Şablonlar yuxarıdan aşağı yoxlanılır: forma və qiymətlər uyğun gəlirmi?

  3. Adlar bağlanır

    Uyğun gələn şablon öz tutan adlarına qiymət verir.

  4. Şərt (guard)

    if varsa, doğru olmalıdır, əks halda növbəti case yoxlanılır.

  5. Blok

    İlk uğurlu case-in bloku icra olunur və match bitir.

ŞablonNümunəNə vaxt uyğun gəlir
hərficase 404: case 'quit':subyekt == qiymət (None, True, False is ilə)
tutan (capture)case x:həmişə; subyekti x-ə bağlayır
«hər şey»case _:həmişə; heç nə bağlamır
qiymət (nöqtəli ad)case Cmd.QUIT:subyekt == sabit
ORcase 401 | 403:variantlardan biri uyğun gəlir
ardıcıllıqcase [x, y, *rest]:uyğun uzunluqlu siyahı və ya kortej
lüğətcase {'type': t}:bu açarları olan lüğət (qalanları nəzərə alınmır)
sinifcase Point(x=0):isinstance + atributlar uyğun gəlir
AScase [_, _] as pair:daxili şablon uyğun gəlir; bütün qiyməti bağlayır
şərt (guard)case x if x > 0:şablon uyğun gəlir və şərt doğrudur

Adi ad (case x:) heç vaxt müqayisə deyil: o, tutan şablondur, istənilən qiymətə uyğun gəlir və onu həmin ada mənimsədir. Ona görə sabiti case QUIT: kimi yazmaq olmaz — bu, QUIT-in qiymətini yoxlamır, onu üstələyir. Sabitlə müqayisə üçün nöqtəli ad lazımdır: 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'))
Gözlənilən nəticə
quitting... (QUIT is now 'hello')
unknown command 'hello' | bye
case QUIT: 'hello'-ya da uyğun gəldi və lokal QUIT-i 'hello' etdi. Cmd.QUIT isə == ilə müqayisə olunur.

Davamını oxumaq üçün pulsuz qeydiyyatdan keç

Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.

Ardıcıllıq şablonları: əmrlərin təhlilçisi

command.split() sətri sözlər siyahısına çevirir, match isə siyahının formasını yoxlayır: ['go', direction] — düz iki söz, birincisi go; ['take', *items] — take və istənilən sayda söz (onlar items siyahısına düşür); ['quit' | 'exit'] — bir söz, iki variantdan biri. Şablonun içindəki adlar uyğun gələn hissələri tutur.

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)}')
Gözlənilən nəticə
'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-da birinci go şablonu uyğun gəldi, amma şərt (if direction in DIRECTIONS) yalan oldu, ona görə yoxlama növbəti case-ə keçdi. Boş sətir boş siyahı verir: case [].

if/elif ilə

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 ilə

match command.split():
    case ['go', direction]:
        move(direction)
    case ['take', *items] if items:
        take(items)
    case ['quit' | 'exit']:
        stop()
Eyni məntiq: match uzunluğu və indeksləri özü yoxlayır və hissələrə ad verir.

Ardıcıllıq şablonu siyahıya, korteja, range-ə və digər ardıcıllıqlara uyğun gəlir, amma sətrə, bytes-a və lüğətə yox — əks halda hər sətir hərflər ardıcıllığı kimi parçalanardı. Ulduzsuz şablon uzunluğu dəqiq tələb edir, *name isə istənilən sayda elementi siyahı kimi tutur (bir şablonda yalnız bir ulduz ola bilər).

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))
Gözlənilən nəticə
empty sequence
one item: 7
pair: 1, 2
from 0 to 4, 3 in between
a string: 'ab'
something else: dict
(7,) kortejdir, amma [x] şablonuna uyğun gəlir: kvadrat və ya dairəvi mötərizə fərq etmir. range(5)-də middle [1, 2, 3] oldu.

Nümunələr: hansı case işləyəcək?

Məsələ

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))

Həllini göstərHəllini gizlət

Həll

1) 12: birinci şablonda ikinci element 0 olmalıdır (4 ≠ 0), ikincidə x = 3, y = 4.
2) short: [x, y, *rest] ən azı 2 element tələb edir.
3) 0: birinci şablon uyğun gəlir, amma items == [] olduğu üçün şərt yalandır; ikinci case items-i boş siyahı kimi tutur.

Lüğət şablonları: JSON və API cavabları

Lüğət şablonu {'açar': şablon} lüğətdə həmin açarların olmasını və qiymətlərinin daxili şablonlara uyğun gəlməsini tələb edir. Ardıcıllıqdan fərqli olaraq artıq açarlar nəzərə alınmır — JSON-dakı yeni sahələr kodu sındırmır. Qalan açarlara ehtiyac varsa, **rest onları ayrıca lüğətə toplayır. Tipi yoxlamaq üçün sinif şablonunu birbaşa içəri yaz: str(city) — «sətirdirsə, city-yə bağla», int() | float() as t — «ədəddirsə, t-yə bağla».

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]))
Gözlənilən nəticə
Baku: 23.5 °C
error: city not found
unexpected response with status 'ok'
not a response
Birinci cavabda artıq 'time' açarı mane olmadı. Üçüncüdə 'temp' ədəd deyil, ona görə birinci şablon uyğun gəlmədi və cavab ümumi {'status': status} şablonuna düşdü. Siyahı lüğət şablonlarına uyğun gəlmir.

Sinif şablonları və şərtlər

case Point(x=0, y=y): əvvəlcə isinstance(subject, Point)-i, sonra atributları yoxlayır. Mövqeli yazılış Point(0, y) sinifdə __match_args__ (atributların sırası) tələb edir — @dataclass onu avtomatik yaradır (bax: «Tip annotasiyaları və dataclass-lar»). int(), str(), float(), list(), dict() kimi daxili tiplər üçün bir mövqeli şablon bütün qiyməti tutur: str(name). Şablondan sonra if ilə şərt (guard) yazmaq olar: şablon uyğun gəlsə də, şərt yalandırsa, yoxlama növbəti case-ə keçir.

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__)
Gözlənilən nəticə
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çə şablondur: dairə, mərkəzi (0; 0) nöqtəsində. Rect(w=w, h=h) if w == h kvadratı adi düzbucaqlıdan əvvəl tutur, çünki xüsusi hal yuxarıda yazılıb.

Mini layihə: hadisələrin paylayıcısı

Onlayn mağazanın serveri JSON hadisələr axını alır. Hər hadisəni növünə və formasına görə lazımi yerə yönəltmək lazımdır: girişləri qeyd et, sifarişlərin məbləğini hesabla, boş sifarişləri at, düzgün ödənişləri gəlirə əlavə et, mənfi məbləğləri rədd et, naməlum və zədəli hadisələri bildir. Burada dərsin bütün şablonları bir yerdə işləyir: OR və as, **extra, iç-içə ardıcıllıq, tip yoxlaması və şərt.

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')
Gözlənilən nəticə
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 «ən azı bir elementli siyahı» deməkdir, boş sifariş növbəti case-ə düşür. Ödəniş yalnız şərt ödənəndə gəlirə əlavə olunur; mənfi məbləğ növbəti, ümumi ödəniş şablonunda rədd edilir.

Tapşırıq

classify(value) funksiyasını tamamla: bool → 'bool' (artıq yazılıb, ilk olmalıdır, çünki True həm də int-dir), 0 → 'zero', müsbət tam → 'positive int', mənfi tam → 'negative int', kəsr → 'float', boş sətir → 'empty string', başqa sətir → 'string', iki elementli ardıcıllıq → 'pair', qalan hər şey → 'other'.

Tapşırıq · 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))
Gözlənilən nəticə
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

Tapşırıq

Əmrlər kalkulyatorunu ardıcıllıq şablonları ilə tamamla: add a b, mul a b, neg a və ən azı bir ədədli sum a b c …. Ədədləri float-a çevir; başqa hər şey 'error' qaytarsın.

Tapşırıq · 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))
Gözlənilən nəticə
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

Yadda saxla

  • match case-ləri yuxarıdan aşağı yoxlayır; ilk uyğun gələn işləyir, break lazım deyil, «düşmə» yoxdur.
  • Adi ad tutan şablondur və hər şeyə uyğun gəlir; sabitlər üçün nöqtəli ad (Cmd.QUIT) yaz.
  • Ardıcıllıq şablonları siyahı və kortejlərə uyğun gəlir (sətirlərə yox); *rest qalan elementləri tutur.
  • Lüğət şablonları artıq açarlara məhəl qoymur; **rest qalanları toplayır; str(x), int() | float() as n tipi yoxlayır.
  • Sinif şablonları isinstance və atributları yoxlayır (__match_args__ dataclass-da hazırdır); if şərti şablondan sonra yoxlanılır.
Dərsdə səhv və ya qeyri-dəqiqlik gördün?

Özünü yoxla

12 sual. Hər düzgün cavab XP qazandırır.

Sual 1 / 12

Sual 1 / 12. match/case Python-un hansı versiyasından mövcuddur?