Yaya nau'i bayani ke aiki kuma nima ne fa'idodin su?

Question

IT Interview Practice · Accepted Answer

**Type hints** (PEP 484+) suna ba ka damar sanya alamomi na nau'ikan da ake fata na masu canji, sigajin aiki, da ƙimar baje. Su ne **zaɓi** kuma **ba a aiwatar a lokaci na aiki ba** — Python ta yi watsi da su lokacin tafi — amma sun ba da damar bincike na static, kuma kayan aiki masu kyau, kuma code mai bayani.

## Sanarwa na asali

```python
def greet(name: str, times: int = 1) -> str:
    return name * times

age: int = 30
names: list[str] = ["Ann", "Bob"]
scores: dict[str, int] = {"math": 90}
```

The `: type` yana bayyana sigajin / masu canji kuma `-> type` ƙimar komawa. Wadannan suna ba da hujja kuma sun yi daidai da kayan aiki, amma Python ba ta **aiwata** su a lokaci na aiki ba (yin watsi da nau'i daidai ba zai bugi bayyana ta nau'in nau'i ba).

## Common typing constructs

```python
from typing import Optional, Union, Callable, Any

def find(id: int) -> Optional[str]:    # str OR None (= str | None in 3.10+)
    ...

x: int | str                           # Union (3.10+ syntax)
handler: Callable[[int], bool]         # a function taking int, returning bool
items: list[dict[str, int]]            # nested generics
```

## Bincike na static type ya kama kutsebbuwar da jiya

```python
def add(a: int, b: int) -> int:
    return a + b

add("hello", 3)   # ✅ Python runs it (and crashes); ❌ mypy/pyright flags it BEFORE running
```

Ma'aikacin bincike nau'i kamar **mypy** ko **pyright** yana bincika alamomi kuma yana ba da rahotanniyar kutsebbuwar nau'i *kafin* ka aiwatar da code — kama gida duka na kutsebbuwa (nau'i na watsi na aiki, rashin amfani da None) da wuri gida, kamar mai gaba yake.

## Fa'idodin

```text
✓ Catch type bugs early via static checkers (mypy, pyright) — before runtime
✓ IDE support — better autocomplete, refactoring, inline error detection
✓ Self-documenting code — signatures show exactly what's expected/returned
✓ Powers frameworks — FastAPI/Pydantic USE hints for validation & docs
✓ Easier maintenance of large codebases (catch breaking changes)
```

## Su ne zaɓi da saurin gida

```text
You can add hints incrementally — a few functions, or strictly everywhere.
Unannotated code still works. "Gradual typing" suits adopting them over time.
```

## Frameworks suna amfani da su a lokaci na aiki

```python
from pydantic import BaseModel
class User(BaseModel):
    name: str
    age: int            # Pydantic USES the hint to VALIDATE data at runtime
User(name="Ann", age="x")   # raises a validation error
```

Wasu laburare (Pydantic, FastAPI) suna karanta alamomi nau'i don tabbatar da bayani kuma samar da bayani — ƙila su m substituted m function a lokaci na aiki.

## Me yasa ya zama muhimmi

Type hints kano godiya da yawa raya nau'i static zuwa Python ba tare da mirgina shi ni dynamic flexibility: sun kama kutsebbuwa masu alaƙa nau'i da wuri (ta hanyar mypy/pyright), sun bai haɗi sosai kayan aiki IDE kuma sabunta aiki, aiki azaman alamun alimahudu da lalai, da ikon zamani frameworks (FastAPI, Pydantic) wanda suke amfani da su don tabbatarwa da auto-jera bayani. Duk da haka optional kuma ba a aiwatar da su ta Python kanta a lokaci na aiki, sun zama standard a cikin kasua kuma masu girma Python codebases saboda sun sa code masu karfi, ban da mutane sa, kuma kanta-alimahudu — ƙara a amsa damje, musamman kamar yadda aiki ya haɗu.

Sanarwa na asali

Common typing constructs

Bincike na static type ya kama kutsebbuwar da jiya

Fa'idodin

Su ne zaɓi da saurin gida

Frameworks suna amfani da su a lokaci na aiki

Me yasa ya zama muhimmi

Tambayoyi masu alaƙa