ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 9 · 4లో పాఠం 1కోర్సులో 33/36~12 min
మాడ్యూల్ పాఠాలు (1/4)

రకం సూచనలు: ఉల్లేఖన రకాలు

రకం సూచనలు (రకం ఉల్లేఖనాలు) ** ఐచ్ఛిక ప్రకటనలు** అని చెప్పవచ్చు "ఈ వేరియబుల్/పారామీటర్ టైప్ Xని కలిగి ఉంది". రన్‌టైమ్‌లో పైథాన్ వాటిని ధృవీకరించదు: అవి మీ కోసం, మీ ఎడిటర్ (స్వయంపూర్తి!) మరియు mypy వంటి సాధనాలు లేదా స్టాటిక్ టైప్-చెకింగ్ చేసే పైరైట్.

ఉల్లేఖన వేరియబుల్స్

Python
nome: str = "Ada"
anni: int = 36
attivo: bool = True
prezzi: list[float] = [1.2, 3.4]

వాక్యనిర్మాణం name: type = value. విలువ లేకుండా అది స్వచ్ఛమైన ప్రకటన:

Python
risultato: int  # nessuna assegnazione, solo "annuncio del tipo"

ఉల్లేఖన విధులు

Python
def saluta(nome: str, urlante: bool = False) -> str:
    s = f"Ciao {nome}"
    return s.upper() if urlante else s

def somma(numeri: list[int]) -> int:
    return sum(numeri)

సింటాక్స్: ప్రతి పరామితికి param: type, తిరిగి రావడానికి -> type. ఏదీ తిరిగి ఇవ్వని ఫంక్షన్ -> Noneని ఉపయోగిస్తుంది.

అంతర్నిర్మిత సాధారణ రకాలు (పైథాన్ 3.9+)

Python
nomi: list[str] = ["a", "b"]
mappa: dict[str, int] = {"x": 1}
coppia: tuple[int, str] = (1, "ok")
unici: set[int] = {1, 2, 3}

ఐచ్ఛికం మరియు యూనియన్

విలువ None కావచ్చు:

Python
def trova_utente(id: int) -> str | None:
    if id == 1:
        return "Ada"
    return None

X | None అనేది ఆధునిక సింటాక్స్ (పైథాన్ 3.10+). సమానమైనది: Optional[X] నుండి typing. బహుళ రకాల యూనియన్‌ల కోసం: int | str | float.

టైపింగ్: ఉపయోగకరమైన సాధనాలు

Python
from typing import Any, Callable

def applica(f: Callable[[int], int], x: int) -> int:
    return f(x)

valore: Any = "qualunque cosa"  # disabilita il check
  • Any = "తనిఖీ చేయవద్దు" (తక్కువగా ఉపయోగించండి).
  • Callable[[arg1, arg2], return] = ఆ పారామితులను తీసుకొని ఆ రకాన్ని అందించే ఫంక్షన్.

mypy: టైప్-చెకర్

మీరు mypyని ఇన్‌స్టాల్ చేసి, mypy file.pyని అమలు చేయండి మరియు రకాలు వరుసలో ఉన్నాయో లేదో మీకు తెలియజేస్తుంది:

Bash
$ mypy script.py
script.py:5: error: Argument 1 to "somma" has incompatible type "str"; expected "int"

mypyతో రకాలను తనిఖీ చేస్తోంది

పైథాన్ రకం సూచనలు రన్‌టైమ్‌లో వ్యాఖ్యాత ద్వారా అమలు చేయబడవు; అమలు సమయంలో అవి విస్మరించబడతాయి. రకం ఖచ్చితత్వాన్ని ధృవీకరించడానికి, మీరు మీ టెర్మినల్‌లో mypy script.py ఆదేశాన్ని అమలు చేయడం ద్వారా mypy వంటి బాహ్య స్టాటిక్ విశ్లేషణ సాధనాన్ని తప్పనిసరిగా అమలు చేయాలి.

మీరే ప్రయత్నించండి

వ్యాయామం#python.m9.l1.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

ప్రతి మూలకం 2తో గుణించబడిన జాబితాను అందించే `డబుల్(సంఖ్యలు: జాబితా[int]) -> జాబితా[int]` ఫంక్షన్‌ను నిర్వచించండి. దానిని [1, 2, 3]తో కాల్ చేసి, `r`కి కేటాయించండి. `r`ని మూల్యాంకనం చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

లిస్ట్ కాంప్రహెన్షన్ లేదా a for లూప్ ఉపయోగించండి.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం సమీక్షించండి

వ్యాయామం#python.m9.l1.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

నిర్వచించండి `first_or_none(అంశాల: జాబితా[int]) -> int | జాబితా ఖాళీగా లేని పక్షంలో మొదటి మూలకాన్ని అందించే ఏదీ లేదు`, లేకుంటే ఏదీ లేదు. `a = first_or_none([10, 20])` మరియు `b = first_or_none([])`ని కేటాయించండి. `(a, b)` మూల్యాంకనం చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

జాబితా ఖాళీగా లేనప్పుడు `ఐటెమ్‌లు ఉంటే` నిజం.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

అదనపు సవాలు

వ్యాయామం#python.m9.l1.e3
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

Write a function `double_value(n: int) -> int` that takes an integer, multiplies it by 2, and returns the result. Make sure to specify type hints for both the parameter and the return value. Finally, evaluate `double_value(5)`.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

ఫంక్షన్ సంతకం తర్వాత n: intని పారామీటర్‌గా మరియు -> intని ఉపయోగించండి.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది