Գլուխ 6. Մոդուլներ

Մոդուլների սահմանում և միացում

Python մոդուլը կոդի մեկ ֆայլ է, որը կարող է կրկին օգտագործվել այլ ծրագրերում:

Մոդուլ ստեղծելու համար անհրաժեշտ է ստեղծել իրական ֆայլը *.py ընդլայնմամբ , որը կներկայացնի մոդուլը: Ֆայլի անունը կներկայացնի մոդուլի անունը: Ապա դուք պետք է սահմանեք մեկ կամ մի քանի գործառույթ այս ֆայլում:

Ենթադրենք ծրագրի հիմնական ֆայլը կոչվում է main.py: Եվ մենք ցանկանում ենք արտաքին մոդուլներ միացնել դրան:

Դա անելու համար մենք նախ կսահմանենք նոր մոդուլ. ստեղծեք նոր ֆայլ նույն պանակում, որտեղ գտնվում է main.py-ը, որը մենք կանվանենք message.py : Լռելյայնորեն, Python թարգմանիչը մոդուլներ է որոնում մի շարք ստանդարտ ուղիներով, որոնցից մեկը հիմնական գործող սցենարի թղթապանակն է։ Հետևաբար, որպեսզի թարգմանիչը վերցնի message.py մոդուլը, պարզության համար մենք երկու ֆայլերը կտեղադրենք մեկ նախագծում։

Համապատասխանաբար, մոդուլը կկոչվի հաղորդագրություն : Դրանում սահմանենք հետևյալ կոդը.

hello = "Hello all" def print_message(text): print(f"Message: {text}")

Այստեղ մենք սահմանում ենք hello փոփոխականը և print_message ֆունկցիան, որը ստանում է որոշակի տեքստ որպես պարամետր և տպում այն վահանակում։

Ծրագրի հիմնական ֆայլում՝ main.py, մենք օգտագործում ենք այս մոդուլը.

import message print(message.hello) # Hello all message.print_message("Hello work") # Message: Hello work

Մոդուլ օգտագործելու համար այն պետք է ներմուծվի՝ օգտագործելով ներմուծման դրույթը, որին հաջորդում է մոդուլի անունը import message.

Մոդուլի ֆունկցիոնալությանը մուտք գործելու համար մենք պետք է ստանանք դրա անվանատարածքը : Լռելյայնորեն այն կհամապատասխանի մոդուլի անվանը, այսինքն՝ մեր դեպքում այն կկոչվի նաև հաղորդագրություն:

Երբ մենք ունենք մոդուլի անվանատարածք, մենք կարող ենք մուտք գործել դրա գործառույթները՝ օգտագործելով սխեմա

namespace.function

Օրինակ՝ print_message() հաղորդագրությունների մոդուլից ֆունկցիա կանչելը.

message.print_message("Hello work")

Եվ դրանից հետո մենք կարող ենք գործարկել main.py հիմնական սցենարը և այն կօգտագործի message.py մոդուլը։

Մոդուլի ֆունկցիոնալությունը միացնելով գլոբալ անվանատարածքին

Կարգավորման մեկ այլ տարբերակ ներառում է մոդուլի ֆունկցիոնալությունը ներմուծել ընթացիկ մոդուլի գլոբալ անվանատարածք՝ օգտագործելով from բանալի բառը.

from message import print_message print_message("Hello work") # Message: Hello work # print(message.hello) # print(hello)

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

Մոդուլից մնացած բոլոր գործառույթներն ու փոփոխականները հասանելի չեն (օրինակ՝ բարև փոփոխականը վերը նշված օրինակում): Եթե մենք նույնպես ցանկանում ենք դրանք օգտագործել, ապա դրանք կարող են առանձին միացվել.

from message import print_message from message import hello print_message("Hello work") # Message: Hello work print(hello) # Hello all

Եթե Ձեզ անհրաժեշտ է ամբողջ ֆունկցիոնալությունը ներմուծել գլոբալ անվանատարածք, ապա առանձին ֆունկցիաների և փոփոխականների անունների փոխարեն կարող եք օգտագործել աստղանիշը * :

from message import * print_message("Hello work") # Message: Hello work print(hello) # Hello all

Բայց հարկ է նշել, որ գլոբալ անունների տարածություն ներմուծելը հղի է ֆունկցիաների անունների բախումներով: Օրինակ, եթե մենք ունենք նույն անունով ֆունկցիա, որը սահմանված է նույն ֆայլում մինչ այն կանչելը, ապա այն ֆունկցիան, որը սահմանվել է վերջին անգամ, կկանչվի.

from message import * print_message("Hello work") def print_message(some_text): print(f"Text: {some_text}") print_message("Hello work")

Այսպիսով, ընթացիկ ֆայլում համանուն գործառույթը թաքցնում է գործառույթը միացված մոդուլից:

Փոխանունների տեղադրում

