Բարելավել կոդի ընթեռնելիությունը և հեշտացնել այն հասկանալը

Python-ը մեզ չի ստիպում հստակորեն նշել փոփոխականի տեսակը: Դա պայմանավորված է նրանով, որ որպես դինամիկ մուտքագրված լեզու՝ Python-ը չի մտածում փոփոխականի տեսակի մասին, քանի դեռ այն չի օգտագործվել: Սա Python-ին դարձնում է ճկուն և հարմար: Այնուամենայնիվ, այս ճկունությունն ու հարմարավետությունը կարող են հանգեցնել թաքնված սխալների և կոդի բազայում տիպի անվտանգության բացակայության:

Բարեբախտաբար, Python 3.5-ից ի վեր մենք լուծում ունենք՝ Type Hints: Այս հատկությունը հիանալի է, քանի որ Python-ը դեռևս պահպանում է իր ճկունությունը որպես դինամիկ մուտքագրված լեզու: Որպես իր անվանումը, մենք միայն ակնարկներ ենք տալիս, և այդ ակնարկները խստորեն չեն կիրառվում հենց լեզվի կողմից:

Այս գրառումը ձեզ խորը ակնարկ կտա Type Hints-ի առավելությունների և դրա օգտագործման դեպքերի մասին:

5 պատճառ, թե ինչու են տպագիր ակնարկները հիանալի

1. Ընդլայնված IDE աջակցություն

IDE-ները (Integrated Development Environments) կարող են օգտագործել տիպային ակնարկներ՝ տրամադրելու առաջադեմ գործառույթներ, ինչպիսիք են ավտոմատ լրացումը, տեսակի ստուգումը և սխալի ընդգծումը տիպի ակնարկների հիման վրա: Այս հատկանիշները շատ օգտակար են, քանի որ դրանք կարող են բարելավել զարգացման փորձը, բարձրացնել արտադրողականությունը և օգնել բացահայտել հնարավոր խնդիրները կոդ գրելիս:

Ստորև բերված է PyCharm-ի օրինակ:

Մենք ունենք add_data անունով ֆունկցիա, որն ունի list արգումենտ, որը կոչվում է data: Մենք ցանկանում ենք այս dataին մի տարր ավելացնել: Եթե ​​որևէ տեսակի հուշում նշված չէ, PyCharm-ը մեզ ներկառուցված գործառույթների վերաբերյալ առաջարկներ չի տալիս (ձախ կողմում գտնվող սքրինշոթ): Եթե ​​նշենք, որ data-ը պետք է լինի list, PyCharm-ը տալիս է բոլոր ներկառուցված գործառույթները list-ի համար (սքրինշոթ՝ աջ կողմում): Կարիք չկա անգիր սովորել բոլոր ներկառուցված գործառույթները: Մենք կարող ենք փրկել մեր թանկարժեք ուղեղը մի բանի համար, որն ավելի կարևոր է:

2. Ավելի լավ փաստաթղթավորում

Տիպի ակնարկները մեզ տալիս են գործառույթների և մեթոդների սպասվող տեսակներն ու օգտագործումը: Այս տեղեկատվությունը կարող է բարելավել կոդերի բազայի ընդհանուր փաստաթղթավորումը՝ մյուս մշակողների համար հեշտացնելով ծածկագիրը արդյունավետ հասկանալն ու օգտագործելը:

def calculate_area_without_type_hint(length, width):
    """
    We need docstring to indicate the expected types and return value
    """
    return length * width


def calculate_area_with_type_hint(length: float, width: float) -> float:
    return length * width

Այս օրինակում calculate_area_with_type_hint-ը տրամադրում է հստակ և հակիրճ փաստաթղթեր գործառույթի ստորագրության մեջ: Ակնկալվում է, որ length և width արգումենտները կլինեն float տիպի, իսկ վերադարձի արժեքը նույնպես float է: Մինչդեռ, calculate_area_without_type_hint-ի դեպքում, փաստաթղթերը հիմնվում են բացառապես փաստաթղթային գծի վրա՝ ակնկալվող տեսակները և վերադարձի արժեքը նշելու համար՝ թողնելով երկիմաստության կամ հնարավոր թյուրիմացության տեղ:

