Python में Type Hints का उपयोग कैसे करें

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

Python में Type Hints क्या हैं?

Type Hints (टाइप एनोटेशन) Python कोड में अपेक्षित डेटा प्रकारों को इंगित करने की एक प्रणाली है, जो सॉफ्टवेयर की पठनीयता, विश्वसनीयता और गुणवत्ता को बढ़ाती है। हालाँकि Python एक डायनामिकली टाइप की गई भाषा बनी हुई है, लेकिन प्रकारों को स्पष्ट रूप से निर्दिष्ट करने की क्षमता डेवलपमेंट के दौरान कई त्रुटियों से बचने में मदद करती है।

टाइप एनोटेशन की आवश्यकता क्यों है?

Python अपनी लचीलापन के लिए जाना जाता है, लेकिन यही कारण अक्सर अप्रत्याशित डेटा प्रकारों के कारण छिपी हुई बग्स की ओर ले जाता है। बिना एनोटेशन के एक उदाहरण देखें:

def add(a, b):
    return a + b

print(add(5, 10))    # 15
print(add("5", "10"))  # '510' — अप्रत्याशित परिणाम

एक्सप्रेशन add("5", "10") कोई त्रुटि नहीं देगा, लेकिन परिणाम डेवलपर के लिए अप्रत्याशित हो सकता है।

Type Hints निम्नलिखित समस्याओं का समाधान करते हैं:

प्रकारों का स्पष्ट निर्देशन आर्गुमेंट्स और रिटर्न वैल्यू के लिए
कोड की पठनीयता में सुधार डेवलपर टीम के लिए
स्थैतिक विश्लेषण प्रोग्राम चलाने से पहले त्रुटियों का पता लगाने के लिए
IDE में ऑटो-कम्पलीशन अधिक सटीक सुझावों के साथ
API का दस्तावेज़ीकरण अतिरिक्त टिप्पणियों के बिना

Type Hints के बुनियादी उदाहरण

फंक्शन एनोटेशन

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

def calculate_area(radius: float) -> float:
    return 3.14159 * radius ** 2

def format_greeting(name: str) -> str:
    return f"Hello, {name}!"

वेरिएबल एनोटेशन

name: str = "Alice"
age: int = 30
pi: float = 3.14159
is_active: bool = True

कलेक्शन के साथ काम करना

from typing import List, Dict, Tuple, Set

def process_scores(scores: List[int]) -> float:
    return sum(scores) / len(scores)

def get_user_data() -> Dict[str, str]:
    return {"name": "John", "email": "john@example.com"}

def get_coordinates() -> Tuple[float, float]:
    return (10.5, 20.3)

def unique_values(items: List[str]) -> Set[str]:
    return set(items)

Type Hints की उन्नत सुविधाएँ

Optional और Union

from typing import Optional, Union

def greet(name: Optional[str] = None) -> str:
    if name:
        return f"Hello, {name}!"
    return "Hello, Guest!"

def process_value(value: Union[int, float, str]) -> str:
    return str(value)

# Python 3.10+ में | ऑपरेटर का उपयोग कर सकते हैं
def process_new_syntax(value: int | float | str) -> str:
    return str(value)

Callable प्रकार

from typing import Callable

def apply_function(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

def multiply(x: int, y: int) -> int:
    return x * y

result = apply_function(multiply, 5, 3)  # 15

Generic प्रकार

from typing import TypeVar, Generic, List

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: List[T] = []
    
    def push(self, item: T) -> None:
        self.items.append(item)
    
    def pop(self) -> T:
        if not self.items:
            raise IndexError("Stack is empty")
        return self.items.pop()
    
    def is_empty(self) -> bool:
        return len(self.items) == 0

# उपयोग
int_stack = Stack[int]()
int_stack.push(42)

क्लासेस में एनोटेशन

from typing import List, Optional
from dataclasses import dataclass

class Person:
    def __init__(self, name: str, age: int, email: Optional[str] = None) -> None:
        self.name = name
        self.age = age
        self.email = email

    def get_details(self) -> str:
        return f"{self.name}, Age: {self.age}"

@dataclass
class Employee:
    name: str
    department: str
    salary: float
    is_manager: bool = False

# उपयोग
person = Person("Ravi", 28, "ravi@example.com")
print(person.get_details())  # Ravi, Age: 28

emp = Employee("Priya", "Engineering", 75000.0)
print(emp)  # Employee(name='Priya', department='Engineering', salary=75000.0, is_manager=False)