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».
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
Subyekt
match-dən sonrakı ifadə bir dəfə hesablanır.Case-lər sıra ilə
Şablonlar yuxarıdan aşağı yoxlanılır: forma və qiymətlər uyğun gəlirmi?
Adlar bağlanır
Uyğun gələn şablon öz tutan adlarına qiymət verir.
Şərt (guard)
ifvarsa, doğru olmalıdır, əks halda növbəticaseyoxlanılır.Blok
İlk uğurlu
case-in bloku icra olunur vəmatchbitir.
| Şablon | Nümunə | Nə vaxt uyğun gəlir |
|---|---|---|
| hərfi | case 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 |
| OR | case 401 | 403: | variantlardan biri uyğun gəlir |
| ardıcıllıq | case [x, y, *rest]: | uyğun uzunluqlu siyahı və ya kortej |
| lüğət | case {'type': t}: | bu açarları olan lüğət (qalanları nəzərə alınmır) |
| sinif | case Point(x=0): | isinstance + atributlar uyğun gəlir |
| AS | case [_, _] 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).
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.
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()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).
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
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».
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
'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.
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.
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'.
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.
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
matchcase-ləri yuxarıdan aşağı yoxlayır; ilk uyğun gələn işləyir,breaklazı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);
*restqalan elementləri tutur. - Lüğət şablonları artıq açarlara məhəl qoymur;
**restqalanları toplayır;str(x),int() | float() as ntipi yoxlayır. - Sinif şablonları
isinstancevə atributları yoxlayır (__match_args__dataclass-da hazırdır);ifşərti şablondan sonra yoxlanılır.