3. Ավելի հեշտ վրիպազերծում

Երբ օգտագործվում են տիպի ակնարկներ, տիպի ստուգիչը կամ IDE-ն կարող է հայտնաբերել անհամապատասխանություններ կամ անհամապատասխանություններ սպասվող տեսակների և իրական օգտագործման միջև: Սա օգնում է բացահայտել սխալները զարգացման գործընթացում: Բացի այդ, երբ տիպի հետ կապված սխալ է հայտնաբերվում տիպի ակնարկների միջոցով, տիպի ստուգիչի կամ IDE-ի կողմից ստեղծված սխալի հաղորդագրությունները հաճախ ավելի կոնկրետ և տեղեկատվական են:

4. Զուգավորումն ավելի պարզ դարձրեք

Տիպի ակնարկների օգտագործումը բաղադրիչների միջև կախվածությունն ու փոխազդեցությունն ավելի ակնհայտ է դարձնում: Դա պայմանավորված է նրանով, որ երբ մենք հստակորեն նշում ենք ակնկալվող տեսակները, ավելի հեշտ է դառնում հասկանալ, թե ինչպես են կոդի բազայի տարբեր մասերը փոխկապակցված: Արդյունքում, զուգակցման հարաբերություններն ավելի պարզ են:

Երբ վերանայում կամ աշխատում է ծածկագրի հետ տիպի ակնարկներով, մենք կարող ենք արագ բացահայտել այն տեսակները, որոնք փոխանցվում են բաղադրիչների միջև: Այս պարզության շնորհիվ մենք կարող ենք գնահատել բաղադրիչի փոփոխությունների հնարավոր ազդեցությունը դրա կախվածության վրա: Արդյունքում մենք կարող ենք նվազագույնի հասցնել անցանկալի կողմնակի ազդեցությունները:

5. Պարզեցրեք Ձեր կոդը

Բավականին սովորական է տեսնել Python-ի չտիպված կոդը՝ օգտագործելովif հայտարարությունները ֆունկցիայի մարմնում՝ ստուգելու համար, թե արդյոք մեր ունեցած արգումենտը իրականում այն ​​է, ինչ մենք ակնկալում էինք: Տիպի ակնարկներով մենք կարող ենք ազատվել նման ստուգումներից:

def add_numbers_without_type_hints(a, b):
    if isinstance(a, int) and isinstance(b, int):
        return a + b
    else:
        return None

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

Հատկանշական է, որ կան դեպքեր, երբ տվյալների տիպի ստուգումը դեռևս անհրաժեշտ է, թեև տիպային ակնարկներ են օգտագործվում։ Օրինակներից մեկն այն է, երբ մենք ապավինում ենք ֆայլից կարդացվող տվյալներին և չունենք վերահսկողություն տվյալների կառուցվածքի վրա:

6 Օգտագործեք տիպի ակնարկների դեպքեր

1. Նշել փոփոխականները

Մենք կարող ենք փոփոխականներին ավելացնել տիպի անոտացիաներ՝ օգտագործելով : կետը, որին հաջորդում է ցանկալի տեսակը: Հնարավոր է նաև նշել տեսակը list և dict ստեղների և արժեքների ներսում: Օրինակ:

age: int = 30
country: str = 'Germany'
skills: list[str] = ['Eat', 'Sleep', 'Repeat']
languages: dict[str, str] = {'English': 'C1', 'German': 'C1'}

Նշում. եթե ձեր Python-ը 3.9-ից ավելի հին է, դուք չեք կարող օգտագործելlist և dict որպես տիպի հուշումներ: Փոխարենը, դուք պետք է դրանք ներմուծեք typing մոդուլից.