Մոդուլը և դրա ֆունկցիոնալությունը ներմուծելիս մենք կարող ենք դրանց համար մականուններ դնել: Դա անելու համար օգտագործեք որպես հիմնաբառը , որին հաջորդում է մականունը: Օրինակ, եկեք մոդուլի համար սահմանենք կեղծանուն.

import message as mes print(mes.hello) # Hello all mes.print_message("Hello work") # Message: Hello work

Այս դեպքում անվանատարածքը կկոչվի mes , և մոդուլի ֆունկցիոնալությունը հասանելի կլինի այս կեղծանունով:

Նմանապես, դուք կարող եք սահմանել այլանուններ առանձին մոդուլի ֆունկցիոնալության համար.

from message import print_message as display from message import hello as welcome print(welcome) display("Hello work")

Այստեղ հաղորդագրության մոդուլից print_message ֆունկցիան դրված է ցուցադրման այլանունով, իսկ hello փոփոխականը՝ ողջույնի անունի: Եվ այս կեղծանունների միջոցով մենք կկարողանանք կապ հաստատել նրանց հետ։

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

from message import print_message as display def print_message(some_text): print(f"Text: {some_text}") display("Hello work") # Message: Hello work print_message("Hello work") # Text: Hello work

Մոդուլի անվանումը

Վերևի օրինակում main.py մոդուլը, որը հիմնական մոդուլն է, օգտագործում է message.py մոդուլը: Երբ գործարկում եք main.py մոդուլը, ծրագիրը կկատարի բոլոր անհրաժեշտ աշխատանքները: Այնուամենայնիվ, եթե առանձին գործարկենք message.py մոդուլը, մենք ոչինչ չենք տեսնի վահանակի վրա: Ի վերջո, հաղորդագրության մոդուլը պարզապես սահմանում է ֆունկցիա և փոփոխական և այլ գործողություններ չի կատարում։ Բայց մենք կարող ենք համոզվել, որ message.py մոդուլը կարող է օգտագործվել ինչպես ինքնուրույն, այնպես էլ միացված այլ մոդուլների հետ:

Երբ մոդուլը գործարկվում է, միջավայրը որոշում է դրա անունը և վերագրում է __name__ գլոբալ փոփոխականին (երկու կողմում երկու ընդգծում): Եթե մոդուլը գործարկվող է, ապա դրա անունը __main__ է (նաև երկու ընդգծում յուրաքանչյուր կողմում): Եթե մոդուլն օգտագործվում է մեկ այլ մոդուլում, ապա կատարման պահին նրա անունը նույնն է, ինչ ֆայլի անունը՝ առանց py ընդլայնման։ Եվ մենք կարող ենք օգտագործել այն: Այսպիսով, եկեք փոխենք message.py ֆայլի բովանդակությունը.

hello = "Hello all" def print_message(text): print(f"Message: {text}") def main(): print_message(hello) if __name__ == "__main__": main()

Այս դեպքում, message.py մոդուլին ավելացվել է ֆունկցիա՝ մոդուլի ֆունկցիոնալությունը ստուգելու համար main: Եվ մենք կարող ենք անմիջապես գործարկել message.py ֆայլը բոլորից առանձին և փորձարկել կոդը:

Ուշադրություն դարձրեք հիմնական գործառույթի զանգին.

if __name__ == "__main__": main()

__name__ փոփոխականը ցույց է տալիս մոդուլի անվանումը: Ուղղակիորեն գործարկվող հիմնական մոդուլի համար այս փոփոխականը միշտ կունենա __main__ արժեքը՝ անկախ ֆայլի անունից:

Հետևաբար, եթե առանձին-առանձին գործարկենք message.py սկրիպտը, ապա Python-ը կնշանակի __name__ արժեքը փոփոխականին __main__, այնուհետև if դրույթում կկանչի հիմնական ֆունկցիան նույն ֆայլից։

Այնուամենայնիվ, եթե մենք գործարկենք մեկ այլ սկրիպտ և միացնենք այս մեկը՝ message.py - որպես օժանդակ, message.py-ի համար __name__ փոփոխականը կունենա արժեքը message: Եվ համապատասխանաբար, message.py ֆայլում հիմնական մեթոդը չի աշխատի։

Մոդուլի անվանումը ստուգելու այս մոտեցումն ավելի առաջարկվող մոտեցում է, քան պարզապես հիմնական մեթոդը կանչելը:

main.py ֆայլում կարող եք նաև ստուգել, թե արդյոք մոդուլը հիմնականն է (չնայած սկզբունքորեն դա անհրաժեշտ չէ).

import message def main(): message.print_message("Hello work") # Message: Hello work if __name__ == "__main__": main()

Python-ը տրամադրում է մի շարք ներկառուցված մոդուլներ, որոնք մենք կարող ենք օգտագործել մեր ծրագրերում: Հաջորդ հոդվածներում մենք կքննարկենք հիմնականները: