Mastering Python Typing Module: Mga Halimbawa ng Paggamit

Ang Python ay isang malakas na programming language na ginagamit sa maraming larangan, mula sa data science hanggang web development. Isa sa mga tampok na maaari mong gamitin upang mapabuti ang kalidad ng iyong code ay ang Python typing module. Kung ikaw ay baguhan pa lamang sa paggamit ng typing module o nais mong mas mapalalim ang iyong kaalaman, narito ang ilang halimbawa na makakatulong sa iyo.

1. Ano ang Python Typing Module?

Bago tayo tumalon sa mga halimbawa, alamin muna kung ano ang Python typing module. Ang typing module ay ipinakilala sa Python 3.5 at nagbibigay ito ng paraan upang ipahayag ang mga uri ng data na inaasahan o tinatanggap ng mga variable, function, at klase sa iyong code. Ang ganitong deklarasyon ng uri ay makakatulong upang mapadali ang pagsusuri ng mga error at pagpapahusay ng maintainability ng code.

2. Basic na Pag-gamit ng Typing sa Python

Ang pinaka-basic na halimbawa ng typing ay ang paggamit ng mga type hints sa function signatures. Halimbawa:

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

Sa halimbawa sa itaas, makikita mo na ang function na add_numbers ay may mga type hints. Ang a at b ay inaasahang mga integer, at ang function ay magbabalik ng isang integer. Ito ay isang simpleng halimbawa kung paano mo matutukoy ang uri ng mga input at output ng function mo gamit ang typing module.

3. Pag-gamit ng Union Type

Isa sa mga powerful na tampok ng typing module ay ang 'Union'. Gamit ito, maaari kang magtukoy na ang isang variable ay maaaring magkaroon ng iba't ibang uri ng data. Halimbawa:

from typing import Union

def concatenate(a: Union[str, int], b: Union[str, int]) -> str:
    return str(a) + str(b)

Sa halimbawa sa itaas, ang function na concatenate ay tumatanggap ng dalawang argumento na maaaring string o integer, at ibinabalik nito ang pinagsamang string. Ginamit ang Union upang tukuyin ang posibilidad ng iba't ibang uri ng input.

4. Pag-gamit ng List at Tuple Types

Sa Python, ang mga koleksyon tulad ng list at tuple ay madalas gamitin. Gamit ang typing module, maaari mong itukoy ang uri ng mga elementong nasa loob ng mga koleksyong ito. Narito ang isang halimbawa ng paggamit ng List:

from typing import List

def sum_list(numbers: List[int]) -> int:
    return sum(numbers)

Sa halimbawa sa itaas, ang function na sum_list ay tumatanggap ng isang listahan ng mga integer at nagbabalik ng kabuuan ng mga ito. Dito, tinukoy natin ang uri ng elemento ng list gamit ang typing module.

Pwede rin nating gamitin ang Tuple na katulad ng List, ngunit ang mga elementong nasa Tuple ay hindi maaaring baguhin. Narito ang halimbawa:

from typing import Tuple

def average_of_tuple(values: Tuple[int, int, int]) -> float:
    return sum(values) / len(values)

Ang function na average_of_tuple ay tumatanggap ng Tuple ng tatlong integers at binabalik ang kanilang average.

5. Pag-gamit ng Optional Type

Sa mga pagkakataon na nais mong magtukoy na ang isang argumento ay maaaring wala (None), maaari mong gamitin ang Optional. Halimbawa:

from typing import Optional

def find_item(items: List[str], target: str) -> Optional[int]:
    try:
        return items.index(target)
    except ValueError:
        return None

Sa halimbawa sa itaas, ang function na find_item ay naghahanap ng target na item sa listahan. Kung hindi ito matagpuan, magbabalik ito ng None. Ang Optional[int] ay nagsasaad na ang return value ay maaaring isang integer o None.

6. Pag-gamit ng Dict Type

Ang Dictionary ay isa pang uri ng koleksyon sa Python. Gamit ang typing module, maaari mong tukuyin ang uri ng mga susi at halaga ng isang dictionary. Narito ang isang halimbawa:

from typing import Dict

def print_employee_details(employee: Dict[str, str]) -> None:
    for key, value in employee.items():
        print(f'{key}: {value}')

Sa halimbawa na ito, ang function print_employee_details ay tumatanggap ng isang dictionary na ang mga susi at halaga ay parehong string. Pinipilit natin ang mga uri ng key at value ng dictionary na ito gamit ang typing module.

7. Pag-gamit ng Callable Type

Isa sa mga pinaka-interesanteng uri sa typing module ay ang Callable type. Ang Callable ay ginagamit upang tukuyin ang isang function o method. Halimbawa:

from typing import Callable

def execute_function(func: Callable[[], None]) -> None:
    func()

Sa halimbawa sa itaas, ang execute_function ay tumatanggap ng isang function na walang argumento at walang return value. Gamit ang typing module, tinukoy natin ang uri ng function na maaaring ipasa sa execute_function.

8. Konklusyon

Ang Python typing module ay isang malakas na tool na makakatulong sa paggawa ng mas malinis at madaling maintindihang code. Sa pamamagitan ng paggamit ng mga type hints, mas madali nating maiiwasan ang mga error at makakapagtrabaho tayo sa mas organisadong paraan. Sa mga halimbawa na nabanggit natin, maaari mo nang simulan ang paggamit ng Python typing module sa iyong mga proyekto at mapabuti ang kalidad ng iyong code.