from typing import List, Dict

skills: List[str] = ['Eat', 'Sleep', 'Repeat']
languages: Dict[str, str] = {'English': 'C1', 'German': 'C1'}

Հատկանշական է, որ փոփոխականներին բացահայտ տիպի ծանոթագրություններ ավելացնելը բացարձակապես կամընտիր է, քանի որ ստատիկ տիպի ստուգիչները կարող են ավտոմատ կերպով եզրակացնել փոփոխականի տեսակը՝ ելնելով նրան հատկացված արժեքից:

2. Սահմանել հաստատունները

Python-ը չունի հաստատուններ սահմանելու ներկառուցված մեխանիզմ: Այն, ինչ մենք ունենք, միայն բոլոր մեծատառերն օգտագործելու պայմանն է՝ նշելու, որ փոփոխականը նախատեսված է որպես հաստատուն դիտարկվելու համար:

Մենք կարող ենք հաստատուններն ավելի պարզ դարձնել typing մոդուլից ներմուծված տիպի ակնարկով Final: Կարևոր է, որ այս Final ակնարկը միայն տեսողական ցուցիչ է: Ոչ մի անփոփոխություն չի կիրառվում, երբ օգտագործվում է Final: Մի քանի IDE-ներ, ինչպիսին է PyCharm-ը, կընդգծեն այն, երբ մենք փորձենք վերահանձնել հաստատուն: Այնուամենայնիվ, ոչ մի սխալ չի բարձրացվի այդ վերահանձնման պատճառով:

3. Ֆունկցիայի պարամետրեր և վերադարձի արժեքներ

Նմանատիպ շարահյուսությամբ մենք կարող ենք տիպի ակնարկներ ավելացնել ֆունկցիայի պարամետրերին և վերադարձնել արժեքները: Այս պրակտիկան բարելավում է ծածկագրի փաստաթղթերը, ինչպես նաև պարզեցնում է մեր կոդը: Այս առավելությունները մանրամասնորեն նշվել են վերը նշված Նպաստներ բաժնում:

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

Հետաքրքիր է, որ մենք կարող ենք օգտագործել typing մոդուլի Callable ֆունկցիան տիպի հուշում տալու համար, որն օգտագործվում է մեկ այլ ֆունկցիայի պարամետրերում:

from typing import Callable

def greet(name: str) -> None:
    print(f"Hello, {name}!")

def perform_action(action: Callable[[str], None], name: str) -> None:
    action(name)

perform_action(greet, "Bobby")

Այս օրինակում greet ֆունկցիան վերցնում է լարային արգումենտ name և տպում ողջույն: Տիպի ակնարկ Callable[[str], None] օգտագործվում է perform_action ֆունկցիայի action պարամետրը ծանոթագրելու համար: Այն սահմանում է, որ action-ը պետք է լինի կանչելի, որն ընդունում է մեկ տողային արգումենտ (str) և վերադարձնում None: perform_action ֆունկցիան ընդունում է Callable action և name արգումենտները: Այնուհետև այն կանչում է action-ը՝ դրան փոխանցելով name արգումենտը: Այս դեպքում greet ֆունկցիան փոխանցվում է որպես action, և այն գործարկվում է տրամադրված name-ով:

4. Մեկ փոփոխականին ավելացրեք մի քանի հնարավոր տեսակներ

Python-ում փոփոխականը կարող է սահմանվել մի քանի տեսակներով։

Եթե ​​ցանկանում եք նշել, որ արժեքը կարող է լինել None կամ նշված տեսակի, օգտագործեք Optional տիպի հուշում typing մոդուլից:

from typing import Optional

def get_name() -> Optional[str]:
    # ...
    return "Bobby"

