మాడ్యూల్ పాఠాలు (1/4)
రకం సూచనలు: ఉల్లేఖన రకాలు
రకం సూచనలు (రకం ఉల్లేఖనాలు) ** ఐచ్ఛిక ప్రకటనలు** అని చెప్పవచ్చు "ఈ వేరియబుల్/పారామీటర్ టైప్ Xని కలిగి ఉంది". రన్టైమ్లో పైథాన్ వాటిని ధృవీకరించదు: అవి మీ కోసం, మీ ఎడిటర్ (స్వయంపూర్తి!) మరియు mypy వంటి సాధనాలు లేదా స్టాటిక్ టైప్-చెకింగ్ చేసే పైరైట్.
ఉల్లేఖన వేరియబుల్స్
nome: str = "Ada"
anni: int = 36
attivo: bool = True
prezzi: list[float] = [1.2, 3.4]వాక్యనిర్మాణం name: type = value. విలువ లేకుండా అది స్వచ్ఛమైన ప్రకటన:
risultato: int # nessuna assegnazione, solo "annuncio del tipo"ఉల్లేఖన విధులు
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+)
nomi: list[str] = ["a", "b"]
mappa: dict[str, int] = {"x": 1}
coppia: tuple[int, str] = (1, "ok")
unici: set[int] = {1, 2, 3}ఐచ్ఛికం మరియు యూనియన్
విలువ None కావచ్చు:
def trova_utente(id: int) -> str | None:
if id == 1:
return "Ada"
return NoneX | None అనేది ఆధునిక సింటాక్స్ (పైథాన్ 3.10+). సమానమైనది: Optional[X] నుండి typing.
బహుళ రకాల యూనియన్ల కోసం: int | str | float.
టైపింగ్: ఉపయోగకరమైన సాధనాలు
from typing import Any, Callable
def applica(f: Callable[[int], int], x: int) -> int:
return f(x)
valore: Any = "qualunque cosa" # disabilita il checkAny= "తనిఖీ చేయవద్దు" (తక్కువగా ఉపయోగించండి).Callable[[arg1, arg2], return]= ఆ పారామితులను తీసుకొని ఆ రకాన్ని అందించే ఫంక్షన్.
mypy: టైప్-చెకర్
మీరు mypyని ఇన్స్టాల్ చేసి, mypy file.pyని అమలు చేయండి మరియు రకాలు వరుసలో ఉన్నాయో లేదో మీకు తెలియజేస్తుంది:
$ mypy script.py
script.py:5: error: Argument 1 to "somma" has incompatible type "str"; expected "int"mypyతో రకాలను తనిఖీ చేస్తోంది
పైథాన్ రకం సూచనలు రన్టైమ్లో వ్యాఖ్యాత ద్వారా అమలు చేయబడవు; అమలు సమయంలో అవి విస్మరించబడతాయి. రకం ఖచ్చితత్వాన్ని ధృవీకరించడానికి, మీరు మీ టెర్మినల్లో mypy script.py ఆదేశాన్ని అమలు చేయడం ద్వారా mypy వంటి బాహ్య స్టాటిక్ విశ్లేషణ సాధనాన్ని తప్పనిసరిగా అమలు చేయాలి.
మీరే ప్రయత్నించండి
ప్రతి మూలకం 2తో గుణించబడిన జాబితాను అందించే `డబుల్(సంఖ్యలు: జాబితా[int]) -> జాబితా[int]` ఫంక్షన్ను నిర్వచించండి. దానిని [1, 2, 3]తో కాల్ చేసి, `r`కి కేటాయించండి. `r`ని మూల్యాంకనం చేయండి.
సూచనను చూపించు
లిస్ట్ కాంప్రహెన్షన్ లేదా a for లూప్ ఉపయోగించండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
వ్యాయామం సమీక్షించండి
నిర్వచించండి `first_or_none(అంశాల: జాబితా[int]) -> int | జాబితా ఖాళీగా లేని పక్షంలో మొదటి మూలకాన్ని అందించే ఏదీ లేదు`, లేకుంటే ఏదీ లేదు. `a = first_or_none([10, 20])` మరియు `b = first_or_none([])`ని కేటాయించండి. `(a, b)` మూల్యాంకనం చేయండి.
సూచనను చూపించు
జాబితా ఖాళీగా లేనప్పుడు `ఐటెమ్లు ఉంటే` నిజం.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
అదనపు సవాలు
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 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది