Type hintlar

Nimalarni örganasiz
- Type hintlar (turlarni körsatuvçi izohlar) nima va nega ularni yoziş kerak
- Özgaruvçilar, parametrlar, qaytariladigan qiymatlar va kolleksiyalarga (
list[int],dict[str, float]) type hint qanday yoziladi - Ixtiyoriy qiymatlar (
str | None), funksiya parametrlari (Callable) va özini nomlaydigan klasslar qanday yoziladi Protocolvatypealias lar (uzun type hint ga berilgan nom) kattaroq ğoyalarni qanday tasvirlaydi- Nega type hintlar dastur işlayotganda tekşirilmaydi
Nega bu muhim
def calculate(items, rate, rounding): da items röyxatmi yoki luğatmi? rate 12 mi yoki 0.12 mi? Type hintlar (parametr va natija turlarini körsatuvçi izohlar) bilan bu savollarga funksiya imzosining özi javob beradi, tanasini öqiş şart bölmaydi:
def calculate(items: list[float], rate: float, rounding: int = 0) -> float:
...Type hintlar kod içidagi hujjatdir. Muharrirlar ulardan avtomatik töldiriş va xatolarni belgilaş uçun foydalanadi, mypy yoki pyright kabi tur tekşiruvçilari esa notöğri çaqiruvlarni hali heç narsa işga tuşirilmasdan xabar qiladi.
Özgaruvçilar va funksiyalar
Özgaruvçi va parametrlar uçun nom: tur, qaytariladigan qiymat uçun -> tur yoziladi:
scores: dict[str, list[int]] = {} # keyinroq töldiriladigan böş luğat
def average(numbers: list[float]) -> float:
return sum(numbers) / len(numbers)
def greet(name: str, times: int = 1) -> str:
return " ".join([f"Salom, {name}!"] * times)
scores.setdefault("Aziza", []).append(91)
print(scores, average([4.5, 5.0, 3.5]))
print(greet("Bekzod", times=2)){'Aziza': [91]} 4.333333333333333
Salom, Bekzod! Salom, Bekzod!Oddiy özgaruvçilarga type hint kamdan-kam kerak böladi, lekin böş kolleksiyaga type hint yoziş foydali. Standart qiymat bölsa, avval type hint keladi: times: int = 1. Heç narsa qaytarmaydigan funksiyaga -> None yoziladi.
Kolleksiyalar va ixtiyoriy qiymatlar
Element turlari kvadrat qavsga yoziladi; kortejlar har bir pozitsiyani tasvirlaydi. Bölmasligi yoki bir neçta turda bölişi mumkin bölgan qiymat uçun | ("yoki") işlatiladi:
| Type hint | Maʼnosi | Misol qiymat |
|---|---|---|
list[int] / set[str] | butun sonlar röyxati / satrlar töplami | [90, 85] / {"çoy"} |
dict[str, float] | satr kalitlar, float qiymatlar | {"USD": 12650.0} |
tuple[str, int] / tuple[int, ...] | avval satr, keyin butun son / istalgança butun son | ("Aziza", 20) / (1, 2, 3) |
str | None | satr yoki None | None |
def find_phone(contacts: dict[str, str], name: str) -> str | None:
return contacts.get(name)
contacts = {"Aziza": "+998901234567"}
for name in ["Aziza", "Dilnoza"]:
phone = find_phone(contacts, name)
if phone is None:
print(f"{name}: telefon saqlanmagan")
else:
print(f"{name}: {phone[-4:]}")Aziza: 4567
Dilnoza: telefon saqlanmaganstr | None çaqiruvçini avval None ni tekşirişga ogohlantiradi.
Argument sifatidagi funksiyalar: Callable
Funksiya parametri uçun collections.abc dan Callable işlatiladi: avval parametr turlari röyxati, keyin qaytariladigan tur:
from collections.abc import Callable
def apply_discount(prices: list[int], rule: Callable[[int], int]) -> list[int]:
return [rule(p) for p in prices]
print(apply_discount([50_000, 8_000], lambda p: round(p * 0.9)))[45000, 7200]Callable[[int], int] "int qabul qilib, int qaytaradigan funksiya" degani. Tasvirlab bölmaydigan maʼlumotlar uçun typing.Any tekşiruvni öçiradi; uni kam işlating.
Type hintlar işlaş vaqtida tekşirilmaydi
Python type hintlarni saqlaydi, lekin kod işlayotganda ularni tekşirmaydi:
def line_total(price: int, qty: int) -> int:
return price * qty
print(line_total(25_000, 3))
print(line_total("100", 3)) # notöğri tur, lekin xato yöq75000
100100100"100" * 3 satrni takrorlaydi. Tur tekşiruvçisi bu çaqiruvni işga tuşirişdan oldin belgilagan bölardi, lekin foydalanuvçi va fayllardan keladigan yomon maʼlumotni baribir if va raise bilan tekşiriş kerak. Ikkalasi ham zarur.
Python 3.14 da nima özgardi (PEP 649)
Python 3.14 type hintlarni keçiktirib, faqat nimadir ularni öqiganda hisoblaydi. Şuning uçun type hint keyinroq aniqlanadigan klassni nomlaşi mumkin, annotationlib esa type hintlarni satr sifatida öqiy oladi:
import annotationlib
def ship(order: Order) -> Receipt: # ikkala klass hali mavjud emas
...
print(annotationlib.get_annotations(ship, format=annotationlib.Format.STRING)){'order': 'Order', 'return': 'Receipt'}Klasslardagi type hintlar
Metodlarga funksiyalar kabi type hint yoziladi (self ga type hint kerak emas). Öz klasslaringiz ham tur hisoblanadi va keçiktirilgan type hintlar tufayli klass özini nomlay oladi:
from typing import Self
class Money:
def __init__(self, amount: int, currency: str = "UZS") -> None:
self.amount = amount
self.currency = currency
def add(self, other: Money) -> Money:
return Money(self.amount + other.amount, self.currency)
def __repr__(self) -> str:
return f"Money({self.amount:,} {self.currency})"
class Counter:
def __init__(self) -> None:
self.count = 0
def tick(self) -> Self:
self.count += 1
return self
class LoudCounter(Counter):
pass
print(Money(150_000).add(Money(35_000)))
c = LoudCounter().tick().tick()
print(type(c).__name__, c.count)Money(185,000 UZS)
LoudCounter 2typing.Self "bu metod çaqirilgan klass" degani, şuning uçun LoudCounter().tick() natijasi LoudCounter ekani maʼlum.
Protocol: duck typing uçun type hintlar
Duck typing da kerakli metodga ega har qanday obyekt işlaydi. Protocol buni vorisliksiz, type hint da aytib beradi:
from typing import Protocol
class Notifier(Protocol):
def send(self, to: str, text: str) -> bool: ...
class SmsNotifier: # Notifier dan meros OLMAYDI
def send(self, to: str, text: str) -> bool:
print(f"{to} ga SMS: {text}")
return True
def remind(notifier: Notifier, person: str) -> bool:
return notifier.send(person, "Uçraşuv soat 10:00 da")
print(remind(SmsNotifier(), "Aziza"))Aziza ga SMS: Uçraşuv soat 10:00 da
TrueTur tekşiruvçisi SmsNotifier ni qabul qiladi, çunki uning send metodi imzosi mos keladi.
Type alias lar
Uzun type hint ga type operatori bilan nom beriladi, bu type alias (turning qisqa nomi) deyiladi:
type Grades = dict[str, list[int]]
def best_student(grades: Grades) -> str:
return max(grades, key=lambda name: sum(grades[name]) / len(grades[name]))
print(best_student({"Aziza": [90, 95], "Bekzod": [70, 81]}))
print(type(Grades).__name__)Aziza
TypeAliasTypeAlias luğat emas, TypeAliasType obyekti, şuning uçun uni faqat type hintlarda işlating: Grades() TypeError beradi.
Eski kodda
Mavjud loyihalarda eskiroq yozuvlar uçraydi:
Optional[str],Union[int, float],List[int],Dict[str, float](typingdan).typeoperatori örnigaGrades = dict[str, list[int]].- Qöştirnoqdagi klass nomlari (
-> "Money") yokifrom __future__ import annotations: 3.14 dan oldin klass özini nomlaşi uçun kerak edi. Bu import barça type hintlarni satrga aylantiradi, PEP 749 esa uni eskirgan deb belgilaşni (3.13 qöllab-quvvatlaşi tugaganidan keyingi birinçi relizdan erta emas) va keyinroq olib taşlaşni rejalaştirgan, şuning uçun yangi kodga qöşmang.
Özingiz sinab köring
Pastdagi çaqiruvlarga notöğri turlarni bering (masalan, qty uçun satr) va type hintlar çaqiruvni töxtatmasligini köring.
Köp uçraydigan xatolar
1. Istalgan kolleksiya yetarli bölganda list talab qiliş
def average(scores: list[int]) -> float:
return sum(scores) / len(scores)
print(average((80, 90))) # kortej: bemalol işlaydi
print(average({"a": 1, "b": 3}.values())) # luğat qiymatlari: bemalol işlaydi85.0
2.0Ikkalasi ham işlaydi, lekin tur tekşiruvçisi ularni rad etadi: heç biri list emas. Tuzatiş: funksiyaga nima kerak bölsa, şuni collections.abc dan yozing: Sequence[int] (röyxatlar, kortejlar), Collection[int] (len() ga ega har narsa, luğat qiymatlari ham) yoki Iterable[int] (aylanib çiqiş mumkin bölgan har narsa).
2. None bölişi mumkin bölgan qiymatni vaʼda qiliş
def find_email(users: dict[str, str], name: str) -> str: # type hint yolğon
return users.get(name)
email = find_email({"aziza": "aziza@mail.uz"}, "bekzod")
print(email.upper())AttributeError: 'NoneType' object has no attribute 'upper'Tuzatiş: dict.get() None qaytarişi mumkin, şuning uçun halol type hint -> str | None böladi va u çaqiruvçiga avval tekşirişni aytadi.
3. Kolleksiya type hintlarini notöğri sintaksis bilan yoziş
def total(prices: [int]) -> int: ... # Yomon: int saqlovçi röyxat
def pair() -> (int, int): ... # Yomon: turlar korteji
def count(prices: list(int)) -> int: ... # Yomon: tur emas (vositalar type hint ni öqiganda xato beradi)
count.__annotations__TypeError: 'type' object is not iterableQatorlar işlaydi, lekin vositalar ulardan foydalana olmaydi. Tuzatiş: list[int], tuple[int, int].
Maşqlar
1. Funksiyalarga type hint yozing
Bu funksiyalarga type hintlarni qöşing, keyin har birini çaqiring:
def is_adult(age):
return age >= 18
def word_lengths(words):
return {w: len(w) for w in words}Yeçim
def is_adult(age: int) -> bool:
return age >= 18
def word_lengths(words: list[str]) -> dict[str, int]:
return {w: len(w) for w in words}
print(is_adult(17))
print(word_lengths(["çoy", "somsa", "palov"]))False
{'çoy': 3, 'somsa': 5, 'palov': 5}2. Ixtiyoriy qidiruv
first_long_word(words: list[str], min_length: int) -> str | None funksiyasini yozing (uzunligi kamida min_length bölgan birinçi söz yoki None). ["quyoş", "daryo", "toğtizmasi"] va 5 hamda 11 çegaralari uçun sözni katta harflarda yoki 11+ harfli söz yöq deb çiqaring.
Yeçim
def first_long_word(words: list[str], min_length: int) -> str | None:
for word in words:
if len(word) >= min_length:
return word
return None
words = ["quyoş", "daryo", "toğtizmasi"]
for limit in [5, 11]:
found = first_long_word(words, limit)
if found is None:
print(f"{limit}+ harfli söz yöq")
else:
print(found.upper())QUYOŞ
11+ harfli söz yöq3. Type hintli statistika
Minimum va maksimumni qaytaradigan summarize(values: list[float]) -> tuple[float, float] va apply_to_all(values: list[float], func: Callable[[float], float]) -> list[float] funksiyalarini yozing. [31.0, 38.0, 29.5] ni Selsiydan Farengeytga özgartiring, keyin ikkala röyxat uçun summarize() natijasini çop eting.
Yeçim
from collections.abc import Callable
def summarize(values: list[float]) -> tuple[float, float]:
return min(values), max(values)
def apply_to_all(values: list[float], func: Callable[[float], float]) -> list[float]:
return [func(v) for v in values]
celsius = [31.0, 38.0, 29.5]
fahrenheit = apply_to_all(celsius, lambda c: c * 9 / 5 + 32)
print(summarize(celsius), summarize(fahrenheit))(29.5, 38.0) (85.1, 100.4)4. Tavsifdan loyihalaş: avtoturargoh
Toşkentdagi avtoturargohda raqamlangan joylar bor, maşinalar esa davlat raqami satri bilan aniqlanadi. Band joylarni dict[int, str] da saqlaydigan, töliq type hintlar bilan yozilgan Garage klassini loyihalang: park(plate) (joy raqamini yoki töla bölsa None qaytaradi) va free_spots(). Ikki joyli avtoturargohga uçta maşinani qöying, keyin böş joylarni çiqaring.
Yeçim
class Garage:
def __init__(self, capacity: int) -> None:
self.capacity = capacity
self.spots: dict[int, str] = {}
def park(self, plate: str) -> int | None:
for spot in self.free_spots():
self.spots[spot] = plate
return spot
return None
def free_spots(self) -> list[int]:
return [s for s in range(1, self.capacity + 1) if s not in self.spots]
g = Garage(2)
for plate in ["01A777AA", "10B123CD", "30C555EF"]:
print(plate, "->", g.park(plate))
print("Böş:", g.free_spots())01A777AA -> 1
10B123CD -> 2
30C555EF -> None
Böş: []5. Protocol asosidagi hisobot
price() -> int metodiga ega Priced nomli Protocol aniqlang. Unga mos keladigan ikkita özaro boğliq bölmagan dataclass yarating: Hotel (nights, per_night) va Flight (cost), hamda trip_total(things: list[Priced]) -> int funksiyasini yozing. Har bir elementning klass nomi va narxini, keyin jami summani çiqaring.
Yeçim
from dataclasses import dataclass
from typing import Protocol
class Priced(Protocol):
def price(self) -> int: ...
@dataclass
class Hotel:
nights: int
per_night: int
def price(self) -> int:
return self.nights * self.per_night
@dataclass
class Flight:
cost: int
def price(self) -> int:
return self.cost
def trip_total(things: list[Priced]) -> int:
for thing in things:
print(f"{type(thing).__name__:<7} {thing.price():>9,}")
return sum(t.price() for t in things)
print(f"Jami {trip_total([Flight(780_000), Hotel(2, 450_000)]):>9,}")Flight 780,000
Hotel 900,000
Jami 1,680,000Heç bir klass Priced dan meros olmaydi.
Xulosa
- Type hintlar funksiya nima qabul qilişi va nima qaytarişini tasvirlaydi:
def f(x: list[int]) -> str:. - Bölmasligi mumkin bölgan qiymatlar uçun
X | None, funksiyalar uçunCallable[[argumentlar], natija]işlating. - Öz klasslaringiz ham tur, 3.14 da esa klass type hintlarda özini nomlay oladi.
Protocolduck typing interfeyslarini tasvirlaydi,type Nom = ...esa uzun type hint ga nom beradi (type alias).- Type hintlar işlaş vaqtida tekşirilmaydi. Ularni tur tekşiruvçilari tekşiradi; maʼlumotni esa baribir
if/raisetekşiradi.