Ի՞նչ անել, եթե ցանկանում եք նշել, որ փոփոխականը կարող է լինել կամ string կամ float: Օգտագործեք |՝ հնարավոր տեսակի ակնարկները առանձնացնելու համար: Ստորև բերված օրինակում, նշելով number: string|float, մենք նշում ենք, որ number-ին կարելի է վերագրել կա՛մ տող, կա՛մ լողացող կետով համար:

number: string|float = 3.14

Նշում. |-ն առաջին անգամ ներկայացվել է Python 3.10-ում: Դա նշանակում է, որ եթե դուք օգտագործում եք ավելի հին տարբերակներ, |-ը չի աջակցվում: Այնուամենայնիվ, դուք կարող եք հասնել նույն արդյունքին Union-ով typing մոդուլից:

from typing import Union

number: Union[str, float] = 3.14

5. Ընդհանուր և տիպի փոփոխականներ

Python-ի տիպի ակնարկները նաև աջակցում են ընդհանուր և տիպի փոփոխականներին: Դուք կարող եք օգտագործել այս հնարավորությունները՝ սահմանելու ընդհանուր գործառույթներ կամ դասեր, որոնք աշխատում են մի քանի տեսակների հետ:

Ստորև բերված կոդի հատվածում մեր print_item-ին անհրաժեշտ է Iterable, որը կարող է լինել ցուցակներ, բազմակներ կամ տողեր:

from typing import Iterable

def print_items(items: Iterable) -> None:
    for item in items:
        print(item)

# Example usage
numbers = (1, 2, 3, 4, 5, 6)
names = ['Bobby', 'Isar', 'Munich']

print_items(numbers)  # Prints: 1 2 3 4 5
print_items(names)    # Prints: Bobby Isar Munich

6. Անանուններ

Լինում են դեպքեր, երբ ունենք բարդ տիպեր կամ կրկնվող տիպային արտահայտություններ, որոնք չենք ուզում նորից գրել։ Սա այն դեպքում, երբ կեղծանունները հարմար են.

from typing import TypeAlias

Coordinates: TypeAlias = tuple[int, int]

target_1: Coordinates = (1, 1)
target_2: Coordinates = (2, 1)

TypeAlias պարզապես ընտրովի է: Նույնիսկ առանց դրա, մեր կոդը լավ է աշխատում: Ստորև բերված կոդի հատվածը ոչնչով չի տարբերվում վերը նշվածից.

Coordinates = tuple[int, int]
target_1: Coordinates = (1, 1)
target_2: Coordinates = (2, 1)

Փոխանունների օգտագործումը մեզ տալիս է մի քանի առավելություններ: Օրինակ, նկարագրական կեղծանունները կարող են բարելավել կոդի ընթերցանությունը և հեշտացնել փոփոխականների նպատակը և դրանց ակնկալվող տեսակները հասկանալը: Այն նաև նպաստում է միևնույն տիպի ակնարկի հետ մի քանի վայրերում աշխատելիս հետևողականությանը, քանի որ դուք կարող եք պարզապես օգտագործել կեղծանունը՝ ամեն անգամ ամբողջական տեսակի ակնարկը կրկնելու փոխարեն:

Շնորհակալություն կարդալու համար: Հուսով եմ, որ այս ուղեցույցը օգտակար կլինի ձեզ համար:

«

Ցանկանու՞մ եք կարդալ ամսական ավելի քան 3 անվճար պատմություն: — Դարձեք Միջին անդամ 5$/ամսական: Դուք կարող եք աջակցել ինձ՝ օգտագործելով իմ ուղղորդման հղումը, երբ գրանցվեք: Ես կստանամ միջնորդավճար՝ առանց ձեզ համար լրացուցիչ ծախսերի:

Բարձր մակարդակի կոդավորում

Շնորհակալություն մեր համայնքի մի մասը լինելու համար: Նախքան գնալը.

🚀👉 Միացեք Level Up տաղանդների կոլեկտիվին և գտեք զարմանալի աշխատանք