VISION ACADEMY

Սովորում ենք Python

Դասավանդող՝ Սմբատ Շախբազյան

Մինչ ընթերցելը

Տեխնիկական տերմինները պահպանված են անգլերեն, իսկ բացատրությունները՝ հայերեն։

Բնագրի հասանելի նյութը թարգմանված է, իսկ ավելացված բացատրություններն ու ստուգված օրինակները նշված են առանձին։ Մկնիկը պահեք կապակցված բառի կամ նշման վրա՝ հիշեցումը բացելու համար։

Աղբյուրի որոշ code-երի և արտածումների վերջերը կտրված են։ Հաստատված կորուստները նշված են։ Ավելացված աշխատող օրինակները չեն ներկայացվում որպես կորած տողերի բառացի վերականգնում։

Նախաբան

Սկզբնաղբյուրի PDF էջ 7

Եթե գրախանութում թերթում եք այս գիրքը և փորձում հասկանալ, թե այն ինչի մասին է, պատկերացրեք հետևյալը։

Python-ն աշխարհի ամենատարածված programming language-ներից մեկն է։ Այն մասնակցում է գրեթե բոլոր այն դերերին, որոնք computer-ներն ունեն մեր կյանքում, իսկ օգտագործման հարաբերական պարզությունը այն դարձնում է programming-ը սկսելու հարմար միջոց։ Այս գիրքը ուսումնական ձեռնարկ է, որը խորությամբ սովորեցնում է Python լեզվի հիմունքները։ Այն ուղղված է Python սովորող ամենատարբեր սկսնակների, կիրառելի է Python-ի օգտագործման բոլոր ոլորտներում և հիմնված է ձեզ նման իրական սովորողներից տասնամյակներ շարունակ ստացված արձագանքների վրա։
Այս հրատարակությունը գիրքը թարմացնում է՝ հաշվի առնելով Python-ում և նրա միջավայրում մեկ տասնամյակի ընթացքում կատարված փոփոխությունները։ Այն այլևս չի ընդգրկում այժմ գործածությունից դուրս եկած Python 2.X-ը, ուսումնասիրում է մինչև Python 3.12-ը ներառյալ ավելացված նոր գործիքները և կիրառելի է նաև Python-ի ավելի վաղ ու ապագա տարբերակների համար։

Նախաբանի մնացած մասը լրացուցիչ տեղեկություններ է տալիս գրքի և նրա թեմայի մասին։ Այն բացատրում է նախորդ հրատարակությունից հետո տեղի ունեցած փոփոխությունները, ներկայացնում է գրքի օրինակների package-ը և օգնում կողմնորոշվել՝ մինչև մանրամասներին անցնելը։

Սկզբնաղբյուրի PDF էջ 8

Այսօր համացանցում հանդիպող չափորոշիչների մեծ մասով Python-ը կամ մոլորակի ամենաշատ օգտագործվող programming language-ն է, կամ շատ մոտ է list-ի գագաթին։ Օրինակ՝ հաճախ հիշատակվող TIOBE հանրաճանաչության ցուցիչը մի քանի տարի շարունակ Python-ին դասել է առաջին տեղում։ Երբ այս հրատարակությունը գրվում էր՝ 2024 թվականին, այդ ցուցիչում Python-ը զբաղեցնում էր առաջին տեղը՝ զգալիորեն առաջ անցնելով մոտակա հետևորդներից՝ C-ից, C++-ից և Java-ից։

Իհարկե, հանրաճանաչության դասակարգումները կարող են փոխվել և հիմնվում են օգտագործման այնպիսի չափումների վրա, որոնց շուրջ կարելի է վիճել․ այստեղ այդ քննարկումը բաց կթողնենք։ Բայց առկա բոլոր նշաններով Python-ի հեղափոխությունն ակնհայտորեն արդեն տեղի է ունեցել։ Այն այսօր համատարած և հաճախ ընտրվող լեզու է վեբ մշակման, գիտական programming-ի, համակարգերի կառավարման, AI-ի և computer-ների կատարած գրեթե բոլոր այլ գործերի մեջ։ Հարաբերական պարզության շնորհիվ Python-ը նաև հաճախ օգտագործվում է՝ կրթության տարբեր մակարդակներում սկսնակներին համակարգչային գիտությանը ծանոթացնելու համար։

Փաստորեն, այսօր բավական հիմնավոր է ասել, որ Python-ը վճռորոշ դեր է ունեցել աշխարհը փոխելու գործում։ Առաջ տանելով static typing-ով compiled լեզուներից դեպի dynamic typing-ով scripting language-ներ անցումը՝ Python-ը նպաստել է փոփոխությունների, որոնք առնվազն նույնքան խորն էին, որքան ավելի վաղ մեքենայական լեզվից compiled լեզուներին անցնելու հետևանքները։ scripting language-ներին

Սկզբնաղբյուրի PDF էջ 9

անցումը միաժամանակ գործնական դարձրեց նախկինում ոչ նպատակահարմար առաջադրանքները և ոլորտը բացեց ոչ պրոֆեսիոնալ մասնակիցների համար։ Այդ ընթացքում այն computer-ներին տվեց այնպիսի նշանակություն, որը նախորդ տասնամյակներում դժվար էր նույնիսկ պատկերացնել։ Օրինակ՝ համացանցն առանց Python-ի նման գործիքների պարզապես չէր կարող լինել այն, ինչ այսօր է։ Լավ կամ վատ՝ Python-ը հնարավոր է դարձնում նորը։

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

Երկրորդ՝ Python-ի տարածվածությունը նշանակում է, որ այս գիրքը կարդալով դուք ձեր գործիքակազմին արժեքավոր հմտություն կավելացնեք, որը կօգնի համակարգչային program-երին առնչվող ամենատարբեր գործերում։ Python սովորելը և՛ ամբողջ ոլորտներ հասանելի կդարձնի ձեզ համար, և՛ հնարավորություն կտա իրականացնել programming-ի նպատակներ, որոնք այլապես դժվար կամ անհնար կլինեին։ Python օգտագործողները այսօր կարող են օգտվել նախապես ստեղծված հարուստ փորձից ու լուծումներից՝ մի լեզվով, որն արագացնում է նրանց աշխատանքը։

Սկզբնաղբյուրի PDF էջ 10

Սակայն Python-ը միակ ընտրությունը չէ։ Օգտակար կլինի համակարգչային գիտությունը սովորել նաև հիմքից վեր՝ մշակողների լեզվով ասած՝ ամբողջ stack-ը։ Օրինակ՝ ավելի ցածր մակարդակի լեզուները, ինչպիսիք են C-ն և Java-ն, դեռ կարող են տալ շատ ավելի ամբողջական պատկեր, քան միայն scripting language-ները, և օգնել լուծել ընթացքում առաջացող բարդ խնդիրները։ Ի վերջո, Python-ի ամենատարածված իրականացումն ինքն էլ C-ով գրված program է։

Այնուամենայնիվ, Python-ը սկսելու հիանալի տեղ է և շատ խնդիրների համար լիովին բավարար։ Այն նույնպես թերություններ ունի և ենթարկվում է այսօրվա ծրագրային աշխարհին բնորոշ անդադար փոփոխություններին, բայց բազմաթիվ մշակողների համար Python օգտագործելը դեռ շատ ավելի հաճելի է, քան այլ գործիքներով աշխատելը։ Օրինակ՝ Java-ն և C++-ը թվում են միջին օղակի ղեկավարների համար նախագծված լեզուներ․ դրանք programmer-ներին կաշկանդում են օժանդակ սահմանափակումներով և բյուրոկրատական խոչընդոտներով, որոնք քիչ կապ ունեն program-ի նպատակների հետ։ Python-ը, հակառակը, ավելի շատ դաշնակից է մնում, քան խոչընդոտ։ Այս տեսակետն, անշուշտ, սուբյեկտիվ է, բայց դուք ճիշտ տեղում եք, որպեսզի ինքներդ գնահատեք այն։

Այս գիրքը Python լեզվի ուսումնական ձեռնարկ է և իր ոլորտի դասական աշխատություններից մեկը։ Այն Python-ն օգտագործելու, տարածելու և դասավանդելու երեք տասնամյակի արդյունք է և սկիզբ է առնում

Սկզբնաղբյուրի PDF էջ 11

1990-ականների կեսերից, երբ Python-ը դեռ 1.X տարբերակում էր, իսկ վեբի մասին մշակողները պարզապես ճաշի ժամանակ էին զրուցում։ Թեև այստեղ հիմնական ուշադրությունը ներկային է ուղղված, այդ պատմությունն ավելացնում է համատեքստ, որը կօգնի Python-ն ավելի խորությամբ հասկանալ։ Ինչ էլ լսած լինեք՝ անցյալը կարևոր է, հատկապես գիտելիքի վրա հիմնված ոլորտներում։

Նույնքան կարևոր է, որ այս գիրքը միշտ հիմնված է եղել Python-ն առաջին անգամ սովորելու դժվարություններ հաղթահարող սկսնակների անմիջական արձագանքի վրա։ Այդ արձագանքի հիմնական աղբյուրը երկու տասնամյակ դասավանդված Python դասընթացներն են։ Թեև այդ դասընթացներն այսօր դոդոյի և Yahoo-ի պես անցյալում են մնացել, գիրքը հոգ է տանում պահպանելու սովորողների փորձից առաջացած նյութը, քանի որ հենց դա է կազմում նրա value-ի մեծ մասը, եթե ոչ հիմնականը։

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

Սկզբնաղբյուրի PDF էջ 12

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

Այս հրատարակությունից ամբողջությամբ հեռացվել է լեզվի նախորդ տարբերակի՝ Python 2.X-ի քննարկումը և ավելացվել են նոր ու դրա հետ անհամատեղելի Python 3.X-ի վերջին փոփոխությունները։ Երբ նախորդ հրատարակությունը լույս տեսավ 2013 թվականին, Python 2.X-ը դեռ լայնորեն օգտագործվում էր և հավանաբար նույնիսկ գերիշխում էր։ Դրա պատճառով այն հրատարակությունը պետք է միաժամանակ ընդգրկեր և՛ հաստատված 2.X-ը, և՛ նոր ու զարգացող 3.X-ը, ինչն երբեմն շարադրանքը զգալիորեն բարդացնում էր։

Սկզբնաղբյուրի PDF էջ 13

Ավելի քան մեկ տասնամյակ անց 2.X-ի պաշտոնական աջակցությունն ավարտվել է, և Python-ի աշխարհն այնքան ամբողջությամբ է անցել 3.X-ի, որ 2.X-ն այսօրվա սկսնակների համար դարձել է չարդարացված շեղում։ Ուստի տասնամյակներ շարունակ ընդգրկված լինելուց հետո 2.X-ին հատուկ նյութը հեռացվել է՝ տեղ բացելով 3.X-ի նոր թեմաների համար և ընդհանուր առմամբ կրճատելով գրքի ծավալը։ Պաշտոնապես այս հրատարակությունը թարմացվել է Python 3.12-ի և նրա ժամանակաշրջանի մակարդակին, թեև նաև նախապես ներկայացնում է 3.13-ի որոշ փոփոխություններ։ Հիմունքների վրա կենտրոնանալը գիրքը ընդհանուր առմամբ կիրառելի է դարձնում Python-ի թե՛ ավելի վաղ, թե՛ ավելի նոր տարբերակների համար։

Մինչ նամակները կհեղեղեն փոստարկղը, գիրքը ցանկանում է հստակեցնել, որ ափսոսում է պատմական համատեքստի այս կորստի համար և գաղտնի կարոտում է 2.X-ի ավելի պարզ օրերը։ Բայց 3.X-ն ինքնին ընդարձակ թեմա է՝ առանց պատմությունը երկու ճյուղի բաժանելու և քիչ օգտագործվող տարբերակի պատճառով էջերի քանակն ավելացնելու։ Այսպիսով՝ խաղաղ անցյալ քեզ, 2.X, և երկար կյանք՝ 3.X-ին։ Եթե այլ բան հատուկ նշված չէ, այս հրատարակության «Python» բառը ընդհանուր առմամբ նշանակում է 3.X շարքը, իսկ մասնավորապես՝ 3.12 և ավելի ուշ տարբերակները։

3.X-ի փոփոխություններից այս հրատարակությունն առաջին անգամ ընդգրկում է f'…' f-string literal-ները, := անունով assignment expression-ները, match statement-ները, type hint-ները, async կորուտինները, աստղանիշով ապափաթեթավորման ընդլայնված կիրառությունը, թվանշանները բաժանող ընդգծման նշանը, package-ների __main__.py file-երը, module-ների __getattr__ կապակցման կետերը, except* exception-ների խմբերը, dictionary-ի key-ների ավելացման հերթականության պահպանումը, միայն դիրքով փոխանցվող function-ի

Սկզբնաղբյուրի PDF էջ 14

argument-ները, hash-ի վրա հիմնված bytecode-ի file-երը և ավելի քան մեկ տասնամյակում ի հայտ եկած այլ հավելումները, հնացած ճանաչված հնարավորություններն ու վերափոխումները։

Դրանցից type hint-ներն ու async կորուտինները միտումնավոր չեն ուսումնասիրվում խորությամբ։ Առաջինը կամընտիր և ակադեմիական գործիք է, որը Python-ն ինքը չի օգտագործում և որը հակադրվում է նրա հիմնարար սկզբունքներին։ Երկրորդը կիրառական program-երի համար նախատեսված առաջադեմ գործիք է, որն իր հայտնվելուց ի վեր անընդհատ փոփոխվել է։ Երկուսն էլ արագ հասնում են այնպիսի բարդության, որ դուրս են գալիս Python-ի սկսնակների համար նախատեսված շրջանակից։ Անհրաժեշտության դեպքում այդ նեղ թեմաների լրացուցիչ տեղեկությունը կարելի է գտնել համացանցում մեկ որոնմամբ։ Այստեղ նպատակը վազել փորձելուց առաջ լավ քայլել սովորելն է։

Այս անգամ կատարված մյուս նշանակալի փոփոխություններից են հետևյալները։

Առաջադեմ մասի 37-րդ գլխում Unicode-ի նյութը նոր է և բարելավված, քանի որ այս թեման այժմ կարևոր է թե՛ Python 3.X-ում, թե՛ ընդհանուր առմամբ աշխարհում։
Օգտագործման եղանակների քննարկումը, ներառյալ նոր A հավելվածը, ավելի մեծ ուշադրություն է դարձնում macOS-ին, Android-ին, Linux-ին և iOS-ին, քանի որ ընթերցողներից ոչ բոլորն են Windows օգտագործում։
code file-երի օրինակների մեծ մասն այժմ ունի համարակալված վերնագիր․ լրացուցիչ ձևականությունը դրանք գրքում ավելի հստակ է տարբերակում և արժե զբաղեցրած տեղը։

Սկզբնաղբյուրի PDF էջ 15

Կրկնությունների մի մասը կրճատվել է, բայց ոչ բոլորը, քանի որ կրկնությունն ուսումնական նյութերում օգտակար է և նույնիսկ կարևոր։
Գրքի ծավալը փոքրացել է նախորդ կետում նշված փոփոխության, վերաշարադրումների ու նյութի ընթացքի փոփոխությունների, ինչպես նաև 2.X-ի հեռացումների ու 3.X-ի հավելումների ընդհանուր արդյունքի շնորհիվ․ այդպես յուրացնելու նյութն ավելի քիչ է։
Տպագիր տարբերակն էլ ավելի է փոքրացել, քանի որ երկու առաջադեմ, բայց կամընտիր գլուխներ՝ 38-րդն ու 39-րդը, տեղափոխվել են առցանց․ այդպես գիրքը կրելն ավելի հեշտ է։
Օրինակների հորինված name-ներն այժմ ավելի չեզոք են սեռի տեսակետից․ «Bob»-ը դարձել է երկիմաստ «Pat», բացառությամբ «Sue»-ի հետ նախկին զույգերի, որպեսզի կանխակալության հավանականությունը փոքրացվի։
Monty Python-ին հղումները հեռացվել են․ դրանք կարող են անհասկանալի կամ բաժանարար լինել, իսկ լրատվամիջոցներից անհատականություն փոխառելը մակերեսային հնարք է թվում։
Առաջին դեմքով շարադրանքն ու անձնական պատմություններն ամբողջ գրքից հեռացվել են, քանի որ դուք գնել եք գիրքը Python սովորելու, ոչ թե հեղինակի կենսագրությունը կարդալու համար։

Վերջին երկու կետերի մասին․ Python-ին անուն տված կատակերգությունն, անշուշտ, զվարճալի էր, բայց գրեթե միայն տղամարդկանցից կազմված խմբի գործերն անընդհատ կրկնելը հետադարձ հայացքով կարող է հիշեցնել փակ տղամարդկանց ակումբի գաղտնի պայմանանշան։ Իսկ երբեմն հանդիպող «ես»-ը կամ «իմ»-ը կարող են շարադրանքին գույն կամ վստահելիություն տալ, բայց դրանց չարաշահումը սովորաբար ինքնասիրահարվածության տպավորություն է թողնում։ Ուստի նախկին հազար «spam»-երն այժմ ավելի ներառական

Սկզբնաղբյուրի PDF էջ 16

նշաններ են, իսկ գրքի երեք տասնամյակի գոյությունը պետք է ինքն իր օգտին վկայի։

Բոլոր փոփոխություններով հանդերձ՝ այս հրատարակությունը ավելի շատ տեխնիկական վեպ է մնում, քան տեղեկատու ձեռնարկ, և բավական բովանդակալից է՝ Python-ի ու programming-ի ամբողջ կիսամյակի դասընթացի հետ համեմատվելու համար։ Այն ներկայացնում է թեմաներ և հետագա գլուխներում վերադառնում դրանց՝ աստիճանաբար ամբողջական ընդգրկում կուտակելով։ python.org-ում կան Python-ի արագ տեղեկատուներ, ինչպես նաև բազմաթիվ բլոգներ ու տեսանյութեր, որոնք խոստանում են արագ սովորեցնել լեզուն։ Այս գիրքը նրանց համար է, ովքեր գիտեն, որ որևէ բան լավ սովորելը մի փոքր ավելին է պահանջում։

Գրելու պահին նախատեսվում է, որ գիրքը հասանելի կլինի երեք ձևով՝ տպագիր, այսինքն՝ թղթային, էլեկտրոնային գիրք՝ օրինակ PDF, ePub կամ Kindle, և առցանց, այսինքն՝ վեբ։ Վերջինն այստեղ նշանակում է հրատարակչի բաժանորդագրային ծառայությունը, որն այժմ կոչվում է O’Reilly learning platform, իսկ նախկինում՝ Safari։ Բնականաբար, յուրաքանչյուր ձևաչափ ունի իր կիրառությունը՝ կախված ընթերցողից։ Օրինակ՝ շատերը հաջորդական ընթերցման համար նախընտրում են թուղթը, իսկ պատահական որոնումների և code-ը պատճենելու ու տեղադրելու համար՝ էլեկտրոնային միջավայրը։

Սկզբնաղբյուրի PDF էջ 17

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

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

Եվս մեկ խորհուրդ ձևաչափերի մասին․ հրատարակիչը կարող է այս գիրքը նաև փոխանցել գեներատիվ AI մոդելներին, որոնք այժմ տեխնոլոգիական մամուլի ամենաքննարկվող թեմաներից են։ Թեև դա կարող է օգտակար լինել առանձին փաստեր փնտրելու համար, այն խորը սովորել չէ և պարտադիր չէ, որ ավելի հուսալի լինի, քան վերապատմվող ամենաանվստահելի տեղեկությունը։ Մինչ աշխարհը փորձում է գլուխ հանել այս հարցից, օգտագործեք այն խելամտորեն։

Սկզբնաղբյուրի PDF էջ 18

Ինչպես հեղինակներից շատերը կհաստատեն, զարմանալիորեն հեշտ է տառասխալներ չնկատել մի նյութում, որը կարդացել ես հարյուրավոր անգամ, իսկ համակարգչային գրքերի թեմաներում անհամատեղելի փոփոխությունը սովորական բան է։ Ուստի այս հրատարակությունը, ինչպես բոլոր նախորդները, նախատեսում է հրատարակվելուց հետո պարբերաբար թարմացվել։

Գրքի լրացումները, օրինակների file-երը, պարզաբանումներն ու ուղղումները՝ errata-ն, կպահվեն համացանցում։ Ստորև նշված են այդ առցանց աղբյուրների հիմնական հասցեական ուղենիշները․ ինչպես միշտ, եթե ժամանակի ընթացքում դրանք փոխվեն, դիմեք ձեր սովորական որոնողական համակարգին։

Հեղինակի կայքը

Այս կայքում կհրապարակվեն գրքին կամ հենց Python-ին վերաբերող ընդհանուր նշումներ ու թարմացումներ․ այն ապագա փոփոխություններից ապահովագրող միջոց և գրքի մի տեսակ վիրտուալ հավելված կլինի։
Գրքի օրինակները

Այս կայքում կտեղադրվի գրքի օրինակների package-ը՝ և՛ առանձին file-երով, որոնք կարելի է առցանց դիտել ու պահպանել, և՛ բոլոր օրինակները պարունակող ZIP file-ով, որը կարելի է ներբեռնել սարքի վրա։
Հրատարակչի կայքը

Սկզբնաղբյուրի PDF էջ 19

Այս կայքում կպահվի հրատարակության վրիպակների list-ը և կգրանցվեն վերահրատարակությունների ժամանակ տեքստում կատարված ուղղումները։ Կլինեն նաև այլ ձևաչափերի, ներառյալ էլեկտրոնային գրքերի, link-ներ։

Դրանցից երկրորդ կայքում է օրինակների source code-ը։ Տեսեք այնտեղի օգտագործման նշումները և օրինակների քննարկումը «Որտեղ գործարկել․ code-ի directory-ներ» բաժնում։ Այս պահին օրինակները GitHub-ում տեղադրելու program չկա, քանի որ այդ կայքի օգտագործումը սովորելու բարդությունը սկսնակներից մեծ ջանք է պահանջում, իսկ նրա առևտրային նպատակները մտահոգության առիթ պետք է լինեն։

Նշված կայքերից ցանկացածում ողջունելի են գրքի սխալների մասին հաղորդումներն ու առաջարկները․ նման արձագանքը անգնահատելի է որակի համար։ Բայց խնդրում ենք գրել փաստերի հիման վրա և քաղաքավարի։ Վրիպակների list-ի գրառումները հիմնականում կառուցողական են եղել, սակայն list-ի օգտակարությունը սահմանափակ է, և այն երբեմն հրապուրում է սովորական տրոլներին։ Այսպիսին է կյանքը համաշխարհային հաղորդակցության դարում։

Գրքի կառուցվածքն ավելի պարզ կդառնա ընթերցելիս, բայց որպես տեղեկանք նշենք՝ այստեղ կիրառվում են հետևյալ տպագրական պայմանականությունները։

Շեղատառ

Սկզբնաղբյուրի PDF էջ 20

Օգտագործվում է էլեկտրոնային հասցեների, URL-ների, file-երի անունների, ուղիների և նոր տերմինների առաջին հիշատակումը շեշտադրելու համար։

Հաստատուն լայնությամբ տառատեսակ

Օգտագործվում է ծրագրային code-ի, file-երի պարունակության և հրամանների արտածման համար, ինչպես նաև module-ներ, method-ներ, statement-ներ ու համակարգային հրամաններ նշանակելու նպատակով։

Հաստատուն լայնությամբ թավ տառատեսակ

code-ի բաժիններում ցույց է տալիս այն հրամանները կամ տեքստը, որոնք պետք է մուտքագրի օգտագործողը, և երբեմն շեշտադրում է code-ի որոշ հատվածներ։

Հաստատուն լայնությամբ շեղ տառատեսակ

Օգտագործվում է փոխարինվող մասերի՝ այն բովանդակության համար, որը պետք է լրացնեք ինքներդ, ինչպես նաև code-ի որոշ comment-ների համար։

ՆՇՈՒՄ
Այս ձևավորումը ցույց է տալիս հարակից տեքստին վերաբերող խորհուրդ, առաջարկ կամ ընդհանուր նշում։ Պատկերակը գուցե ավելի հասկանալի լինի, եթե պատկերացնեք վտանգի մասին կռռացող ագռավի։

Եվս երեք կարճ նշում բովանդակության մասին։ Նախ՝ ամբողջ գրքում երբեմն կհանդիպեք շրջանակներով առանձնացված լրացուցիչ բաժինների և տողատակերի,

Սկզբնաղբյուրի PDF էջ 21

որոնց ընթերցումը հաճախ կամընտիր է, բայց դրանք ներկայացվող թեմաներին լրացուցիչ համատեքստ են տալիս։ Օրինակ՝ «Ինչու սա ձեզ պետք կգա» բառերով սկսվող բաժինները լեզվի հնարավորությունները լրացնում են իրական կյանքի կիրառություններով։

Երկրորդ՝ տեղ խնայելու համար Python-ի սխալների հաղորդագրությունները գրքում հաճախ կրճատված են։ Ամբողջ տեքստը տեսնելու համար սխալ առաջացնող code-ն աշխատեցրեք ձեր սարքի վրա։ Որոշ հաղորդագրություններ պարունակում են stack-ի հետագիծ, իսկ Python-ի վերջին տարբերակներում դրանցից մի մասն ունի նաև սխալի տեղը նշող ցուցիչներ և «Գուցե նկատի ունեիք…» type-ի ենթադրական օգնություն։ Դա կարող է օգտակար լինել սկսնակներին, թեև փորձառուների գնահատականները տարբեր կլինեն։ Ամեն դեպքում՝ լրացուցիչ տեքստը չափազանց մեծ տեղ է զբաղեցնում ծավալով սահմանափակ գրքում։

Վերջապես՝ հրատարակիչը պահպանում է գրքի code-ը վերօգտագործելու մասին ստանդարտ հայտարարություն, թեև այստեղ լայնորեն կիրառվող կարճ ինտերակտիվ հատվածները հազիվ թե արժեն իրավաբանական այդ լեզվին։ Եթե այս հարցը ձեզ անհրաժեշտ է, վերօգտագործման պաշտոնական պայմանները փնտրեք ավելի վաղ նկարագրված գրքի կայքերում։

Վերը քննարկված՝ անձնական շեշտը նվազեցնելու նպատակի համաձայն այս հրատարակությունը հրաժարվում է նախորդների սովորական երկար երախտագիտության բաժիններից։ Փոխարենը այն պարզապես շնորհակալություն է հայտնում

Սկզբնաղբյուրի PDF էջ 22

նախկին այն բազմաթիվ ուսանողներին ու ընթերցողներին, որոնք մեծապես ձևավորել են գիրքը, հրատարակչությանը, որը հնարավորություն տվեց նրան հասնել սովորողներին և ժամանակի ընթացքում բարելավվել, օգտագործողների, ներդրողների ու տարածողների set-ին, որոնք Python-ը դարձրին այն, ինչ այսօր է, և ձոնի էջի հասցեատիրոջը, որը համբերությամբ հանդուրժեց ևս մեկ գրքային նախագիծ։ Սա գուցե վերջինն է, բայց երբեք չես իմանա, թե ձանձրացող հեղինակը հաջորդն ինչ կհորինի։

Մաս I․ Սկսում ենք

Սկզբնաղբյուրի PDF էջ 23

1․ Python-ի մասին հարցեր և պատասխաններ

name՝ a · reference · object՝ [1, 2] · type՝ list · name-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։name՝ areferenceobject՝ [1, 2]type՝ listname-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։

Սկզբնաղբյուրի PDF էջ 24

Եթե կարդում եք այս գիրքը, գուցե արդեն գիտեք՝ ինչ է Python-ը և ինչու է այն սովորելու արժանի կարևոր գործիք։ Եթե չգիտեք, հավանաբար Python-ի առավելությունները ձեզ չեն համոզի, մինչև գրքի մնացած մասը կարդալով չսովորեք լեզուն և մեկ-երկու նախագիծ չիրականացնեք։ Սակայն նախքան մանրամասների մեջ մտնելը՝ այս առաջին գլուխը համառոտ կներկայացնի Python-ի հանրաճանաչության հիմնական պատճառներից մի քանիսը և կսկսի ձևավորել լեզվի սահմանումը։ Սա արվում է հարցուպատասխանի ձևով՝ անդրադառնալով այն առավել տարածված հարցերից մի քանիսին, որոնք տալիս են ձեզ նման սկսնակները։

Քանի որ ընտրության համար բազմաթիվ programming language-ներ կան, նորեկների առաջին հարցը սովորաբար հենց սա է, և այն լավ մեկնակետ է։ Հաշվի առնելով, որ այսօր միլիոնավոր մարդիկ օգտագործում են Python-ը, այս հարցին լիովին ճշգրիտ պատասխանել իրականում հնարավոր չէ. մշակման գործիքների ընտրությունը հաճախ հիմնվում է յուրահատուկ սահմանափակումների կամ անձնական նախասիրությունների վրա։

Սակայն հարյուրավոր խմբերի և հազարավոր ուսանողների Python դասավանդելուց հետո ի հայտ են եկել որոշ ընդհանուր միտումներ։ Հիմնական

Սկզբնաղբյուրի PDF էջ 25

գործոնները, որոնք նշում են Python-ի օգտատերերը, կարծես հետևյալներն են։

software-ի որակ

Շատերի համար ընթեռնելիության, հետևողականության և ընդհանրապես software-ի որակի վրա Python-ի շեշտադրումը նրան առանձնացնում է programming-ի աշխարհի մյուս գործիքներից։ Python-ի code-ը նախագծված է ընթեռնելի լինելու և, հետևաբար, կրկնակի օգտագործումն ու սպասարկումը հեշտացնելու համար՝ շատ ավելի մեծ չափով, քան ավանդական scripting language-ներում։ Python-ի code-ի միատեսակությունը այն համեմատաբար դյուրին է դարձնում հասկանալու համար, նույնիսկ եթե դուք չեք գրել այն։ Բացի այդ, Python-ը խորքային աջակցություն է տրամադրում software-ի կրկնակի օգտագործման ավելի առաջադեմ մեխանիզմների, օրինակ՝ object-oriented (OO) և functional programming-ի համար, որոնք կարող են էլ ավելի բարձրացնել code-ի որակը։
Մշակողի արտադրողականություն

Python-ը բազմապատիկ բարձրացնում է մշակողի արտադրողականությունը՝ համեմատած compiled կամ static typing-ով լեզուների հետ։ Որպես դրա չափանիշներից մեկը՝ Python-ի code-ի ծավալը սովորաբար համարժեք C++ կամ Java code-ի մեկ երրորդից մինչև մեկ հինգերորդն է։ Դա նշանակում է, որ ավելի քիչ բան է պետք մուտքագրել, վրիպազերծել և հետագայում սպասարկել։ Python-ի program-երի մեծ մասը նաև աշխատում է անմիջապես՝ առանց որոշ այլ գործիքների պահանջած compilation-ի և կապակցման երկարատև քայլերի, ինչը հավելյալ արագացնում է programmer-ի աշխատանքը։
program-երի տեղափոխելիություն

Սկզբնաղբյուրի PDF էջ 26

Python-ի program-երը հիմնականում առանց փոփոխությունների աշխատում են համակարգչային բոլոր խոշոր հարթակներում։ Օրինակ՝ Python-ի program-ը Linux-ից Windows տեղափոխելը հաճախ պարզապես նշանակում է դրա code-ը մի համակարգչից մյուսը պատճենել։ Ավելին, Python-ը տրամադրում է տեղափոխելի գրաֆիկական օգտատիրական interface-ներ, տվյալների շտեմարաններին հասանելիության program-եր, վեբ համակարգեր և այլ լուծումներ գրելու բազմաթիվ տարբերակներ։ Նույնիսկ operating system-ի այնպիսի առանձնահատուկ interface-ներ, ինչպիսիք են program-երի գործարկումն ու directory-ների մշակումը, Python-ում այնքան տեղափոխելի են, որքան առհասարակ հնարավոր է։
Կիրառությունների աջակցություն

Python-ի հետ տրամադրվում է նախապես կառուցված և տեղափոխելի հնարավորությունների մեծ հավաքածու, որը կոչվում է standard library։ Այս library-ն աջակցում է կիրառական մակարդակի programming-ի մի շարք խնդիրների՝ տեքստային ձևանմուշների համադրումից մինչև ցանցային script-ների մշակում։ Բացի այդ, Python-ը կարելի է ընդլայնել ինչպես սեփական library-ներով, այնպես էլ երրորդ կողմերի software-ի հսկայական հավաքածուով։ Ինչպես կտեսնենք հետագայում, Python-ի երրորդ կողմերի գործիքների ոլորտը ներառում է կայքերի կառուցման, թվային programming-ի, արհեստական բանականության և բազմաթիվ այլ խնդիրների գործիքներ։ Օրինակ՝ NumPy ընդլայնումը Python-ը դարձրել է գիտության, տեխնոլոգիայի, ճարտարագիտության և մաթեմատիկայի (STEM) հիմնական գործիքներից մեկը, իսկ Django-ն ու PyTorch-ը նման դեր են խաղացել համապատասխանաբար վեբի և արհեստական բանականության ոլորտներում։
Բաղադրիչների ինտեգրում

Սկզբնաղբյուրի PDF էջ 27

Python-ի script-ները կարող են հաղորդակցվել կիրառության այլ մասերի հետ՝ ինտեգրման տարատեսակ մեխանիզմներով։ Նման ինտեգրումները թույլ են տալիս Python-ն օգտագործել որպես արտադրանքը հարմարեցնելու և ընդլայնելու գործիք։ Օրինակ՝ Python-ի code-ը կարող է կանչել compiled library-ներ և գործարկվել compiled program-երի կողմից, ցանցով փոխազդել այլ բաղադրիչների հետ և սմարթֆոններում օգտագործել Android-ի ու iOS-ի գործիքակազմերը։ Իրականում Python-ի բազմաթիվ հիմնական գործիքներ, այդ թվում՝ file-երը, ի վերջո օգտագործում են համակարգային library-ների նախապես գրված interface-ներ. նույնիսկ եթե ձեր ամբողջ program-ը Python-ով է, այն մեկուսացած չէ։
Արհեստի հանդեպ սեր

Օգտագործման պարզության և built-in գործիքակազմի շնորհիվ Python-ը կարող է programming-ը դարձնել ավելի շատ հաճույք, քան պարտականություն։ Թեև այս առավելությունը շոշափելի չէ և սուբյեկտիվ է, արտադրողականության վրա դրա ազդեցությունը կարևոր արժեք է։ Մարդիկ իսկապես վարձատրվում են Python-ով code գրելու համար, սակայն շատերն այն օգտագործում են պարզապես զվարճանքի համար. software-ի ոլորտում սա հազվադեպ հանդիպող վկայություն է։

Այս գործոններից առաջին երկուսը՝ որակն ու արտադրողականությունը, հավանաբար Python-ի օգտատերերի մեծ մասի համար ամենահամոզիչ առավելություններն են. եկեք ավելի մանրամասն դիտարկենք յուրաքանչյուրը։

Սկզբնաղբյուրի PDF էջ 28

Python-ն ի սկզբանե նախագծված է միտումնավոր պարզ ու ընթեռնելի syntax-ով և programming-ի խիստ հետևողական մոդելով։ Ինչպես վկայում էր Python-ի վաղ համաժողովներից մեկի կարգախոսը, արդյունքում Python-ը կարծես համապատասխանում է ձեր մտածողությանը. այսինքն՝ լեզվի հնարավորությունները փոխազդում են հետևողական և սահմանափակ ձևերով ու բնականորեն բխում են հիմնական հասկացությունների փոքր հավաքածուից։ Սա լեզուն ավելի հեշտ է դարձնում սովորելու, հասկանալու և հիշելու համար։ Գործնականում Python programmer-ները code կարդալիս կամ գրելիս կարիք չունեն անընդհատ դիմելու ձեռնարկներին. այն հիմնականում պարզապես հասկանալի է։

Իր փիլիսոփայությամբ Python-ը որդեգրում է որոշ չափով մինիմալիստական մոտեցում։ Սա նշանակում է, որ թեև programming-ի խնդիրը լուծելու համար սովորաբար կան մի քանի եղանակներ, հիմնականում կա միայն մեկ ակնհայտ եղանակ, մի քանի պակաս ակնհայտ այլընտրանքներ և ամբողջ լեզվով մեկ՝ հետևողական փոխազդեցությունների փոքր հավաքածու։ Ավելին, Python-ը սովորաբար ձեր փոխարեն կամայական որոշումներ չի ընդունում. երբ փոխազդեցությունները երկիմաստ են, բացահայտ միջամտությունը գերադասվում է «կախարդանքից»։ Python-ի մտածելակերպով՝ բացահայտը ավելի լավ է, քան անբացահայտը, իսկ պարզը՝ բարդից։

Այս նախագծային սկզբունքներից բացի՝ Python-ը ներառում է այնպիսի գործիքներ, ինչպիսիք են module-ներն ու object-oriented programming-ը (OOP), որոնք բնականորեն նպաստում են code-ի կրկնակի օգտագործմանը հմուտ ձեռքերում՝ հենց այնպիսի հմտություններով, որոնք շուտով

Սկզբնաղբյուրի PDF էջ 29

ձեռք եք բերելու։ Եվ քանի որ Python-ը կենտրոնացած է որակի վրա, Python programmer-ների մեծ մասը բնականաբար նույնպես այդպես է վարվում. սա կարող է վճռորոշ առավելություն լինել, երբ ժամանակը գա օգտագործելու մեկ ուրիշի Python code-ը։

Եթե աշխատել եք software-ի ոլորտում, գիտեք, որ այն կարող է լինել դինամիկ և անհարթ ճանապարհ։ 1990-ականների կեսերից մինչև վերջ ինտերնետի մեծ վերելքի ժամանակ դժվար էր գտնել բավականաչափ programmer-ների՝ ծրագրային նախագծերն իրականացնելու համար. մշակողներից պահանջվում էր համակարգեր ստեղծել այնքան արագ, որքան զարգանում էր ինտերնետը։ Տնտեսական անկման և աշխատակիցների կրճատումների ավելի ուշ շրջաններում պատկերը փոխվեց. programmer-ների խմբերից հաճախ պահանջվում էր նույն աշխատանքը կատարել էլ ավելի քիչ մարդկանցով։

Այս երկու իրավիճակներում էլ Python-ը փայլել է որպես գործիք, որը programmer-ներին թույլ է տալիս ավելի քիչ ջանքով ավելի շատ բան անել։ Այն միտումնավոր օպտիմալացված է մշակման արագության համար. պարզ syntax-ը, dynamic typing-ը, compilation-ի քայլերի բացակայությունն ու built-in գործիքակազմը programmer-ներին թույլ են տալիս program-եր մշակել որոշ այլ գործիքներով անհրաժեշտ ժամանակի մի փոքր մասում։

Արդյունքում Python-ը սովորաբար բազմապատիկ բարձրացնում է մշակողի արտադրողականությունը՝ գերազանցելով

Սկզբնաղբյուրի PDF էջ 30

ավանդական լեզուների ապահոված մակարդակները, և հաճախ անհնարինը դարձնում է հնարավոր։ Սա լավ լուր է թե՛ վերելքի, թե՛ անկման ժամանակներում և այն բոլոր միջանկյալ պայմաններում, որոնցով անցնում է software-ի ոլորտը։

Գուցե։ Python-ը հաճախ օգտագործվում է սկրիպտային դերերում, բայց ոչ միշտ։ Այն պարբերաբար անվանում են object-oriented scripting language. այս սահմանումը OOP-ի աջակցությունը միավորում է սկրիպտային կիրառությունների ուղղվածության հետ, սակայն այն կարող է չափազանց նեղ և թերագնահատող լինել։ Եթե պետք է մեկ line-ով բնութագրել, Python-ը հավանաբար ավելի ճիշտ է ներկայացնել այսպես՝

Ընդհանուր նշանակության programming language, որը միավորում է ընթացակարգային, functional և object-oriented պարադիգմները և բարդությունը նվազեցնելով արագացնում է software-ի մշակումը։

Սա գուցե նույնքան լավ չտեղավորվի շապիկի վրա, բայց արտացոլում է ներկայիս Python-ի և՛ հարստությունը, և՛ ընդգրկումը։

Այնուամենայնիվ, սկրիպտային եզրույթը կարծես սոսնձվել է Python-ին, գուցե՝ որպես հակադրություն որոշ այլ գործիքների պահանջած ավելի մեծ ջանքերին։ Օրինակ՝ որոշ մարդիկ Python-ի code պարունակող file-ը նկարագրելիս «program» բառի փոխարեն օգտագործում են «script», քանի որ code գրելը թվում է ավելի պարզ և պակաս ձևական։ Ավելի գործնական մոտեցմամբ՝

Սկզբնաղբյուրի PDF էջ 31

ուրիշները «script» են անվանում վերին մակարդակի file-ը, իսկ «program»՝ ավելի բարդ multi-file կիրառությունը. երկուսն էլ սովորական են Python-ում։

Սակայն քանի որ տարբեր դիտարկողների համար scripting language եզրույթն այդքան տարբեր իմաստներ ունի, ոմանք կնախընտրեին, որ այն ընդհանրապես չկիրառվեր Python-ի նկատմամբ։ Իրականում, երբ մարդիկ լսում են Python-ի այսպիսի բնորոշումը, հակված են երեք խիստ տարբեր ենթադրություններ անելու, որոնցից որոշներն ավելի օգտակար են, քան մյուսները։

shell-ի գործիքներ

Երբեմն մարդիկ, լսելով, որ Python-ը նկարագրվում է որպես scripting language, կարծում են՝ դա նշանակում է, որ Python-ը operating system-ին ուղղված script-ներ գրելու գործիք է։ Նման program-երը հաճախ գործարկվում են վահանակի command line-ից և կատարում այնպիսի առաջադրանքներ, ինչպիսիք են text file-երի մշակումը և այլ program-երի գործարկումը։

Ինչպես կիմանաք հետագայում, Python-ի program-երը կարող են կատարել և կատարում են նման դերեր, սակայն սա Python-ի տարածված կիրառման տասնյակ ոլորտներից ընդամենը մեկն է։ Այն պարզապես shell-ի script-ների ավելի լավ լեզու չէ։

Կառավարման լեզու

Սկզբնաղբյուրի PDF էջ 32

Ուրիշների համար սկրիպտավորումը վերաբերում է «սոսնձող» շերտին, որն օգտագործվում է կիրառության այլ բաղադրիչները կառավարելու և ուղղորդելու համար, այսինքն՝ դրանց գործողությունների սցենարը սահմանելու։ Ինչպես նշվեց ավելի վաղ, Python-ի program-երն իսկապես հաճախ կիրառվում են ավելի մեծ կիրառությունների շրջանակում։ Օրինակ՝ ապարատային սարքեր փորձարկելիս Python-ի program-երը կարող են կանչել բաղադրիչներ, որոնք ցածր մակարդակի հասանելիություն են տրամադրում սարքին կամ պորտին։ Նմանապես, program-երը կարող են կարևոր կետերում գործարկել Python-ի code-ի հատվածներ՝ վերջնական օգտատիրոջը արտադրանքը հարմարեցնելու հնարավորություն տալու համար՝ առանց ամբողջ համակարգի source code-ը տարածելու և վերակոմպիլացնելու անհրաժեշտության։

Python-ի պարզությունն այն բնականորեն դարձնում է կառավարման ճկուն գործիք։ Տեխնիկապես, սակայն, սա նույնպես Python-ի տարածված դերերից միայն մեկն է. Python programmer-ներից շատերը, և գուցե մեծ մասը, գրում են ինքնուրույն script-ներ՝ երբեք չօգտագործելով որևէ ինտեգրված բաղադրիչ կամ նույնիսկ չիմանալով դրանց մասին։ Այն պարզապես կառավարման լեզու չէ։

Օգտագործման պարզություն

scripting language եզրույթի հավանաբար լավագույն կիրառությունն այն է, երբ դրանով նկատի ունեն համեմատաբար պարզ լեզու՝ programming-ի առաջադրանքներն արագ կատարելու համար։ Սա հատկապես ճիշտ է Python-ի դեպքում, որը թույլ է տալիս շատ ավելի արագ program-եր մշակել, քան C++-ի պես compiled լեզուները կամ Java-ի պես ավելի մեծ լեզուները։ Մշակման դրա արագ cycle-ը խրախուսում է programming-ի հետազոտական,

Սկզբնաղբյուրի PDF էջ 33

աստիճանական եղանակ, որի արժեքը գնահատելու համար պետք է այն փորձել։

Սակայն մի՛ մոլորվեք. Python-ը միայն պարզ առաջադրանքների համար չէ։ Փոխարենը՝ օգտագործման պարզությամբ և ճկունությամբ այն առաջադրանքներն է դարձնում պարզ։ Python-ն ունի հասանելի հնարավորությունների հավաքածու, սակայն թույլ է տալիս անհրաժեշտության դեպքում աստիճանաբար ավելի բարդ program-եր ստեղծել։ Այդ պատճառով այն սովորաբար օգտագործվում է ինչպես արագ մարտավարական առաջադրանքների, այնպես էլ երկարաժամկետ ռազմավարական մշակման համար։

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

Հարակից մի հանգամանք ևս. մարդիկ երբեմն Python-ն անվանում են interpreted լեզու՝ այն C-ի և C++-ի նման լեզուներից տարբերակելու համար։ Թեև երբեմն սա նույնպես այն նեղ շրջանակում տեղավորելու փորձ է, այս բնորոշումը ավելի հեշտ է մերժել. այսօր կան Python-ի բազմաթիվ implementation-ներ՝ ավանդական interpreter-ներից մինչև ավանդական compiler-ներ, ուստի «interpreted» բնորոշումը կիրառելի չէ։ Ավելի հստակ տարբերությունն այն է, որ Python-ն ունի dynamic typing, այլ ոչ թե static typing, ինչպես սովորաբար compiled լեզուները։ Ինչպես

Սկզբնաղբյուրի PDF էջ 34

շուտով կիմանաք, սա մեծապես բացատրում է այն հզորությունը, որը Python-ը բերում է մշակման առաջադրանքներին։

Python-ի ավելի քան երեք տասնամյակ գոյության ընթացքում ի հայտ եկած միակ համընդհանուր ճանաչված թերությունը գուցե նաև օգտագործման պարզության անխուսափելի փոխզիջումն է. Python-ի կատարման արագությունը միշտ չէ, որ նույնքան բարձր է, որքան C-ի և C++-ի պես ամբողջությամբ compiled ու ավելի ցածր մակարդակի լեզուներինը։ Թեև այսօր դա համեմատաբար հազվադեպ է, որոշ առաջադրանքների համար երբեմն դեռ կարող է պետք լինել «ավելի մոտենալ երկաթին»՝ օգտագործելով լեզուներ, որոնք ավելի ուղղակիորեն են արտապատկերվում հիմքում ընկած սարքակազմին։

implementation-ի հասկացությունների մասին կխոսենք Գլուխ 2-ում, բայց համառոտ՝ Python-ի ներկայումս ամենաշատ օգտագործվող տարբերակները source code-ի statement-ները կոմպիլացնում են, այսինքն՝ թարգմանում, միջանկյալ ձևաչափի, որը կոչվում է bytecode, և ապա մեկնաբանում են bytecode-ը։ bytecode-ն ապահովում է տեղափոխելիություն, քանի որ այն հարթակից անկախ ձևաչափ է։ Սակայն, քանի որ Python-ը սովորաբար մինչև վերջ չի կոմպիլացվում երկուական machine code-ի, օրինակ՝ ձեր համակարգչի կամ հեռախոսի Intel կամ ARM չիպի instruction-ների, որոշ program-եր Python-ով ավելի դանդաղ կաշխատեն, քան C-ի պես ամբողջությամբ compiled լեզվով։

Սկզբնաղբյուրի PDF էջ 35

Արդյոք կատարման արագության այս տարբերությունը ձեզ երբևէ կհետաքրքրի՝ կախված է նրանից, թե ինչ program-եր եք գրում։ Python-ը պարբերաբար օպտիմալացվում է, և կիրառությունների մեծ մասում Python-ի code-ն ինքնին բավական արագ է աշխատում։ Ավելին, երբ Python-ի script-ում որևէ «իրական» բան եք անում, օրինակ՝ file մշակում կամ գրաֆիկական օգտատիրական interface (GUI) կառուցում, ձեր program-ն իրականում աշխատում է C-ի արագությամբ, քանի որ նման առաջադրանքներն անմիջապես փոխանցվում են Python-ի interpreter-ի ներսում գտնվող compiled C code-ին։

Եվ իրականում Python-ի արագությունն այսօր որոշ չափով ուշադրությունը շեղող հարց է. ճշմարտությունն այն է, որ Python-ը սովորաբար օգտագործվում է օպտիմալ կատարման արագություն պահանջող ոլորտներում։ Օրինակ՝ թվային programming-ն ու համակարգչային խաղերը հաճախ պահանջում են, որ առնվազն հիմնական հաշվարկային բաղադրիչներն աշխատեն C-ի արագությամբ կամ ավելի արագ, սակայն, այնուամենայնիվ, դրանք հաճախ գրվում են Python-ով։

Python-ում անհրաժեշտ պահերին արագության հասնելու բազմաթիվ եղանակներ կան։ Օրինակ՝ PyPy-ի նման համակարգերը bytecode-ը լրացուցիչ կոմպիլացնում են program-ի կատարման ընթացքում, Cython-ը թույլ է տալիս code գրել C-ի և Python-ի խառնուրդով, որն ամբողջությամբ կոմպիլացվում է, իսկ վճռորոշ code-ը կարելի է առանձնացնել compiled ընդլայնումներում, որոնք կապակցվում են Python-ին՝ script-ներում օգտագործվելու համար։ Որպես օրինակ՝ թվային programming-ի NumPy ընդլայնումը compiled ու օպտիմալացված library-ները միավորում է Python լեզվի հետ և այդ ընթացքում Python-ը վերածում է

Սկզբնաղբյուրի PDF էջ 36

թվային programming-ի գործիքի, որը միաժամանակ արդյունավետ է և օգտագործման համար պարզ։ Իսկապես, NumPy-ով Python-ի code-ը պարբերաբար արագությամբ հավասարվում է Fortran-ին ու C++-ին՝ առանց դրանց լրացուցիչ բարդությունների։

Ավելի հիմնարար առումով, սակայն, կատարման արագությունը software-ի մշակման դեպքերի մեծ մասում միակ precedence-ը չէ։ Python-ի տված մշակման արագության շահույթը հաճախ շատ ավելի կարևոր է, քան կատարման արագության ցանկացած կորուստ, հատկապես՝ ժամանակակից computer-ների արագությունների և ժամանակակից համակարգչային աշխատանքների վերջնաժամկետների պարագայում։ Բնականաբար, Python-ն ունի նաև այլ հնարավոր թերություններ, ներառյալ հաճախակի փոփոխություններն ու խճճված կողմերը, սակայն դրանք սուբյեկտիվ գնահատականներ են, որոնք լավագույնն է տալ այն բանից հետո, երբ այս գրքում հնարավորություն կունենաք դրանք ստուգելու։

Քանի որ Python-ն ազատ և բաց source code-ով software tool է (FOSS), դրա օգտատերերի թիվը ճշգրիտ հաշվել հնարավոր չէ. հաշվարկի ենթակա լիցենզիայի գրանցումներ չկան։ Ավելին, Python-ն ինքնաբերաբար ներառվել է Linux-ի անթիվ բաշխումներում, Macintosh computer-ներում և արտադրանքների ու սարքակազմերի լայն տեսականու մեջ, ինչը օգտատերերի թվի պատկերն էլ ավելի է մշուշում։

Սկզբնաղբյուրի PDF էջ 37

Ընդհանուր առմամբ, սակայն, Python-ն ունի շատ մեծ օգտատիրական բազա և մշակողների ակտիվ համայնք։ Այն հիմնականում համարվում է այսօր աշխարհում ամենալայն օգտագործվող programming-ի լավագույն 5 լեզուներից մեկը, իսկ իսկական մրցասերների համար՝ հաճախ զբաղեցնում է #1 տեղը։ Քանի որ Python-ը լայնորեն կիրառվում է արդեն ավելի քան երեք տասնամյակ, այն նաև շատ կայուն և հուսալի է։

Այս ամենի շնորհիվ Python-ը պարբերաբար կիրառվում է իրական ընկերությունների՝ իրական եկամուտ բերող արտադրանքներում։ Թեև օգտատերերի ցանկերը փոփոխվում են, Python-ն այսօր օգտագործող հայտնի ու նշանավոր ընկերությունների ցանկը նման է software-ի ոլորտի ամենահայտնի անունների տեղեկատուի՝ Google, Intel, Disney, YouTube, Industrial Light & Magic, Red Hat, NASA, Eve Online, Seagate, JPL, Hewlett-Packard, JP Morgan Chase, Dropbox, ESRI, Instagram, Spotify, Pinterest, Reddit, Microsoft, Netflix և բազմաթիվ ուրիշներ։

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

Python-ի լրացուցիչ օգտատերերի և կիրառությունների օրինակների համար, որոնք, հուսանք, ավելի արդիական կլինեն, քան երբևէ կարող է լինել գիրքը, փորձեք Python-ի կայքի հետևյալ էջերը՝ Python Success Stories, Applications for Python և Quotes about Python։ Ինչպես միշտ՝

Սկզբնաղբյուրի PDF էջ 38

ձեր տեղական դիտարկիչում կամ հավելվածում վեբ որոնմամբ գուցե կարողանաք բացահայտել նաև ձեզ հետաքրքրող Python-ի այլ դերեր։

Առևտրային կիրառությունները գուցե համոզիչ են, սակայն մարդիկ Python-ն օգտագործում են նաև իրական կյանքի ամենատարբեր առօրյա առաջադրանքների համար՝ շահույթի, անհրաժեշտության, հոբբիի կամ զվարճանքի նպատակով։ Իրականում, որպես ընդհանուր նշանակության լեզու, Python-ի դերերը գրեթե անսահմանափակ են. այն կարող եք օգտագործել ամեն ինչի համար՝ խաղերից և կայքերի մշակումից մինչև ռոբոտատեխնիկա ու բովանդակության կառավարում։

Այդուհանդերձ, Python-ի դերերը կարծես տեղավորվում են մի քանի լայն կատեգորիաների մեջ։ Հաջորդ բաժինները ներկայացնում են Python-ի ներկայումս առավել տարածված կիրառման ոլորտներից մի քանիսը, ինչպես նաև յուրաքանչյուր ոլորտում օգտագործվող նշանավոր գործիքները։

Նախապես երկու նշում. առաջին՝ չենք կարող այս գործիքները խորությամբ ուսումնասիրել ո՛չ այստեղ, ո՛չ էլ գրքում ընդհանրապես։ Օրինակ՝ NumPy-ն և Django-ն ինքնուրույն ամբողջ գրքի ծավալով թեմաներ են, իսկ այս գրքի նպատակը Python-ի այն code-ը սովորելն է, որը դուք գրելու եք նման համակարգեր օգտագործելու համար։ Երկրորդ՝ նախապես ներողություն ենք խնդրում այստեղ միայն տեղի սղության պատճառով բաց թողնված բազմաթիվ այլ գործիքների համար. եթե ձեզ

Սկզբնաղբյուրի PDF էջ 39

հետաքրքրում է հետևյալ թեմաներից որևէ մեկը, համացանցում փնտրեք լրացուցիչ գործիքներ և նյութեր։

operating system-ի ծառայությունների հետ աշխատանքի Python-ի built-in interface-ներն այն իդեալական են դարձնում տեղափոխելի ու սպասարկելի համակարգային կառավարման օժանդակ program-եր գրելու համար. դրանք երբեմն կոչվում են shell-ի կամ command line-ի գործիքներ, թեև կարող են օգտագործվել բազմաթիվ եղանակներով։ Python-ի program-երը կարող են որոնել file-երում և directory-ների ծառերում, գործարկել ու կազմաձևել այլ program-եր, կատարել զուգահեռ մշակում process-ներով, հոսքերով ու համածրագրերով և ավելին։

Python-ի standard library-ի հետ տրամադրվում են operating system-ի տեղափոխելի interface-ի (POSIX) կապակցումներ և բոլոր սովորական ՕՀ գործիքների աջակցությունը, ներառյալ միջավայրի variable-ները, file-երը, սոկետները, խողովակները, process-ները, հոսքերը, regular expression-ներով ձևանմուշների համադրումը, command line-ի argument-ները, standard stream-երի interface-ները, shell-ի հրամանների գործարկիչները, filename-ների ընդլայնումը, ZIP file-երի օժանդակ գործիքները և XML, JSON ու CSV վերլուծիչները։ Բացի այդ, Python-ի համակարգային interface-ների մեծ մասը նախագծված է տեղափոխելի լինելու համար. օրինակ՝ directory-ների ծառեր պատճենող script-ը սովորաբար առանց փոփոխությունների աշխատում է Python-ն աջակցող բոլոր հարթակներում։

Սկզբնաղբյուրի PDF էջ 40

Python-ի պարզությունն ու աշխատանքի արագ loop-ն այն նաև լավ ընտրություն են դարձնում ամեն տեսակի սարքերում GUI programming-ի համար։ Օրինակ՝ Python-ի հետ տրամադրվում է Tk GUI գործիքակազմի ստանդարտ object-oriented interface-ը՝ Tkinter անունով, իսկ code-ում՝ tkinter, որը Python-ի program-երին թույլ է տալիս իրականացնել տեղափոխելի GUI-ներ՝ հարթակին բնորոշ արտաքին տեսքով ու գործելակերպով։ Python/Tkinter GUI-ներն առանց փոփոխությունների աշխատում են Windows-ում, macOS-ում ու Linux-ում, իսկ այսօր՝ նաև Android-ում՝ անվճար հավելվածի օգնությամբ (տե՛ս Հավելված A)։

Բացի այդ, երրորդ կողմերի գործիքները տեղափոխելի օգտատիրական interface-ների այլ ուղիներ են առաջարկում՝ ներառյալ ավանդական GUI լուծումները, օրինակ՝ Kivy-ն, BeeWare-ի Toga-ն, PyQt-ն ու wxPython-ը, և վեբ դիտարկիչի վրա հիմնված լուծումները, օրինակ՝ Django-ն, Flask-ն ու WebAssembly-ն։ Եթե ձեր հավելվածը, ինչպես մեծ մասը, պետք է փոխազդի օգտատերերի հետ, Python-ն ունի մեկ անգամ գրելու և ամենուր գործարկելու բազմաթիվ եղանակներ։

Python-ի հետ տրամադրվում են ինտերնետի ստանդարտ module-ներ, որոնք program-երին թույլ են տալիս ցանցային ամենատարբեր առաջադրանքներ կատարել թե՛ հաճախորդի, թե՛ սերվերի ռեժիմում։ script-ները կարող են հաղորդակցվել սոկետներով, ստանալ սերվերի կողմի CGI վեբ script-ներին ուղարկված ձևերի տվյալները, file-եր փոխանցել FTP-ով, վերլուծել և ստեղծել XML ու JSON

Սկզբնաղբյուրի PDF էջ 41

փաստաթղթեր, կազմել ու ուղարկել, ինչպես նաև ստանալ ու վերլուծել էլեկտրոնային նամակներ, URL-ներով բեռնել վեբ էջեր ու վերլուծել դրանց HTML-ը և ավելին։

Բացի այդ, համացանցում հասանելի է երրորդ կողմերի գործիքների մեծ հավաքածու՝ Python-ով ինտերնետային programming-ի համար։ Օրինակ՝ վեբ մշակման Django, Flask, TurboGears և Zope հենքերը աջակցում են Python-ով լիարժեք և արտադրական որակի կայքերի կառուցմանը։ Դրանցից շատերը ներառում են այնպիսի գործիքներ, ինչպիսիք են object-relational արտապատկերիչները, սերվերի կողմի սկրիպտավորումն ու ձևանմուշավորումը և AJAX-ի աջակցությունը՝ վեբ մշակման ամբողջական ու ձեռնարկատիրական մակարդակի լուծումներ ապահովելու համար։ Python-ը JavaScript-ի վերածող Pyjamas տրանսպիլյատորը, HTML բովանդակությունն առանձնացնող Beautiful Soup-ը և Python-ը դիտարկիչում գործարկելու հնարավորություն տվող WebAssembly, Pyodide, py2wasm ու PyScript գործիքները վեբի համար էլ ավելի շատ հնարավորություններ են տրամադրում։

Բաղադրիչների ինտեգրման դերը քննարկեցինք ավելի վաղ։ C-ով, C++-ով և Java-ով գրված համակարգերով ընդլայնվելու ու դրանց ներսում ներդրվելու Python-ի հնարավորությունն այն օգտակար է դարձնում որպես այլ ծրագրային բաղադրիչների վարքը script-ներով կառավարող ճկուն կապող լեզու։ Օրինակ՝ C library-ն Python-ին ինտեգրելը թույլ է տալիս Python-ով փորձարկել և գործարկել library-ի գործիքները, իսկ Python-ն արտադրանքի մեջ ներդնելը հնարավորություն է տալիս տեղում հարմարեցումների code գրել՝ առանց

Սկզբնաղբյուրի PDF էջ 42

ամբողջ արտադրանքը վերակոմպիլացնելու կամ առհասարակ դրա source code-ը տարածելու անհրաժեշտության։

SWIG-ի, Boost.Python-ի, CFFI-ի և HPy-ի նման գործիքներն ավտոմատացնում են compiled բաղադրիչները Python-ի script-ների հետ կապելու համար անհրաժեշտ աշխատանքի մեծ մասը, իսկ Cython համակարգը code գրողներին թույլ է տալիս խառնել Python-ը և C-ի նման code-ը՝ compiled ընդլայնումներ ստեղծելու համար։ Այլ գործիքներ բաղադրիչները script-ներով կառավարելու լրացուցիչ եղանակներ են տրամադրում, ներառյալ Python/Java կապող pyjnius ու Chaquopy գործիքները, Windows-ի Component Object Model-ի (COM) համար pywin32-ի աջակցությունը, REST, SOAP ու XML-RPC միջցանցային կապուղիները և Python-ի՝ Jython Java ու IronPython .NET implementation-ները։ Կարճ ասած՝ ծրագրային բաղադրիչների մեծ մասը հասանելի է Python-ի code-ին։

Տվյալների շտեմարանների ավանդական պահանջների համար կան Python-ի interface-ներ բոլոր տարածված ռելյացիոն շտեմարանային համակարգերի՝ Oracle-ի, MySQL-ի, PostgreSQL-ի, Informix-ի, ODBC-ի, SQLite-ի և այլոց համար։ Python-ի աշխարհը նաև սահմանել է տվյալների շտեմարանների տեղափոխելի API՝ Python-ի script-ներից SQL շտեմարանային համակարգերին դիմելու համար, որը նույն տեսքն ունի հիմքում ընկած շտեմարանների տարատեսակ implementation-ների դեպքում։ program-ի տվյալների պահպանման հիմնական կարիքների համար Python-ի հետ տրամադրվում է սեփական pickle object-ների built-in աջակցություն, լեզվից

Սկզբնաղբյուրի PDF էջ 43

անկախ JSON փաստաթղթերի և նույն process-ում աշխատող SQLite ներդրված SQL շտեմարանի շարժիչի համար։

Նաև Python-ի script-ների համար PyYAML-ը վերլուծում և արտածում է YAML տվյալներ, ZODB-ն ու Durus-ը տրամադրում են object-oriented շտեմարաններ, SQLObject-ը և SQLAlchemy-ն իրականացնում են object-relational արտապատկերիչներ (ORM), որոնք Python-ի class-երը կապում են ռելյացիոն աղյուսակներին, իսկ PyMongo-ն interface է տրամադրում MongoDB-ին՝ բարձր արտադրողականությամբ, JSON ոճի փաստաթղթային շտեմարանին։ Python-ը կարող է նաև օգտվել ամպային պահեստավորման տարբերակներից Google-ի App Engine-ում, Microsoft-ի Azure-ում և Amazon-ի AWS-ում։

Python-ի program-երի համար Python-ով և C-ով գրված բաղադրիչները նույն տեսքն ունեն։ Դրա շնորհիվ հնարավոր է համակարգերի նախատիպերը սկզբում ստեղծել Python-ով, ապա ընտրված բաղադրիչները վերջնական տարբերակի համար տեղափոխել C-ի կամ C++-ի պես ամբողջությամբ compiled լեզու։ Քանի որ նախատիպի կայունացումից հետո Python-ը չի պահանջում ամբողջական assignment, համակարգի այն մասերը, որոնք compiled լեզվի արդյունավետության կարիքը չունեն, կարող են մնալ Python-ով գրված՝ սպասարկումն ու օգտագործումը պարզ պահելու համար։ Սակայն զգուշացե՛ք. հաշվի առնելով ավելի վաղ հանդիպած օպտիմալացման բազմաթիվ ուղիները՝ ձեր նախատիպը շատ հնարավոր է դառնա հենց ձեր վերջնական արտադրանքը։

Սկզբնաղբյուրի PDF էջ 44

Python-ը լայնորեն օգտագործվում է նաև թվային programming-ի մեջ՝ մի ոլորտում, որն ավանդաբար չէր համարվի scripting language-ների կիրառման շրջանակում, սակայն աստիճանաբար դարձել է Python-ի կիրառման ամենահամոզիչ դեպքերից մեկը։ Այս ոլորտում առանձնանում է ավելի վաղ նշված NumPy-ն՝ Python-ի թվային programming-ի բարձր արտադրողականությամբ ընդլայնումը, որը ներառում է այնպիսի առաջադեմ գործիքներ, ինչպիսիք են զանգվածի object-ը, ստանդարտ մաթեմատիկական library-ների interface-ները և շատ ավելին։ Python-ն արագության համար compiled լեզվով գրված թվային ենթածրագրերի հետ ինտեգրելով՝ NumPy-ն Python-ը դարձնում է բարդ հնարավորություններով, բայց օգտագործման համար պարզ թվային programming-ի գործիք, որը հաճախ կարող է փոխարինել Fortran-ի կամ C++-ի նման ավանդական լեզուներով գրված code-ը։

Լրացուցիչ թվային գործիքները հաճախ NumPy-ն օգտագործում են որպես հիմնական բաղադրիչ և ավելացնում պատկերավորման, զուգահեռ մշակման, վիճակագրական վերլուծության և այլ հնարավորությունների աջակցություն։ Օրինակ՝ SciPy-ն տրամադրում է գիտական programming-ի գործիքների library-ներ, pandas-ն աջակցում է տվյալների վերլուծությանը, matplotlib-ն ավելացնում է պատկերավորման գործիքներ, Jupyter նոթատետրերը նախատեսված են մաթեմատիկայով աշխատողների կարիքների համար, Numba-ն և PyThran-ը համապատասխանաբար տրամադրում են կատարման պահին (JIT) և նախապես (AOT) աշխատող compiler-ներ Python-ի թվային code-ի համար, իսկ ավելի վաղ նշված Cython և PyPy համակարգերը կարող են օպտիմալացնել ալգորիթմական code-ը։ Ավելի հիմնական կարիքների համար հենց Python-ի հետ տրամադրվում են

Սկզբնաղբյուրի PDF էջ 45

statistics module-ը, կոմպլեքս թվերով, ֆիքսված ստորակետով և ռացիոնալ թվերով մաթեմատիկական գործողությունները և այլ գործիքներ, որոնց մասին կիմանաք այս գրքում։

Python-ը սովորաբար կիրառվում է շատ ավելի բազմաթիվ ոլորտներում և շատ ավելի շատ գործիքներով, քան հնարավոր է այստեղ ներկայացնել։ Օրինակ՝ այն օգտագործվում է նաև հետևյալ ոլորտներում՝

Արհեստական բանականություն (տե՛ս PyTorch, TensorFlow և Keras)
Խաղերի programming (տե՛ս pygame, Panda3D և Kivy)
Պատկերների և գրաֆիկայի մշակում (տե՛ս Pillow, PyOpenGL և OpenCV)
Որակի ապահովում և փորձարկում (տե՛ս PyTest, unittest և Selenium)
Excel աղյուսակներ (տե՛ս xlwings, PyXLL և Excel)
Սմարթֆոնների հավելվածներ (տե՛ս Kivy, BeeWare և Հավելված A)
Միկրոկառավարիչներ և պորտեր (տե՛ս MicroPython և PySerial)
Եվ, իհարկե, շատ ավելին

Այս և բազմաթիվ այլ ոլորտների նյութերի link-ների համար փորձեք Wikipedia-ի Python software էջը, PyPI կայքը, որտեղ տեղակայված են Python-ի pip-ով տեղադրվող ընդլայնման package-ները, և սովորական վեբ որոնումները։

Սկզբնաղբյուրի PDF էջ 46

Թեև կիրառման ոլորտներն ընդգծում են Python-ի գործնական օգտակարությունը, հիշեք, որ դրանցից շատերը մեծ մասամբ պարզապես Python-ի՝ բաղադրիչների ինտեգրման դերի հերթական դրսևորումներն են։ Python-ը որպես դիմային շերտ ավելացնելը C-ի պես compiled լեզվով գրված բաղադրիչների library-ներին այն օգտակար է դարձնում տարատեսակ դերերում սկրիպտավորման համար։ Որպես ինտեգրմանն աջակցող ընդհանուր նշանակության լեզու՝ Python-ը լայնորեն, եթե ոչ համընդհանուր, կիրառելի է։

Բնականաբար, սա մշակողի հարց է։ Եթե դեռ programming-ի փորձ չունեք, հաջորդ բաժինների տերմինաբանությունը կարող է մի փոքր շփոթեցնող լինել. մի՛ անհանգստացեք, գրքով առաջ շարժվելիս այս բոլոր թեմաները ավելի մանրամասն կուսումնասիրենք։ Այնուամենայնիվ, թե՛ ներկա, թե՛ ապագա մշակողների համար ահա Python-ի հիմնական տեխնիկական հնարավորությունների համառոտ ակնարկը։ Դրանցից մի քանիսին արդեն անդրադարձել ենք, սակայն այս բաժինը լրացնում է պատկերը։

Python-ն իր հիմքից object-oriented լեզու է։ Ինչպես կտեսնեք այս գրքում, դրա class-երի մոդելը աջակցում է այնպիսի առաջադեմ

Սկզբնաղբյուրի PDF էջ 47

հասկացությունների, ինչպիսիք են բազմաձևությունը, operator-ների գերբեռնումը և բազմակի inheritance-ը, սակայն Python-ի պարզ syntax-ի ու typing-ի համատեքստում OOP-ն կիրառելը զարմանալիորեն հեշտ է։ Իրականում, եթե այս տերմինները չեք հասկանում, կտեսնեք, որ Python-ով դրանք շատ ավելի հեշտ է սովորել, քան հասանելի գրեթե ցանկացած այլ OOP լեզվով։

Նույնքան նշանակալի է այն, որ Python-ում OOP-ն ընտրովի հնարավորություն է. կարող եք շատ առաջ գնալ՝ առանց միանգամից object-ների գիտակի վերածվելու անհրաժեշտության։ C++-ի նման Python-ն աջակցում է և՛ ընթացակարգային, և՛ object-oriented programming-ի եղանակներին։ Դրա object-oriented գործիքները կարելի է կիրառել, եթե և երբ սահմանափակումները դա թույլ տան։ Սա հատկապես օգտակար է մշակման մարտավարական եղանակներում, որոնք հաճախ բացառում են OOP-ի առավելությունները լավագույնս օգտագործող նախագծման փուլերը։

Իր սկզբնական ընթացակարգային՝ statement-ների վրա հիմնված, և object-oriented՝ class-երի վրա հիմնված, պարադիգմներից բացի՝ Python-ն այսօր ունի functional programming-ի built-in աջակցություն։ Այս հավաքածուն չափանիշների մեծ մասով ներառում է generator-ներ, comprehension-ներ (comprehension), փակույթներ, արտապատկերումներ, դեկորատորներ, անանուն function-ների lambda expression-ներ և առաջին կարգի function-ի object-ներ։ Ինչպես նաև կիմանաք այս գրքում, դրանք կարող են ծառայել և՛ որպես OOP գործիքների լրացում, և՛ որպես դրանց այլընտրանք։

Սկզբնաղբյուրի PDF էջ 48

Python-ն օգտագործելն ու տարածելը լիովին անվճար է։ Ինչպես Linux-ի և Apache-ի նման այլ բաց source code-ով software-ի դեպքում, ինտերնետից կարող եք անվճար ստանալ ամբողջ Python համակարգի source code-ը։ Այն պատճենելու, ձեր համակարգերում ներդնելու կամ ձեր արտադրանքների հետ տարածելու սահմանափակումներ չկան։

Սակայն սխալ մի՛ հասկացեք. «անվճար» չի նշանակում «առանց աջակցության»։ Ընդհակառակը, Python-ի օգտատերերին հասանելի են բազմաթիվ առցանց ռեսուրսներ, որոնք հարցումներին ու խնդիրներին արձագանքում են ավելի արագ, քան առևտրային software-ի մեծ մասը։ Ավելին, քանի որ Python-ը տրամադրվում է ամբողջական source code-ով, այն մշակողներին տալիս է այնպիսի հնարավորություններ, որոնք փակ առևտրային software-ը չի կարող տալ։ Թեև programming language-ի implementation-ի code-ն ուսումնասիրելը կամ փոխելը ոչ բոլորի համար է հաճույք, մխիթարիչ է իմանալ, որ դա հնարավոր է։ Դուք կախված չեք առևտրային մատակարարի քմահաճույքներից, քանի որ վերջնական փաստաթղթավորումը՝ source code-ը, ձեր տրամադրության տակ է որպես վերջին միջոց։

Տեղափոխելիությանն արդեն անդրադարձել ենք։ Python-ի ստանդարտ implementation-ը գրված է տեղափոխելի ANSI C-ով և կոմպիլացվում ու աշխատում է

Սկզբնաղբյուրի PDF էջ 49

ներկայումս օգտագործվող գրեթե բոլոր հիմնական հարթակներում։ Օրինակ՝ Python-ի program-երն այսօր աշխատում են ամեն ինչի վրա՝ սմարթֆոններից մինչև գերհամակարգիչներ։ Որպես մասնակի ցանկ՝ Python-ը հասանելի է Windows ու macOS անհատական computer-ներում, Linux ու Unix աշխատանքային կայաններում և սերվերներում, Android ու iOS սմարթֆոններում և պլանշետներում, VxWorks-ի նման իրական ժամանակի համակարգերում, Cray գերհամակարգիչներում, IBM մեծ computer-ներում և այլուր։ Ավելին, այս ցանկը պարբերաբար ընդլայնվում է. օրինակ՝ այս տողերը գրելիս Android-ն ու iOS-ը ձեռք են բերում python.org-ի պաշտոնական աջակցությունը։

Ինչպես հենց լեզուն, այնպես էլ Python-ի հետ տրամադրվող standard library-ի module-ները նախագծված են տարբեր հարթակների միջև տեղափոխելի լինելու համար. օրինակ՝ դրանց file գործիքները վերացնում են որոշ համակարգերում պահեստավորման առանձնահատուկ կողմերից շատերը կամ մեծ մասը։ Ավելին, Python-ի program-երն ինքնաբերաբար կոմպիլացվում են տեղափոխելի bytecode-ի, որը նույն կերպ է աշխատում ցանկացած հարթակում, որտեղ տեղադրված է Python-ի համատեղելի տարբերակ (այս մասին ավելի մանրամասն՝ հաջորդ գլխում), և կան Python-ով տեղափոխելի օգտատիրական interface-ներ գրելու բազմաթիվ եղանակներ՝ ավելի վաղ նկարագրված ավանդական GUI-ներով ու վեբ տարբերակներով։

Սա նշանակում է, որ Python լեզուն, դրա standard library-ներն ու տեղափոխելի ընդլայնումներն օգտագործող program-երը նույն կերպ են աշխատում Python-ի interpreter ունեցող համակարգերի մեծ մասում։ Python-ը նաև աջակցում է հարթակին հատուկ ընդլայնումներ, օրինակ՝ pywin32-ը

Սկզբնաղբյուրի PDF էջ 50

Windows-ում, PyObjC-ն macOS-ում և pyjnius-ը Android-ում, սակայն հենց Python-ն ամենուր նույն կերպ է աշխատում։

Հնարավորությունների տեսանկյունից Python-ը որոշակիորեն հիբրիդ է։ Դրա գործիքակազմը այն տեղավորում է ավանդական scripting language-ների, օրինակ՝ Tcl-ի, Scheme-ի ու Perl-ի, և համակարգերի մշակման լեզուների, օրինակ՝ C-ի, C++-ի ու Java-ի միջև։ Python-ն ապահովում է scripting language-ի ողջ պարզությունն ու օգտագործման հեշտությունը՝ ծրագրային ճարտարագիտության ավելի առաջադեմ գործիքների հետ միասին, որոնք սովորաբար հանդիպում են compiled լեզուներում։ Ի տարբերություն որոշ scripting language-ների՝ այս համակցությունը Python-ն օգտակար է դարձնում խոշոր մշակման նախագծերի համար։ Որպես նախադիտում՝ ահա հիմնական հնարավորություններից մի քանիսը, որոնք կգտնեք Python-ի գործիքների հավաքածուում։

dynamic typing

Python-ը կատարման ընթացքում հետևում է ձեր program-ի օգտագործած object-ների տեսակներին և չի պահանջում code-ում type-երի ու չափերի բարդ հայտարարություններ։ Իրականում, ինչպես կտեսնեք Գլուխ 6-ում, Python-ում որևէ տեղ type-ի կամ variable-ի հայտարարություն գոյություն չունի՝ բացի վերջերս ավելացված «հուշումներից», որոնք հենց Python-ը չի օգտագործում։ Քանի որ Python-ի code-ը տվյալների type-երը չի սահմանափակում, այն նաև

Սկզբնաղբյուրի PDF էջ 51

սովորաբար ինքնաբերաբար կիրառելի է object-ների մի ամբողջ շարքի նկատմամբ։
memory-ի ավտոմատ կառավարում

Python-ն ինքնաբերաբար memory է հատկացնում object-ներին և ազատում դրանք, երբ այլևս չեն օգտագործվում՝ կատարելով «garbage collection»։ Ինչպես կիմանաք, Python-ը հետևում է օգտագործվող object-ներին ու դրանց զբաղեցրած memory-ին, որպեսզի դուք դա չանեք։
Մեծածավալ programming-ի աջակցություն

Ավելի մեծ համակարգեր կառուցելու համար Python-ը ներառում է այնպիսի գործիքներ, ինչպիսիք են module-ները, class-երն ու exception-ները։ Այս գործիքները թույլ են տալիս համակարգերը կազմակերպել բաղադրիչների տեսքով, OOP-ով կրկնակի օգտագործել և հարմարեցնել code-ը, ինչպես նաև կոռեկտ մշակել իրադարձություններն ու սխալները։ Ավելի վաղ նկարագրված Python-ի functional programming-ի գործիքները ծառայում են նույն նպատակներից մի քանիսին։
object-ների built-in type-եր

Python-ը լայնորեն օգտագործվող տվյալների կառուցվածքներ, օրինակ՝ list-ները, dictionary-ներն ու string-երը, տրամադրում է որպես լեզվի անբաժանելի մասեր։ Ինչպես կտեսնեք, դրա built-in object-ները և՛ ճկուն են, և՛ օգտագործման համար պարզ։ Դրանք ըստ անհրաժեշտության կարող են մեծանալ ու փոքրանալ, կամայականորեն ներդրվել միմյանց մեջ՝ բարդ տեղեկություն ներկայացնելու համար, և պաշտպանված են memory-ի տարածված սխալներից։
built-in գործիքներ

object-ների այս բոլոր type-երը մշակելու համար Python-ի հետ տրամադրվում են հզոր ու ստանդարտ գործողություններ, ներառյալ

Սկզբնաղբյուրի PDF էջ 52

կցումը՝ հավաքածուների միացումը, slicing-ը՝ հատվածների առանձնացումը, տեսակավորումը, արտապատկերումը և ավելին։
library օժանդակ գործիքներ

Ավելի առանձնահատուկ առաջադրանքների համար Python-ի հետ տրամադրվում է նաև նախապես գրված library գործիքների մեծ հավաքածու, որն աջակցում է ամեն ինչի՝ regular expression-ներով ձևանմուշների համադրումից մինչև ցանցային սերվերներ։ Հենց որ սովորեք լեզուն, կիրառական մակարդակի աշխատանքի մեծ մասը կատարվելու է Python-ի library գործիքներով։
Երրորդ կողմերի օժանդակ գործիքներ

Քանի որ Python-ը բաց source code-ով է, մշակողները խրախուսվում են ներդնելու նախապես գրված գործիքներ, որոնք աջակցում են դրա built-in հնարավորություններից դուրս գտնվող առաջադրանքների։ Վեբում կգտնեք պատկերների մշակման, թվային programming-ի, տվյալների շտեմարանների հասանելիության, կայքերի մշակման, ձևական փորձարկման և շատ այլ խնդիրների համար անվճար աջակցություն (տե՛ս «Ի՞նչ կարող եմ անել Python-ով»)։

Չնայած Python-ի գործիքների բազմազանությանը՝ այն պահպանում է նկատելիորեն պարզ syntax ու կառուցվածք։ Արդյունքը programming-ի հզոր գործիք է՝ scripting language-ի օգտագործման ամբողջ հարմարավետությամբ։

Սկզբնաղբյուրի PDF էջ 53

Ինչպես նշվեց ավելի վաղ, Python-ի program-երը տարբեր եղանակներով հեշտությամբ կարելի է «սոսնձել» այլ լեզուներով գրված բաղադրիչներին՝ թե՛ տեղային, թե՛ ցանցերի միջոցով։ Սա նշանակում է, որ ըստ անհրաժեշտության կարող եք հնարավորություններ ավելացնել Python համակարգին և Python-ի program-երն օգտագործել այլ միջավայրերում կամ համակարգերում։

Օրինակ՝ Python-ն ավելի պահանջկոտ լեզուներով գրված համակարգերի մեջ ներառելը այն դարձնում է փորձարկման ու հարմարեցման համար օգտագործման պարզ դիմային լեզու։ Ինչպես նույնպես նշվեց ավելի վաղ, սա Python-ը հարմար է դարձնում նաև արագ նախատիպավորման համար. համակարգերը սկզբում կարող են գրվել Python-ով՝ մշակման արագության համար, ապա, անհրաժեշտության դեպքում և ժամանակին, մաս առ մաս տեղափոխվել ընդլայնումների մեջ՝ կատարման արագության համար։

C++-ի, Java-ի և C#-ի նման այլընտրանքների համեմատ՝ Python-ով programming-ը դիտարկողների մեծ մասին զարմանալիորեն պարզ է թվում։ Շատ համատեքստերում Python-ի code-ը գործարկելու համար պարզապես այն մուտքագրում և գործարկում եք։ Չկան compilation-ի ու կապակցման միջանկյալ քայլեր, որոնք բնորոշ են C-ի կամ C++-ի պես լեզուներին։ Python-ը program-երը կատարում է անմիջապես՝ ապահովելով programming-ի ինտերակտիվ փորձառություն և արագ արդյունք program-ի

Սկզբնաղբյուրի PDF էջ 54

փոփոխություններից հետո. շատ դեպքերում program-ի փոփոխության ազդեցությունը կարող եք տեսնել գրեթե նույնքան արագ, որքան այն մուտքագրում եք։

Իհարկե, մշակման cycle-ի արագությունը Python-ի օգտագործման պարզության միայն մեկ կողմն է։ Այն նաև տրամադրում է միտումնավոր պարզ syntax և հզոր built-in գործիքներ։ Իրականում ոմանք այնքան հեռու են գնացել, որ Python-ն անվանում են կատարվող pseudocode։ Քանի որ այն վերացնում է իր ժամանակակիցների բարդության մեծ մասը, Python-ի program-երն ավելի պարզ, փոքր և ճկուն են, քան այլ հանրաճանաչ լեզուներով համարժեք program-երը։

Սա չի նշանակում, թե Python-ը programming-ը դարձնում է առանց մտածելու կատարվող գործ։ Python-ը նույնպես ունի խճճվածություններ և մութ անկյուններ, որոնց այս գրքում ուղղակիորեն կանդրադառնանք, իսկ դրա որոշ դերերում աշխատանքն ավելի արագ է, քան մյուսներում։ Օրինակ՝ Python-ի OOP inheritance-ի տարբերակն այժմ շատ ավելի բարդ է, քան նախկինում, և ինքնուրույն հավելվածներ կամ հաջորդ գլխում հանդիպող տեսակի նախապես compiled program-եր կառուցելը դեռ կարող է դանդաղ լինել։ Այնուամենայնիվ, համանման գործիքների համեմատ՝ Python-ը code գրողի համար զգալիորեն ավելի հարմար է։

Վերջապես, սա մեզ բերում է այս գրքի բուն նպատակին. հատկապես այլ լայնորեն օգտագործվող programming language-ների համեմատ՝ Python-ի հիմնական լեզուն զարմանալիորեն հեշտ է սովորել։ Իրականում, եթե

Սկզբնաղբյուրի PDF էջ 55

արդեն փորձառու programmer եք, կարող եք ակնկալել, որ մի քանի օրվա ընթացքում կգրեք փոքրածավալ Python program-եր, թեև չպետք է սպասեք, որ այդքան արագ մասնագետ կդառնաք՝ անկախ նրանից, թե ինչ եք լսել մարքեթինգային բաժիններից։

Բնականաբար, ներկայիս Python-ի նման ծավալուն թեմային տիրապետելը հեշտ գործ չէ, և գրքի մնացած մասը կնվիրենք այս խնդրին։ Սակայն Python-ին տիրապետելու համար պահանջվող ներդրումն արժե կատարել. ի վերջո ձեռք կբերեք programming-ի հմտություններ, որոնք կիրառելի են համակարգչային կիրառությունների գրեթե բոլոր ոլորտներում։ Ավելին, մեծ մասը գտնում է, որ Python-ի ուսուցման կորը շատ ավելի մեղմ է, քան programming-ի այլ գործիքներինը, նույնիսկ եթե այն այնքան էլ հարթ չէ, որքան պնդում են բովանդակության որոշ հրապարակողներ։

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

Սկզբնաղբյուրի PDF էջ 56

Այս ամենն ինքներդ տեսնելու համար եկեք ավարտենք այս ակնարկը և սկսենք code գրել։

Սկզբնաղբյուրի PDF էջ 57

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

Հաջորդ երկու գլուխները սկսում են լեզվի ձեր տեխնիկական ներածությունը։ Դրանցում կուսումնասիրեք Python-ի program-եր գործարկելու եղանակները, հայացք կգցեք Python-ի կատարման մոդելին և կսովորեք code-ը պահելու համար նախատեսված module file-երի հիմունքները։ Նպատակն այնքան տեղեկություն տալն է, որքան անհրաժեշտ է գրքի մնացած մասի օրինակներն ու վարժությունները գործարկելու համար։ Բուն programming-ն իրականում չեք սկսի մինչև Գլուխ 4-ը, սակայն շարունակելուց առաջ համոզվեք, որ հասկանում եք գործարկման մանրամասները։

Այս գրքում յուրաքանչյուր գլուխ կավարտենք դրա նյութի մասին կարճ հարցաշարով, որի ընթացքում կարելի է օգտվել գրքից՝ օգնելու ձեզ կրկնել հիմնական

Սկզբնաղբյուրի PDF էջ 58

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

Բացի գլուխների վերջում տրված այս հարցաշարերից՝ գրքի յուրաքանչյուր մասի վերջում կգտնեք գործնական վարժություններ, որոնք կօգնեն ձեզ սկսել ինքնուրույն Python-ով code գրել. առաջարկվող պատասխանները հասանելի են հավելվածում։ Իսկ այժմ՝ ձեր առաջին հարցաշարը։ Հաջողություն, և անհրաժեշտության դեպքում անպայման վերադարձեք այս գլխի նյութին։

Ինչպե՞ս ստացվեց։ Ահա առաջարկվող պատասխանները, թեև հարցաշարի որոշ հարցեր կարող են ունենալ մի քանի լուծում։ Կրկին, նույնիսկ եթե վստահ եք ձեր պատասխաններին, խորհուրդ է տրվում դիտել

Սկզբնաղբյուրի PDF էջ 59

առաջարկվող տարբերակները՝ լրացուցիչ համատեքստի համար։ Եթե այս պատասխաններից որևէ մեկը ձեզ համար անհասկանալի է, ավելի մանրամասն տեղեկության համար դիմեք գլխի նյութին։

1. software-ի որակ, մշակողի արտադրողականություն, program-երի տեղափոխելիություն, աջակցող library-ներ, բաղադրիչների ինտեգրում և պարզապես հաճույք։ Դրանցից որակն ու արտադրողականությունը կարծես այն հիմնական պատճառներն են, որոնցով մարդիկ ընտրում են Python-ն օգտագործելը, սակայն հաճույքը նույնպես նշանակություն ունի software-ի պես դժվարին ոլորտում։

2. Google, Industrial Light & Magic, JPL, ESRI, Instagram և շատ ուրիշներ։ software մշակող գրեթե յուրաքանչյուր կազմակերպություն Python-ն օգտագործում է որևէ ձևով՝ երկարաժամկետ ռազմավարական արտադրանքների մշակման կամ փորձարկման և համակարգային կառավարման պես կարճաժամկետ մարտավարական առաջադրանքների համար։

3. Python-ի հիմնական թերությունը կատարողականությունն է. առնվազն ներկայումս ամենատարածված տարբերակում այն չի աշխատի այնքան արագ, որքան C-ի և C++-ի նման ամբողջությամբ compiled լեզուները։ Մյուս կողմից՝ այն բավական արագ է կիրառությունների մեծ մասի համար, և Python-ի սովորական code-ն ամեն դեպքում աշխատում է C-ի արագությանը մոտ արագությամբ, քանի որ կանչում է interpreter-ին կապակցված C code-ը։ Եթե արագությունը վճռորոշ է, հասանելի են compiled ընդլայնումներ և Cython-ի նման այլ գործիքներ՝ Python կիրառության ինտենսիվ հաշվարկային մասերն օպտիմալացնելու համար։

Սկզբնաղբյուրի PDF էջ 60

4. Python-ը կարող եք օգտագործել գրեթե այն ամենի համար, ինչ կարելի է անել համակարգչով՝ կայքերի մշակումից ու խաղերից մինչև արհեստական բանականություն և տիեզերանավերի կառավարում։ Թվային programming-ն ու վեբ մշակումը գուցե այսօր առաջատար են, բայց հավանաբար այն պատճառով, որ դրանք computer-ների օգտագործման հիմնական ուղղություններից են։

2․ Ինչպես է Python-ը կատարում program-երը

Python · source code · compilation · դեպի bytecode · interpreter-ի · կատարում · program-ի · արդյունք · Python-ը և CPython իրականացումը տարբեր հասկացություններ են։Pythonsource codecompilationդեպի bytecodeinterpreter-իկատարումprogram-իարդյունքPython-ը և CPython իրականացումը տարբեր հասկացություններ են։

Սկզբնաղբյուրի PDF էջ 61

Այս և հաջորդ գլուխները նվիրված են program-երի կատարմանը՝ ինչպես եք գործարկում code-ը, և ինչպես է Python-ը կատարում այն։ Այս գլխում նախ վերացական տեսանկյունից կուսումնասիրենք, թե ընդհանուր առմամբ Python-ի interpreter-ն ինչպես է կատարում program-երը։ Այդ պատկերացումն ունենալուց հետո Գլուխ 3-ում կանցնենք ձեր սեփական program-երը գործարկելու գործնական մանրամասներին։

Գործարկման մանրամասներն իրենց բնույթով կախված են հարթակից, և այս երկու գլուխների նյութի մի մասը գուցե չվերաբերի Python-ը ձեր օգտագործելու եղանակներին, ուստի հանգիստ կարող եք բաց թողնել ձեր նպատակներին չառնչվող հատվածները։ Նմանապես, նախկինում համանման գործիքներ օգտագործած և լեզվի բուն էությանը շուտ անցնել ցանկացող ընթերցողները կարող են այս գլուխների որոշ մասեր թողնել հետագայում անդրադառնալու համար։ Իսկ մյուսներս, նախքան code գրելու կամ գործարկելու մանրամասներին անցնելը, համառոտ նայենք, թե Python-ն ինչպես է կատարելու մեր code-ը։

Սկզբնաղբյուրի PDF էջ 62

Մինչ այժմ Python-ի մասին հիմնականում խոսել ենք որպես programming language-ի։ Սակայն իր ամենատարածված ձևով այն նաև software system է, որը կոչվում է interpreter։ interpreter-ը program է, որը կատարում է այլ program-եր։ Երբ գրում եք Python program, Python-ի interpreter-ը կարդում է ձեր program-ը և կատարում դրանում պարունակվող instruction-ները։ Ըստ էության, interpreter-ը տրամաբանության շերտ է ձեր code-ի և ձեր համակարգչի hardware-ի միջև։

Python-ը տեղադրելիս ստեղծվում են մի շարք բաղադրիչներ՝ առնվազն interpreter և օժանդակ library։ Կախված օգտագործման ձևից՝ Python-ի interpreter-ը կարող է հանդես գալ որպես գործարկվող program կամ մեկ այլ program-ին կապակցված library-ների հավաքածու։ Կախված նրանից, թե Python-ի որ տարբերակն եք գործարկում՝ interpreter-ն ինքը կարող է իրականացված լինել որպես C program, Java class-երի հավաքածու կամ այլ բան։ Ինչ ձև էլ այն ունենա, ձեր գրած Python code-ը միշտ պետք է կատարվի այս interpreter-ի միջոցով։ Իսկ դա հնարավոր դարձնելու համար սովորաբար պետք է ձեր համակարգչում տեղադրեք Python-ի interpreter։

Այս պահին Python տեղադրելու կարիք չկա, եթե չեք ցանկանում ինքներդ փորձարկել քիչ անց բերվող միակ պարզ օրինակը, և այս

Սկզբնաղբյուրի PDF էջ 63

գիրքը մինչև հաջորդ գլուխը չի ենթադրի, որ արդեն ունեք օգտագործման պատրաստ Python։ Երբ պատրաստ լինեք, հաշվի առեք, որ Python-ի տեղադրման մանրամասները տարբեր են ըստ հարթակի․ դրանք համառոտ քննարկվում են Գլուխ 3-ում և ամբողջությամբ ներկայացվում են Հավելված A-ում։

Թե ինչ է նշանակում գործարկել Python script-ը, կախված է նրանից՝ այդ խնդրին նայում եք որպես ծրագրավորո՞ղ, թե՞ որպես Python-ի interpreter։ Երկու հայացքներն էլ Python-ով programming-ի վերաբերյալ կարևոր պատկերացումներ են տալիս։

Իր ամենապարզ, բայց և ամենատարածված ձևով Python program-ը պարզապես Python statement-ներ պարունակող text file է։ Օրինակ՝ Օրինակ 2-1-ում ներկայացված script0.py անունով file-ը գուցե ամենապարզ Python script-ներից մեկն է, որ կարելի է պատկերացնել, բայց լիարժեք աշխատող Python program է։

Օրինակ 2-1. script0.py

Գրքի code · PDF էջ 63

  print('hello world')
  print(2 ** 100)

Սկզբնաղբյուրի PDF էջ 64

Այս file-ը պարունակում է Python-ի երկու print statement, որոնք output stream-ում պարզապես արտածում են string-ը՝ չակերտների մեջ եղած տեքստը, և թվային expression-ի արդյունքը՝ 2-ի 100 աստիճանը (սովորաբար՝ graphical interface-ում կամ այն պատուհանում, որտեղ գործարկվում է file-ը)։ Այս code-ի syntax-ի մասին առայժմ մի անհանգստացեք․ այժմ մեզ հետաքրքրում է միայն այն, թե ինչպես է այն գործարկվում։ Հետագա գլուխներում այս գիրքը կբացատրի print statement-ը և այն, թե ինչու կարող եք Python-ում այդքան հեշտությամբ 2-ը բարձրացնել 100 աստիճանի։

statement-ների նման file կարող եք ստեղծել ձեր նախընտրած ցանկացած text editor-ով․ առաջարկներ կգտնեք Հավելված A-ում։ Ընդունված պայմանավորվածությամբ Python program-երի file-երին տրվում են .py-ով ավարտվող name-ներ․ տեխնիկապես անվանման այս ձևը պարտադիր է միայն «ներմուծվող» file-երի համար. այս տերմինը կպարզաբանվի հաջորդ գլխում։ Սակայն միօրինակության համար Python file-երի մեծ մասն ունի .py name։

Այս statement-ները text file-ի մեջ մուտքագրելուց հետո պետք է Python-ին ասեք կատարել file-ը․ դա պարզապես նշանակում է file-ի բոլոր statement-ները հերթով կատարել վերևից ներքև։ Ինչպես կտեսնեք հաջորդ գլխում, Python program-երի file-երը կարելի է գործարկել command line-եր մուտքագրելով, դրանց պատկերակները սեղմելով, code գրելու գրաֆիկական միջավայրերից և այլ եղանակներով։ Եթե ամեն ինչ բարեհաջող անցնի, file-ը կատարելիս ձեր համակարգչում ինչ-որ տեղ կտեսնեք երկու print statement-ների արդյունքները՝

Սկզբնաղբյուրի PDF էջ 65

սովորաբար և լռելյայն՝ նույն պատուհանում, որտեղից գործարկել եք program-ը․

Գրքի code · PDF էջ 65

  hello world
  1267650600228229401496703205376

Օրինակ՝ ահա թե ինչ եղավ, երբ այս script-ը Windows նոութբուքի Command Prompt պատուհանում գործարկվեց command line-ով՝ համոզվելու համար, որ դրանում անուշադրությունից վրիպակներ չկան․

Գրքի code · PDF էջ 65

  C:\Users\me\code> py script0.py
  hello world
  1267650600228229401496703205376

Այս գործընթացի ամբողջական նկարագրությունը տե՛ս Գլուխ 3-ում, հատկապես եթե նոր եք programming սովորում․ այնտեղ մանրամասն կքննարկենք program-եր գրելն ու գործարկելը։ Այստեղ մեր նպատակների համար պարզապես գործարկեցինք Python script, որը արտածում է string և թիվ։ Այս code-ով հավանաբար վենչուրային ներդրումներ չենք ներգրավի կամ GitHub-ում սենսացիա չենք դառնա, բայց program-ի կատարման հիմունքները ներկայացնելու համար այն բավական է։

Սկզբնաղբյուրի PDF էջ 66

Նախորդ բաժնի համառոտ նկարագրությունը բավական սովորական է scripting language-ների համար, և սկսնակ Python programmer-ների մեծ մասի համար սովորաբար հենց այսքանն իմանալը բավական է։ Դուք code-ը մուտքագրում եք text file-երի մեջ և այդ file-երը գործարկում interpreter-ի միջոցով։ Սակայն ներսում մի փոքր ավելին է տեղի ունենում, երբ Python-ին ասում եք «սկսել»։ Թեև Python-ով ծրագրավորելու համար դրա ներքին կառուցվածքի իմացությունը խիստ պարտադիր չէ, Python-ի runtime-ի կառուցվածքի մասին նախնական հիմնական պատկերացումն օգնում է հասկանալ, թե ձեր code-ն ինչպես է տեղավորվում program-ի կատարման ընդհանուր պատկերի մեջ։

Երբ Python-ին հանձնարարում եք գործարկել ձեր script-ը, այն մի քանի քայլ է կատարում մինչև ձեր code-ն իրականում կսկսի աշխատել։ Մասնավորապես՝ այն նախ կոմպիլացվում է «bytecode» կոչվող ձևի, ապա փոխանցվում «virtual machine» կոչվող բաղադրիչին։ Սա ճիշտ է միայն Python-ի ամենատարածված տարբերակի համար․ քիչ անց կտեսնեք այս մոդելի այլ տարբերակներ։ Քանի որ ամենատարածվածն իսկապես ամենատարածվածն է, նախ տեսնենք, թե սա ինչպես է աշխատում։

Ներքին մակարդակում և ձեզնից գրեթե ամբողջությամբ թաքնված՝ program կատարելիս Python-ը նախ ձեր source code-ը՝

Սկզբնաղբյուրի PDF էջ 67

ձեր text file-ի statement-ները, կոմպիլացնում է bytecode անունով հայտնի ձևաչափի։ compilation-ը ընդամենը թարգմանության քայլ է, իսկ bytecode-ը ձեր source code-ի ավելի ցածր մակարդակի, հարթակից անկախ ներկայացումն է։ Մոտավորապես ասած՝ Python-ը ձեր սկզբնական յուրաքանչյուր statement-ը տրոհում է առանձին քայլերի և թարգմանում bytecode-ի instruction-ների խմբի։ bytecode-ի այս թարգմանությունը կատարվում է կատարումն արագացնելու համար․ bytecode-ը կարելի է կատարել շատ ավելի արագ, քան ձեր text file-ի սկզբնական statement-ները։

Կնկատեք, որ նախորդ պարբերությունում ասվեց՝ սա ձեզնից գրեթե ամբողջությամբ է թաքնված։ Եթե Python program-ը ձեր համակարգչում գրելու իրավունք ունի, այն ձեր program-երի bytecode-ը կպահի .pyc ընդլայնմամբ ավարտվող file-երում (.pyc նշանակում է՝ compiled .py սկզբնական file)։ Տեխնիկապես այս պահպանումը տեղի չի ունենում մեկ file գործարկելիս, ինչպես արեցինք նախորդ բաժնում, բայց ավելի ծավալուն, multi-file program-երում կատարվում է բոլոր file-երի համար՝ բացի ամենավերինից (այս մասին՝ քիչ անց)։

Python-ն իր bytecode-ի file-երը պահում է __pycache__ name-ով subdirectory-ում, որը գտնվում է ձեր սկզբնական file-երի directory-ում, և այնպիսի file-երում, որոնց name-ները ցույց են տալիս դրանք ստեղծած Python-ի տարբերակը (օրինակ՝ script0.cpython-312.pyc՝ 3.12-ի համար)։ __pycache__ subdirectory-ն կանխում է անկարգ կուտակումը, իսկ bytecode-ի file-երի անվանման պայմանավորվածությունը թույլ չի տալիս, որ նույն համակարգչում տեղադրված Python-ի տարբեր

Սկզբնաղբյուրի PDF էջ 68

տարբերակները վերագրեն միմյանց պահած bytecode-ը։ bytecode-ի file-երի այս մոդելն ավելի մանրամասն կուսումնասիրենք Գլուխ 22-ում, թեև այն ինքնաշխատ է, Python program-երի մեծ մասի համար էական չէ և կարող է տարբեր լինել ստորև նկարագրվող Python-ի այլընտրանքային implementation-ներում։

Ուրեմն ինչո՞ւ այսքան քաշքշուկ։ Կարճ ասած՝ Python-ն այսպես պահում է bytecode-ը՝ գործարկման մեկնարկն արագացնելու համար։ Երբ հաջորդ անգամ գործարկեք ձեր program-ը, Python-ը կբեռնի .pyc file-երը և բաց կթողնի compilation-ի քայլերը, եթե bytecode-ն առկա է, դրա վերջին պահպանումից ի վեր չեք փոխել source code-ը և չեք գործարկում այն ստեղծածից տարբեր Python-ով։ Դա աշխատում է այսպես․

source code-ի փոփոխություններ

Python-ը source code-ի file-ի վերջին փոփոխության ժամանակային նշումն ու չափը (կամ, ընտրովի, hash-ի value-ն) պահում է դրա bytecode-ի file-ում և bytecode-ը բեռնելիս այս տվյալները համեմատում է սկզբնական file-ի հետ՝ իմանալու, թե երբ պետք է այն կրկին կոմպիլացնի։ Եթե խմբագրեք և նորից պահեք source code-ը, դրա bytecode-ը կվերստեղծվի program-ը հաջորդ անգամ գործարկելիս։
Python-ի տարբերակներ

Python-ը bytecode-ի file-երի անուններին նաև տարբերակի մասին տեղեկություն պարունակող վերջածանց է ավելացնում՝ իմանալու համար, թե երբ պետք է նորից կոմպիլացնի։ Եթե ձեր program-ը գործարկեք Python-ի մեկ այլ implementation-ով կամ

Սկզբնաղբյուրի PDF էջ 69

տարբերակով, դրա bytecode-ը կստեղծվի և կպահվի նաև այդ Python-ի համար։

Արդյունքում թե՛ source code-ի փոփոխությունները, թե՛ Python-ի տարբեր տարբերակներն ինքնաշխատ առաջացնում են bytecode-ի նոր file։ Եթե Python-ը չի կարող bytecode-ի file-երը գրել ձեր համակարգչում, program-ը միևնույն է աշխատում է․ bytecode-ը ստեղծվում է memory-ի մեջ և program-ից դուրս գալու ժամանակ պարզապես դեն է նետվում։

Սակայն քանի որ .pyc file-երը կրճատում են գործարկման սկզբնական ժամանակը, մեծ program-երի համար լավ կլինի համոզվել, որ դրանք գրվում են։ bytecode-ի file-երը նաև Python program-եր տարածելու եղանակներից մեկն են․ Python-ը պատրաստ է կատարել program, եթե կարողանում է գտնել միայն համատեղելի .pyc file-եր, նույնիսկ երբ սկզբնական .py file-երը բացակայում են։ Սակայն սա այնքան պարզ չէ, որքան .py file-երը ջնջելը, և կարող է պահանջել file-երի տեղափոխում ու վերանվանում կամ հատուկ միջոցներ, որոնք քննարկվում են հետագայում՝ Գլուխ 22-ում։ Երբ փաթեթավորման համար անհրաժեշտ է հարկադրաբար կատարել compilation-ը, տե՛ս Python-ի compileall module-ը, իսկ տարածման մեկ այլ տարբերակի համար՝ սառեցված բինար file-երը (տե՛ս «Ինքնուրույն գործարկվող file-եր»)։

Խիստ ասած՝ bytecode-ը ներմուծման օպտիմալացում է։ bytecode-ը .pyc file-երում պահվում է միայն ներմուծվող file-երի համար, այլ ոչ թե program-ի վերին մակարդակի այն file-երի, որոնք գործարկվում են միայն որպես script-ներ։ Ավելին՝ program-ի մեկ գործարկման ընթացքում տվյալ file-ը ներմուծվում և հնարավոր է՝ կոմպիլացվում է միայն մեկ անգամ․ հետագա ներմուծումներն օգտագործում են արդեն

Սկզբնաղբյուրի PDF էջ 70

բեռնվածը։ Ներմուծման հիմունքները կուսումնասիրենք Գլուխ 3-ում, իսկ ներմուծումներն ավելի խորությամբ կդիտարկենք Մաս V-ում։ Առայժմ հիշեք, որ bytecode-ը երբեք չի պահվում interactive prompt-ի մոտ մուտքագրված code-ի համար․ programming-ի այս ռեժիմին կծանոթանաք Գլուխ 3-ում և կօգտագործեք գրքի սկզբնական մասում։

Երբ ձեր program-ը կոմպիլացվել է bytecode-ի (կամ bytecode-ը բեռնվել է առկա .pyc file-երից), այն կատարման համար ուղարկվում է մի բաղադրիչի, որն ընդհանուր առմամբ հայտնի է որպես Python virtual machine (հապավումների սիրահար ընթերցողների համար՝ PVM)։ PVM-ն ավելի տպավորիչ է հնչում, քան իրականում կա․ այն առանձին program չէ, և այն պետք չէ առանձին տեղադրել։ Իրականում PVM-ն պարզապես code-ի մեծ loop է, որը մեկ առ մեկ անցնում է ձեր bytecode-ի instruction-ներով և կատարում դրանց գործողությունները։ Այսինքն՝ PVM-ն Python-ի կատարման շարժիչն է։ Այն միշտ առկա է որպես Python համակարգի մաս, հենց այն բաղադրիչն է, որն իրականում կատարում է ձեր script-ները, և ըստ էության «Python-ի interpreter-ի» ընդամենը վերջին քայլն է։

Նկար 2-1-ը ցույց է տալիս կատարման այս կառուցվածքը։ Հիշեք, որ այս ամբողջ բարդությունը միտումնավոր թաքցված է Python programmer-ներից։ bytecode-ի compilation-ն ինքնաշխատ է, իսկ PVM-ն ընդամենը ձեր

Սկզբնաղբյուրի PDF էջ 71

համակարգչում տեղադրած Python համակարգի մասն է։ Կրկին՝ programmer-ները պարզապես գրում և գործարկում են statement-ներով file-եր, իսկ Python-ը կուլիսների հետևում հոգում է դրանց կատարման կազմակերպման մասին։

Սկզբնաղբյուրի պատկեր, PDF էջ 71
Սկզբնաղբյուրի պատկեր · PDF էջ 71

Նկար 2-1. Python-ի կատարման ավանդական մոդելը․ PVM-ն կատարում է compiled bytecode-ը

C և C++ նման ամբողջությամբ compiled լեզուների փորձ ունեցող ընթերցողները գուցե Python-ի մոդելում մի քանի ակնառու տարբերություն նկատեն։ Նախ՝ Python-ով աշխատելիս սովորաբար հավաքման կամ «make» քայլ չկա․ code-ը գործարկվում է այն գրելուց անմիջապես հետո։ Բացի այդ՝ Python-ի bytecode-ը բինար machine code չէ (օրինակ՝ Intel կամ ARM չիպի՝ կենտրոնական processor-ի՝ CPU-ի instruction-ներ)․ դա Python-ին հատուկ ձևաչափ է։ Այս կանոններից exception-ներ կան (օրինակ՝ սմարթֆոնների հավելվածների հավաքումը կարող է որոշ ժամանակ պահանջել, և ամբողջական compiler-ներ իսկապես գոյություն ունեն, ինչպես կտեսնեք ստորև), բայց այստեղ նախ կենտրոնանում ենք տարածված դեպքի վրա։

Սկզբնաղբյուրի PDF էջ 72

Այս տարբերությունները բացատրում են, թե ինչու Python code-ի մի մասը կարող է C կամ C++ code-ի չափ արագ չաշխատել, ինչպես նկարագրվեց Գլուխ 1-ում․ bytecode-ը դեռ պետք է մեկնաբանի PVM-ի loop-ը, ոչ թե CPU չիպը, իսկ bytecode-ի instruction-ները CPU-ի instruction-ներից ավելի շատ աշխատանք են պահանջում։ Մյուս կողմից՝ ի տարբերություն դասական interpreter-ների՝ այստեղ, այնուամենայնիվ, ներքին compilation-ի քայլ կա․ Python-ը կարիք չունի յուրաքանչյուր սկզբնական statement-ի տեքստը բազմիցս նորից վերլուծելու և շարահյուսորեն մշակելու։ Արդյունքում զուտ Python code-ը կատարվում է ավանդական compiled և ավանդական interpreted լեզուների արագությունների միջև ընկած արագությամբ։

Python-ի կատարման մոդելի մեկ այլ հետևանք այն է, որ մշակման և կատարման միջավայրերի միջև իրականում տարբերություն չկա․ ձեր source code-ը կոմպիլացնող և կատարող համակարգերն ըստ էության նույնն են։ Այս նմանությունը գուցե մի փոքր ավելի նշանակալի լինի ավանդական compiled լեզուների փորձ ունեցող ընթերցողների համար, բայց Python-ում compiler-ը միշտ առկա է runtime և program-երը գործարկող համակարգի մաս է։

Սա մշակման cycle-ը դարձնում է շատ ավելի արագ։ Կատարումն սկսելուց առաջ նախապես կոմպիլացնելու և կապակցելու կարիք չկա․ պարզապես մուտքագրեք code-ն ու գործարկեք։ Սա նաև լեզվին շատ ավելի

Սկզբնաղբյուրի PDF էջ 73

դինամիկ բնույթ է հաղորդում․ Python program-երը կարող են runtime կառուցել և կատարել այլ Python program-եր, և դա հաճախ շատ հարմար է։ Օրինակ՝ built-in eval և exec գործիքներն ընդունում ու կատարում են Python program-ի code պարունակող string-եր։ Այս կառուցվածքն է նաև պատճառը, որ Python-ը հարմար է արտադրանքն անհատականացնելու համար․ քանի որ Python code-ը կարելի է փոփոխել աշխատանքի ընթացքում, օգտատերերը կարող են տեղում փոխել համակարգի Python մասերը՝ առանց համակարգի մնացած code-ը կոմպիլացնելու կամ նույնիսկ այն ունենալու անհրաժեշտության։

Ավելի հիմնարար մակարդակում հիշեք, որ Python-ում իրականում ունենք միայն runtime․ սկզբնական compilation-ի ժամանակի փուլ ընդհանրապես չկա, և ամեն ինչ տեղի է ունենում program-ի աշխատանքի ընթացքում։ Սա ներառում է նույնիսկ function-ների ու class-երի ստեղծումը և module-ների կապակցումը։ Նման իրադարձություններն ավելի ստատիկ լեզուներում հաճախ տեղի են ունենում կատարումից առաջ, իսկ Python-ում՝ կատարման ընթացքում։ Ինչպես կտեսնեք, սա programming-ը դարձնում է շատ ավելի դինամիկ, քան որոշ ընթերցողներ գուցե սովոր են։

Սկզբնաղբյուրի PDF էջ 74

ԻՆՉՈ՞Ւ Է PYTHON-Ն ՕԳՏԱԳՈՐԾՈՒՄ bytecode
Հաշվի առնելով, որ bytecode-ը ընդհանուր առմամբ machine code-ից դանդաղ է կատարվում՝ սա շատ լավ հարց է։ Կարճ պատասխանն այն է, որ Python-ն օգտագործում է bytecode՝ մշակման արագության և լեզվի ճկունության համար։

Ավելի մանրամասն՝ յուրաքանչյուր program ի վերջո պետք է կատարվի որպես machine code՝ այն գործարկող սարքի CPU-ի վրա, բայց program-ի code-ը ընդամենը լեզվի կանոններով գրված տեքստ է։ C-ի նման ավանդական լեզուները այս բացը լրացնում են՝ code-ի վրա սահմանափակումներ դնելով CPU-ի ակնկալիքներին համապատասխանելու համար և code-ի տեքստը նախապես machine code-ի թարգմանելով։ Սա program-երը դարձնում է արագ, սակայն թարգմանությունը ժամանակ է պահանջում, իսկ ստացվող լեզուները կիրառելն անհարմար է։

Փոխարենը Python-ը սահմանում է հեշտ կիրառելի լեզու, որը machine code-ից չափազանց հեռու է անմիջական թարգմանության համար, և օգտագործում է PVM միջնորդը՝ ձեր program-ի bytecode-ը CPU-ի վրա կատարելու համար։ Սա արագության և օգտագործման հարմարության միջև դասական փոխզիջում է, բայց նաև կեղծ երկընտրանք․ այն այլընտրանքային implementation-ներից շատերը, որոնց կծանոթանաք ստորև, իսկապես Python code-ի մի մասը կոմպիլացնում են machine code-ի, և Python-ը շատ դերերի համար բավական արագ է նույնիսկ իր PVM մոդելով։ Այս փոխզիջման մասին ավելին տե՛ս «Լավ, բայց ո՞րն է բացասական կողմը» բաժնում։

Սկզբնաղբյուրի PDF էջ 75

Այժմ, երբ ուսումնասիրել եք նախորդ բաժնում նկարագրված կատարման ներքին ընթացքը, պետք է նաև իմանաք, որ այն արտացոլում է միայն Python-ի այսօրվա ստանդարտ implementation-ը և Python լեզվի բուն պահանջը չէ։ Այդ պատճառով կատարման մոդելը ժամանակի ընթացքում կարող է փոխվել։ Իրականում շատ համակարգեր արդեն այս կամ այն կերպ փոփոխում են Նկար 2-1-ի պատկերը։ Առաջ անցնելուց առաջ համառոտ ուսումնասիրենք այդ տարբերակներից ամենանշանավորները։

Այս տողերը գրելիս Python լեզվի մի քանի implementation գոյություն ունի։ Թեև Python-ի այս տարբերակների միջև գաղափարների և աշխատանքի զգալի փոխանակում կա, դրանցից յուրաքանչյուրն առանձին տեղադրվող software system է՝ իր նախագծով և օգտատերերի շրջանակով։ Բոլոր այս համակարգերի մասին, բացի մեկից, ընթերցանությունը Python-ի սկսնակների մեծ մասի համար պարտադիր չէ, բայց կատարման մոդելում դրանց կատարած փոփոխություններին հակիրճ ծանոթանալը կարող է օգնել պարզաբանել, թե ընդհանրապես ինչ է նշանակում code գործարկել։

Կարճ ասած՝ CPython-ը ստանդարտ implementation-ն է՝ այն, ինչ մինչ այժմ անվանել ենք «տարածված» տարբերակ։ Դա անհատական computer-ների և սմարթֆոնների սովորական Python-ն է և այն համակարգը, որը

Սկզբնաղբյուրի PDF էջ 76

կօգտագործի ընթերցողների մեծ մասը (և եթե վստահ չեք, ապա հավանաբար նաև դուք)։ Այս գրքում ևս օգտագործվում է հենց այս տարբերակը, թեև այստեղ ներկայացված Python լեզվի հիմունքները վերաբերում են նաև բոլոր այլընտրանքներին։ Python-ի մյուս բոլոր implementation-ներն ունեն հատուկ նպատակներ և կարող են իրականացնել կամ չիրականացնել CPython-ի սահմանած Python լեզուն ամբողջությամբ, բայց բավական մոտ են դրան՝ Python համարվելու համար։

Օրինակ՝ PyPy-ն CPython-ի անմիջական փոխարինիչ է, որը շատ program-եր կատարում է ավելի արագ՝ աշխատանքի ընթացքում դրանց մասերը հետագա compilation-ի ենթարկելով։ Իսկ Jython-ն ու IronPython-ը CPython-ը վերաիրականացնում են՝ Java և .NET բաղադրիչներին հասանելիություն ապահովելու համար․ թեև սովորական CPython program-երն էլ կարող են օգտվել նման բաղադրիչներից (օրինակ՝ Java-ի դեպքում՝ pyjnius-ի և Chaquopy-ի միջոցով), Jython-ն ու IronPython-ը ձգտում են ավելի անխափան համակցման։ Մյուս տարբերակներն արագացնում են թվային code-ը կամ code-ը ընդհանրապես։

Ավելի մանրամասն՝ հետևյալ ցանկը այսօր հասանելի Python implementation-ներից ամենանշանավորների համառոտ ակնարկն է՝ սովորականի պես ներողություն խնդրելով տեղ չլինելու պատճառով բաց թողնված ներկա տարբերակների և բյուրեղյա գնդի բացակայության պատճառով բաց թողնված ապագա տարբերակների համար․

CPython․ ստանդարտը

Python-ի սկզբնական, ստանդարտ և reference implementation-ը սովորաբար կոչվում է CPython, երբ ցանկանում եք այն

Սկզբնաղբյուրի PDF էջ 77

համեմատել մյուս տարբերակների հետ (իսկ այլ դեպքերում՝ պարզապես «Python»)։ Այս name-ը գալիս է նրանից, որ այն գրված է տեղափոխելի ANSI C լեզվով։ Սա այն Python-ն է, որն անհատական computer-ների համար ներբեռնում եք python.org-ից, ստանում այլընտրանքային բաշխումների և Linux-ի պահոցների մեծ մասից և ունենում Android ու iOS սմարթֆոնների Python հավելվածներում։ Սա նաև այն տարբերակն է, որի implementation-ը պատկերված է Նկար 2-1-ում, թեև այն ենթակա է փոփոխության (և իրականում կարող է փոխվել․ տե՛ս «Ապագայի հնարավորությունները»)։
Jython․ Python Java-ի համար

Jython համակարգը Python լեզվի այլընտրանքային implementation է։ Այն ուղղված է Java programming language-ի հետ ինտեգրմանը, ճիշտ այնպես, ինչպես CPython-ն է ինտեգրվում C և C++ բաղադրիչների հետ։ Jython-ը բաղկացած է Java class-երից, որոնք Python-ի source code-ը կոմպիլացնում են Java bytecode-ի, ապա այն փոխանցվում է Java-ի վիրտուալ մեքենային (JVM)։ programmer-ները շարունակում են սովորականի պես Python statement-ներ գրել .py text file-երում․ Jython համակարգն ըստ էության պարզապես Նկար 2-1-ի աջ կողմի երկու պղպջակները փոխարինում է Java-ի վրա հիմնված համարժեքներով՝ Java-ի հետ անխափան կապակցման համար։ Այս տողերը գրելիս Jython-ն իրականացնում է այս գրքում չօգտագործվող հին Python 2.X-ը, բայց աշխատում է 3.X-ի ուղղությամբ։
IronPython․ Python .NET-ի համար

IronPython-ը Python-ի ևս մեկ այլընտրանքային implementation է։ Այն գրված է C#-ով և նախատեսված է, որ Python

Սկզբնաղբյուրի PDF էջ 78

program-երը կարողանան ինտեգրվել այն հավելվածների հետ, որոնք գրված են Windows-ի համար Microsoft-ի .NET Framework-ի, ինչպես նաև դրա բաց code-ով համարժեք Mono-ի հետ աշխատելու համար։ Jython-ի նման՝ IronPython-ը Նկար 2-1-ի վերջին երկու պղպջակները փոխարինում է .NET միջավայրում կատարման համար նախատեսված համարժեքներով։ Դրանով Python code-ը կարող է և՛ հասանելիություն ստանալ այլ .NET լեզուներին, և՛ հասանելի դառնալ դրանցից, ինչպես նաև օգտվել .NET library-ներից։
Stackless․ Python՝ զուգահեռ ընթացքների համար

Stackless Python համակարգը ստանդարտ CPython լեզվի ընդլայնված տարբերակ է՝ ուղղված միաժամանակ ընթացող աշխատանքներին։ Քանի որ այն վիճակը չի պահում C լեզվի կանչերի stack-ում, Stackless-ը կարող է հեշտացնել Python-ի տեղափոխումը փոքր stack ունեցող ճարտարապետությունների վրա։ Stackless-ը նաև տրամադրում է բազմապրոցես աշխատանքի արդյունավետ միջոցներ, որոնք ոմանք ավելի պարզ են համարում, քան CPython-ի ավելի ուշ հայտնված async համածրագրերը, և նպաստում է programming-ի նոր կառուցվածքների ստեղծմանը։ Օրինակ՝ EVE Online խաղը օգտագործում է Stackless Python՝ զանգվածաբար զուգահեռ առաջադրանքների բարձր արտադրողականության հասնելու համար։
PyPy․ JIT compiler՝ արագության համար

PyPy-ն Python-ի վերաիրականացում է՝ արագության նպատակով։ Այն առաջին համակարգերից էր, որը սովորական Python code-ի համար օգտագործեց հենց կատարման պահին աշխատող՝ just-in-time (JIT) compiler։ JIT compiler-ը պարզապես PVM-ի՝ Նկար 2-1-ի ամենաաջ պղպջակի ընդլայնումն է, որը ձեր bytecode-ի հատվածները մինչև վերջ թարգմանում է machine code-ի՝ ավելի արագ կատարման համար։ PyPy-ն դա անում է ձեր

Սկզբնաղբյուրի PDF էջ 79

program-ի աշխատանքի ընթացքում, այլ ոչ թե գործարկմանը նախորդող compilation-ի քայլով, և կարողանում է դինամիկ Python լեզվի համար ստեղծել type-ին հատուկ machine code՝ հետևելով ձեր program-ի մշակած object-ների տվյալների type-երին։ Ձեր bytecode-ի հատվածներն այս կերպ փոխարինելու շնորհիվ program-ն իր կատարման ընթացքում աշխատում է ավելի ու ավելի արագ։ Բացի այդ՝ Python-ի որոշ program-եր PyPy-ի ներքո կարող են նաև ավելի քիչ memory զբաղեցնել։
Numba․ JIT compiler՝ թվային հաշվարկների արագության համար

Python-ի Numba ընդլայնումն ավելացնում է JIT compiler, որը օպտիմալացնում է թվային հաշվարկներին ուղղված code-ը՝ ձեր program-ի աշխատանքի ընթացքում այն ամբողջությամբ machine code-ի կոմպիլացնելով։ Numba-ի compiler-ն ուղղորդելու համար function-ներին ավելացվում են Numba-ի տեղադրմամբ տրամադրվող Python-ի «@» դեկորատորներ։ Թեև Numba-ն չի կարող արագացնել ցանկացած Python code, այն լավ է աշխատում NumPy զանգվածներ ու function-ներ օգտագործող code-ի, ինչպես նաև մաթեմատիկական հաշվարկների loop-երի հետ։ Numba-ն նաև աջակցում է գիտական programming-ի մեջ հաճախ օգտագործվող code-ի զուգահեռացման մոտեցումներին։
Shed Skin․ AOT compiler՝ պահանջներին համապատասխանող code-ի համար

Shed Skin-ը նախապես՝ ahead-of-time (AOT) աշխատող compiler է, որը սովորական Python code-ը թարգմանում է C++ code-ի, որն այնուհետև՝ մինչև գործարկվելը, կոմպիլացվում է machine code-ի։ AOT-ի դեպքում Նկար 2-1-ի աջ կողմի երկու պղպջակները փոխարինվում են նախապես compiled machine code-ով։ Shed Skin-ը կարող է ստանալ և՛

Սկզբնաղբյուրի PDF էջ 80

ինքնուրույն program-եր, և՛ ընդլայնման module-ներ՝ այլ program-երում օգտագործելու համար։ Փոխարենը՝ այն իրականացնում է Python-ի սահմանափակ subset, որը պահանջում է, որ Python-ի variable-ները բավարարեն static typing-ի անուղղակի սահմանափակմանը, և ներկայումս չի աջակցում Python-ի որոշ հնարավորությունների կամ library-ների։ Այնուամենայնիվ, պահանջներին համապատասխանող որոշ code-ի դեպքում Shed Skin-ը կարող է արագությամբ գերազանցել թե՛ CPython-ին, թե՛ JIT-ի վրա հիմնված տարբերակներին։
PyThran․ AOT compiler՝ թվային հաշվարկների արագության համար

PyThran-ն իրականացնում է ևս մեկ AOT compiler՝ Python լեզվի մի subset-ի համար, կենտրոնանալով գիտական programming-ի վրա։ Shed Skin-ի նման այն Python code-ը թարգմանում է C++-ի՝ օգտագործելով ստատիկ type-երի հայտարարություններ, որոնք տրվում են կա՛մ հատուկ ձևաչափով comment-ներում, կա՛մ առանձին հրամանային file-երում։ Ստեղծված C++-ի compilation-ի արդյունքը հարթակին բնիկ module է, որը կարող է ներմուծվել և օգտագործվել այլ Python code-ից։
Cython․ Python/C հիբրիդ՝ արագության համար

Cython համակարգը սահմանում է Python/C հիբրիդային լեզու, որը Python code-ը համադրում է C function-ներ կանչելու և variable-ների, parameter-երի ու class-երի attribute-ների համար C type-երի հայտարարություններ օգտագործելու հնարավորության հետ։ Cython code-ը կարող է AOT եղանակով կոմպիլացվել C code-ի, որն օգտագործում է Python/C API-ն և ապա կարող է ամբողջությամբ կոմպիլացվել machine code-ի։ Թեև Cython-ը համատեղելի չէ ստանդարտ Python-ի հետ, այն կարող է օգտակար լինել ինչպես արտաքին C library-ները փաթաթելու, այնպես էլ

Սկզբնաղբյուրի PDF էջ 81

համակարգի արտադրողականության համար վճռորոշ մասերը որպես արդյունավետ C ընդլայնումներ իրականացնելու համար՝ CPython program-երում օգտագործելու նպատակով։
MicroPython․ Python-ի subset՝ սահմանափակ պայմանների համար

MicroPython համակարգը այլընտրանքային Python է, որի ուշադրության կենտրոնում արդյունավետությունն է։ Այն իրականացնում է CPython լեզվի սահմանափակ բարբառ և դրա standard library-ի փոքր subset՝ Python-ը սահմանափակ միջավայրերում աշխատելու համար օպտիմալացնելու նպատակով։ Թեև սկզբում այն նախատեսված էր միկրոկառավարիչների համար, MicroPython-ը կոմպիլացվում է նաև WebAssembly համակարգի համար, որին կծանոթանաք Գլուխ 3-ում․ դա թույլ է տալիս վեբ զննարկիչներում աշխատեցնել Python program-եր՝ առանց CPython-ի ամբողջ ծանրության։
Եվ, իհարկե, ավելին

Python-ի այլ այլընտրանքների համար տե՛ս Python-ի վիքիի ցանկը, ինչպես նաև համացանցային որոնման արդյունքները։ Մյուսների թվում են՝ Cinder-ը՝ CPython-ի արտադրողականությանն ուղղված implementation՝ JIT compiler-ով և այլ հնարավորություններով, որը ստեղծել է Meta-ն և օգտագործում է Instagram-ի համար, Pyston-ը՝ CPython-ի ճյուղավորում՝ JIT compiler-ով և այլ օպտիմալացումներով, որը սկսել է Dropbox-ը, և Nuitka-ն՝ անվճար ու վճարովի տարբերակներով օպտիմալացնող AOT compiler, որը ստանդարտ Python code-ը թարգմանում է C-ի և օգտագործվում է զարգացող py2wasm-ի կողմից՝ Python code-ը զննարկիչներում օգտագործելու համար WebAssembly-ի թարգմանելու նպատակով։

Սկզբնաղբյուրի PDF էջ 82

Այս ամենով հանդերձ, եթե չունեք հատուկ պահանջ, որը բավարարում է միայն այլընտրանքներից մեկը, հավանաբար կցանկանաք օգտագործել ստանդարտ CPython համակարգը։ Քանի որ այն լեզվի reference implementation-ն է, այն միշտ ամենաամբողջականն է և սովորաբար նաև մյուսներից ավելի արդիական ու հուսալի։ Այնուամենայնիվ, քիչ հավանական է, որ CPython-ը երբևէ ներառի Python-ի աշխարհում ընթացող բոլոր օպտիմալացման նախագծերը, ուստի ձեր նպատակները հստակեցնելուց հետո անպայման գնահատեք նաև այլընտրանքները։

Երբեմն, երբ մարդիկ խնդրում են Python-ի «իրական» compiler, իրականում պարզապես իրենց Python program-երից ինքնուրույն գործարկվող file-եր ստեղծելու եղանակ են փնտրում։ Սա ավելի շատ փաթեթավորման և տարածման թեմա է, քան կատարման ընթացքի հասկացություն, և ավելի հետաքրքիր է ծրագրաշար մշակողների, քան Python-ի սկսնակների համար, բայց հարակից գաղափար է։

Կարճ ասած՝ համացանցից ստացվող երրորդ կողմի գործիքների օգնությամբ հնարավոր է ձեր Python program-երը վերածել իսկապես ինքնաբավ գործարկվող file-երի, որոնք Python-ի աշխարհում երբեմն անվանում են նաև սառեցված բինար file-եր։ Ինչպես էլ դրանք կոչվեն, այս program-երը կարելի է գործարկել՝ առանց Python-ի տեղադրում պահանջելու կամ ձեր source code-ի file-երը տարածելու։

Սկզբնաղբյուրի PDF էջ 83

Ինքնուրույն գործարկվող file-երը մեկ bundle-ում միավորում են ձեր ծրագրային file-երի bytecode-ը, PVM-ը (interpreter-ը) և ձեր program-ին անհրաժեշտ Python-ի բոլոր օժանդակ file-երն ու library-ները։ Այս մոտեցումը տարբեր ձևեր ունի, բայց վերջնական արդյունքը կարող է լինել մեկ գործարկվող file (օրինակ՝ .exe file Windows-ում) կամ հավելված (օրինակ՝ .app՝ macOS-ում, և .apk կամ .aab՝ Android-ում), որը հեշտ է տրամադրել հաճախորդներին։ Նկար 2-1-ում սա այնպիսի պատկեր է, ասես ամենաաջ երկու պղպջակները՝ bytecode-ը և PVM-ը, միավորվել են մեկ բաղադրիչի՝ ինքնուրույն գործարկվող bundle-ի մեջ։

Այսօր տարբեր համակարգեր կարող են ստեղծել ինքնուրույն գործարկվող file-եր և տարբերվում են աջակցվող հարթակներով ու հնարավորություններով։ Օրինակ՝ py2exe-ն նման file-եր է հավաքում Windows-ի համար, PyInstaller-ն ու cx_freeze-ը՝ Windows-ի, macOS-ի և Linux-ի համար, py2app-ը՝ macOS-ի համար, իսկ Buildozer-ն ու Briefcase-ը հավելվածներ են ստեղծում Android-ի և iOS-ի համար։

Սառեցված բինար file-երը նույնը չեն, ինչ իսկական compiler-ի արդյունքը․ դրանք bytecode-ը կատարում են վիրտուալ մեքենայի միջոցով։ Հետևաբար, բացի մեկնարկի հնարավոր արագացումից, սառեցված բինար file-երը գործում են սկզբնական file-երի նույն արագությամբ։ Դրանք նաև ընդհանուր առմամբ փոքր չեն (պարունակում են PVM), բայց ներկայիս չափանիշներով արտասովոր մեծ էլ չեն։ Սակայն քանի որ Python-ը embedded է սառեցված bundle-ում, ձեր program-ը կատարելու համար ընդունող կողմում այն տեղադրելու կարիք չկա։

Սկզբնաղբյուրի PDF էջ 84

Ավելին՝ քանի որ ձեր bytecode-ը embedded է bundle-ում, այն այնքան էլ հեշտ չէ դիտել։

Ավելի մանրամասն տե՛ս այս գրքի Հավելված A-ում ինքնուրույն գործարկվող file-երի լրացուցիչ քննարկումը, որը ներառում է խորհուրդներ՝ նույն codebase-ից դրանք տարբեր հարթակների համար հավաքելու վերաբերյալ։

Վերջապես, նկատեք, որ այստեղ ուրվագծված կատարման մոդելն իրականում Python-ի ներկա implementation-ի արդյունք է, ոչ թե բուն լեզվի հատկությունը։ Օրինակ՝ հնարավոր է, որ այս գրքի արդիականության ընթացքում հայտնվի AOT compiler, որը Python-ի անսահմանափակ և առանց հավելումների source code-ը կթարգմանի machine code-ի (թեև ավելի քան երեք տասնամյակում դրա չհայտնվելու փաստը դա քիչ հավանական է դարձնում), իսկ JIT compiler-ները կարծես ամենուր են առաջանում։

Ամեն դեպքում bytecode-ի մոդելը, հավանաբար, դեռ որոշ ժամանակ ստանդարտ կմնա։ bytecode-ի տեղափոխելիությունն ու ճկունությունը Python-ի բազմաթիվ համակարգերի կարևոր հատկություններն են։ Ավելին՝ ստատիկ compilation-ին աջակցելու համար type սահմանափակումների հայտարարություններ ավելացնելը կխախտեր Python-ով code գրելու ճկունության, հակիրճության, պարզության և ոգու մեծ մասը, որը շուտով կուսումնասիրենք։ Python-ի type-երի

Սկզբնաղբյուրի PDF էջ 85

հուշումները, որոնք նույնպես կքննարկվեն ավելի ուշ, մոտ են դրան, բայց, բարեբախտաբար, այսօր դեռ չեն օգտագործվում հենց Python-ի կողմից։

ՆՇՈՒՄ
JIT-ի ապագայի մասին․ թեև CPython-ն այժմ հետևում է Նկար 2-1-ի bytecode/PVM մոդելին, ապագայում կարող է այն ընդլայնել։ 3.13 տարբերակը, որն այս տողերը գրելիս դեռ մշակվում է, կավելացնի փորձարարական JIT compiler։ Ինչպես PyPy-ում և այլ համակարգերում, այն ձեր program-ի աշխատանքի ընթացքում bytecode-ի մի մասն ամբողջությամբ կթարգմանի machine code-ի։ 3.13-ում դրա արագության աճը կլինի աննշան, և լռելյայն այն անջատված կլինի։ Թեև հրատարակչական գործում կանխատեսումները վտանգավոր են, ապագայում JIT compiler-ը կարող է լռելյայն միացվել CPython-ում, եթե երբևէ Python program-երի համար զգալի զուտ օգուտ տա։

Սկզբնաղբյուրի PDF էջ 86

Այս գլուխը ներկայացրեց Python-ի կատարման մոդելը՝ ինչպես է Python-ը կատարում ձեր program-երը, և ուսումնասիրեց այդ մոդելի մի քանի տարածված տարբերակներ, որոնք նախատեսված են թե՛ տարբեր դերերի, թե՛ ավելի բարձր արտադրողականության համար։ Թեև Python script-ներ գրելու համար իրականում կարիք չկա խորամուխ լինելու Python-ի ներքին կառուցվածքին, այս գլխի թեմաներին թեկուզ մակերեսային ծանոթությունը կօգնի իսկապես հասկանալ, թե ինչպես են կատարվում ձեր program-երը, երբ սկսեք դրանք գրել, ինչպես կանեք հաջորդ գլխում։ Բայց նախ ահա գլխի սովորական հարցաշարը՝ մինչ այժմ սովորածը վերանայելու համար։

Սկզբնաղբյուրի PDF էջ 87

1. Python-ի interpreter-ը program է, որը կատարում է ձեր գրած Python program-երը։ Այն ըստ էության միջնորդում է ձեր Python instruction-ների և CPU-ի machine code-ում հասանելի instruction-ների միջև։

2. source code-ն այն statement-ներն են, որոնք գրում եք ձեր program-ի համար։ Այն տեքստ է՝ text file-երում, որոնց name-ները սովորաբար ավարտվում են .py ընդլայնմամբ։

3. bytecode-ը ձեր program-ի ավելի ցածր մակարդակի ձևն է՝ Python-ի կողմից այն կոմպիլացնելուց հետո։ Հնարավորության դեպքում Python-ը bytecode-ն ինքնաշխատ պահում է .pyc ընդլայնմամբ file-երում և անհրաժեշտության դեպքում ինքնաշխատ վերստեղծում է այն։

4. PVM-ը Python virtual machine-ն է՝ Python-ի կատարման շարժիչը, որը մեկնաբանում է ձեր compiled bytecode-ը։

5. machine code-ը համակարգչի կամ հեռախոսի նման հաշվարկային սարքի հիմքում ընկած CPU-ի ցածր մակարդակի instruction-ներն են։ Քանի որ յուրաքանչյուր program ի վերջո հենց սա է կատարում, Python code-ը պետք է այս ձևի թարգմանվի ծրագրային շերտի միջոցով, օրինակ՝ PVM interpreter-ով կամ JIT ու AOT compiler-ներով։

6. Numba-ն, Shed Skin-ը և ինքնուրույն գործարկվող file-երը բոլորը կատարման մոդելի տարբերակներ են։ Բացի այդ՝ հաջորդ երկու պատասխաններում նշված Python-ի այլընտրանքային implementation-ները նույնպես այս կամ այն կերպ փոփոխում են մոդելը՝

Սկզբնաղբյուրի PDF էջ 88

փոխարինելով bytecode-ն ու virtual machine-ները կամ ավելացնելով JIT և AOT compiler-ներ։

7. CPython-ը լեզվի ստանդարտ և reference implementation-ն է։ Jython-ն ու IronPython-ը մշակում են Python program-երը՝ համապատասխանաբար Java և .NET միջավայրերում օգտագործելու համար․ դրանք Python-ի այլընտրանքային compiler-ներ են։

8. PyPy-ն ու Shed Skin-ը Python-ի վերաիրականացումներ են՝ ուղղված արագությանը։ PyPy-ն արագացնում է սովորական Python program-երը՝ օգտագործելով runtime type-երի մասին տեղեկությունն ու JIT compiler՝ program-ի աշխատանքի ընթացքում Python-ի bytecode-ի մի մասը machine code-ով փոխարինելու համար։ Shed Skin-ը program-երն արագացնում է AOT compiler-ով, որը Python-ի սահմանափակ subset-ը թարգմանում է C++-ի, որից այն կարող է ամբողջությամբ կոմպիլացվել machine code-ի՝ որպես program գործարկվելու կամ այլ program-երում օգտագործվելու համար։ Cython-ը Python/C համադրություն է, որը կարելի է կոմպիլացնել machine code-ով ընդլայնումների՝ հասանելի CPython code-ից։

3․ Ինչպես ենք մենք գործարկում program-երը

Python · source code · compilation · դեպի bytecode · interpreter-ի · կատարում · program-ի · արդյունք · Python-ը և CPython իրականացումը տարբեր հասկացություններ են։Pythonsource codecompilationդեպի bytecodeinterpreter-իկատարումprogram-իարդյունքPython-ը և CPython իրականացումը տարբեր հասկացություններ են։

Սկզբնաղբյուրի PDF էջ 89

Լավ, ժամանակն է սկսել code գործարկել։ Այժմ, երբ արդեն պատկերացում ունեք Python-ի նպատակի և կատարման մոդելի մասին, վերջապես պատրաստ եք սկսել իսկական Python programming։

Python-ին ձեր մուտքագրած code-ը կատարել հանձնարարելու մի քանի եղանակ կա, և այս գլուխն ընդգրկում է այսօր լայնորեն օգտագործվող program-երի գործարկման բոլոր հիմնական method-ները։ Ընթացքում կսովորեք թե՛ code-ն ինտերակտիվ ձևով կատարել, թե՛ այն պահել file-երում՝ տարբեր եղանակներով գործարկելու համար՝ command line-երով, պատկերակների սեղմումներով, IDLE graphical interface-ով, բջջային հավելվածներով, վեբ interface-ներով, module-ների ներմուծմամբ և այլ կերպ։

Ինչպես նախորդ գլխի դեպքում, եթե արդեն ունեք programming-ի փորձ և անհամբեր ուզում եք սկսել բուն Python-ի ուսումնասիրությունը, կարող եք արագ աչքի անցկացնել այս գլուխը և անցնել Գլուխ 4-ին։ Բայց բաց մի՛ թողեք այս գլխի սկզբի նախապատրաստական տեղեկություններն ու պայմանավորվածությունները, debugging-ի method-ների ակնարկը և module-ների ներմուծման առաջին ներկայացումը․ սա էական թեմա է Python program-երի ճարտարապետությունը հասկանալու համար, և մենք դրան չենք վերադառնա մինչև Մաս V։ Արժե նաև աչքի անցկացնել IDE-ների և հավելվածների բաժինները՝ ծանոթանալու գործիքներին, որոնք կարող են ավելի օգտակար դառնալ, երբ սկսեք մեծ program-եր գրել։

Սկզբնաղբյուրի PDF էջ 90

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

Եթե Python չունեք և ցանկանում եք այն տեղադրել, հիմա տե՛ս Հավելված A-ն՝ յուրաքանչյուր հարթակի համար տեղադրման օգնությամբ։ Համառոտ՝

Windows-ի և macOS-ի օգտատերերը ստանում ու գործարկում են ինքնատեղադրվող գործարկվող file, որը Python-ը տեղադրում է նրանց սարքերում։ Պարզապես կրկնակի սեղմեք և բոլոր հարցումներին պատասխանեք Yes կամ Next։
Linux-ի (ներառյալ Windows WSL-ի) օգտատերերի computer-ներում կարող է նախապես տեղադրված լինել օգտագործելի Python, բայց անհրաժեշտության կամ ցանկության դեպքում այն կարող են տեղադրել իրենց բաշխման պահոցներից։
Android-ի և iOS-ի օգտատերերը տեղադրում են հավելված, որը թույլ է տալիս Python-ը տեղային գործարկել իրենց հեռախոսներում ու պլանշետներում։
Unix-ի (և Linux-ի որոշ) օգտատերերը Python-ը հաճախ կոմպիլացնում են դրա ամբողջական source code-ի բաշխման package-ից։

Օրինակ՝ սմարթֆոնների օգտատերերը Python հավելված են ստանում հավելվածների խանութից, իսկ Windows և macOS computer-ների օգտատերերը տեղադրիչ են ստանում

Սկզբնաղբյուրի PDF էջ 91

Python-ի գլխավոր կայքի ներբեռնումների էջից։ Python-ը կարելի է ձեռք բերել նաև տարածման այլ ուղիներով, իսկ Python-ով code գրելու որոշ ռեժիմներ, որոնք քննարկվում են ստորև, օրինակ՝ Jupyter նոթատետրերը, ունեն տեղադրման ու օգտագործման իրենց հատուկ քայլերը։ Որոշ պայմաններում գուցե չկարողանաք ընտրել Python-ի տարբերակը, բայց այս գիրքն օգտագործում է Python 3.12, ուստի որքան դրան մոտ լինի, այնքան լավ։

Տեղադրելուց առաջ սովորաբար պետք է ստուգել՝ արդյոք Python-ն արդեն առկա չէ։ Windows-ում այն փնտրեք Start ընտրացանկում, իսկ հարթակների մեծ մասում՝ գործարկելով Python command line-ը, ինչպես նկարագրվում է և՛ Հավելված A-ում, և՛ այս գլխի հաջորդ բաժնում։ Տեսնելու համար, թե ինչպես, տեղադրումը համարենք կատարված և անցնենք Python code-ը գործարկելու բազմաթիվ եղանակների ուսումնասիրությանը։

Այս բաժնով սկսում ենք Python-ով ինտերակտիվ code գրելու հիմունքներից։ Քանի որ սա code գործարկելուն մեր առաջին անդրադարձն է, այստեղ նաև քննարկում ենք մեկնարկային կազմակերպչական որոշ հարցեր, օրինակ՝ working directory-ի ստեղծումը, ուստի եթե programming-ի մեջ համեմատաբար նորեկ եք, անպայման նախ կարդացեք այս բաժինը։ Այստեղ նաև բացատրվում են գրքի ամբողջ ընթացքում կիրառվող որոշ պայմանավորվածություններ, ուստի ընթերցողների մեծ մասը հավանաբար պետք է գոնե արագ աչքի անցկացնի այն։

Սկզբնաղբյուրի PDF էջ 92

Չափանիշների մեծ մասով Python code գործարկելու ամենապարզ եղանակը այն Python-ի ինտերակտիվ command line-ում մուտքագրելն է, որը երբեմն կոչվում է interactive prompt և հաճախ ավելի հակիրճ՝ REPL (read–eval–print loop՝ կարդալու–հաշվելու–արտածելու loop)։

Այս command line-ը գործարկելու տարբեր եղանակներ կան՝ code գրելու գրաֆիկական միջավայրում կամ հավելվածում, վեբ նոթատետրում, system console-ից և այլն։ Եթե ենթադրենք, որ Python-ը ձեր սարքում տեղադրված է տեղային՝ որպես գործարկվող program, ապա ինտերակտիվ interpreter-ի նիստ սկսելու՝ հարթակից ամենաքիչ կախված եղանակը ձեր սարքի վահանակի հրավերի մոտ պարզապես Python հրաման մուտքագրելն է՝ առանց argument-ների։ Քանի որ սա ամենատարածված, գրեթե համընդհանուր և, կարելի է ասել, ամենապարզ եղանակն է, սկսենք այստեղից։

Չնայած այս մոտեցման ընդհանրականությանը՝ թե՛ Python-ի մուտքագրվող հրամանը, թե՛ այն մուտքագրելու տեղը տարբեր են ըստ հարթակի։ Օրինակ՝ Windows-ում, macOS-ում և Android-ում համապատասխանաբար py, python3 և python հրամանները գործը կատարում են հետևյալ կերպ․

Գրքի code · PDF էջ 92

  $ py
  Python 3.12.3 (…etc…, Apr  9 2024, 14:05:25) [MSC
  Type "help", "copyright", "credits" or "license"

Սկզբնաղբյուրի PDF էջ 93

Գրքի code · PDF էջ 93

  >>> ^Z

Գրքի code · PDF էջ 93

  $ python3
  Python 3.12.2 (…etc…, Feb  6 2024, 17:02:06) [Cla
  Type "help", "copyright", "credits" or "license"
  >>> ^D

Գրքի code · PDF էջ 93

  $ python
  Python 3.11.4 (…etc…, Jul  2 2023, 11:17:00) [Cla
  Type "help", "copyright", "credits" or "license"
  >>> ^D

python3-ը գործում է նաև Android-ում և Linux-ում, եթե ցանկանում եք տարբերությունները հասցնել մեկ exception-ի՝ Windows-ի py-ին։ Այս գիրքը հարթակներից անկախ օրինակներում օգտագործում է python3 պարզապես այն պատճառով, որ այն աշխատում է գրեթե ամենուր։ Եթե աշխատում եք Windows-ում, փոխարենը օգտագործեք py (կամ py -3՝ Python 3.X-ի օգտագործումն ապահովելու համար)․ python3-ը գործում է նաև Windows-ում, բայց այսօր նախատեսված է Store-ից ավելի սահմանափակ տեղադրման համար, ինչպես նշվում է Հավելված A-ում։ Նույն հավելվածի համաձայն՝ այս բոլոր հրամանները պետք է լինեն ձեր համակարգի որոնման ուղու վրա (որը սովորաբար հայտնի է որպես PATH), իսկ հակառակ դեպքում անհրաժեշտ է ամբողջական ուղի, բայց տեղադրումների մեծ մասն այս կարգավորումն ինքնաշխատ է կատարում։

Համակարգի հրավերի մոտ այսպես Python հրաման մուտքագրելը սկսում է Python-ի ինտերակտիվ նիստ (այսինքն՝ REPL)։ $

Սկզբնաղբյուրի PDF էջ 94

character-ը, որն այստեղ ցուցադրությունների սկզբում է, ամբողջ գրքում նշանակում է ընդհանուր համակարգային հրավեր բոլոր հարթակների համար․ ձեր սարքում այն հավանաբար տարբեր կլինի, և դա մուտքագրման մաս չէ, որը պետք է ինքներդ գրեք։ Windows-ում ցուցադրվածի պես Ctrl+Z ստեղների համակցությունը (որին հաջորդում է Enter-ը) ավարտում է այս նիստը․ Unix-ում (որը ներառում է macOS-ը, Linux-ը և Android-ը) դրա փոխարեն օգտագործվում է Ctrl+D։

Կնկատեք, որ interactive prompt-ը բացվում է հաղորդագրությամբ, որը նշում է օգտագործվող Python-ը (օրինակ՝ «3.12.3»-ը Python 3.12-ն է) և այն հարթակը, որտեղ այն աշխատում է (օրինակ՝ «win32»՝ Windows-ի, «darwin»՝ macOS-ի և «linux»՝ թե՛ Linux-ի, թե՛ Android-ի համար Python 3.12-ում), որին հաջորդում է լրացուցիչ տեղեկություն ստանալու հուշումներով line։ Այս գրքում սկզբնական այդ line-երը բաց կթողնենք, բացառությամբ այն դեպքերի, երբ դրանք օգտակար են։

Համակարգային հրավերի (որը նաև կոչվում է shell կամ վահանակ) գաղափարը, որտեղ մուտքագրում եք Python հրամանը, ընդհանուր է, բայց դրան հասնելու ճշգրիտ եղանակը կախված է հարթակից։ Դա կարող է լինել Command Prompt-ը կամ PowerShell-ը Windows-ում, Terminal-ը՝ macOS-ում և Linux-ում, Termux հավելվածը՝ Android-ում, կամ հատուկ terminal-ի էկրան՝ Pydroid 3-ի նման որոշ հավելվածներում։

Հարթակների մեծ մասում կարող եք նաև ինտերակտիվ նիստ սկսել այնպիսի եղանակներով, որոնք ընդհանրապես հրաման մուտքագրել չեն պահանջում, բայց դրանք է՛լ ավելի բազմազան են։ Օրինակ՝ Windows-ում Start ընտրացանկի

Սկզբնաղբյուրի PDF էջ 95

մի ընտրանք բացում է նման REPL, ինչպես նաև IDLE graphical interface-ը՝ բոլոր անհատական computer-ներում, Android-ի և iOS-ի հավելվածների հատուկ էկրանները և վեբ զննարկիչների որոշ interface-ներ։ Այս տարբերակներից մի քանիսը կքննարկենք ստորև, բայց հարթակների վերաբերյալ լրացուցիչ խորհուրդների համար տե՛ս Հավելված A-ն, իսկ այլ տարբերակների մասին լրացուցիչ օգնության համար՝ համացանցը։

Սակայն որտեղ էլ տեսնեք >>> հրավերը, դուք Python-ի ինտերակտիվ նիստում և REPL-ում եք․ այստեղ կարող եք մուտքագրել Python-ի ցանկացած statement կամ expression և այն անմիջապես կատարել՝ պարզապես սեղմելով Enter ստեղնը (կամ համանման կոճակ)։ Քիչ անց այդպես էլ կանենք, բայց նախ պետք է լուծենք մի քանի կազմակերպչական մանրուք՝ համոզվելու համար, որ բոլոր ընթերցողները պատրաստ են սկսելու։

Այժմ, երբ սկսում եք սովորել, թե ինչպես գործարկել code-ը, պետք է նաև իմանաք՝ որտեղ այն գործարկել։ code-ը կարող եք պահել և գործարկել ամենուր, որտեղ կարող եք file-եր ստեղծել, բայց այս գիրքն իր օրինակներն օգտագործելու համար ունի երկու խորհուրդ՝ հատկապես սկսնակների համար․

Աշխատեք code-ի համար առանձնացված directory-ում

Այլ բովանդակություն չվերագրելու համար այս գրքի օրինակները գործարկեք ձեր սարքում code-ի համար առանձնացված directory-ից (այլ կերպ՝ directory-ից)։ Օրինակ՝ այս գրքում ամբողջ code-ը գործարկվում է

Սկզբնաղբյուրի PDF էջ 96

յուրաքանչյուր սարքի օգտահաշվի (կամ «տնային») directory-ի ներսում գտնվող directory-ում։ Ձեր code-ի directory-ն կարող է գտնվել ձեր ուզած տեղում և կոչվել ինչպես ցանկանաք, բայց մեկ directory-ից գործարկելը կօգնի հետևել ձեր աշխատանքին և կհեշտացնի որոշ խնդիրներ։
Աշխատեք ձեր code-ի directory-ի՝ գլուխներին համապատասխան subdirectory-ներում

Անկարգ կուտակումից և file-երի name-ների բախումից խուսափելու համար code-ը նաև դասավորեք ըստ գլուխների subdirectory-ների մեջ՝ ձեր code-ի առանձնացված directory-ի ներսում։ Յուրաքանչյուր գլխի առանձին subdirectory-ները կապահովեն, որ օրինակներում ներմուծումներն աշխատեն առանց առաջադեմ կարգավորումների (որոնց կծանոթանաք ավելի ուշ)։ Ներմուծումների և directory-ների մասին ավելին կա առաջիկա նշումներից մեկում։ Առայժմ հիշեք, որ այս գրքի վահանակային հրամանները ենթադրաբար կգործարկվեն տվյալ գլխի subdirectory-ում՝ համակարգչի code-ի համար առանձնացված directory-ի ներսում։ Հարթակից անկախ լինելու համար directory-ի name-ը սովորաբար բաց կթողնվի, և այն code-ի համար էական չէ։

Եթե օգտագործելու եք այս գրքի օրինակների package-ը, այն արդեն կատարել է նախապատրաստական աշխատանքը ձեր փոխարեն։ Օրինակ՝ օրինակների արխիվը բացելիս ստեղծվում է LP6E անունով code-ի directory, որի Chapter03 subdirectory-ն պարունակում է այս գլխի code-ը։ Եթե այս package-ն օգտագործելու եք code-ը մուտքագրելուց կամ էլեկտրոնային նյութից պատճենելուց խուսափելու համար, պարզապես դրա օրինակները գործարկեք այն գլխի subdirectory-ում, որն ուսումնասիրում եք։ Այստեղ են գործարկվելու REPL-ները և script-ների file-երը։ Ինչպես

Սկզբնաղբյուրի PDF էջ 97

կիմանաք ավելի ուշ, այստեղ կհայտնվեն նաև մեր script-ների ստեղծած տվյալների file-երը, եթե script-ները չեն օգտագործում directory-ների բացահայտ ուղիներով filename-ներ։

Եթե պատրաստվում եք ինքնուրույն code ստեղծել, ապա առաջ անցնելուց առաջ հավանաբար պետք է ստեղծեք code-ի directory-ների ձեր սեփական նման կառուցվածքը։ Անհատական computer-ներում օգտագործեք համակարգի file-երի դիտարկիչը կամ գործարկեք command line․ mkdir folder-ն աշխատում է Windows-ում և Unix-ում։ Android-ում ևս կարող եք օգտագործել file-երի դիտարկիչ (կամ mkdir՝ Termux-ում), բայց անպայման ընտրեք ձեր Python հավելվածին հասանելի directory։ code գրելու որոշ interface-ներ կարող են առաջարկել directory ստեղծելու այլ եղանակներ․ տեղեկությունների համար նայեք ձեր գործիքի նյութերը։

Երբ գլուխներին համապատասխան ձեր code-ի directory-ները պատրաստ լինեն, այս գրքի օրինակները գրելու, պահելու և գործարկելու համար միշտ սկսեք այնտեղից։ Դա անելու ձևը կախված է օգտագործման ռեժիմից։ Վահանակներում հարթակների միջև տեղափոխելի cd folder հրամանը փոխում է directory-ն։ IDLE-ի նման graphical interface-ում file-ը բացելն ու գործարկելը կարող է տեղափոխել դրա directory-ն։ Իսկ այլ interface-ներում գուցե REPL գործարկեք interface-ում բացված file-ի համար կամ օգտագործեք այլ մոտեցումներ, որոնք չափազանց բազմազան են այստեղ ընդգրկելու համար։ Որպես պահուստային տարբերակ՝ Python-ի os.getcwd()-ը, որին քիչ անց կծանոթանաք, ցույց է տալիս ընթացիկ directory-ն, իսկ os.chdir('path')-ը փոխում է այն՝ պայմանով, որ նախ կատարել եք import os։

Սկզբնաղբյուրի PDF էջ 98

Հրամանների մասին խոսելիս հիշեք, որ պետք չէ մուտքագրել $ character-ը, որն այս գրքի command line-երի սկզբում օգտագործվում է system console-ի հրավերը նշելու համար․ մուտքագրեք միայն այդ հրավերներին հաջորդող տեքստը։ Փորձառու programmer-ներին սա գուցե պարզ թվա, բայց սկսնակների առաջին սխալներից շատ տարածված մեկն է, իսկ այստեղ մենք ոչ ոքի չենք բացառում։

Նմանապես, մի՛ մուտքագրեք >>> և ... հրավերի character-երը, որոնք interpreter-ի հետ աշխատանքի ցուցադրություններում երևում են line-երի սկզբում և այս գրքում նշանակում են REPL-ում կատարվող code․ մուտքագրեք միայն այդ հրավերներին հաջորդող տեքստը։ Սրանք հրավերներ են, որոնք Python-ի ստանդարտ REPL-ն ինքնաշխատ ցուցադրում է որպես ինտերակտիվ code մուտքագրելու տեսողական ուղեցույց, և դրանք ձեր interface-ում կարող են երևալ կամ չերևալ։ Օրինակ՝ ... հրավերն օգտագործվում է որոշ REPL-ների շարունակության line-երում, բայց IDLE-ում պարզապես պիտակ է և այս գրքի որոշ ցուցադրություններից բաց է թողնված՝ պատճենելն ու տեղադրելը հեշտացնելու համար․ ամեն դեպքում այն ինքներդ մի՛ մուտքագրեք։

Սա հիշելն օգնելու համար այս գրքում ձեր մուտքագրելիք տվյալները ցուցադրվում են թավատառ, իսկ հրավերները՝ ոչ։ Նաև հիշեք, որ այս համակարգային և Python հրավերներից հետո մուտքագրված հրամանները նախատեսված են անմիջապես կատարելու համար և սովորաբար

Սկզբնաղբյուրի PDF էջ 99

նախատեսված չեն պահվելու այն սկզբնական file-երում, որոնք ստեղծելու ենք․ ստորև կտեսնեք, թե ինչու է այս տարբերությունը կարևոր։

Նույն կերպ՝ այս գրքի code-ի ցուցադրություններում սովորաբար կարիք չկա մուտքագրել # character-ով սկսվող տեքստը․ ինչպես կիմանաք ավելի ուշ, դրանք comment-ներ են, այլ ոչ թե կատարվող code։ Բացառությամբ այն դեպքի, երբ # character-ը script-ի վերևում սկսում է #! directive, կարող եք հանգիստ բաց թողնել այն և դրան հաջորդող line-ի ամբողջ մնացած մասը (#!-ի մասին ավելին կա Հավելված A-ում)։

Այս ամենն ասելուց հետո պետք է նաև իմանաք, որ Python REPL-ներ կարելի է ստանալ նաև այնպիսի համակարգերում, որոնք փոփոխում ու բարդացնում են այս գլխում նկարագրված ավանդական մոդելը։ Օրինակ՝ IPython-ը տրամադրում է այլընտրանքային, առանձին տեղադրվող և ընդլայնված Python ինտերակտիվ նիստ, որը հրամանները նշում է համարներով և չի օգտագործում >>> հրավերներ։ Jupyter նոթատետրերը նույնպես տրամադրում են IPython REPL-ը և այն գործարկում system console-ի փոխարեն վեբ զննարկիչում (այս գլխում ավելի ուշ կուսումնասիրենք Jupyter-ը)։

Պատկերն ավելի խճճելու համար՝ Գլուխ 2-ի PyPy համակարգն իր REPL-ի հրավերների համար օգտագործում է >>>>՝ այն CPython-ի երեք character-ով >>>-ից տարբերելու համար (թեև տարբերությունն իմանալու համար գուցե հարկ լինի ուշադիր նայել)․ ստորև քննարկվող IDLE graphical interface-ը >>>-ը ցուցադրում է կողքի մասում (և ոչ թե

Սկզբնաղբյուրի PDF էջ 100

system console-ում)․ սմարթֆոնների հավելվածները նույնպես կարող են տարբերվել (տե՛ս Հավելված A-ն)․ իսկ interactive prompt-ը տեխնիկապես կարելի է փոխել ցանկացած բանի (ձեր code-ում այն sys.ps1-ն է և, Python-ի փաստաթղթերի համաձայն, կարող է սահմանվել մեկնարկային file-ում)։

Այս ամենը նշանակում է, որ ձեր Python ինտերակտիվ նիստը կարող է տարբերվել հիմնական մոդելից, որն այս գլուխը հաճախ կիրառում է։ Կախված ձեր գործիքներից և նպատակներից՝ կարող եք տեսնել այլ հրավեր կամ ընդհանրապես հրավեր չտեսնել, իսկ Python-ի ինտերակտիվ code-ը կարող եք մուտքագրել system console-ի փոխարեն վեբ զննարկիչում, graphical interface-ում կամ հավելվածում։

Ընդհանուր առմամբ, սակայն, այս գիրքը խորհուրդ է տալիս, երբ նոր եք սկսում, օգտագործել այն ավանդական ու ավելի պարզ տարբերակները, որոնք այն ցուցադրում և քննարկում է։ Օրինակ՝ IPython-ն ու Jupyter-ն ունեն սովորելու իրենց առանձին ընթացքը, իսկ Jupyter-ն ուղղված է գիտական աշխատանքին, որը Python-ի բազմաթիվ դերերից ընդամենը մեկն է։ Եթե և երբ ընտրեք նման այլընտրանքային code գրելու interface-ներ կամ ապագայում անպայման առաջացող ուրիշները, անհրաժեշտության դեպքում սովորածը հարմարեցրեք դրանց REPL-ների փոքր տարբերություններին։

Սկզբնաղբյուրի PDF էջ 101

ՆՇՈՒՄ
REPL-ի ապագան. նախատեսվում է, որ ստանդարտ CPython-ը կբարելավի իր interactive environment-ի՝ REPL-ի interface-ը 3.13 տարբերակում, որը գիրքը գրելու պահին դեռ չէր թողարկվել։ Ըստ program-երի՝ REPL-ը կստանա գունավոր հուշումներ, ավտոմատ նահանջներ, մի քանի line-ի խմբագրում և տեղադրում, ինչպես նաև այլ user interface-ներից ու IDE-ներից փոխառված՝ գույներով առանձնացված exception-ներ։ Իհարկե, այս գրքի տպագիր տարբերակում գույները դեր չեն ունենա, և ապագան դեռ գրված չէ, բայց այս նշումը կարդալու պահին ավելի գունավոր ապագան գուցե արդեն հասած լինի։

Հուշում. եթե այդ ապագան շեղում է ձեր ուշադրությունը, միջավայրի PYTHON_COLORS variable-ին 0 արժեք տալով՝ կարող եք անջատել REPL-ի նոր գույները։

Այս նախնական հարցերը պարզելուց հետո անցնենք իրական code-ի մուտքագրմանը։ Ինչ եղանակով էլ այն մեկնարկի, Python-ի ինտերակտիվ սեանսը նախ արտածում է որոշ տեղեկություններ, որոնք այսուհետ կրկին հիմնականում բաց կթողնենք, ապա, երբ սպասում է, որ մուտքագրեք Python-ի նոր statement կամ expression, ցուցադրում է >>> հուշումը կամ նման մի բան։

Ինտերակտիվ աշխատելիս ձեր code-ի արդյունքները հայտնվում են >>> մուտքագրման line-երի տակ՝ Enter ստեղնը կամ դրա համարժեքը սեղմելուց հետո։ Օրինակ՝ ահա Python-ի երկու print statement-ների արդյունքները։

Սկզբնաղբյուրի PDF էջ 102

Գրքի code · PDF էջ 102

  $ python3
  >>> print('Hello world!')
  Hello world!
  >>> print(2 ** 8)
  256

Ահա և վերջ. հենց նոր մենք գործարկեցինք Python-ի որոշ code։ Այն քիչ էր, բայց ցույց տվեց անհրաժեշտը։ Առայժմ դեռ բաց ենք թողնում code-ի մանրամասների մեծ մասը, սակայն հակիրճ ասած՝ print-ը built-in գործիք է, որն իրեն փոխանցված ամեն ինչ ներկայացնող մի line է ուղարկում այնտեղ, որտեղ աշխատում եք։ Քանի որ Python-ում այն function call է, այս code-ի փակագծերը պարտադիր են։ Այստեղ այն օգտագործեցինք Python-ի string և ամբողջ թիվ ցուցադրելու համար, ինչպես երևում է յուրաքանչյուր >>> input line-ից հետո հայտնվող output line-երից։

Այսպես ինտերակտիվ code գրելիս կարող եք մուտքագրել Python-ի այնքան հրաման, որքան ցանկանում եք. դրանցից յուրաքանչյուրը կատարվում է մուտքագրելուց անմիջապես հետո։ Ավելին, քանի որ ինտերակտիվ սեանսն ինքնաբերաբար արտածում է ձեր մուտքագրած expression-ների արդյունքները, այս հուշման մոտ սովորաբար կարիք չկա բացահայտ նշելու «print»։ Ստորև բերված ավտոմատ ցուցադրումների ձևաչափը կարող է փոքր-ինչ տարբերվել print-ի ձևաչափից, սակայն առայժմ կարևոր չէ իմանալ՝ ինչով։

Սկզբնաղբյուրի PDF էջ 103

Գրքի code · PDF էջ 103

  >>> language = 'Python'
  >>> language
  'Python'
  >>> 2 ** 8
  256
  >>> ^Z                     # Use Ctrl-D (on Unix)
  $

Մեկնաբանություն, տող 6․ Օգտագործեք Ctrl-D (Unix-ում)

Այստեղ առաջին line-ը պահում է մի value՝ այն վերագրելով variable-ի՝ language-ին, որը ստեղծվում է = assignment-ի միջոցով։ Իսկ վերջին երկու մուտքագրված line-երն expression-ներ են՝ language և 2 ** 8, որոնց արդյունքները ցուցադրվում են ինքնաբերաբար։ Կրկնենք՝ այսպիսի ինտերակտիվ սեանսից դուրս գալու և համակարգի հրամանի հուշմանը վերադառնալու համար Unix-ի նման համակարգերում մուտքագրեք Ctrl+D, իսկ Windows-ում՝ Ctrl+Z։ Ավելի ուշ քննարկվող IDLE գրաֆիկական միջավայրում բոլոր համակարգերում կամ մուտքագրեք Ctrl+D, կամ պարզապես փակեք պատուհանը։

Ուշադրություն դարձրեք այս list-ի աջ կողմի շեղատառ նշմանը, որն այստեղ սկսվում է #-ով։ Գիրքն ամենուր օգտագործում է այսպիսի նշումներ՝ ներկայացվողի վերաբերյալ դիտարկումներ ավելացնելու համար, բայց դուք ինքներդ այդ տեքստը մուտքագրելու կարիք չունեք։ Եթե մուտքագրեք էլ, Python-ն այն կանտեսի որպես comment։ Իրականում, համակարգային $ և Python-ի >>> հուշումների պես, սա նույնպես չպետք է մուտքագրեք, երբ այն համակարգային

Սկզբնաղբյուրի PDF էջ 104

command line-ում է. #… հատվածը Python-ն անտեսում է, բայց համակարգային shell-ներում այն կարող է սխալ առաջացնել։

Այս սեանսի code-ում շատ բան չարեցինք. պարզապես մուտքագրեցինք Python-ի մի քանի print և assignment-ի statement, ինչպես նաև մի քանի expression, որոնք բոլորը հետագայում մանրամասն կուսումնասիրենք։ Հիմնականը, որին պետք է ուշադրություն դարձնել, այն է, որ Python-ի REPL-ը յուրաքանչյուր line-ում մուտքագրված code-ը կատարում է անմիջապես, երբ սեղմվում է Enter ստեղնը կամ դրա համարժեքը։

Օրինակ՝ երբ >>> հուշման մոտ մուտքագրեցինք առաջին print statement-ը, ելքը՝ Python-ի մի string, անմիջապես ցուցադրվեց։ Կարիք չկար source code-ի file ստեղծելու կամ նախ code-ն անցկացնելու compiler-ի և linker-ի միջով, ինչպես սովորաբար կանեիք C-ի կամ C++-ի նման լեզու օգտագործելիս։ Խիստ ասած՝ CPython-ում ինտերակտիվ code-ը memory-ի մեջ կոմպիլացվում է bytecode-ի և կատարվում PVM-ի կողմից (տե՛ս գլուխ 2), բայց այդ մասին անհանգստանալու կարիք չունեք։

Ինչպես կտեսնեք հետագա գլուխներում, interactive prompt-ի մոտ կարող եք գործարկել նաև բազմատող statement-ներ, օրինակ՝ for loop-եր։ Ինչպես արդեն նշվել է, նման statement-ը շարունակության line-երի համար կարող է ցուցադրել ... հուշումը և կատարվում է անմիջապես այն բանից հետո, երբ մուտքագրում եք դրա բոլոր line-երը և երկու անգամ սեղմում Enter՝ դատարկ line ավելացնելու համար։ code-ի file-երում դատարկ line-երը պարտադիր չեն և անտեսվում են, բայց դրանք անհրաժեշտ են,

Սկզբնաղբյուրի PDF էջ 105

որպեսզի որոշ REPL-ներ իմանան, որ ձեր statement-ներն ավարտված են։ Նաև հիշեք, որ ներկայիս ստանդարտ REPL-ը միաժամանակ կատարում է ընդամենը մեկ statement. դրա հուշման մոտ code-ի մեծ block-ներ մի՛ տեղադրեք։

interactive prompt-ն աշխատանքի ընթացքում կատարում է code-ը և ցուցադրում արդյունքները, բայց ձեր code-ը չի պահպանում file-ում։ Թեև սա նշանակում է, որ իրական programming-ի աշխատանքի մեծ մասը չեք անի ինտերակտիվ սեանսներում, պարզվում է՝ interactive prompt-ը հիանալի տեղ է և՛ լեզուն սովորելու, և՛ ծրագրային file-երն ընթացքի մեջ փորձարկելու համար։ Ահա այդ դերերի համառոտ նկարագրությունը։

Քանի որ interactive prompt-ն անմիջապես կատարում է code-ը, այն իդեալական է code-ով փորձեր անելու և լեզուն սովորելու համար։ Մենք այն կօգտագործենք ամբողջ գրքում՝ փոքր օրինակներ ցույց տալու և հասկացությունները պարզաբանելու նպատակով։ Իրականում սա առաջին գործնական կանոնն է, որ պետք է հիշել. եթե երբևէ կասկածում եք, թե ինչպես է աշխատում Python-ի code-ի որևէ հատված, բացեք ինտերակտիվ command line-ը և փորձեք այդ code-ը՝ տեսնելու, թե ինչ է տեղի ունենում։

Օրինակ՝ ենթադրենք կարդում եք Python-ի մի program-ի code և հանդիպում 'Hack!' * 8 տեսքի expression-ի, որի

Սկզբնաղբյուրի PDF էջ 106

իմաստը չեք հասկանում։ Այդ պահին կարող եք 10 րոպե տրամադրել ձեռնարկները, գրքերն ու համացանցը քրքրելուն՝ փորձելով պարզել, թե ինչ է անում code-ը, կամ պարզապես կարող եք այն գործարկել ինտերակտիվ եղանակով։

Գրքի code · PDF էջ 106

  $ python3
  >>> 'Hack!' * 8
  'Hack!Hack!Hack!Hack!Hack!Hack!Hack!Hack!'

interactive prompt-ի մոտ ստացվող այս անմիջական արձագանքը հաճախ code-ի որևէ հատվածի գործողությունը հասկանալու ամենաարագ ճանապարհն է։ Այստեղ պարզ է, որ այն կրկնում է string-ը. Python-ում *-ը թվերի համար նշանակում է բազմապատկել, իսկ string-երի համար՝ կրկնել։ Դա նման է string-ն ինքն իրեն բազմիցս կցելուն։ string-երի մասին ավելին՝ գլուխ 4-ում։

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

Սկզբնաղբյուրի PDF էջ 107

Օրինակ՝ տեսեք, թե ինչ է տեղի ունենում, երբ interactive prompt-ի մոտ սխալ եք անում։

Գրքի code · PDF էջ 107

  >>> X
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'X' is not defined

Python-ում variable-ն օգտագործելը, նախքան դրան value վերագրելը, միշտ սխալ է։ Հակառակ դեպքում, եթե name-ները լրացվեին լռելյայն value-ներով, որոշ սխալներ կարող էին աննկատ մնալ, մինչև արդեն շատ ուշ լիներ։ Սա նշանակում է, որ հաշվիչներին որևէ բան գումարելուց առաջ պետք է դրանց սկզբնական value-ն սահմանել զրո, list-ներն ընդլայնելուց առաջ պետք է դրանք սկզբնարժեքավորել որպես դատարկ list-ներ և այդպես շարունակ։ Python-ում variable-ներ հայտարարելու կարիք չկա, բայց դրանց value-ները ստանալուց առաջ պետք է value-ներ վերագրել։

Այսօրվա Python-ի այլ error message-ներ փորձում են ավելի օգտակար լինել «Did you…?» հուշումներով, օրինակ՝ ավելի վաղ հիշատակված sys.ps1 հուշման կարգավորման միջոցը փնտրելիս։ sys-ի նման module-ներն օգտագործելուց առաջ պետք է ներմուծել։ Թեև բավական շուտով այս հիշեցումն այլևս հավանաբար ձեզ պետք չի լինի, իսկ գրքում որոշ error message-ներ հակիրճության համար կկրճատենք։

Սկզբնաղբյուրի PDF էջ 108

Գրքի code · PDF էջ 108

  >>> sys.ps1
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'sys' is not defined. Did you for

Այս ամենի մասին ավելի ուշ ավելին կիմանաք։ Այստեղ կարևորն այն է, որ այս ձևով սխալվելիս ո՛չ Python-ը, ո՛չ ձեր computer-ը չեն խափանվի։ Փոխարենը կստանաք իմաստալից error message, որը ցույց է տալիս սխալը և այն առաջացրած code-ի line-ը, իսկ դուք կարող եք շարունակել սեանսը կամ script-ը։ Իրականում, երբ արդեն վարժվեք Python-ին, դրա error message-ները հաճախ կարող են debugging-ի համար ձեզ անհրաժեշտ ողջ աջակցությունը տալ։ debugging-ի հնարավորությունների մասին ավելին փնտրեք «Python-ի code-ի debugging» ներդիրում։

Լեզուն սովորելիս փորձեր անելու գործիք լինելուց բացի, ինտերակտիվ interpreter-ը նաև իդեալական տեղ է file-երում գրած code-ը փորձարկելու համար։ Կարող եք ինտերակտիվ կերպով ներմուծել ձեր module-ների file-երը և փորձարկել դրանց սահմանած գործիքները՝ տեղում կանչեր մուտքագրելով interactive prompt-ի մոտ։

Սկզբնաղբյուրի PDF էջ 109

Օրինակ՝ ստորև փորձարկվում է Python-ի standard library-ի կազմում մատակարարվող, նախապես գրված մի module-ի function։ Մանրամասն՝ os.getcwd-ն արտածում է այն directory-ի name-ը, որտեղ տվյալ պահին աշխատում եք, այստեղ՝ macOS համակարգչի վրա։ Բայց նույնը կարող եք անել, երբ սկսեք գրել սեփական module-ների file-երը։

Գրքի code · PDF էջ 109

  >>> import os
  >>> os.getcwd()
  '/Users/me/code'

Ավելի ընդհանուր՝ interactive prompt-ը program-ի բաղադրիչները փորձարկելու տեղ է՝ անկախ դրանց ծագումից։ Կարող եք ներմուծել և փորձարկել ձեր Python file-երի function-ներն ու class-երը, մուտքագրել կապակցված C function-ների կանչեր, Jython-ում գործարկել Java class-եր և այլն։ Մասամբ իր ինտերակտիվ բնույթի շնորհիվ Python-ն աջակցում է փորձերի և հետազոտության վրա հիմնված programming-ի ոճին, որը ձեզ հարմար կթվա։ Թեև Python programmer-ները փորձարկում են նաև file-երի ներսում գրված code-ով, և գրքում հետագայում կսովորեք դա հեշտացնելու եղանակներ, շատերի համար interactive prompt-ը դեռ փորձարկման պաշտպանության առաջին գիծն է։

Սկզբնաղբյուրի PDF էջ 110

Թեև interactive prompt-ը հիանալի է փորձեր անելու և փորձարկելու համար, այն մի մեծ թերություն ունի. այնտեղ մուտքագրված program-երն անհետանում են հենց որ Python-ի interpreter-ը կատարում է դրանք։ Քանի որ ինտերակտիվ մուտքագրած code-ը երբեք չի պահվում file-ում, չեք կարող այն կրկին գործարկել՝ առանց զրոյից նորից մուտքագրելու։ Կտրել-տեղադրելը և նախկին հրամանները հետ կանչելը կարող են ինչ-որ չափով օգնել, բայց ոչ այնքան, հատկապես երբ սկսեք ավելի մեծ program-եր գրել։ Ինտերակտիվ սեանսից code-ը կտրելու և տեղադրելու համար պետք է հեռացնեք Python-ի հուշումները, program-ի ելքը և այլն, ինչը փորձելու համար չափազանց տաղտկալի աշխատանք է։

program-երը մշտապես պահպանելու համար պետք է code-ը գրեք file-երում, որոնք սովորաբար կոչվում են module-ներ։ module-ներն ընդամենը Python-ի statement-ներ պարունակող text file-եր են։ Դրանք գրելուց հետո կարող եք Python-ի interpreter-ին խնդրել այդպիսի file-ի statement-ները կատարել կամայական թվով անգամներ և տարբեր եղանակներով՝ համակարգի command line-երից, file-ի պատկերակը սեղմելով, IDLE-ի user interface-ի ընտրանքներով և այլն։ Անկախ գործարկման եղանակից՝ Python-ը module-ի file-ը գործարկելիս ամեն անգամ դրա ամբողջ code-ը կատարում է վերևից ներքև։

Սկզբնաղբյուրի PDF էջ 111

Այս ոլորտում տերմինները կարող են փոխվել ըստ դերի։ Օրինակ՝ Python-ում module-ների file-երը հաճախ անվանում են program-եր, այսինքն՝ program է համարվում կրկնվող կատարման համար file-ում պահված, նախապես գրված statement-ների շարքը։ Անմիջապես գործարկվող module-ների file-երը երբեմն կոչվում են նաև script-ներ՝ ոչ պաշտոնական տերմին, որը սովորաբար նշանակում է վերին մակարդակի ծրագրային file։ Ոմանք module տերմինը վերապահում են այլ file-ից ներմուծվող file-ին, իսկ script-ը՝ program-ի հիմնական file-ին։ Մենք էլ այստեղ հիմնականում այդպես կանենք։ Վերին մակարդակի, ներմուծումների և հիմնական file-երի իմաստի մասին ավելին կիմանաք այս գլխում ավելի ուշ։

Ինչպես էլ դրանք անվանեք, հաջորդ մի քանի բաժիններն ուսումնասիրում են file-երում մուտքագրված code-ը գործարկելու եղանակները։ Այս բաժնում կսովորեք file-երը գործարկել ամենապարզ և ամենադյուրափոխադրելի ձևով՝ դրանց name-ները նշելով ձեր համակարգչի համակարգային հուշման մոտ մուտքագրված Python command line-ում։ Թեև ոմանց սա կարող է պարզունակ թվալ, և ավելի ուշ քննարկվող այլընտրանքների շնորհիվ հաճախ կարելի է դրանից ընդհանրապես խուսափել, շատ programmer-ների համար command line-երի system console-ի պատուհանը՝ text editor-ի պատուհանի հետ միասին, ապահովում է զարգացման այնքան ամբողջական միջավայր, որքան նրանց երբևէ պետք կգա, և ավելի անմիջական վերահսկողություն է տալիս program-երի նկատմամբ։

Սկզբնաղբյուրի PDF էջ 112

Սկսենք։ Բացեք ձեր սիրելի text editor-ը, օրինակ 3-1-ի statement-ները մուտքագրեք կամ պատճենեք-տեղադրեք script1.py անունով նոր text file-ի մեջ և այն պահեք code-ի working directory-ում, որը ստեղծել էիք ավելի վաղ։ Եթե այդ քայլը բաց եք թողել, ստեղծեք այն հիմա։ Ցանկացած editor հարմար է՝ ներառյալ vi-ն, Notepad-ը, սմարթֆոնի որևէ հավելվածի editor-ը և շուտով ներկայացվող IDLE գրաֆիկական միջավայրը։ Այս file-ը կարող եք գտնել նաև գրքի օրինակների package-ում, բայց սկզբնական շրջանում code մուտքագրելը կարևոր վարժություն է։

Օրինակ 3-1. script1.py

Գրքի code · PDF էջ 112

  # A first Python script
  import sys                  # Load a library modu
  print(sys.platform)
  print(2 ** 100)             # Raise 2 to a power
  x = 'Hack!'
  print(x * 8)                # String repetition

Մեկնաբանություն, տող 1․ Առաջին Python script-ը

Մեկնաբանություն, տող 2․ Բեռնել library-ի մոդու…

Մեկնաբանություն, տող 4․ 2-ը բարձրացնել աստիճանի

Մեկնաբանություն, տող 6․ string-ի կրկնում

Այս file-ը Python-ի մեր առաջին պաշտոնական script-ն է՝ չհաշված գլուխ 2-ի երկու տողանոցը։ Առայժմ չպետք է շատ մտահոգվեք այս file-ի բովանդակությամբ, բայց հակիրճ նկարագրենք. դրա code-ը՝

Սկզբնաղբյուրի PDF էջ 113

Ներմուծում է Python-ի module՝ լրացուցիչ գործիքների library, որպեսզի ստանա հարթակի name-ը։
Կատարում է print function-ի երեք կանչ՝ script-ի արդյունքները ցուցադրելու համար։
Օգտագործում է x name-ով variable, որը ստեղծվում է արժեք վերագրելիս՝ string object-ը պահելու համար։
Կիրառում է object-ների տարբեր գործողություններ, որոնք կսկսենք ուսումնասիրել հաջորդ գլխում։

Այստեղ sys.platform-ը պարզապես string է, որը նույնականացնում է այն համակարգչի տեսակը, որի վրա աշխատում եք։ Այն գտնվում է sys անունով Python module-ում՝ standard library-ի մի մասում, որը բեռնելու համար պետք է ներմուծեք։ Ներմուծումների մասին կրկին ավելին կխոսենք հետո։ Նկատեք նաև, թե ինչպես է այս file-ն օգտագործում print-ի բացահայտ կանչեր։ Ի տարբերություն REPL-ի՝ file-երում ելքը երբեք ավտոմատ չէ, ուստի դրանց ելքը տեսնելու համար file-երում պետք է գրեք print։ Սա մոռանալը սկսնակների սովորական սխալ է, բայց գոնե ձեզ զգուշացրինք։

Պատկերը լրացնելու համար այս file-ում ավելացված են Python-ի comment-ներ՝ # character-երին հաջորդող տեքստը։ Դրանք արդեն հիշատակվել են, բայց հիմա, երբ հայտնվում են script-ներում, արժե ավելի հստակ սահմանել։ comment-ները կարող են առանձին line-երում լինել կամ նույն line-ում՝ code-ից աջ։ #-ից հետո եղած տեքստը պարզապես անտեսվում է որպես մարդու համար ընթեռնելի նշում և չի համարվում statement-ի syntax-ի մաս։ Եթե պատճենում եք այս code-ը, կարող եք comment-ները բաց թողնել. դրանք

Սկզբնաղբյուրի PDF էջ 114

միայն տեղեկացնող բնույթ ունեն։ Այս գրքում comment-ները տեսողականորեն ավելի առանձնացնելու համար օգտագործվում է այլ ձևավորում, բայց ձեր code-ում դրանք սովորական տեքստ կլինեն։

Կրկին՝ առայժմ մի՛ կենտրոնացեք այս file-ի code-ի syntax-ի վրա. այդ ամենը կսովորեք հետո։ Գլխավորն այն է, որ այս code-ը մուտքագրել եք file-ի մեջ, այլ ոչ թե interactive prompt-ի մոտ։ Այդ ընթացքում դուք գրել եք Python-ի լիարժեք աշխատող script։

Սակայն նկատեք, որ module-ի filename-ը script1.py է։ Ինչպես վերին մակարդակի բոլոր file-երի, այսինքն՝ անմիջապես գործարկվող file-երի դեպքում, այն կարող էր կոչվել նաև պարզապես script1, բայց այն code-ի file-երը, որոնք ուզում եք ներմուծել այլ file-ի կամ REPL-ի մեջ, պետք է ավարտվեն .py վերջածանցով։ Քանի որ ապագայում գուցե ցանկանաք ներմուծել դրանք, լավ կլինի ձեր գրած Python file-երի մեծ մասի համար օգտագործել .py վերջածանցը։ Բացի այդ, որոշ text editor-ներ ու file-երի դիտարկիչներ Python file-երը ճանաչում են .py վերջածանցով։ Եթե վերջածանցը բացակայում է, գուցե չստանաք editor-ների այնպիսի հնարավորություններ, ինչպիսիք են syntax-ի գունավորումը և ավտոմատ նահանջները, կամ դիտարկիչներում՝ հպումով գործարկումը։

Նախորդ բաժնի text file-ը պահպանելուց հետո կարող եք Python-ին խնդրել գործարկել այն՝ file-ի լրիվ անունը նշելով որպես առաջին argument

Սկզբնաղբյուրի PDF էջ 115

Python-ի հրամանին, ինչպես ստորև՝ Unix սարքի համակարգային shell-ի $ հուշման մոտ մուտքագրված օրինակում։ Սակայն սա մի՛ մուտքագրեք Python REPL-ի հուշման մոտ, իսկ եթե ձեզ մոտ միանգամից չի աշխատում, կարդացեք հաջորդ պարբերությունը։

Գրքի code · PDF էջ 115

  $ python3 script1.py
  darwin
  1267650600228229401496703205376
  Hack!Hack!Hack!Hack!Hack!Hack!Hack!Hack!

Ինչպես ավելի վաղ ուսումնասիրած REPL-ի մեկնարկի դեպքում, հրամանի name-ը կարող է տարբեր լինել։ Օրինակ՝ Windows-ում սովորաբար python3-ի փոխարեն օգտագործեք py։ Նման հրաման կարող եք մուտքագրել command line-ի համար ձեր համակարգի տրամադրած ցանկացած միջավայրում՝ Windows-ի Command Prompt-ում, macOS-ի Terminal-ում կամ Android-ի Termux հավելվածում և այլն։ Այս code-ի file-ը գուցե կարողանաք գործարկել նաև գրաֆիկական միջավայրի, հավելվածի կամ զննարկչային user interface-ի հատուկ գործարկման կոճակով, բայց այս տարբերակները կթողնենք գլխի ավելի ուշ մասի համար։ Հարթակին հատուկ բոլոր հարցերի համար տե՛ս նաև հավելված A-ն։

Անպայման Python-ի հրամանը գործարկեք նույն working directory-ում, որտեղ պահել եք script-ի file-ը։ Անհրաժեշտության դեպքում նախ cd-ով անցեք այդտեղ։ Եվ այն գործարկեք համակարգային հուշման մոտ, ոչ թե Python-ի >>> հուշման։ Բացի այդ, ինչպես REPL-ը մեկնարկելիս, գուցե անհրաժեշտ լինի փոխարինել

Սկզբնաղբյուրի PDF էջ 116

հրամանի առաջին բառը directory-ի ամբողջական ուղիով, եթե Python-ը ներառված չէ ձեր PATH կարգավորման մեջ։ Սակայն տեղադրումների մեծ մասը դա ապահովում է ինքնաբերաբար։ Python-ի տեղադրումների և PATH-ի մասին ավելին՝ հավելված A-ում։

Եթե ամեն ինչ աշխատի ինչպես նախատեսված է, shell-ի այս կամ նման մի հրամանը Python-ին կմղի line by line կատարել այս file-ի code-ը, և կտեսնեք script-ի երեք print statement-ների ելքը՝ հիմքում ընկած հարթակի name-ն այնպես, ինչպես այն հայտնի է Python-ին, 100-րդ աստիճան բարձրացված 2-ը և ավելի վաղ տեսած string-ի կրկնության նույն expression-ի արդյունքը։ Վերջին երկուսի իմաստի մասին ավելին՝ մաս II-ում։

Եթե ամեն ինչ նախատեսվածի պես չաշխատեց, error message կստանաք։ Համոզվեք, որ ձեր file-ում code-ը մուտքագրել եք ճիշտ այնպես, ինչպես ցույց է տրված, և կրկին փորձեք։ debugging-ի տարբերակների մասին կխոսենք «Python-ի code-ի debugging» ներդիրում, բայց գրքի այս փուլում ձեր լավագույն տարբերակը հավանաբար ճշգրիտ ընդօրինակումն է։ Եվ եթե մնացած ամեն ինչ ձախողվում է, կարող եք փորձել գործարկել նաև ստորև քննարկվող IDLE գրաֆիկական միջավայրում։ Այս գործիքը հեշտացնում է գործարկման որոշ մանրամասներ, թեև երբեմն՝ command line-երն օգտագործելիս ունեցած ավելի բացահայտ վերահսկողության հաշվին։

Եթե code-ը պատճենելը չափազանց տաղտկալի կամ սխալների աղբյուր է դառնում, կարող եք այս գրքի օրինակները վերցնել նաև համացանցից, թեև կրկին՝ սկզբում code-ը մուտքագրելը

Սկզբնաղբյուրի PDF էջ 117

կօգնի սովորել խուսափել syntax error-ներից։ Օրինակները ձեռք բերելու մասին տեղեկությունները տե՛ս նախաբանում։

Երբ Python-ի code-ի file-ը գործարկելու հրաման եք մուտքագրում, այդ հրամանը կատարում է համակարգի shell-ի program-ը, օրինակ՝ Bash-ը Unix-ում։ Այդ պատճառով ավելի հարմարեցված գործարկումների համար հասանելի է թաղանթի ամբողջ syntax-ը։ Օրինակ՝ թաղանթի հատուկ syntax-ով կարող եք Python script-ի արտածվող ելքը ուղղել file-ի մեջ՝ հետագայում օգտագործելու կամ ուսումնասիրելու համար։

Գրքի code · PDF էջ 117

  $ python3 script1.py > saveit.txt

Այս դեպքում նախորդ գործարկման ժամանակ ցուցադրված երեք ելքային line-երը արտածվելու փոխարեն պահվում են saveit.txt file-ում։ Սա սովորաբար հայտնի է որպես հոսքի վերահղում։ Այն աշխատում է և՛ ելքային ( > ), և՛ մուտքային ( < ) տեքստի համար ու հասանելի է Windows-ում և Unix-ի նման համակարգերում։ Սա օգտակար է փորձարկման համար, քանի որ կարող եք գրել program-եր, որոնք հետևում են այլ program-երի ելքերի փոփոխություններին։ Սակայն այն քիչ կապ ունի հենց Python-ի հետ. Python-ը պարզապես աջակցում է դրան։ Ուստի այստեղ չենք քննարկի shell-ի վերահղման

Սկզբնաղբյուրի PDF էջ 118

syntax-ի հետագա մանրամասները։ Սակայն վերահղումը նախատեսված է միայն command line-երի համար, քանի որ դա համակարգի shell-ի գործառույթ է։

Windows-ում կարող եք մուտքագրել նաև միայն ձեր script-ի name-ը՝ բաց թողնելով հենց Python-ի name-ը։ Քանի որ Windows-ը file-ը գործարկող program-ը գտնելու համար օգտագործում է filename-ների կապակցումները, .py file գործարկելու համար բավական է filename-ը։ Օրինակ՝ հետևյալ հրամանը Windows-ում ինքնաբերաբար կգործարկվի Python-ի միջոցով, տեխնիկապես՝ հավելված A-ում նկարագրված Python-ի py Windows գործարկիչի միջոցով։

Գրքի code · PDF էջ 118

  $ script1.py

Սա աշխատում է ճիշտ այնպես, կարծես File Explorer-ում սեղմած լինեք file-ի պատկերակը. գործարկման այս եղանակը կքննարկենք ավելի ուշ։ Այստեղ կա մի նրբություն. Command Prompt-ն այս ձևով program-երը գործարկում է իր սեփական պատուհանում, իսկ PowerShell-ը կարող է այդպես չանել։ Վերջինում չվերահղված ելքը տեսնելու համար անհրաժեշտության դեպքում օգտագործեք py-ն կամ պատկերակով գործարկելու համար նախատեսված input()-ի հնարքը, որը նույնպես շուտով կներկայացվի։

Վերջապես հիշեք՝ պետք է տալ ձեր script-ի file-ի ամբողջական ուղին, եթե այն գտնվում է այլ directory-ում, ոչ թե այնտեղ, որտեղ աշխատում եք։ Օրինակ՝ ստորև ներկայացված Python-ի py հրամանը,

Սկզբնաղբյուրի PDF էջ 119

որը գործարկվում է Windows-ի PowerShell-ում, ենթադրում է, որ Python-ը ձեր համակարգային որոնման ուղու մեջ է, բայց գործարկում է մեկ այլ տեղ գտնվող file։

Գրքի code · PDF էջ 119

  PS C:\Users\me\code> cd D:\temp\savecode
  PS D:\temp\savecode> py C:\Users\me\code\script1
  win32
  1267650600228229401496703205376
  Hack!Hack!Hack!Hack!Hack!Hack!Hack!Hack!

Եթե ձեր PATH-ը չի ներառում Python-ի directory-ն, և ո՛չ Python-ը, ո՛չ ձեր script-ի file-ը չեն գտնվում ձեր working directory-ում, երկուսի համար էլ օգտագործեք ամբողջական ուղիներ։ Այդպես է ստորև բերված macOS-ի օրինակում, որտեղ լրացուցիչ ներառված է նաև output stream-ի վերահղում դեպի current working directory-ից՝ հրամանը գործարկելու պահին ձեր գտնվելու տեղից դուրս գտնվող մի file։

Գրքի code · PDF էջ 119

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  $ /usr/local/bin/python3 /Users/me/code/script1.p

Սա շատ բան է պահանջում մուտքագրել, բայց նաև ծայրահեղ և ոչ բնորոշ դեպք է։ Որպեսզի ձեր հրամանները սրանից պարզ լինեն, համոզվեք, որ Python-ը ձեր PATH-ում է, և նախ cd-ով անցեք script-ի կամ տվյալների directory-ն։ Կրկին՝ մեծ մասամբ

Սկզբնաղբյուրի PDF էջ 120

տեղադրումները PATH-ը կարգավորում են ինքնաբերաբար, ուստի հրամաններ գործարկելիս պետք է կենտրոնանաք միայն script-ների և տվյալների directory-ների վրա։

Եթե command line-երի սիրահար չեք, սովորաբար կարող եք դրանցից խուսափել՝ Python script-ները գործարկելով file-երի պատկերակները սեղմելով, մշակման գրաֆիկական միջավայրերով և այլ մոտեցումներով, որոնք տարբեր են ըստ հարթակի ու դերի։ Այս գիրքը սովորողներին ընդհանուր առմամբ խորհուրդ է տալիս օգտագործել command line-ը և՛ դրա պարզության, և՛ այն պատճառով, որ դա code-ը գործարկելու տարածված, ընդհանուր կիրառելի, դյուրափոխադրելի ու հզոր եղանակ է։ Բայց դա պարտադիր չէ։ Թեև Python-ի աշխարհը չափազանց հարուստ է ընտրանքներով, որպեսզի այստեղ բոլորը սպառիչ ընդգրկենք, գլխի ավարտին համառոտ շրջայց կատարենք command line-ի առավել հայտնի այլընտրանքներով։

Անձնական computer-ների հարթակների մեծ մասում Python program-երի file-երը կարելի է գործարկել՝ պարզապես տեղային file-երի դիտարկիչում սեղմելով կամ հպելով դրանց filename-ին կամ պատկերակին։ Օրինակ՝ սա ինքնաբերաբար աշխատում է Windows-ի File Explorer-ում՝ Python-ի տեղադրման ընթացքում սահմանված filename-ների կապակցումների շնորհիվ։ Սեղմումով code-ի file-երը գործարկվում են նաև macOS-ի Finder-ում, եթե դրանց համար Open With-ի միջոցով ընտրված է macOS-ի

Սկզբնաղբյուրի PDF էջ 121

տեղադրման կազմում ներառված Python Launcher-ը։ Երբ Python Launcher հավելվածը հասանելի է, file-ը դրա վրա քաշելը գործում է նույն կերպ, ինչպես սեղմելը։

file-ը սեղմելով գործարկելու հարցը Linux-ում ավելի բարդ է. file-երին հավանաբար անհրաժեշտ է կատարման թույլտվություն և Python-ը նշող #! առաջին line։ Սմարթֆոններում Android-ի file-երի դիտարկիչում կամ iOS-ի Files-ում filename-ին հպելը կարող է file-ը բացել կապված Python հավելվածում, բայց սա կարող է աշխատել միայն դիտարկիչի ու հավելվածի որոշ զուգակցումների դեպքում և որոշ իրավիճակներում կարող է չտրամադրել հասանելիություն program-ի բոլոր file-երին։ Ավելին իմանալու համար դիմեք ձեր հարթակի և հավելվածի փաստաթղթերին կամ փորձեր արեք ձեր սարքում։

Լրացուցիչ տեղեկությունների համար տե՛ս նաև հավելված A-ն։ Ինչպես այնտեղ նշվում է, Windows-ում և Linux-ում սեղմումով գործարկումը program-երի ավարտից հետո պատուհանը բաց չի պահում՝ ելքն ու error message-ները դիտելու համար։ Եթե script-ը պարզապես արտածում և ավարտվում է, ապա հենց դա էլ անում է. վահանակի պատուհանը հայտնվում է, այնտեղ տեքստ է արտածվում, բայց program-ից դուրս գալու պահին վահանակի պատուհանը փակվում ու անհետանում է։ Հավելված A-ում նշվածի համաձայն՝ վերջում Python-ի input() կանչ գրելը պարտադրում է դադար ելքից առաջ, որպեսզի կարողանաք տեսնել արտածվածը, բայց դա error message-ների համար չի օգնում։ Երբ սա կարևոր է, օգտագործեք գործարկման այլ եղանակներ։

Սկզբնաղբյուրի PDF էջ 122

Մինչ այժմ տեսանք, թե ինչպես Python code-ը գործարկել ինտերակտիվ սեանսներով, համակարգային command line-երով և պատկերակները սեղմելով։ Եթե փնտրում եք մի փոքր ավելի տեսողական տարբերակ, IDLE-ն տրամադրում է Python-ով programming-ի graphical user interface և Python համակարգի ստանդարտ ու անվճար մասն է։ IDLE-ն սովորաբար անվանում են զարգացման ինտեգրված միջավայր՝ IDE, քանի որ այն մշակման մի քանի խնդիրներ միավորում է մեկ տեսքի մեջ։

Կարճ ասած՝ IDLE-ն թույլ է տալիս Python program-երը խմբագրել, գործարկել, զննել ու վրիպազերծել նույն գրաֆիկական միջավայրից։ Քանի որ այն գրված է Python-ով՝ tkinter գրաֆիկական գործիքակազմի օգնությամբ, դյուրափոխադրելի կերպով աշխատում է Python-ի բոլոր համակարգչային հարթակներում՝ Windows-ում, macOS-ում և Linux-ում։ Շատերի համար IDLE-ն command line-եր մուտքագրելու հեշտ օգտագործվող այլընտրանք է, պատկերակները սեղմելու համեմատ՝ ավելի քիչ խնդիրներ առաջացնող տարբերակ, և սկսնակների համար՝ code-ը խմբագրել ու գործարկել սկսելու հիանալի եղանակ։ Դրա դիմաց որոշ վերահսկողություն կզիջեք, բայց սա սովորաբար կարևոր է դառնում միայն Python-ի հետ ձեր աշխատանքի ավելի ուշ փուլերում։

IDLE-ի տեղադրումն ու մեկնարկը նկարագրված են հավելված A-ում, ուստի այստեղ ամբողջ մանրամասները չենք կրկնի։ Հակիրճ՝ այն ստանդարտ կերպով ներառվում է Windows-ի և macOS-ի համար python.org-ի Python տեղադրիչներում և առանձին հասանելի է Linux-ի պահոցներում։ Տեղադրելուց հետո այն կարելի է մեկնարկել սովորական միջոցներով՝ Windows-ի Start-ից,

Սկզբնաղբյուրի PDF էջ 123

macOS-ի Launchpad-ից կամ Finder-ից, Linux-ի command line-ից և, որտեղ աջակցվում է, file-ի վրա աջ սեղմումով։

Հավելված A-ում կան նաև յուրաքանչյուր հարթակում IDLE-ի աշխատանքը ցույց տվող էկրանապատկերներ, բայց նկար 3-1-ը բազմազանության և ավելի արագ ծանոթանալու համար ներկայացնում է դրա մուգ թեման Windows-ում։ Ինչպես ցույց է տրված, վերևի խմբագրման պատուհանում այս գլխի օրինակ 3-1-ի script1.py-ն գործարկելուց հետո դրա ելքը հայտնվում է ինտերակտիվ Shell պատուհանում։

Սկզբնաղբյուրի պատկեր, PDF էջ 123
Սկզբնաղբյուրի պատկեր · PDF էջ 123

Նկար 3-1. IDLE-ն՝ մուգ թեմայով Windows-ում

Սկզբնաղբյուրի PDF էջ 124

Հուշում. քանի որ IDLE-ն ընդամենը Python script է standard library-ում՝ module-ների որոնման ուղու վրա, սովորաբար այն կարող եք գործարկել նաև ցանկացած հարթակում և ցանկացած directory-ից՝ system console-ի պատուհանում մուտքագրելով Python-ի հետևյալ հրամանը։ Windows-ում, ինչպես միշտ, python3-ի փոխարեն օգտագործեք py։ Python-ի –m դրոշակը պարզապես գտնում է module-ը ներմուծման սովորական որոնմամբ, բայց այն գործարկում է որպես վերին մակարդակի script։ Մաս V-ն նկարագրում է և՛ այս որոնումը, և՛ այստեղ անհրաժեշտ package-ի «.» syntax-ը։

Գրքի code · PDF էջ 124

  $ python3 -m idlelib.idle         # Find and run

Մեկնաբանություն, տող 1․ Գտնել և գործարկել

Մեկնարկելուց հետո IDLE-ի օգտագործումը պարզ է և փաստագրված է դրա ներծրագրային Help-ում։ Հակիրճ՝ Shell պատուհանը տրամադրում է սովորական ինտերակտիվ REPL՝ նախկին հրամանները հետ կանչելու հնարավորությամբ, իսկ խմբագրման յուրաքանչյուր պատուհան թույլ է տալիս դիտել, փոփոխել և գործարկել code-ի file։ Shell-ի File→New File և File→Open… ընտրանքները ստեղծում ու բացում են code-ի file-եր։ Խմբագրման պատուհանների Run→Run Module-ը գործարկում է այն պատուհանի code-ը, որտեղ ընտրված է այդ հրամանը, իսկ Run→Run… Customized-ը թույլ է տալիս command line-ի argument-ներ փոխանցել script-ներին։ Վերջինը դուրս է մեր քննարկման շրջանակից և լիարժեք համակարգային shell չէ, բայց օգտակար է այդպիսի argument-ներ սպասող script-ների համար։

Սկզբնաղբյուրի PDF էջ 125

IDLE-ն ունի շատ այլ հնարավորություններ, բայց որպես մի քանի օրինակ՝ այն code մուտքագրելիս առաջարկում է նաև Tab-ով լրացում, function-ների համար բացվող հուշումներ և object-ների attribute-ների list-ներ, ինչպես նաև ներառում է object-ների դիտարկիչ ու գրաֆիկական debugger։ IDLE-ի debugger-ն օգտագործելու համար միացրեք այն Debug ընտրացանկում, խմբագրման պատուհաններում աջ սեղմումներով սահմանեք կանգառի կետեր և գործարկեք։ debugging-ի ավելի պարզ կարիքների համար Shell պատուհանում ցանկացած error message-ի տեքստի վրա աջ սեղմեք՝ code-ի այն line-ին անցնելու համար, որտեղ սխալն առաջացել է։

IDLE-ի այլ հուշումների համար տե՛ս այս գրքի հավելված A-ն, IDLE-ի սեփական Help ընտրացանկը և Python-ի ստանդարտ ձեռնարկների «Python Setup and Usage» բաժնի՝ ձեր հարթակին վերաբերող նշումները։ Ինչպես գրաֆիկական միջավայրերի մեծ մասի դեպքում, IDLE-ն սովորելու լավագույն եղանակը գուցե այն ինքնուրույն փորձարկելն է։ Ի վերջո, օգտագործման դրա հարմարավետությունը որոշ սկսնակների համար կարող է էական լինել, բայց այն նաև լրացուցիչ ուսուցում է պահանջում, այնքան ճկուն չէ, որքան command line-երը, և ավելացնում է պարզեցնող շերտ, որը կարող է թերություն դառնալ, երբ programming-ի ձեր կարիքները դուրս գան դրա շրջանակից։ Ինչպես միշտ, գնահատեք ինքներդ՝ մոտակա համակարգչի վրա։

Քանի որ IDLE-ն անվճար է, դյուրափոխադրելի և Python-ի ստանդարտ մասն է, այն մշակման լավ առաջին գործիք է, որին արժե ծանոթանալ, եթե ընդհանրապես ցանկանում եք օգտագործել IDE։ Սակայն կան մի շարք

Սկզբնաղբյուրի PDF էջ 126

այլընտրանքային IDE-ներ Python մշակողների համար, որոնցից մի քանիսը զգալիորեն ավելի հզոր ու հուսալի են, քան IDLE-ն։

Դրանց թվում PyCharm-ը, PyDev-ը, Wing-ը, VSCode-ը, Spyder-ը և PyScripter-ը բոլորն ունեն խմբագրման ու գործարկման սովորական գրաֆիկական միջավայրեր, բայց որոշներն ավելացնում են լրացուցիչ ու առաջադեմ գործիքներ, օրինակ՝ code-ի վերակառուցում և տարբերակների վերահսկման ինտեգրում։ Այս IDE-ների յուրացումը նույնպես զգալի ուսուցում է պահանջում, ուստի դրանք խորհուրդ չեն տրվում Python-ի սկսնակների մեծ մասին։ Այնուամենայնիվ, գուցե ցանկանաք սա մտապահել Python-ի հետ ձեր աշխատանքի ավելի ուշ շրջանի համար, երբ արդեն տիրապետեք լեզվին և անցնեք արդյունաբերական մակարդակի մշակման։

Եթե այս գրքի օրինակները գործարկում եք Android կամ iOS սմարթֆոնով կամ պլանշետով, օգտագործելու եք հավելված։ Որոշները, օրինակ՝ Android-ի Termux-ը, ունեն ավանդական command line և աջակցում են մինչ այժմ տեսած REPL-ի ու file-երի բոլոր հրամաններին։ Մյուսներում, սակայն, code-ի file-երը կգործարկեք հավելվածի user interface-ի միջոցներով, օրինակ՝ կոճակներին հպելով, այլ ոչ թե ավանդական command line-երով։ Էությամբ սա շատ չի տարբերվում IDLE-ում կամ այլ IDE-ներում code գործարկելուց, բայց քանի որ մանրամասները տարբեր են ըստ հավելվածի, բջջային հարթակների հուշումների համար տե՛ս հավելված A-ն, իսկ ավելի շատ տեղեկությունների համար՝ նաև ձեր հավելվածի փաստաթղթերը։

Սկզբնաղբյուրի PDF էջ 127

Թեև տեխնոլոգիան դեռ զարգանում է, Python code հնարավոր է գործարկել նաև վեբ զննարկիչներում։ Այսօր դա հնարավոր է WebAssembly-ի՝ նաև Wasm կոչվող տեխնոլոգիայի շնորհիվ, որը սահմանում է վեբ զննարկիչների կողմից կատարվող դյուրափոխադրելի bytecode-ի ձևաչափ՝ նման նրան, ինչպես Python-ի PVM-ն կատարում է իր bytecode-ը (տե՛ս գլուխ 2)։ Python-ի interpreter-ի source code-ն այդ ձևաչափին կոմպիլացնելով այնպիսի գործիքներով, ինչպիսին LLVM-ի վրա հիմնված Emscripten compiler-ն է, վեբ զննարկիչները կարողանում են գործարկել Python-ը և, հետևաբար, ձեր Python program-երը։ Թեև զննարկչում Python գործարկելու նախկին այլ նախաձեռնությունները մեծ մասամբ մարել են, WebAssembly-ն ստանդարտացվում է Համաշխարհային սարդոստայնի կոնսորցիումի՝ W3C-ի կողմից և արդեն աջակցվում է համակարգչային ու բջջային բոլոր հիմնական վեբ զննարկիչներում։

Հենց Python-ը Wasm-ի կոմպիլացնելը պարզ գործ չէ, և դա Python-ի սկսնակներից պահանջելը չափազանց շատ կլիներ, բայց Pyodide համակարգն աշխատանքի մեծ մասն արդեն արել է ձեր փոխարեն։ Դա CPython-ի փոխադրումն է WebAssembly/Emscripten հարթակ՝ compiled ու գործարկման պատրաստ, JavaScript-ի ինտեգրմամբ՝ զննարկչի Document Object Model-ին՝ DOM-ին և վեբ API-ներին հասնելու համար։ Pyodide-ը վեբ էջում օգտագործելու համար այն կբեռնեք սերվերից և սկզբնարժեքավորեք զննարկչում՝ HTML փաստաթղթով, որն օգտագործում է տրամադրված JavaScript code-ն ու API գործիքները։ Վերջնական արդյունքը կարող է վեբ զննարկիչներում կատարել բազմաթիվ Python program-եր՝ առանց տեղային տեղադրումների անհրաժեշտության։

Սկզբնաղբյուրի PDF էջ 128

Այս մոդելի հիմնական թերությունները, կարծես, արագությունն ու գործնական օգտակարությունն են։ compiled CPython interpreter-ը ներբեռնելը՝ զննարկչում Python script գործարկելու համար, արագ չէ, իսկ Python script-ների արագությունն այս միջավայրում կարող է տարբերվել։ Ավելին, Pyodide-ը տրամադրվում է Python գործիքների ֆիքսված հավաքածուով, իսկ զննարկիչների գործարկած Python script-ներն ապրում են մեկուսացված միջավայրում՝ հյուրընկալող սարքի գործիքներին ու ռեսուրսներին սահմանափակ հասանելիությամբ։ Օրինակ՝ մշտական պահեստը կարող է աջակցել POSIX file կանչերին ու ուղիներին, բայց վիրտուալ է և այս միջավայրում, ի վերջո, սահմանափակված է զննարկիչների աջակցած տարբերակներով։

Հետևաբար, թեև այս տարբերակը կարող է թույլ տալ խուսափել Python-ի որոշ տեղադրումներից և Python-ի համար համացանցում նոր հնարավորություններ բացել, ընդհանուր ծրագրային մշակման համար այն այնքան օգտակար չէ, որքան մյուսները, իսկ դրա ապագան կանխատեսելն անհնար է։ Հետևեք համացանցին՝ այս զարգացող պատմության մասին ավելին իմանալու համար, այդ թվում՝ Wasm-ի համար այլընտրանքային MicroPython-ի մասին, որը CPython-ից փոքր է, բայց, ինչպես նկարագրված է գլուխ 2-ում, իրականացնում է Python-ի սահմանափակ subset, և py2wasm՝ Python-ից Wasm compiler-ի մասին, որը հայտարարվել է հենց այս գիրքը գրելու ընթացքում։

Այս տարբերակին ավելի վաղ հանդիպել ենք REPL-ների հետ միասին։ Jupyter-ը գործիքների հավաքածու է, որը թույլ է տալիս Python code-ը գործարկել վեբ զննարկիչներում՝ կենտրոնանալով գիտական programming-ի խնդիրներին աջակցելու վրա։ Դրա հիմնական ու դասական գործիքները պահանջում են առանձին

Սկզբնաղբյուրի PDF էջ 129

տեղադրել և մեկնարկել սերվեր՝ վեբ էջում մուտքագրած code-ը գործարկելու համար, բայց այն տրամադրվում է նաև մի ձևով, որը code-ը տեղային կատարում է զննարկիչներում՝ նախորդ բաժնում նկարագրված WebAssembly և Pyodide համակարգերի միջոցով։ Երկու ձևերում էլ Jupyter էջերը հետևում են ճկուն նոթատետրի մոտեցմանը՝ ինտերակտիվ encoding ավելի վաղ նույնպես հանդիպած IPython REPL-ով, կոճակի սեղմումով կատարվող code-ի բջիջներ, պատկերավորում Python-ի թվային գործիքներով և այլն։

Թեև Jupyter-ն օգտակար ու տարածված գործիք է STEM-ի բազմաթիվ աշխատանքներում, այն նախատեսված չէ ընդհանուր նշանակության ծրագրային մշակման համար և այնքան լայնորեն կիրառելի չէ, որքան ավանդական գործիքները, օրինակ՝ այս գրքում շեշտադրվող command line-երը։ Եթե Jupyter նոթատետրերը կարող են լինել Python-ով ձեր ապագա աշխատանքի մի մասը, օգտագործման մանրամասների համար դիմեք այլ աղբյուրների։

Ինչպես նաև նշվել է գլուխ 2-ում, մի շարք AOT compiler-ների համակարգեր, ներառյալ Nuitka-ն և Shed Skin-ը, Python program-երը կոմպիլացնում են ընդհուպ մինչև machine code՝ մոտավորապես C և C++ compiler-ների նման։ Նման համակարգ տեղադրելուց հետո նախ դրա compiler-ը կգործարկեք Python code-ի file-ի վրա, ապա ստացված program-ը կգործարկեք ցանկացած այլ գործարկվող file-ի նման։ AOT compiler-ները կարող են բարձրացնել program-ի արագությունը, բայց մշակմանը լրացուցիչ քայլեր են ավելացնում, որոնք զգալիորեն դանդաղեցնում են programming-ի ընթացքը և չեզոքացնում են Python

Սկզբնաղբյուրի PDF էջ 130

օգտագործելու առավելությունների մի մասը։ Հատկապես Python-ի նորեկների համար այս համակարգերը, հավանաբար, լավագույնն է ուսումնասիրել Python լեզուն ավելի մատչելի տարբերակներով սովորելուց հետո՝ ավանդական REPL-ներով, IDE-ներով և command line-երով։

Այս գլխում մի քանի անգամ խոսել ենք «module-ներ ներմուծելու» մասին՝ իրականում չբացատրելով, թե ինչ է նշանակում այս տերմինը։ module-ներն ու ավելի մեծ program-երի ճարտարապետությունը խորությամբ կուսումնասիրենք մաս V-ում, բայց քանի որ ներմուծումները նաև program-եր գործարկելու եղանակ են, այս բաժինը ձեզ սկսելու համար անհրաժեշտ չափով կներկայացնի module-ների հիմունքները։ Ներմուծումների նման՝ Python-ի built-in exec-ը նույնպես կարող է օգտագործվել code-ի միջից file-եր գործարկելու համար, իսկ standard library-ի module-ների գործիքները թույլ են տալիս program-եր գործարկել command line-երով։ Թեև այս գլխում չենք կարող բոլոր մանրամասները ներկայացնել, այս բաժինը համառոտ ուսումնասիրում է այս խմբի գործարկման միջոցները։

Պարզ ասած՝ Python-ի source code-ի յուրաքանչյուր file, որի name-ն ավարտվում է .py ընդլայնմամբ, module է։ file-ը module դարձնելու համար հատուկ code կամ syntax պետք չէ. այդպիսի ցանկացած file հարմար է։ Այլ file-եր կարող են հասնել module-ի սահմանած տարրերին՝ ներմուծելով այդ module-ը, ինչը ըստ էության բեռնում է մեկ այլ file և հասանելիություն տալիս

Սկզբնաղբյուրի PDF էջ 131

դրա բովանդակությանը։ module-ի բովանդակությունն արտաքին աշխարհին հասանելի է դառնում նրա attribute-ների միջոցով. այս տերմինը ոչ պաշտոնապես կսահմանենք հաջորդ բաժնում։

Պարզվում է՝ module-ների այս մոտեցումը Python-ի ծրագրային ճարտարապետության հիմքում ընկած գլխավոր գաղափարն է։ Ավելի մեծ program-երը սովորաբար կազմված են մի քանի module-ի file-երից, որոնք գործիքներ են ներմուծում այլ module-ների file-երից։ module-ներից մեկը նշանակվում է որպես հիմնական կամ վերին մակարդակի file, որը հաճախ նաև կոչվում է script։ Սա այն file-ն է, որը մեկնարկվում է ամբողջ program-ը գործարկելու համար և, ինչպես միշտ, կատարվում է line by line։ Այս մակարդակից ներքև ամեն ինչ module-ներ են, որոնք ներմուծում են module-ներ։

Նման ճարտարապետական հարցերը գրքում հետագայում ավելի մանրամասն կուսումնասիրենք։ Այս գլխին հիմնականում հետաքրքրում է այն փաստը, որ ներմուծման գործողությունները որպես վերջին քայլ կատարում են բեռնվող file-ի code-ը։ Դրա շնորհիվ file ներմուծելն այն գործարկելու ևս մեկ եղանակ է։ Օրինակ՝ եթե մեկնարկեք ինտերակտիվ սեանս՝ համակարգային command line-ից կամ այլ կերպ, կարող եք ավելի վաղ օրինակ 3-1-ում գրած script1.py file-ը գործարկել պարզ import statement-ով, որն իրականում Python code է՝ այլ Python code գործարկող։

Գրքի code · PDF էջ 131

  $ python3
  >>> import script1

Սկզբնաղբյուրի PDF էջ 132

Գրքի code · PDF էջ 132

  darwin
  1267650600228229401496703205376
  Hack!Hack!Hack!Hack!Hack!Hack!Hack!Hack!

ՆՇՈՒՄ
Որտեղ գործարկել ներմուծումները. Python-ի այս հրամանն անպայման գործարկեք script1.py-ն պարունակող directory-ում, այսինքն՝ directory-ում։ Այս գլխում code-ի directory-ների մասին ավելի վաղ ասվածի համաձայն՝ սա ամենահեշտն է, եթե module-ների file-երը պահում և ներմուծումները գործարկում եք այն գլխի առանձին directory-ում, որի վրա աշխատում եք։ Գրքում ավելի ուշ կիմանաք, որ REPL-ի ներմուծումները module-ը փնտրում են ընթացիկ directory-ում, ինչպես նաև PYTHONPATH միջավայրի variable-ում թվարկված կամ այլ կերպ սահմանված directory-ներում։ Մինչ այդ ընթացիկ directory-ում որոնումը բավարար կլինի այն ներմուծումների մեծ մասի համար, որոնք հավանաբար կփորձեք, պայմանով, որ ձեր բոլոր code-ի file-երը հենց այնտեղ են։

Ներմուծումները կարող են գործարկել file-ը, բայց լռելյայն՝ յուրաքանչյուր սեանսում միայն մեկ անգամ։ Ավելի ճշգրիտ՝ յուրաքանչյուր գործընթացում, այսինքն՝ program-ի մեկ գործարկման ընթացքում։ Առաջին ներմուծումից հետո հետագա ներմուծումները ոչինչ չեն անում, նույնիսկ եթե module-ի սկզբնական file-ը մեկ այլ պատուհանում փոխեք ու կրկին պահպանեք։

Գրքի code · PDF էջ 132

  >>> import script1
  >>> import script1

Սկզբնաղբյուրի PDF էջ 133

Սա միտումնավոր է. ներմուծումները չափազանց ծախսատար գործողություն են, որպեսզի program-ի տվյալ գործարկման ընթացքում յուրաքանչյուր file-ի համար մեկից ավելի անգամ կրկնվեն։ Ինչպես կիմանաք գլուխ 22-ում, ներմուծումները պետք է գտնեն file-երը, կոմպիլացնեն դրանք bytecode-ի և կատարեն code-ը line by line, իսկ ներմուծողներին սովորաբար հետաքրքրում է միայն այն, որ module-ի line-երը սահմանած լինեն դրա արտահանվող տարրերը։

Եթե իսկապես ցանկանում եք ստիպել Python-ին նույն սեանսում կրկին կատարել file-ը՝ առանց REPL-ը կանգնեցնելու և վերագործարկելու, դրա փոխարեն պետք է կանչեք standard library-ի importlib module-ում հասանելի reload function-ը։ Նախկինում այն այժմ այլևս չգործող imp module-ում էր, իսկ մինչ այդ՝ built-in function։ Հաշվողների համար՝ սա արդեն երեք մարմնավորում է։

Գրքի code · PDF էջ 133

  >>> from importlib import reload
  >>> reload(script1)
  darwin
  1267650600228229401496703205376
  Hack!Hack!Hack!Hack!Hack!Hack!Hack!Hack!
  <module 'script1' from '/Users/me/Code/script1.py

Այստեղ from statement-ը պարզապես module-ից պատճենում է name-ը. այս մասին ավելին՝ հաջորդ բաժնում։ Հենց reload function-ը բեռնում և կատարում է ձեր file-ի

Սկզբնաղբյուրի PDF էջ 134

source code-ի ընթացիկ տարբերակը՝ հաշվի առնելով file-ի փոփոխությունները, եթե այն փոփոխել և պահպանել եք մեկ այլ պատուհանում։

Սա թույլ է տալիս ընթացիկ Python ինտերակտիվ սեանսում տեղում խմբագրել և օգտագործել նոր code-ը։ reload function-ը սպասում է արդեն բեռնված module-ի object-ի name-ին, ուստի module-ը վերաբեռնելուց առաջ պետք է այն հաջողությամբ ներմուծած լինեք։ Եթե ներմուծումն ավարտվել է սխալով, դեռ չեք կարող վերաբեռնել և պետք է կրկին ներմուծեք։

Նկատեք, որ reload-ը module-ի object-ի name-ի շուրջ պահանջում է նաև փակագծեր, իսկ import-ը՝ ոչ։ reload-ը argument-ով կանչվող function է, իսկ import-ը՝ statement։ Սա նաև բացատրում է, թե ինչու վերաբեռնելիս ելքում լրացուցիչ line եք ստանում։ Տարօրինակ վերջին line-ը ընդամենը reload կանչի վերադարձվող value-ի՝ Python-ի module-ի object-ի ցուցադրման ներկայացումն է։ Ընդհանուր առմամբ function-ների օգտագործման մասին ավելին կսովորեք գլուխ 16-ում։ Առայժմ «function» լսելիս հիշեք, որ կանչը կատարելու համար փակագծերը պարտադիր են, նույնիսկ եթե փոխանցելու ոչինչ չկա։

Ներմուծումներն ու վերաբեռնումները program-ի գործարկման բնական տարբերակ են տալիս, քանի որ ներմուծման գործողությունները որպես վերջին քայլ կատարում են file-երը։ Ավելի

Սկզբնաղբյուրի PDF էջ 135

լայն տեսանկյունից, սակայն, module-ները ծառայում են որպես գործիքների library-ներ, ինչպես կիմանաք մաս V-ում։ Այնուամենայնիվ, հիմնական գաղափարը պարզ է. module-ը հիմնականում պարզապես variable-ների name-ների հավաքածու է, որը կոչվում է namespace, իսկ այդ հավաքածուի name-ները կոչվում են attribute-ներ՝ variable-ների name-ներ, որոնք կցված են որոշակի object-ի, օրինակ՝ module-ի։

Ավելի կոնկրետ՝ module-ի file-ի վերին մակարդակում արժեք ստացած բոլոր name-ները դառնում են դրա attribute-ները, և module-ը ներմուծողները հասանելիություն են ստանում դրանց բոլորին։ Այս name-ները սովորաբար կապակցվում են module-ի արտահանած գործիքներին՝ function-ներին, class-երին, variable-ներին և այլն, որոնք նախատեսված են այլ file-երում ու այլ program-երում օգտագործելու համար։ Դրսից module-ի filename-ները կարելի է ստանալ Python-ի երկու statement-ով՝ import և from, իսկ reload կանչով դրանք կարող են վերասահմանվել։

Պարզաբանելու համար text editor-ով ձեր working directory-ում ստեղծեք myfile.py անունով մեկ տողանոց Python module-ի file՝ օրինակ 3-2-ում ներկայացված բովանդակությամբ։

Օրինակ 3-2. myfile.py

Գրքի code · PDF էջ 135

  title = 'Learning Python, 6th Edition'

Սկզբնաղբյուրի PDF էջ 136

Սա գուցե աշխարհում Python-ի ամենապարզ module-ներից մեկն է. այն պարունակում է assignment-ի մեկ statement։ Բայց սա բավարար է գաղափարը ցույց տալու համար։ Երբ այս file-ը ներմուծվում է, դրա code-ը կատարվում է՝ module-ի attribute-ը ստեղծելու համար։ Այսինքն՝ assignment-ի statement-ը ստեղծում է variable և module-ի attribute՝ հետևյալ անունով՝

Գրքի code · PDF էջ 136

title.

Այս module-ի title attribute-ին այլ բաղադրիչներից կարող եք հասնել երկու տարբեր եղանակով։ Նախ՝ import statement-ով կարող եք բեռնել ամբողջ module-ը, ապա module-ի name-ին կցել attribute-ի name-ը՝ դրա արժեքը ստանալու համար։ Նկատեք, որ այստեղ թույլ ենք տալիս interpreter-ին արդյունքն ինքնաբերաբար արտածել։

Գրքի code · PDF էջ 136

  $ python3                          # Start Python
  >>> import myfile                  # Run file, lo
  >>> myfile.title                   # Use its attr
  'Learning Python, 6th Edition'

Մեկնաբանություն, տող 1․ Մեկնարկել Python-ը

Մեկնաբանություն, տող 2․ Գործարկել file-ը, բեռ…

Մեկնաբանություն, տող 3․ Օգտագործել դրա ատր…

Ընդհանուր առմամբ, կետով expression-ի object.attribute syntax-ը թույլ է տալիս ստանալ ցանկացած object-ին կցված ցանկացած attribute և Python code-ի ամենատարածված գործողություններից մեկն է։ Այստեղ այն օգտագործեցինք myfile module-ի ներսում գտնվող title string variable-ին հասնելու համար, այլ կերպ ասած՝ myfile.title։

Սկզբնաղբյուրի PDF էջ 137

Այլընտրանքային ձևով՝ from statement-ներով կարող եք module-ից ստանալ, ավելի ճիշտ՝ պատճենել name-ները։

Գրքի code · PDF էջ 137

  $ python3                          # Restart Pyth
  >>> from myfile import title         # Run file,
  >>> title                          # Use name dir
  'Learning Python, 6th Edition'

Մեկնաբանություն, տող 1․ Վերագործարկել Pyth… [կտրված է]

Մեկնաբանություն, տող 2․ Գործարկել file-ը, …

Մեկնաբանություն, տող 3․ Օգտագործել name-ն անմիջ…

Ինչպես ավելի ուշ մանրամասն կտեսնեք, from-ը նույնն է, ինչ import-ը, բայց ներմուծող code-ի name-ներին լրացուցիչ assignment-ով։ Տեխնիկապես from-ը պատճենում է module-ի attribute-ները, այնպես որ ստացողի մոտ դրանք դառնում են սովորական variable-ներ։ Այսպիսով, այս անգամ ներմուծված string-ին կարող եք դիմել որպես title՝ variable, ոչ թե myfile.title՝ attribute։

Բնականաբար, module-ները սովորաբար սահմանում են մեկից ավելի name՝ իրենց file-երի թե՛ ներսում, թե՛ դրսում օգտագործելու համար։ Օրինակ՝ օրինակ 3-3-ը սահմանում է երեքը։

Օրինակ 3-3. threenames.py

Գրքի code · PDF էջ 137

  a = 'PC'                       # Define three att
  b = 'Phone'                    # Exported to othe

Մեկնաբանություն, տող 1․ Սահմանել երեք ատր…

Մեկնաբանություն, տող 2․ Արտահանվում է այլ…

Սկզբնաղբյուրի PDF էջ 138

Գրքի code · PDF էջ 138

  c = 'Tablet'
  print(a, b, c)                 # Also used as var

Մեկնաբանություն, տող 2․ Նաև օգտագործվում են որպես փոփո…

code-ի այս՝ threenames.py file-ն արժեքներ է assignment երեք variable-ի և այդպիսով արտաքին աշխարհի համար ստեղծում երեք attribute։ Այն նաև իր երեք variable-ներն օգտագործում է print statement-ում, ինչպես տեսնում եք, երբ սա համակարգային հուշումից գործարկվում է որպես վերին մակարդակի file։

Գրքի code · PDF էջ 138

  $ python3 threenames.py
  PC Phone Tablet

Այս file-ի ամբողջ code-ը սովորականի պես կատարվում է նաև այն առաջին անգամ մեկ այլ տեղ ներմուծելիս՝ թե՛ import-ով, թե՛ from-ով։ Այս file-ն օգտագործող այն code-ը, որը կիրառում է import, ստանում է attribute-ներով module, իսկ from կիրառող code-ը ստանում է filename-ների պատճենները։

Գրքի code · PDF էջ 138

  $ python3
  >>> import threenames                    # Grab t
  PC Phone Tablet

Մեկնաբանություն, տող 2․ Վերցնել t… [կտրված է]

Գրքի code · PDF էջ 138

  >>> threenames.b, threenames.c           # Access
  ('Phone', 'Tablet')

Մեկնաբանություն, տող 1․ Հասանելիություն

Սկզբնաղբյուրի PDF էջ 139

Գրքի code · PDF էջ 139

  >>> from threenames import b, c          # Copy m
  >>> b, c
  ('Phone', 'Tablet')

Մեկնաբանություն, տող 1․ Պատճենել m… [կտրված է]

Այստեղ արդյունքներն արտածվում են փակագծերում, քանի որ դրանք իրականում tuple-ներ են՝ object-ների տեսակ, որը ստեղծվում է մուտքագրված expression-ների ստորակետով և ներկայացվում է այս գրքի հաջորդ մասում։ Առայժմ այս բացատրությունը հանգիստ կարող եք ընդունել վստահությամբ։

Ավելի լայն տեսանկյունից՝ module-ները կազմում են Python program-ի ճարտարապետության ամենաբարձր շերտը։ Որպես ինքնուրույն namespace-ներ՝ դրանք բնականորեն աջակցում են code-ի կազմակերպմանն ու վերաօգտագործմանը և ինքնաբերաբար նվազագույնի են հասցնում name-ների բախումները ձեր code-ում։ Դրանց ավելի բարձր նպատակներին կանդրադառնանք գրքում ավելի ուշ։

Այս գլխի համար բավական է իմանալ, որ ներմուծումներն ու վերաբեռնումները ձեր code-ի file-երը գործարկելու ևս մեկ եղանակ են, թեև հավանաբար՝ երկրորդական տարբերակ։ Բարդ առանձնահատկությունների պատճառով, որոնք այստեղ բաց կթողնենք, Python code-ը գործարկելու համար սովորաբար ավելի լավ ընտրություն են command line-երի և IDE-ների նման գործիքները։ Օրինակ՝ reload-ը թարմացնում է import օգտագործող ներմուծողների տեսած տվյալները, բայց ոչ from օգտագործողներինը։

Սկզբնաղբյուրի PDF էջ 140

Python-ը տալիս է նաև code-ով file-եր գործարկելու եղանակ, որը հիմնված չէ նախորդ բաժնի module-ների հասկացությունների վրա։ built-in exec function-ը կոմպիլացնում և կատարում է Python-ի source code-ի բոլոր այն statement-ները, որոնք կան իրեն փոխանցված string-ի մեջ։ expression-ների համար նախատեսված իր ազգակից eval-ի հետ միասին այն աջակցում է բազմաթիվ դինամիկ դերերի, որոնց կհանդիպեք հաջորդ գլուխներում։

Սակայն code-ի file-ի բեռնված բովանդակությունը exec-ին փոխանցելը տալիս է code-ի file-երը REPL-ից կամ այլ file-ից գործարկելու ևս մեկ եղանակ՝ առանց ներմուծելու և հետո վերաբեռնելու անհրաժեշտության։ Յուրաքանչյուր այդպիսի exec կատարում է file-ից կարդացված code-ի ընթացիկ տարբերակը՝ առանց ներմուծումներ կամ վերաբեռնումներ պահանջելու։ Օրինակ՝ կրկին օգտագործենք օրինակ 3-1-ի script1.py-ն։

Գրքի code · PDF էջ 140

  $ python3
  >>> exec(open('script1.py').read())
  darwin
  1267650600228229401496703205376
  Hack!Hack!Hack!Hack!Hack!Hack!Hack!Hack!

Այս code-ը հասկանալու համար նախ պետք է իմանաք, որ դրա ներսում ներդրված open-ը և read-ը կատարվում են առաջինը՝ ձախից աջ, և բեռնում են

Սկզբնաղբյուրի PDF էջ 141

file-ի ամբողջ բովանդակությունը՝ որպես string։ file-երը կուսումնասիրենք այս գրքի հաջորդ մասում, ուստի առայժմ սա ընդունեք որպես նախադիտում։ (Սա նաև նախապես չսովորած գիտելիքի պահանջ էր, որն ավելացվեց Python 3.X-ում, բայց այս գիրքը հենց այն է ներկայացնում։)

Սակայն file-ը բեռնելուց հետո exec կանչն ունի import-ին նման ազդեցություն, բայց իրականում չի ներմուծում module-ը։ Փոխարենը՝ ամեն անգամ, երբ այս կերպ գործարկում եք exec / open համակցությունը, այն file-ի code-ը կատարում է նորից և անվերապահորեն՝ կարծես file-ի code-ը տեղադրած լինեիք այնտեղ, որտեղ կանչվում է exec-ը։ Հետևանքներից մեկն այն է, որ exec / open-ի այս սխեմայի դեպքում file-ի փոփոխություններից հետո module-ները վերաբեռնելու կարիք չկա։

Բացասական կողմն այն է, որ քանի որ exec-ն աշխատում է այնպես, կարծես code-ը տեղադրած լինեիք դրա կանչի տեղում, այն կարող է լուռ վերագրել տվյալ պահին ձեր օգտագործած variable-ները։ Օրինակ՝ մեր script1.py-ն value է assignment x name-ով variable-ին։ Եթե այդ name-ն օգտագործվում է նաև exec-ի կանչի տեղում, name-ի value-ն փոխարինվում է՝ առանց զգուշացման.

Գրքի code · PDF էջ 141

  >>> x = 999
  >>> exec(open('script1.py').read())    # Code run
  …same output…

Մեկնաբանություն, տող 2․ code-ի գործարկում

Սկզբնաղբյուրի PDF էջ 142

Գրքի code · PDF էջ 142

  >>> x                                  # Its assi
  'Hack!'

Մեկնաբանություն, տող 1․ Դրա վերագ…

name-ների բախման այս հնարավորությունը նախորդ բաժնի from statement-ին ևս բնորոշ թերություն է։ Ի տարբերություն դրա՝ սովորական import statement-ը file-ը դարձնում է module-ի առանձին namespace, այնպես որ դրա assignment-ները չեն փոխում ներմուծողի տեսանելիության տիրույթի variable-ները։ module-ներն namespace-ներով բաժանելու դիմաց վճարած գինը վերաբեռնելու և name-ները որակավորելու անհրաժեշտությունն է։

Վերջապես, Python-ի code-ը կարող է գործարկվել նաև Python-ի այնպիսի code-ով, որն օգտագործում է standard library-ի գործիքներ՝ զուգահեռ process-ներում command line-եր գործարկելու համար։ Օրինակ՝ os module-ի system կանչը հրամանը կատարում է այնպես, կարծես այն մուտքագրած լինեիք system console-ում (այստեղ վերջում արտապատկերված 0 վերադարձվող value-ն նշանակում է, որ ամեն ինչ հաջողվել է).

Գրքի code · PDF էջ 142

  $ python3
  >>> import os
  >>> os.system('python3 script1.py')
  darwin
  1267650600228229401496703205376

Սկզբնաղբյուրի PDF էջ 143

Գրքի code · PDF էջ 143

  Hack!Hack!Hack!Hack!Hack!Hack!Hack!Hack!
  0

os module-ի popen կանչը նման բան է անում, սակայն վերադարձնում է file-ի object, որից կարող եք գործարկված հրամանի տպած ելքը կարդալ որպես string՝ գործարկող code-ում օգտագործելու համար։ Իսկ Python-ի subprocess.run կանչը կարելի է օգտագործել command line-երով program-եր գործարկելու համար՝ մանրամասների նկատմամբ շատ ավելի մեծ վերահսկողությամբ։ popen-ը կկիրառենք Գլուխ 21-ում։

Թեև այս գործիքները կապված են code-ի գործարկման հետ, դրանք շատ դուրս են այս սկզբնական գլխի շրջանակից, ուստի, եթե և երբ նման միջոցները ձեր ապագա աշխատանքում օգտակար դառնան, ամբողջական տեղեկության համար դիմեք Python-ի library-ի ձեռնարկներին։ Եվ մի զգուշացում. այս գործիքները, exec-ի հետ միասին, հաճույքով կկատարեն ձեր փոխանցած ցանկացած command line՝ ներառյալ ձեր բոլոր file-երը ջնջողը։ Ուստի լավ կլինի դրանց օգտագործումը սահմանափակել Python-ի հրամանների գործարկմամբ, մինչև համոզված լինեք, որ մյուս հրամաններն անվտանգ են։

Արդեն տեսաք Python-ի code գործարկելու տարբերակների մի ամբողջ հեղեղ, սակայն այս թվարկումը դեռ ամբողջական չէ։ Օրինակ՝ այսօր Python-ի code-ը կարող է գործարկվել նաև հետևյալ միջոցներով.

Սկզբնաղբյուրի PDF էջ 144

C-ով, C++-ով, Java-ով և այլ լեզուներով գրված program-եր, որոնք ներդնում են Python-ն ու Python-ի code-ը
text editor-ներ, որոնք լիարժեք IDE-ներ չեն, բայց կարողանում են գործարկել ձեր խմբագրած Python-ի code-ը
Excel աղյուսակներ՝ Python-ով encoded բջիջները հաշվարկելիս
Վեբ սերվերներ, որոնք ինքնաբերաբար script-ներ են գործարկում՝ ի պատասխան դիտարկիչի օգտատիրական interface-ում կատարված գործողությունների
Օգտատերեր, որոնք գործարկում են ինքնուրույն կատարվող file-եր. դրանք ուսումնասիրեցինք Գլուխ 2-ում
Եվ, ինչպես միշտ, ավելին

Ավելին, գործարկման եղանակները հակված են զարգանալու այնքան արագ, որքան հաշվողական աշխարհի մնացած ամեն ինչ, և ապագա տարբերակները կանխատեսել հնարավոր չէ։ Ընդհանուր առմամբ, քանի որ Python-ը համընթաց է նման փոփոխություններին, Python-ի program-երը պետք է կարողանաք գործարկել ձեր օգտագործած սարքերի համար իմաստ ունեցող ցանկացած ձևով՝ թե՛ հիմա, թե՛ ապագայում. լինի դա սմարթֆոնի էկրանին մատը սահեցնելով, վիրտուալ իրականությունում պատկերակներ բռնելով, թե գործընկերների զրույցների ձայնը գերազանցելով՝ script-ի name-ը բղավելով։

Սկզբնաղբյուրի PDF էջ 145

Այսքան տարբերակների առկայությամբ սկսնակները բնականաբար կարող են հարցնել. ո՞րն է ինձ համար լավագույնը։ Ընդհանուր առմամբ, եթե նոր եք սկսում Python-ով աշխատել, պետք է փորձեք և՛ հիմնական command line-երը, և՛ IDLE-ի graphical interface-ը, եթե չեք աշխատելու սմարթֆոնների հավելվածներում կամ ավելի յուրահատուկ interface-ներով վեբ նոթատետրերում։ command line-երը պարզ են և հզոր, սակայն IDLE-ն ապահովում է օգտատիրոջ համար հարմար գրաֆիկական միջավայր, որը թաքցնում է որոշ հիմքում ընկած մանրամասներ և բոլոր անհատական computer-ներում նույն կերպ է աշխատում։

Մյուս կողմից, եթե փորձառու programmer եք, գուցե ձեզ ավելի հարմար լինի պարզապես մի պատուհանում բացել ձեր ընտրած text editor-ը, իսկ մյուսում՝ system console-ը՝ խմբագրված program-երը Python-ի command line-երով գործարկելու համար։ Քանի որ development environment-ի ընտրությունը խիստ սուբյեկտիվ է, այս գիրքը չի կարող շատ ավելին առաջարկել համընդհանուր ուղեցույցների առումով։ Ընդհանուր առմամբ, այն միջավայրը, որը ձեզ դուր է գալիս օգտագործել, լավագույնը կլինի ձեզ համար։

Սկզբնաղբյուրի PDF էջ 146

Այս գլխում ուսումնասիրեցինք Python-ի program-եր գործարկելու տարածված եղանակները՝ ինտերակտիվ մուտքագրված code-ը կատարելով և file-երում պահված code-ը գործարկելով համակարգային command line-երով, file-երի պատկերակների սեղմումներով, IDLE-ի նման IDE-ների graphical interface-ներով և այլ ձևերով։ Այստեղ ընդգրկեցինք աշխատանքի մեկնարկի բազմաթիվ գործնական հարցեր։ Այս գլխի նպատակն էր ձեզ բավարար տեղեկություն տալ՝ code գրել սկսելու համար, ինչն անելու եք այս գրքի հաջորդ մասում։ Այնտեղ կսկսենք ուսումնասիրել հենց Python լեզուն՝ դրա հիմնական տվյալների type-երից՝ ձեր program-երի մշակման առարկան հանդիսացող object-ներից։

Սակայն նախ անցեք գլխի սովորական հարցաշարը՝ այստեղ սովորածը վարժելու և կրկնելու համար։ Քանի որ սա գրքի այս մասի վերջին գլուխն է, դրան հաջորդում է ավելի ամբողջական վարժությունների հավաքածու, որը ստուգում է այս ամբողջ մասի թեմաներին ձեր տիրապետումը։ Խնդիրների այդ վերջին հավաքածուի օգնության ու պատասխանների համար, կամ պարզապես գիտելիքը թարմացնելու նպատակով, վարժությունները փորձելուց հետո անպայման դիմեք Հավելված B-ին։

Սկզբնաղբյուրի PDF էջ 147

1. Python-ի ինտերակտիվ աշխատաշրջանը կարելի է սկսել՝ ձեր համակարգի վահանակի պատուհանում Python-ի command line մուտքագրելով։ Windows-ում մուտքագրեք py, իսկ այլ հարթակներում՝ python3. այն մուտքագրեք Windows-ի Command Prompt կամ PowerShell պատուհանում, macOS-ի և Linux-ի Terminal-ում կամ Android-ի Termux հավելվածում։ Մեկ այլ տարբերակ է IDLE-ն գործարկելը, քանի որ դրա հիմնական Shell պատուհանն ինտերակտիվ աշխատաշրջան է։ Այլ IDE-ներ,

Սկզբնաղբյուրի PDF էջ 148

սմարթֆոնների հավելվածներ և դիտարկիչի վրա հիմնված համակարգեր կարող են REPL-ներ առաջարկել ավելի յուրահատուկ եղանակներով։

2. Համակարգային command line-երը մուտքագրում եք նույն interface-ում, որն օգտագործվում է command line-ով ինտերակտիվ աշխատաշրջան սկսելու համար։ Դա այն է, ինչ ձեր հարթակը տրամադրում է որպես system console. կրկին՝ Command Prompt կամ PowerShell Windows-ում, Terminal macOS-ում ու Linux-ում, Termux Android-ում կամ այլ միջոց։ Սա մուտքագրում եք համակարգի prompt-ի մոտ, որն այս գրքում ներկայացված է $ նշանով, այլ ոչ Python-ի ինտերակտիվ interpreter-ի >>> prompt-ի մոտ, որն օգտագործվում է Python-ի code մուտքագրելու համար։ Զգույշ եղեք՝ այս prompt-երը չշփոթեք, քանի որ Python-ն ու համակարգային shell-ը տարբեր համակարգեր են։

3. script-ի, իրականում՝ module-ի, file-ի code-ը կարելի է գործարկել համակարգային command line-երով, file-երի պատկերակներին սեղմելով, ներմուծումներով ու վերաբեռնումներով, built-in exec function-ով, os module-ի գործիքներով և IDE-ի graphical interface-ի միջոցներով, օրինակ՝ IDLE-ի Run→Run Module ընտրացանկի հրամանով։ Որոշ հարթակներ աջակցում են գործարկման ավելի մասնագիտացված եղանակներ, օրինակ՝ քաշել-գցելը macOS-ում, հավելվածների interface-ները սմարթֆոններում և վեբ նոթատետրերը։ Բացի այդ, որոշ text editor-ներ ունեն Python-ի code գործարկելու յուրահատուկ եղանակներ, Python-ի որոշ program-եր տրամադրվում և գործարկվում են որպես ինքնուրույն կատարվող file-եր, իսկ որոշ համակարգեր Python-ի code-ն օգտագործում են ներդրված ռեժիմում, որտեղ այն գործարկվում է այլ լեզվով գրված ընդգրկող program-ի կողմից։ Թեև սա դեռ սկզբնական փուլում է, code-ը կարող է գործարկվել նաև վեբ դիտարկիչներում՝ Python-ը WebAssembly տեղափոխող Pyodide-ի նման միջոցներով։

Սկզբնաղբյուրի PDF էջ 149

4. Այն script-ները, որոնք տպում են, ապա ավարտվում, առաջացնում են ելքային file-ի անմիջապես անհետանալը՝ նախքան կհասցնեք դիտել ելքը։ input()-ը կարող է դադար տալ ավարտից առաջ, որպեսզի ելքային պատուհանը բաց մնա, սակայն ձեր script-ի առաջացրած error message-ները նույնպես հայտնվում են ելքային պատուհանում, որը փակվում է նախքան կհասցնեք ուսումնասիրել դրա բովանդակությունը և նախքան կհասնեք input()-ի դադարին։ Ուստի մշակման մեծ մասի համար համակարգային command line-երն ու IDLE-ի նման IDE-ներն ավելի լավ են։

5. Լռելյայն Python-ը յուրաքանչյուր process-ում module-ը ներմուծում, այսինքն՝ բեռնում է միայն մեկ անգամ, ուստի, եթե փոխել եք դրա source code-ը և ցանկանում եք կատարել նոր տարբերակը՝ առանց Python-ը դադարեցնելու ու վերագործարկելու, ստիպված եք այն վերաբեռնել։ Վերաբեռնելուց առաջ պետք է module-ը գոնե մեկ անգամ ներմուծած լինեք։ code-ի file-երը համակարգային shell-ի command line-ից, պատկերակի սեղմումով կամ IDLE-ի նման IDE-ում գործարկելիս սա հիմնականում խնդիր չէ, քանի որ գործարկման այդ սխեմաները սովորաբար ամեն անգամ կատարում են source code-ի file-ի ընթացիկ տարբերակը։ exec / open զույգը նույնպես կարող է վերացնել վերաբեռնումների կարիքը։

6. Այն file-ի տեքստի խմբագրման պատուհանում, որը ցանկանում եք գործարկել, ընտրեք պատուհանի Run→Run Module ընտրացանկի հրամանը։ Սա պատուհանի source code-ը կատարում է որպես վերին մակարդակի script-ի file IDLE-ում և դրա ելքը ցուցադրում Python-ի ինտերակտիվ «Shell» պատուհանում։

Սկզբնաղբյուրի PDF էջ 150

7. module-ի յուրաքանչյուր file ինքնաբերաբար namespace է, այսինքն՝ variable-ների մի հավաքածու, որն արտացոլում է file-ի վերին մակարդակում կատարված assignment-ները։ module-ի յուրաքանչյուր variable ներմուծման ժամանակ դառնում է module-ի attribute և հասանելի է «.»-ով որակավորմամբ կամ from-ի միջոցով name-ների պատճեններով։ namespace-ներն օգնում են խուսափել Python-ի program-երում name-ների բախումներից. քանի որ module-ի յուրաքանչյուր file ինքնաբավ namespace է, file-երը պետք է բացահայտ ներմուծեն այլ file-երը՝ դրանց name-ներն օգտագործելու համար։

Սկզբնաղբյուրի PDF էջ 151

Ժամանակն է սկսել մի փոքր ինքնուրույն code գրել։ Վարժությունների այս առաջին բաժինը բավական պարզ է, սակայն նախատեսված է համոզվելու, որ պատրաստ եք աշխատելու գրքի մնացած մասի հետ զուգահեռ, իսկ դրա որոշ հարցեր ակնարկում են հետագա գլուխներում ներկայացվելիք թեմաներ։ Պատասխանների համար անպայման ստուգեք Հավելված B-ի «Մաս I. Աշխատանքի սկիզբ» բաժինը. վարժություններն ու դրանց լուծումները երբեմն պարունակում են հիմնական տեքստում չքննարկված լրացուցիչ տեղեկություն, ուստի խորհուրդ է տրվում նայել լուծումներին նույնիսկ այն դեպքում, երբ կարողանում եք բոլոր հարցերին ինքնուրույն պատասխանել։

1. Փոխազդեցություն. համակարգային command line-ի, IDLE-ի կամ ձեր սարքում աշխատող որևէ այլ եղանակի միջոցով սկսեք Python-ի ինտերակտիվ command line-ը (>>> prompt-ը, որը նաև կոչվում է REPL) և մուտքագրեք 'Hello World!' expression-ը՝ ներառյալ չակերտները։ string-ը պետք է արտապատկերվի ձեզ։ Այս վարժության նպատակը ձեր միջավայրը Python գործարկելու համար կազմաձևելն է։ Հազվադեպ իրավիճակներում կարող է անհրաժեշտ լինել մուտքագրել Python-ի կատարվող file-ի ամբողջ ուղին կամ դրա ուղին ավելացնել ձեր PATH միջավայրի variable-ին։ Անհրաժեշտության դեպքում միջավայրի variable-ների կարգավորումների վերաբերյալ խորհուրդների համար տե՛ս Հավելված A։

Սկզբնաղբյուրի PDF էջ 152

2. program-եր. ձեր ընտրած text editor-ով գրեք պարզ module file, որը պարունակում է միակ print('Hello module world!') statement-ը, և պահեք այն որպես module1.py։ Այժմ գործարկեք այս file-ը ձեր նախընտրած ցանկացած եղանակով՝ IDLE-ում, սեղմելով կամ հպվելով դրա file-ի պատկերակին, վահանակի command line-ով (օրինակ՝ python3 module1.py), code-ի ներսում կատարելով այն exec-ի և ներմուծումների/վերաբեռնումների նման գործիքներով կամ օգտագործելով հավելվածների, այլ IDE-ների ու վեբ նոթատետրերի interface-ի տարբերակները։ Իրականում փորձարկեք՝ ձեր file-ը գործարկելով այս գլխում քննարկված հնարավորինս շատ եղանակներով։ Ո՞ր եղանակն է ձեզ ամենահեշտը թվում։

3. module-ներ. սկսեք Python-ի ինտերակտիվ command line-ը (>>> prompt-ը) և ներմուծեք վարժություն 2-ում ձեր գրած module-ը։ Փորձեք file-ը տեղափոխել այլ directory և նորից ներմուծել սկզբնական directory-ից, այսինքն՝ ներմուծելիս Python-ը գործարկեք սկզբնական directory-ում։ Ի՞նչ է տեղի ունենում։ Հուշում. այնտեղի __pycache__ subdirectory-ում module1-ի համար դեռ կա .pyc bytecode-ի file, սակայն այն տարօրինակ անուն ունի։ Ընդհանուր առմամբ՝ ներմուծումները module-ներ են փնտրում ընթացիկ directory-ում, ինչպես նաև PYTHONPATH միջավայրի variable-ում նշված յուրաքանչյուր directory-ում, ինչպես կիմանաք Մաս V-ում։

4. script-ներ. եթե ձեր հարթակը դա աջակցում է, module1.py module file-ը պատճենեք մեկ այլ՝ script1.py անունով file-ի մեջ, ապա script1.py-ի սկզբում ավելացրեք #! line-ը, այս file-ին տվեք կատարման

Սկզբնաղբյուրի PDF էջ 153

իրավունքներ և գործարկեք այն անմիջապես որպես կատարվող file, օրինակ՝ առանց «python3»-ի։ Ի՞նչ պետք է պարունակի առաջին line-ը։ #! line-երն ավանդաբար իմաստ ունեն միայն Unix-ի նման հարթակներում, օրինակ՝ macOS-ում, Linux-ում և Android-ում, սակայն այսօր կիրառվում են նաև Windows-ում՝ py Windows գործարկիչի շնորհիվ։ Եթե աշխատում եք Windows-ում, նաև փորձեք ձեր file-ը գործարկել՝ Command Prompt պատուհանում նշելով միայն դրա name-ը՝ առանց դրան նախորդող py բառի, Start ընտրացանկից, Windows+R Run երկխոսության պատուհանից կամ այլ եղանակներով։ macOS-ում փորձեք այն քաշել ու գցել Applications-ում կամ այլ տեղ գտնվող Python Launcher հավելվածի վրա։

5. Սխալներ և debugging. փորձարկեք՝ Python-ի ինտերակտիվ command line-ում, այսինքն՝ REPL-ում, մուտքագրելով մաթեմատիկական expression-ներ ու assignment-ներ։ Ընթացքում մուտքագրեք 2 ** 500 և 1 / 0 expression-ները և դիմեք չսահմանված variable-ի name-ի, ինչպես արեցինք այս գլխի սկզբում։ Ի՞նչ է տեղի ունենում։
Գուցե դեռ չգիտեք, սակայն սխալ թույլ տալիս զբաղվում եք exception handling-ով՝ մի թեմայով, որը խորությամբ կուսումնասիրենք Մաս VII-ում։ Ինչպես այնտեղ կիմանաք, տեխնիկապես դուք գործարկում եք այսպես կոչված լռելյայն exception-ի մշակիչը՝ ստանդարտ error message տպող տրամաբանությունը։ Եթե դուք չեք որսում սխալը, լռելյայն մշակիչը որսում է այն և ի պատասխան տպում ստանդարտ error message-ը։

Սկզբնաղբյուրի PDF էջ 154

exception-ները Python-ում կապված են նաև debugging-ի գաղափարի հետ։ Երբ նոր եք սկսում, exception-ների դեպքում Python-ի լռելյայն error message-ները հավանաբար կտրամադրեն սխալների մշակման այնքան աջակցություն, որքան անհրաժեշտ է ձեզ. դրանք նշում են սխալի պատճառը և ցույց տալիս ձեր code-ի այն line-երը, որոնք ակտիվ էին սխալի առաջացման պահին։ debugging-ի մասին ավելի մանրամասն տե՛ս առաջիկա «Python-ի code-ի debugging» ներդիրում։

6. Ընդհատումներ և cycle-եր. Python-ի ցանկացած REPL-ում մուտքագրեք.

Գրքի code · PDF էջ 154

    L = [1, 2]              # Make a 2-item list
    L.append(L)             # Append L as a single
    L                       # Print L: a cyclic/cir

Մեկնաբանություն, տող 1․ Ստեղծել 2 տարրով list

Մեկնաբանություն, տող 2․ L-ն ավելացնել որպես մեկ…

Մեկնաբանություն, տող 3․ Արտածել L-ը՝ ցիկլային/շրջա…

Ի՞նչ է տեղի ունենում։ Python-ի բոլոր տարբերակներում, բացի ամենահնագույններից, կտեսնեք տարօրինակ ելք, որը նկարագրված է Հավելված B-ի լուծման մեջ և ավելի հասկանալի կդառնա, երբ գրքի հաջորդ մասում ուսումնասիրեք object-ների reference-ները։ Ձեր կարծիքով՝ ինչո՞ւ է Python-ի ձեր տարբերակն այս code-ին այդպես արձագանքում։

7. Փաստաթղթավորում. շարունակելուց առաջ առնվազն հինգ րոպե հատկացրեք Python-ի library-ի և լեզվի ձեռնարկները թերթելուն՝ պատկերացում կազմելու standard library-ում հասանելի գործիքների և փաստաթղթերի հավաքածուի կառուցվածքի մասին։ Առնվազն այսքան

Սկզբնաղբյուրի PDF էջ 155

ժամանակ է պետք՝ ձեռնարկների հավաքածուում հիմնական թեմաների տեղերին ծանոթանալու համար. դրանից հետո անհրաժեշտը գտնելը հեշտ է։ Այս ձեռնարկը կարող եք գտնել Windows-ի որոշ տարբերակների Python Start ընտրացանկի տարրում, IDLE-ի Help բացվող ընտրացանկի Python Docs տարբերակում կամ առցանց՝ http://www.python.org/doc հասցեում։ Ձեռնարկների և փաստաթղթավորման այլ աղբյուրների, ներառյալ PyDoc-ի ու help function-ի մասին ավելի շատ կիմանաք նաև Գլուխ 15-ում։ Եթե դեռ ժամանակ ունեք, ուսումնասիրեք Python-ի կայքը, ինչպես նաև դրա՝ երրորդ կողմերի ընդլայնումների PyPI շտեմարանը. օրինակ՝ python.org-ի About և Search բաժինները կարող են օգտակար լինել աշխատանքի սկզբում։

Սկզբնաղբյուրի PDF էջ 156

PYTHON-Ի code-ի debugging
Բնականաբար, այս գրքի ընթերցողներից ոչ մեկի code-ում երբեք վրիպակներ չեն լինում (այստեղ ժպտիկ պատկերացրեք), բայց ձեր պակաս հաջողակ ընկերների համար, որոնց մոտ գուցե լինում են, ահա իրական աշխատանքում Python programmer-ների կողմից իրենց code-ի սխալները վրիպազերծելու տարածված ռազմավարությունների արագ ակնարկը։ Առաջին երկուսը ուսուցման սկզբնական փուլում գուցե լիովին բավարար լինեն, սակայն մյուսները կարող են կարևոր դառնալ, երբ սկսեք ավելի մեծ script-ներ գրել։ Բոլորն էլ օգտակար է վերանայել հիմա՝ նախքան հաջորդ գլխում լրջորեն կսկսեք code գրել և programming-ի մեջ անխուսափելի սխալները կատարել։

Ոչինչ մի՛ արեք։ Սա չի նշանակում, թե Python programmer-ները չեն debugging իրենց code-ը։ Սակայն երբ սխալվում եք Python-ի program-ում, ստանում եք օգտակար ու ընթեռնելի error message։ Այն ճշգրիտ ցույց է տալիս սխալի տեղը ձեր code-ում՝ file-ով և line-ով, և նույնիսկ կարող է առաջարկել «Արդյո՞ք դուք…» տեսակի ուղղում, ինչպես տեսաք այս գլխում ավելի վաղ։ Եթե արդեն գիտեք Python-ը, հատկապես երբ գործ ունեք ձեր սեփական code-ի հետ, սա հաճախ բավական է. կարդացեք error message-ը և ուղղեք նշված line-ը։ Շատ դեպքերում Python-ում debugging-ը սա է։
Տեղադրեք print statement-ներ։ Հավանաբար Python programmer-ների՝ code-ը վրիպազերծելու հիմնական եղանակը print statement-ներ տեղադրելն ու նորից գործարկելն է։ Քանի որ Python-ի code-ի մեծ մասը փոփոխություններից անմիջապես հետո աշխատում է, սա սովորաբար ամենաարագ եղանակն է՝

Սկզբնաղբյուրի PDF էջ 157

ավելի շատ տեղեկություն ստանալու, քան տալիս են error message-ները։ print statement-ները պարտադիր չէ, որ բարդ լինեն. պարզ «Ես այստեղ եմ» ազդանշանը կամ variable-ների value-ների ցուցադրումը սովորաբար բավական են անհրաժեշտ համատեքստը տրամադրելու համար։ Եթե գրում եք վահանակի պատուհան չունեցող program-եր, օրինակ՝ որոշ GUI-ներ ու հավելվածներ, գուցե պետք լինի տպված հաղորդագրությունները փնտրել ինքնաբերաբար ստեղծվող գրանցամատյանի file-ում կամ օգտվել հաջորդ կետից։
Ավելացրեք logging module-ի կանչեր։ Նախորդ կետի ազդանշանային հաղորդագրությունները print-ի փոխարեն կարող են օգտագործել նաև Python-ի logging module-ը՝ գործընթացն ավելի ձևական դարձնելու և ելքն ավելի լավ կառավարելու համար։ Քանի որ սա որոշ նախապատրաստություն է պահանջում, այն ավելի տարածված է խոշոր program-երում, քան մարտավարական script-ներում։ logging-ի օգտագործման մանրամասների համար տե՛ս Python-ի library-ի ձեռնարկը։
Օգտագործեք գրաֆիկական debugger-ներ։ Ավելի մեծ համակարգերի համար, որոնք դուք չեք գրել, և սկսնակների համար, որոնք ցանկանում են ավելի մանրամասն հետևել code-ի կատարմանը, Python-ի մշակման գրաֆիկական միջավայրերի մեծ մասն ունի մատնանշումով ու սեղմումով debugging-ի որևէ աջակցություն։ IDLE-ն նույնպես ունի debugger, սակայն գործնականում այն կարծես շատ հաճախ չի օգտագործվում. գուցե այն պատճառով, որ command line չունի, կամ պարզապես քանի որ print statement-ներ ավելացնելը հաճախ ավելի արագ է, քան debugging-ի աշխատաշրջան կարգավորելը։ debugger-ի մասին ավելին իմանալու համար տե՛ս IDLE-ի Help ընտրացանկը կամ պարզապես ինքնուրույն փորձեք այն. դրա հիմնական interface-ը

Սկզբնաղբյուրի PDF էջ 158

նկարագրված է այս գլխում ավելի վաղ։ Այլ IDE-ների նմանատիպ աջակցության համար տե՛ս դրանց փաստաթղթերը։
Օգտագործեք pdb command line-ի debugger-ը։ Ամբողջական վերահսկողության համար Python-ի հետ տրամադրվում է pdb name-ով source code-ի debugger-ը, որը հասանելի է որպես Python-ի standard library-ի module։ pdb-ով հրամաններ եք մուտքագրում՝ line by line անցնելու, variable-ները ցուցադրելու, ընդհատման կետեր սահմանելու ու մաքրելու, մինչև ընդհատման կետ կամ սխալ շարունակելու և այլ գործողությունների համար։ pdb-ն կարող եք գործարկել կամ ներմուծելով այն ու կանչելով pdb.run('code'), կամ որպես վերին մակարդակի script՝ python3 -m pdb file.py հրամանով։ Կարող եք նաև սխալ առաջանալուց հետո ներմուծել և կանչել pdb-ի հետմահու վերլուծության pdb.pm()-ը՝ ավելի շատ տեղեկություն ստանալու, թե ինչն է սխալ գնացել։ pdb-ին կվերադառնանք Գլուխ 36-ում, սակայն օգտագործման լրացուցիչ խորհուրդների համար տե՛ս Python-ի library-ի ձեռնարկը և հենց pdb-ի help հրամանը։
Օգտագործեք Python-ի –i command line-ի argument-ը։ Նույնիսկ առանց տպումներ ավելացնելու կամ debugger-ներ գործարկելու կարող եք տեսնել՝ սխալի ժամանակ ինչն է սխալ գնացել։ Եթե ձեր script-ը գործարկում եք command line-ից և Python-ի ու script-ի name-ի միջև փոխանցում եք -i argument-ը, օրինակ՝ python3 –i script.py, Python-ն ինքնաբերաբար կբացի ինտերակտիվ ռեժիմը (>>> prompt-ը), երբ script-ն ավարտվի՝ անկախ նրանից՝ հաջող ավարտվում է, թե սխալի հանդիպում։ Այնուհետև կարող եք տպել variable-ների վերջնական value-ները՝ code-ում տեղի ունեցածի մասին ավելի շատ մանրամասներ ստանալու համար, կամ ներմուծել և գործարկել pdb-ի debugger-ը կամ հետմահու վերլուծության ռեժիմը։

Սկզբնաղբյուրի PDF էջ 159

Որսացեք և մշակեք սխալները code-ում։ Ի վերջո, սխալները Python-ում հստակ սահմանված մեխանիզմ են՝ exception-ներ անունով, որոնք կարող եք ձեր սեփական code-ում որսալ, մշակել և դրանցից հետո վերականգնվել։ Թե ինչպես՝ կսովորեք Մաս VII-ում։

debugging-ի մասին գուցե ամենակարևոր միտքն այն է, որ Python-ում սխալները, որպես կանոն, հայտնաբերվում ու հաղորդվում են՝ լուռ անցնելու կամ ամբողջ համակարգը խափանելու փոխարեն։ Իհարկե, սխալվելը երբեք հաճելի չէ, սակայն հատկապես նրանց համար, ովքեր հիշում են, երբ debugging-ը նշանակում էր հանել տասնվեցական հաշվիչը և ուսումնասիրել memory-ի արտապատկերման տպված թղթերի կույտերը, Python-ի debugging-ի աջակցությունը սխալները դարձնում է շատ ավելի քիչ ցավոտ, քան դրանք այլապես կլինեին։

Մաս II․ object-ներ և գործողություններ

Սկզբնաղբյուրի PDF էջ 160

4․ Ծանոթություն Python-ի object-ներին

name՝ a · reference · object՝ [1, 2] · type՝ list · name-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։name՝ areferenceobject՝ [1, 2]type՝ listname-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։

Սկզբնաղբյուրի PDF էջ 161

Այս գլխով սկսվում է մեր շրջայցը Python լեզվով։ Ոչ պաշտոնական իմաստով՝ Python-ում մենք բաների հետ գործողություններ ենք անում։ «Գործողությունները» ընդունում են գումարման ու կցման նման գործողությունների ձև, իսկ «բաները» այն object-ներն են, որոնց նկատմամբ կատարում ենք այդ գործողությունները։ Գրքի այս մասում կենտրոնանալու ենք հենց այդ բաների և դրանց հետ մեր program-երի կատարելիք գործողությունների վրա։

Մի փոքր ավելի պաշտոնական ձևակերպմամբ՝ Python-ում տվյալներն object-ների ձև ունեն. դրանք կա՛մ Python-ի տրամադրած built-in object-ներ են, օրինակ՝ string-երն ու list-ները, կա՛մ լրացուցիչ object-ներ, որոնք ստեղծում ենք Python-ի class-երով կամ արտաքին լեզուների գործիքներով։ Ինչպես կտեսնեք, այս object-ներն ըստ էության պարզապես memory-ի հատվածներ են՝ value-ներով և դրանց հետ կապված գործողություններով։ Ավելին, Python-ի script-ում ամեն ինչ object է։ Նույնիսկ պարզ թվերն են համապատասխանում այս սահմանմանը՝ իրենց value-ներով, օրինակ՝ 99, և աջակցվող գործողություններով՝ +, - և այլն։

Քանի որ object-ները նաև Python-ով programming-ի ամենահիմնարար հասկացությունն են, այս գլուխը սկսում ենք Python-ի built-in object-ների type-երը նախնականորեն ներկայացնող ակնարկով։ Այս մասի հետագա գլուխներում երկրորդ անգամ կանդրադառնանք դրանց՝ լրացնելով այն մանրամասները, որոնք այս ակնարկում հպանցիկ կանցնենք։ Այստեղ մեր նպատակը հիմունքները ներկայացնող համառոտ շրջայցն է։

Սկզբնաղբյուրի PDF էջ 162

Նախքան code-ին անցնելը՝ եկեք հստակ պատկերացնենք, թե այս գլուխն ինչպես է տեղավորվում Python-ի ընդհանուր պատկերի մեջ։ Ավելի կոնկրետ տեսանկյունից Python-ի program-երը կարելի է բաժանել module-ների, statement-ների, expression-ների և object-ների՝ հետևյալ կերպ.

1. program-երը կազմված են module-ներից։

2. module-ները պարունակում են statement-ներ։

3. statement-ները պարունակում են expression-ներ։

4. expression-ները ստեղծում և մշակում են object-ներ։

Գլուխ 3-ում module-ների քննարկումը ներկայացրեց այս հիերարխիայի ամենաբարձր մակարդակը։ Այս մասի գլուխները սկսում են ներքևից՝ ուսումնասիրելով և՛ built-in object-ները, և՛ այն expression-ները, որոնք կարող եք գրել դրանք օգտագործելու համար։

statement-ներին կանցնենք գրքի հաջորդ մասում, թեև կտեսնեք, որ դրանք հիմնականում գոյություն ունեն այստեղ հանդիպող object-ները կառավարելու համար։ Ավելին, երբ հասնենք գրքի OOP մասի class-երին, կբացահայտեք, որ դրանք թույլ են տալիս սահմանել ձեր սեփական նոր object-ների type-երը՝ և՛ օգտագործելով, և՛ նմանակելով այն object-ների type-երը, որոնք ուսումնասիրելու եք այստեղ։ Այս ամենի

Սկզբնաղբյուրի PDF էջ 163

պատճառով built-in object-ները Python-ի ցանկացած ուղևորության պարտադիր մեկնակետն են։

ՆՇՈՒՄ
Մի պահ տերմինաբանության մասին. programming-ի ավանդական ներածությունները հաճախ շեշտադրում են դրա երեք հիմնասյուները՝ sequence-ը («Արա սա, հետո՝ այն»), ընտրությունը («Արա սա, եթե այն ճշմարիտ է») և կրկնությունը («Արա սա բազմիցս»)։ Python-ն ունի բոլոր երեք կատեգորիաների գործիքներ, և այս եզրույթները կարող են սկզբնական շրջանում օգնել համակարգել ձեր մտածողությունը։ Սակայն դրանք նաև արհեստական ու պարզունակ են և կարող են շփոթեցնել։ Օրինակ՝ comprehension-ների (comprehension) նման գործիքները և՛ կրկնություն են, և՛ ընտրություն, այս եզրույթները Python-ում ունեն այլ՝ ավելի որոշակի իմաստներ, իսկ բազմաթիվ հետագա հասկացություններ կարծես ընդհանրապես չեն տեղավորվում այս կաղապարում։ Python-ում ավելի ուժեղ միավորող սկզբունքն object-ներն են և այն, թե ինչ կարող ենք անել դրանց հետ։ Պատճառը տեսնելու համար շարունակեք կարդալ։

Եթե օգտագործել եք ավելի ցածր մակարդակի programming language-ներ, գիտեք, որ ձեր աշխատանքի մեծ մասը կենտրոնանում է object-ների, որոնք նաև կոչվում են տվյալների կառուցվածքներ, իրականացման վրա՝ ձեր կիրառության առարկայական ոլորտի բաղադրիչները ներկայացնելու համար։ Գուցե պետք լինի կազմակերպել memory-ի կառուցվածքները, կառավարել memory allocation-ը, իրականացնել որոնման ու հասանելիության ենթածրագրեր և այլն։ Այս պարտականությունները մոտավորապես նույնքան ձանձրալի են և սխալների հակված, որքան հնչում են, և սովորաբար շեղում են ձեր program-ի իրական նպատակներից։

Սկզբնաղբյուրի PDF էջ 164

Python-ի սովորական program-երում այս սևագործ աշխատանքի մեծ մասը վերանում է։ Քանի որ Python-ը որպես լեզվի անբաժանելի մաս տրամադրում է object-ների հզոր type-եր, սովորաբար խնդիրներ լուծել սկսելուց առաջ object-ների implementation-ներ գրելու կարիք չկա։ Իրականում, եթե չունեք հատուկ մշակման կարիք, որը built-in object-ները չեն ապահովում, գրեթե միշտ ավելի լավ է օգտագործել built-in object՝ ձեր սեփականն իրականացնելու փոխարեն։ Ահա մի քանի պատճառ.

built-in object-ները հեշտացնում են program-եր գրելը։ Ավելի պարզ խնդիրներում առարկայական ոլորտների կառուցվածքը ներկայացնելու համար հաճախ միայն built-in object-ներն են պետք։ Քանի որ հավաքածուների՝ list-ների, և որոնման աղյուսակների՝ dictionary-ների նման հզոր գործիքները ստանում եք պատրաստի, կարող եք դրանք անմիջապես օգտագործել։ Միայն Python-ի built-in object-ների type-երով արդեն կարող եք մեծ աշխատանք կատարել։
built-in object-ները ընդլայնումների բաղադրիչներ են։ Ավելի բարդ առաջադրանքների համար գուցե պետք լինի տրամադրել ձեր սեփական object-ները՝ Python-ի class-երով կամ C լեզվի interface-ներով։ Սակայն, ինչպես կտեսնեք գրքի հետագա մասերում, ձեռքով իրականացված object-ները հաճախ կառուցվում են list-ների ու dictionary-ների նման built-in object-ների հիման վրա։ Օրինակ՝ stack տվյալների կառուցվածքը կարող է իրականացվել որպես class, որը կառավարում կամ հարմարեցնում է built-in list-ը։

Սկզբնաղբյուրի PDF էջ 165

built-in object-ները հաճախ ավելի արդյունավետ են, քան հատուկ ստեղծված տվյալների կառուցվածքները։ Python-ի built-in object-ներն օգտագործում են արդեն օպտիմալացված algorithm-ներ և արագության համար հաճախ իրականացված են C-ի նման ավելի ցածր մակարդակի լեզվով։ Թեև կարող եք ինքնուրույն գրել object-ների նմանատիպ type-եր, սովորաբար դժվար կլինի հասնել built-in object-ների type-երի ապահոված կատարողականության մակարդակին։
built-in object-ները լեզվի ստանդարտ մասն են։ Որոշ առումներով Python-ը փոխառում է թե՛ built-in գործիքների վրա հիմնվող լեզուներից, օրինակ՝ Lisp-ից, թե՛ այն լեզուներից, որոնք գործիքների սեփական implementation-ները թողնում են programmer-ին, օրինակ՝ C++-ից։ Թեև Python-ում կարող եք իրականացնել յուրահատուկ object-ների type-եր, պարզապես սկսելու համար դա անելու կարիք չկա։ Ավելին, քանի որ Python-ի built-in հնարավորությունները ստանդարտ են, դրանք միշտ նույնն են, մինչդեռ սեփական գործիքակազմերը սովորաբար տարբեր են տարբեր աշխատավայրերում։

Այլ կերպ ասած՝ built-in object-ների type-երը ոչ միայն հեշտացնում են programming-ը, այլև ավելի հզոր ու հասանելի են, քան այն ամենի մեծ մասը, ինչը կարելի է ստեղծել զրոյից։ Անկախ նրանից՝ իրականացնում եք object-ների նոր type-եր, թե ոչ, built-in object-ները կազմում են Python-ի յուրաքանչյուր program-ի հիմքը։

Սկզբնաղբյուրի PDF էջ 166

Աղյուսակ 4-1-ը նախնականորեն ներկայացնում է Python-ի built-in object-ները և դրանց literal-ները՝ այսինքն այդ object-ներն ստեղծող expression-ները գրելու syntax-ի մի մասը։ Եթե այլ լեզուներ եք օգտագործել, այս object-ներից մի քանիսը հավանաբար ծանոթ կթվան. օրինակ՝ թվերն ու string-երը ներկայացնում են համապատասխանաբար թվային և տեքստային value-ներ, իսկ file-ի object-ները interface են տրամադրում ձեր համակարգչում պահված իրական file-երը մշակելու համար։

Սակայն որոշ ընթերցողների համար Աղյուսակ 4-1-ի object-ների type-երը կարող են ավելի ընդհանուր և ճկուն լինել, քան նրանք սովոր են։ Օրինակ՝ կտեսնեք, որ միայն list-ներն ու dictionary-ներն արդեն տվյալների ներկայացման հզոր գործիքներ են, որոնք վերացնում են ավելի ցածր մակարդակի լեզուներում հավաքածուներն ու որոնումն ապահովելու համար ձեր կատարած աշխատանքի մեծ մասը։ Մի խոսքով՝ list-ները տրամադրում են այլ object-ների կարգավորված հավաքածուներ, իսկ dictionary-ներն object-ները պահում են ըստ key-ի։ Երկուսն էլ ունեն memory-ի ավտոմատ կառավարում, աջակցում են կամայական ներդրվածության, կարող են ըստ անհրաժեշտության մեծանալ ու փոքրանալ և պարունակել ցանկացած տեսակի object-ներ։

Սկզբնաղբյուրի PDF էջ 167

Աղյուսակ 4-1. Python-ի built-in (հիմնական) object-ները

Բացել այս աղյուսակի ընթեռնելի ուղեցույցը →

object-ի type | literal-ների/ստեղծման օրինակներ

Թվեր | 1234 , 3.1415 , 0b111 , 1_234 , 3+4 [սկզբնաղբյուրում line-ը կտրված է]

Գրքի code · PDF էջ 167

                  j, Decimal, Fraction

string · աղբյուրի աղյուսակից

 Strings            'code', "app's", b'a\x01c', 'h\u
Սկզբնաղբյուրի պատկեր, PDF էջ 167
Սկզբնաղբյուրի պատկեր · PDF էջ 167․ աղյուսակի տողից առանձին արտահանված նշան

Գրքի code · PDF էջ 167

                  00c4ck','hÄck  '

list · աղբյուրի աղյուսակից

 Lists              [1, [2, 'three'], 4.5], list(ra
                  nge(10))

dictionary-ներ | {'job': 'dev', 'years': 40} , di [սկզբնաղբյուրում line-ը կտրված է]

Գրքի code · PDF էջ 167

                  ct(hours=10)

tuple · աղբյուրի աղյուսակից

 Tuples             (1, 'app', 4, 'U'), tuple('hac
                  k'), namedtuple

file · աղբյուրի աղյուսակից

 Files              open('docs.txt'), open(r'C:\dat
                  a.bin', 'wb')

set · աղբյուրի աղյուսակից

 Sets               set('abc'), {'a', 'b', 'c'}

Այլ հիմնական object-ներ | Boolean արժեքներ, type-եր, None

Ծրագրային միավորների | function-ներ, module-ներ, class-եր (Մասեր IV, V,

Սկզբնաղբյուրի PDF էջ 168

object-ի type | literal-ների/ստեղծման օրինակներ

object-ներ | և VI)

implementation-ի object-ներ | compiled code, stack-ի հետագծումներ (Մասեր IV և VII)

Ինչպես նաև ցույց է տրված Աղյուսակ 4-1-ում, ծրագրային միավորները, օրինակ՝ function-ները, module-ներն ու class-երը, որոնց կհանդիպեք գրքի հետագա մասերում, Python-ում նույնպես object-ներ են։ Դրանք ստեղծվում են def-ի, class-ի, import-ի և lambda-ի նման statement-ներով ու expression-ներով և կարող են ազատ փոխանցվել script-ներում, պահվել այլ object-ների ներսում և այլն։ Python-ը տրամադրում է նաև implementation-ին առնչվող object-ների հավաքածու, օրինակ՝ compiled code-ի object-ներ, որոնք սովորաբար ավելի շատ հետաքրքրում են գործիքների ստեղծողներին, քան կիրառությունների մշակողներին։ Դրանք կուսումնասիրենք ավելի ուշ, թեև ավելի փոքր խորությամբ՝ դրանց մասնագիտացված դերերի պատճառով։

Չնայած վերնագրին՝ Աղյուսակ 4-1-ն իրականում ամբողջական չէ, քանի որ Python-ի program-երում մեր մշակած ամեն ինչ որևէ տեսակի object է։ Օրինակ՝ երբ Python-ում տեքստային ձևանմուշների համադրում ենք կատարում, ստեղծում ենք ձևանմուշի object-ներ, իսկ երբ զբաղվում ենք ցանցային սկրիպտավորմամբ, օգտագործում ենք սոկետի object-ներ։ Այս այլ տեսակի object-ները հիմնականում ստեղծվում են ստանդարտ կամ լրացուցիչ library module-ների function-ները ներմուծելով ու օգտագործելով և ունեն իրենց հատուկ վարքը։

Սկզբնաղբյուրի PDF էջ 169

Օրինակ՝ ձևանմուշներն ու սոկետները ստեղծվում են համապատասխանաբար standard library-ի re և socket module-ների գործիքները կանչելով։

Սակայն Աղյուսակ 4-1-ի object-ները սովորաբար անվանում ենք object-ների հիմնական type-եր, քանի որ դրանք փաստացի built-in են հենց Python լեզվի մեջ. այսինքն՝ դրանց մեծ մասը ստեղծելու համար կա expression-ի հատուկ syntax։ Օրինակ՝ երբ REPL-ում կամ program-ի file-ում կատարում եք հետևյալ code-ը՝ չակերտներով շրջապատված character-երով.

Գրքի code · PDF էջ 169

  >>> 'Python'

տեխնիկական իմաստով կատարում եք literal expression, որը ստեղծում և վերադարձնում է string-ի նոր object։ Այս object-ը ստեղծելու համար գոյություն ունի Python լեզվի syntax։ Նմանապես՝ քառակուսի փակագծերով պարփակված expression-ը ստեղծում է list, ձևավոր փակագծերովը՝ dictionary կամ set և այլն։ Թեև, ինչպես կտեսնեք, Python-ը չի պահանջում և չի օգտագործում type-ի հայտարարություններ, ձեր կատարած expression-ների syntax-ը որոշում է ձեր ստեղծած ու օգտագործած object-ների type-երը։ Իրականում, Աղյուսակ 4-1-ի նման object ստեղծող expression-ներն ընդհանուր առմամբ հենց այն տեղերն են, որտեղից Python լեզվում ծագում են type-երը։

Նույնքան կարևոր է այն, որ object ստեղծելուց հետո դրա գործողությունների հավաքածուն կապակցում եք ընդմիշտ. string-ի նկատմամբ կարող եք կատարել միայն string գործողություններ, իսկ list-ի նկատմամբ՝ list։ Պաշտոնական

Սկզբնաղբյուրի PDF էջ 170

տերմիններով սա նշանակում է, որ Python-ն ունի dynamic typing՝ մի մոդել, որը հայտարարությունների code պահանջելու փոխարեն ինքնաբերաբար հետևում է object-ների type-երին, սակայն այն նաև ունի խիստ typing՝ սահմանափակում, ըստ որի object-ի նկատմամբ կարող եք կատարել միայն դրա type-ի համար վավեր գործողություններ։

Աղյուսակ 4-1-ի object-ների յուրաքանչյուր type-ն ամբողջությամբ կուսումնասիրենք առաջիկա գլուխներում։ Սակայն մինչև բոլոր մանրամասների մեջ խորանալը՝ եկեք նախ ավելի արագ նայենք Python-ի հիմնական object-ներին գործողության մեջ։ Այս գլխի մնացած մասը նախնականորեն ներկայացնում է այն գործողությունները, որոնք ավելի խորությամբ կուսումնասիրենք հաջորդ գլուխներում։ Այստեղ ամբողջական պատկերը մի՛ սպասեք. այս գլխի նպատակը միայն ձեր հետաքրքրությունն առաջացնելն ու որոշ առանցքային գաղափարներ ներկայացնելն է։ Այդուհանդերձ, սկսելու լավագույն եղանակը սկսելն է, ուստի եկեք անմիջապես անցնենք object-ների հետ աշխատող իրական code-ի։

Եթե նախկինում որևէ programming կամ սկրիպտավորում եք արել, Աղյուսակ 4-1-ի object-ների որոշ type-եր հավանաբար ծանոթ կթվան։ Նույնիսկ եթե չեք արել, թվերը բավական պարզ են։ Python-ի հիմնական object-ների հավաքածուն ներառում է սովորական տեսակները՝ ամբողջ թվեր, որոնք կոտորակային մաս չունեն, floating-point թվեր, որոնք ունեն այդպիսի մաս, և ավելի արտասովոր type-եր՝ կեղծ մասերով կոմպլեքս թվեր,

Սկզբնաղբյուրի PDF էջ 171

ճկուն ճշտությամբ տասնորդական թվեր, համարիչ ու հայտարար ունեցող ռացիոնալ թվեր և լիարժեք set-ներ։ built-in թվերը բավարար են թվային մեծությունների մեծ մասը ներկայացնելու համար՝ ձեր տարիքից մինչև բանկային հաշվի մնացորդը, սակայն վեկտորների և մատրիցների նման մասնագիտացված թվային object-ները նույնպես հասանելի են որպես երրորդ կողմերի հավելումներ։

Թեև դրանք առաջարկում են ավելի բարդ տարբերակներ, Python-ի հիմնական թվային object-ները, դե՛, հիմնական են։ Python-ի թվերն աջակցում են սովորական մաթեմատիկական գործողություններին։ Օրինակ՝ պլյուսի նշանը (+) կատարում է գումարում, աստղանիշը (*) օգտագործվում է բազմապատկման, իսկ երկու աստղանիշը (**)՝ աստիճան բարձրացնելու համար։ Ահա ցուցադրություն Python-ի այնպիսի REPL-ում, որի մասին սովորեցինք Գլուխ 3-ում.

Գրքի code · PDF էջ 171

  $ python3                        # Start up a REP
  >>> 123 + 222                    # Integer additi
  345
  >>> 1.5 * 4                      # Floating-point
  6.0
  >>> 1_234_567, 0x15, bin(21)     # Separators, he
  (1234567, 21, '0b10101')
  >>> 2 ** 100                     # 2 to the power
  1267650600228229401496703205376

Մեկնաբանություն, տող 1․ Մեկնարկել REP… [կտրված է]

Մեկնաբանություն, տող 2․ Ամբողջ թվերի գումա…

Մեկնաբանություն, տող 4․ floating-point

Մեկնաբանություն, տող 6․ Բաժանիչներ, տասնվե…

Մեկնաբանություն, տող 8․ 2-ն աստիճան բարձրացնել

Ուշադրություն դարձրեք այստեղի վերջին արդյունքին. Python-ի ամբողջ թվի object-ն այսպիսի մեծ թվերի համար ինքնաբերաբար ապահովում է լրացուցիչ ճշտություն, երբ

Սկզբնաղբյուրի PDF էջ 172

անհրաժեշտ է։ Օրինակ՝ Python-ում կարող եք հաշվարկել 2-ի 12,345 աստիճանը որպես ամբողջ թիվ, բայց հավանաբար չպետք է փորձեք խորապես ըմբռնել արդյունքը. գրեթե 4K թվանշանով այն շատ մեծ է ամբողջությամբ ընկալելու համար.

Գրքի code · PDF էջ 172

  >>> len(str(2 ** 12345))         # How many digit
  3717

Մեկնաբանություն, տող 1․ Քանի՞ թվանշա…

Ներդրված կանչի այս ձևն աշխատում է ներսից դեպի դուրս՝ նախ հաշվարկելով **-ի արդյունքը, ապա built-in str function-ով այն փոխակերպելով թվանշանների string-ի, և վերջում len-ով ստանալով արդյունքում ստացված string-ի երկարությունը։ Վերջնական արդյունքը թվի թվանշանների քանակն է։ str-ն ու len-ը երկուսն էլ աշխատում են object-ների բազմաթիվ type-երի հետ, և հետագայում նորից կօգտագործենք դրանք։

Բացի expression-ներից՝ Python-ի հետ տրամադրվում են մի քանի օգտակար թվային module-ներ. module-ները պարզապես լրացուցիչ գործիքների հավաքածուներ են, որոնք ներմուծում ենք օգտագործելու համար՝ Գլուխ 3-ում ներկայացված import-ի նման statement-ներով.

Գրքի code · PDF էջ 172

  >>> import math
  >>> math.pi
  3.141592653589793
  >>> math.sqrt(85)
  9.219544457292887

Սկզբնաղբյուրի PDF էջ 173

math module-ը պարունակում է ավելի առաջադեմ թվային գործիքներ՝ function-ների տեսքով, իսկ random module-ը կատարում է պատահական թվերի գեներացում և պատահական ընտրություններ (այստեղ՝ քառակուսի փակագծերով գրված Python-ի list-ից՝ այլ object-ների կարգավորված հավաքածուից, որը կներկայացնենք այս գլխում ավելի ուշ).

Գրքի code · PDF էջ 173

  >>> import random
  >>> random.random()
  0.7082048489415967
  >>> random.choice([1, 2, 3, 4])
  2

Python-ը նաև ներառում է ավելի արտասովոր թվային object-ներ, օրինակ՝ կոմպլեքս, ֆիքսված ճշտությամբ և ռացիոնալ թվեր, ինչպես նաև set-ներ ու Boolean արժեքներ, իսկ երրորդ կողմերի բաց source code-ով ընդլայնումների ոլորտն առաջարկում է ավելին՝ օրինակ մատրիցներ, վեկտորներ և ընդլայնված ճշտությամբ թվեր։ Այս object-ների քննարկումը կհետաձգենք մինչև այս գլխի և գրքի հետագա հատվածները։

Մինչ այժմ Python-ն օգտագործում էինք պարզ հաշվիչի նման. դրա built-in object-ների ցանկն ավելի արժանվույնս ներկայացնելու համար եկեք անցնենք string-երի ուսումնասիրությանը։

Սկզբնաղբյուրի PDF էջ 174

ՆՇՈՒՄ
Մեծ թվերն ընդդեմ DOS հարձակումների. Python-ի ամբողջ թվերը կարող են կամայականորեն մեծ լինել և նույնիսկ օգտագործվել ընդլայնված ճշտությամբ floating-point value-ներ ներկայացնելու համար։ Սակայն, թեև ամբողջ թվի չափը սահմանափակվում է միայն ձեր համակարգչի memory-ով, Python 3.11 և ավելի նոր տարբերակներում չափազանց մեծ թվերը տասնորդական string-երի փոխակերպելու համար, օրինակ՝ str-ի կամ ցուցադրման նպատակով, պահանջվում են լրացուցիչ քայլեր։ Սա կանխում է ծառայության մերժման հազվադեպ հարձակումները՝ սահմանելով 4,300 թվանշանի սահմանաչափ, որը կարելի է հանել sys module-ի set_int_max_str_digits գործիքով։ Կանչեք այն՝ ավելի մեծ թվերի թվանշանները հաշվելու համար, և բոլոր խրթին մանրամասների համար տե՛ս Python-ի փաստաթղթերը։

string-երն օգտագործվում են ինչպես տեքստային տեղեկություն, օրինակ՝ ձեր name-ը, այնպես էլ byte-երի կամայական հավաքածուներ, օրինակ՝ պատկերի file-ի բովանդակությունը, գրանցելու համար։ Դրանք մեր առաջին օրինակն են այն բանի, ինչը Python-ում կոչում ենք sequence՝ այլ object-ների ըստ դիրքի կարգավորված հավաքածու։ sequence-ները իրենց պարունակած տարրերի միջև պահպանում են ձախից աջ կարգը. դրանց տարրերը պահվում և ստացվում են իրենց հարաբերական դիրքերով։ Խիստ ասած՝ string-երը մեկ character-ից կազմված string-երի sequence-ներ են. այլ՝ ավելի ընդհանուր sequence-ի object-ները ներառում են list-ներն ու tuple-ները, որոնց կանդրադառնանք ավելի ուշ։

Սկզբնաղբյուրի PDF էջ 175

Որպես sequence-ներ՝ string-երն աջակցում են գործողությունների, որոնք ենթադրում են տարրերի դիրքային կարգավորում։ Օրինակ՝ եթե ունենք չակերտների ներսում գրված չորս character-ից կազմված string (ուղիղ մեկական կամ կրկնակի չակերտներ. դրանք նույն բանն են նշանակում, բայց մեկականը ավելի տարածված է և պակաս ծանրաբեռնված), կարող ենք ստուգել դրա երկարությունը built-in len function-ով և ստանալ դրա բաղադրիչները indexing-ի expression-ներով.

Գրքի code · PDF էջ 175

  >>> S = 'Code'           # Make a 4-character str
  >>> len(S)               # Length: number charact
  4
  >>> S[0]                 # The first item in S, i
  'C'
  >>> S[1]                 # The second item from t
  'o'

Մեկնաբանություն, տող 1․ Ստեղծել 4 նիշանոց տո…

Մեկնաբանություն, տող 2․ Երկարություն՝ character-երի քանակ…

Մեկնաբանություն, տող 4․ S-ի առաջին տարրը, i… [կտրված է]

Մեկնաբանություն, տող 6․ Երկրորդ տարրը՝ t… [կտրված է]

Python-ում index-ները գրվում են քառակուսի փակագծերում՝ որպես սկզբից հաշված շեղումներ, ուստի սկսվում են 0-ից. առաջին տարրը 0 index-ում է, երկրորդը՝ 1 index-ում և այդպես շարունակ։

Ուշադրություն դարձրեք, թե այստեղ ինչպես ենք string-ը assignment S անունով variable-ին։ Թե ինչպես է սա աշխատում՝ մանրամասն կքննարկենք ավելի ուշ, հատկապես Գլուխ 6-ում, սակայն Python-ի variable-ները երբեք կարիք չունեն նախապես

Սկզբնաղբյուրի PDF էջ 176

հայտարարվելու։ variable-ը ստեղծվում է, երբ դրան value եք assignment, կարող է ստանալ ցանկացած type-ի object և expression-ում հանդիպելիս փոխարինվում է իր value-ով։ Այն նաև պետք է նախապես value ստացած լինի այն պահին, երբ օգտագործում եք դրա value-ն։ Այս գլխի նպատակների համար բավական է իմանալ, որ object-ը հետագա օգտագործման համար պահելու նպատակով պետք է այն վերագրենք variable-ի։

Python-ում կարող ենք նաև ինդեքսավորել հետընթաց՝ վերջից. դրական index-ները հաշվում են առաջ՝ ձախից, իսկ բացասական index-ները՝ հետ՝ աջից։ Շարունակենք մեր REPL աշխատաշրջանը.

Գրքի code · PDF էջ 176

  >>> S[-1]                # The last item from the
  'e'
  >>> S[-2]                # The second-to-last ite
  'd'

Մեկնաբանություն, տող 1․ Վերջին տարրը՝ …-ից

Մեկնաբանություն, տող 3․ Նախավերջին տար…

Ձևականորեն՝ բացասական index-ը պարզապես գումարվում է string-ի երկարությանը՝ դրական շեղում ստանալու համար, ուստի հետևյալ երկու գործողությունները համարժեք են, թեև առաջինն ավելի հեշտ է գրել և դրանում սխալվելն ավելի դժվար է.

Գրքի code · PDF էջ 176

  >>> S[-1]                # The last item in S
  'e'

Մեկնաբանություն, տող 1․ S-ի վերջին տարրը

Սկզբնաղբյուրի PDF էջ 177

Գրքի code · PDF էջ 177

  >>> S[len(S)-1]          # Negative indexing, the
  'e'

Մեկնաբանություն, տող 1․ Բացասական indexing՝ …

Ուշադրություն դարձրեք, որ քառակուսի փակագծերում կարող ենք օգտագործել կամայական expression, ոչ միայն code-ում ամրագրված թվային literal. ամենուր, որտեղ Python-ն value է սպասում, կարող ենք օգտագործել literal, variable կամ ցանկացած ցանկալի expression։ Այս առումով Python-ի syntax-ն ամբողջովին ընդհանուր է։

Բացի պարզ դիրքային indexing-ից՝ sequence-ները նաև աջակցում են indexing-ի ավելի ընդհանուր ձևի՝ slicing-ին, որը մեկ քայլով ամբողջ հատվածն առանձնացնելու եղանակ է։ Օրինակ՝

Գրքի code · PDF էջ 177

  >>> S                     # A 4-character string
  'Code'
  >>> S[1:3]                # Slice of S from offse
  'od'

Մեկնաբանություն, տող 1․ 4 նիշանոց string

Մեկնաբանություն, տող 3․ S-ի slice-ը՝ սկսած շեղու…

slice-ների մասին մտածելու հավանաբար ամենահեշտ ձևն այն է, որ դրանք մեկ քայլով string-ից մի ամբողջ սյունակ առանձնացնելու միջոց են։ Դրանց ընդհանուր X[I:J] ձևը նշանակում է՝ «տուր ինձ X-ի ամեն ինչ՝ I շեղումից մինչև J շեղումը՝ այն չներառելով»։ Արդյունքը վերադարձվում է նոր object-ով։ Նախորդ

Սկզբնաղբյուրի PDF էջ 178

գործողություններից երկրորդը, օրինակ, մեզ տալիս է S string-ի բոլոր character-երը 1-ից մինչև 2 շեղումներով, այսինքն՝ 1-ից մինչև 3 – 1, որպես նոր string։ Արդյունքում հատվում կամ «առանձնացվում» են մեջտեղի երկու character-երը՝ 1 և 2 շեղումներով։

slice-ի մեջ ձախ սահմանը լռելյայն զրո է, իսկ աջ սահմանը՝ հատվող sequence-ի երկարությունը։ Սրանից բխում են օգտագործման մի քանի տարածված տարբերակներ.

Գրքի code · PDF էջ 178

  >>> S[1:]                 # Everything past the f
  'ode'
  >>> S                     # S itself hasn't chang
  'Code'
  >>> S[0:3]                # Everything but the la
  'Cod'
  >>> S[:3]                 # Same as S[0:3]
  'Cod'
  >>> S[:-1]                # Everything but the la
  'Cod'
  >>> S[:]                  # All of S as a top-lev
  'Code'

Մեկնաբանություն, տող 1․ Ամեն ինչ՝ առաջինից հետո…

Մեկնաբանություն, տող 3․ S-ն ինքը չի փոխվել…

Մեկնաբանություն, տող 5․ Ամեն ինչ՝ բացի վերջի…

Մեկնաբանություն, տող 7․ Նույնը, ինչ S[0:3]-ը

Մեկնաբանություն, տող 9․ Ամեն ինչ՝ բացի վերջի…

Մեկնաբանություն, տող 11․ Ամբողջ S-ը՝ որպես վերին մակար…

Նախավերջին հրամանում նկատեք, թե ինչպես կարող են բացասական շեղումները նաև slice-ների սահմանները տալ, և թե ինչպես է վերջին գործողությունն ըստ էության պատճենում ամբողջ string-ը։ Ինչպես հետագայում կիմանաք՝

Սկզբնաղբյուրի PDF էջ 179

string-ը պատճենելու պատճառ չկա, սակայն այս ձևը կարող է օգտակար լինել այլ sequence-ների, օրինակ՝ list-ների համար։

Վերջապես, որպես sequence-ներ՝ string-երը նաև աջակցում են պլյուսի նշանով կցմանը՝ երկու string-երը նոր string-ի մեջ միացնելուն, և կրկնմանը՝ մեկ այլ string-ը կրկնելով նոր string ստեղծելուն.

Գրքի code · PDF էջ 179

  >>> S
  'Code'
  >>> S + 'xyz'             # Concatenation
  'Codexyz'
  >>> S                     # S is unchanged
  'Code'
  >>> S * 8                 # Repetition
  'CodeCodeCodeCodeCodeCodeCodeCode'

Մեկնաբանություն, տող 3․ Կցում

Մեկնաբանություն, տող 5․ S-ն անփոփոխ է

Մեկնաբանություն, տող 7․ Կրկնում

Նկատեք, որ պլյուսի նշանը (+) տարբեր object-ների համար տարբեր բաներ է նշանակում՝ թվերի համար գումարում, իսկ string-երի համար՝ կցում։ Սա Python-ի ընդհանուր հատկություն է, որն այս գրքում պարբերաբար կանվանենք բազմաձևություն. համառոտ՝ սա նշանակում է, որ գործողության իմաստը կախված է այն object-ներից, որոնց նկատմամբ այն կատարվում է։

Ինչպես կտեսնեք dynamic typing-ն ուսումնասիրելիս, բազմաձևության այս հատկությունը մեծապես բացատրում է Python-ի code-ի հակիրճությունն ու ճկունությունը։ Քանի որ object-ների type-երը չեն

Սկզբնաղբյուրի PDF էջ 180

սահմանափակվում, Python-ով գրված գործողությունը սովորաբար կարող է ինքնաբերաբար աշխատել object-ների բազմաթիվ տարբեր type-երի հետ, եթե դրանք աջակցում են համատեղելի interface-ի, ինչպես այստեղի + գործողությունը։ Պարզվում է՝ սա Python-ում հսկայական գաղափար է. դրա մասին ավելին կիմանաք այս շրջայցի ընթացքում։

Նախորդ օրինակներում նաև նկատեք, որ string-ի նկատմամբ կատարած գործողություններից ոչ մեկով սկզբնական string-ը չէինք փոխում։ Պարզվում է՝ string-ի յուրաքանչյուր գործողություն սահմանված է այնպես, որ որպես արդյունք նոր string ստեղծի, քանի որ Python-ում string-երն immutable են. ստեղծվելուց հետո դրանք տեղում փոխել հնարավոր չէ։

Ավելի ընդհանուր առմամբ՝ immutable object-ների value-ները երբեք չեք կարող վերագրել։ Օրինակ՝ չեք կարող string-ը փոխել՝ դրա դիրքերից մեկին value վերագրելով, սակայն միշտ կարող եք կառուցել նոր string և այն վերագրել նույն name-ին։ Քանի որ Python-ն աշխատանքի ընթացքում ինքնաբերաբար մաքրում է հին object-ները, ինչպես ավելի ուշ կիմանաք, սա այնքան էլ անարդյունավետ չէ, որքան կարող է հնչել.

Գրքի code · PDF էջ 180

  >>> S
  'Code'

Գրքի code · PDF էջ 180

  >>> S[0] = 'z'             # Immutable objects ca

Մեկնաբանություն, տող 1․ immutable object-ները ca… [կտրված է]

Սկզբնաղբյուրի PDF էջ 181

Գրքի code · PDF էջ 181

  …error text omitted…
  TypeError: 'str' object does not support item ass

Գրքի code · PDF էջ 181

  >>> S = 'Z' + S[1:]        # But we can run expre
  >>> S
  'Zode'

Մեկնաբանություն, տող 1․ Բայց կարող ենք կատարել արտահա…

Python-ի յուրաքանչյուր object դասվում է կա՛մ immutable-ների (չփոփոխվողների), կա՛մ մյուսների շարքին։ Հիմնական object-ներից թվերը, string-երը և tuple-ներն immutable են, իսկ list-ները, dictionary-ները և set-ները՝ ոչ․ դրանք կարելի է ազատորեն փոխել տեղում, ինչպես նաև այն նոր object-ների մեծ մասը, որոնք կգրեք class-երի միջոցով։ Պարզվում է՝ այս տարբերությունը վճռորոշ է Python-ով աշխատելիս, այնպիսի առումներով, որոնք առայժմ չենք կարող ամբողջությամբ ուսումնասիրել։ Ի թիվս այլ բաների՝ immutability-ն կարելի է օգտագործել երաշխավորելու համար, որ object-ը ձեր ամբողջ program-ի ընթացքում հաստատուն կմնա․ իսկ mutable object-ների value-ները կարող են փոխվել ցանկացած ժամանակ և ցանկացած տեղում (և անկախ նրանից՝ ձեր code-ը դա ակնկալում է, թե ոչ)։

Խիստ ասած՝ տեքստային տվյալները կարելի է փոխել տեղում, եթե կա՛մ դրանք վերածեք առանձին character-երի list-ի և նորից միացնեք՝ արանքում ոչինչ չդնելով, կա՛մ օգտագործեք հատուկ նշանակության bytearray object-ը․

Սկզբնաղբյուրի PDF էջ 182

Գրքի code · PDF էջ 182

  >>> S = 'Python'
  >>> L = list(S)                             # Exp
  >>> L
  ['P', 'y', 't', 'h', 'o', 'n']
  >>> L[0] = 'C'                              # Cha
  >>> ''.join(L)                              # Joi
  'Cython'

Մեկնաբանություն, տող 2․ Exp… [կտրված է]

Մեկնաբանություն, տող 5․ Cha… [կտրված է]

Մեկնաբանություն, տող 6․ Միաց…

Գրքի code · PDF էջ 182

  >>> B = bytearray(b'app')                   # A b
  >>> B.extend(b'lication')                   # 'b
  >>> B                                       # B[i
  bytearray(b'application')
  >>> B.decode()                              # Tra
  'application'

Մեկնաբանություն, տող 1․ Մի b… [կտրված է]

Մեկնաբանություն, տող 2․ 'b [կտրված է]

Մեկնաբանություն, տող 3․ B[i [կտրված է]

Մեկնաբանություն, տող 5․ Փոխա…

bytearray-ն աջակցում է տեքստի տեղում փոփոխություններին, բայց միայն այն տեքստի, որի բոլոր character-երը առավելագույնը 8 bit լայնություն ունեն (օրինակ՝ ASCII)։ Մնացած բոլոր string-երը շարունակում են immutable մնալ․ bytearray-ն immutable bytes string-երի (որոնց b'…' syntax-ը տարբերում է սովորական տեքստային string-երից) և mutable list-ների (որոնք գրվում ու ցուցադրվում են []-ի մեջ) առանձին հիբրիդ է, բայց այս code-ն ամբողջությամբ ըմբռնելու համար պետք է սպասենք, մինչև ստորև ավելի շատ բան իմանանք թե՛ դրանց, թե՛ Unicode տեքստի մասին։

Սկզբնաղբյուրի PDF էջ 183

string-երի բոլոր գործողությունները, որոնք մինչ այժմ ուսումնասիրել ենք, իրականում sequence-ի գործողություններ են․ այսինքն՝ դրանք կաշխատեն նաև Python-ի այլ sequence-ների, ներառյալ list-ների և tuple-ների վրա։ Սակայն sequence-ի ընդհանուր գործողություններից բացի՝ string-երն ունեն նաև միայն իրենց հատուկ գործողություններ, որոնք հասանելի են որպես method-ներ՝ function-ներ, որոնք կցված են որոշակի object-ի, գործում են դրա վրա և գործարկվում են փակագծերով կանչի expression-ով։

Օրինակ՝ string-ի find method-ը substring որոնելու հիմնական գործողությունն է (այն վերադարձնում է փոխանցված substring-ի դիրքի շեղումը կամ −1, եթե այն չկա), իսկ string-ի replace method-ը կատարում է համատարած որոնում ու փոխարինում․ երկուսն էլ գործում են այն object-ի վրա, որին կցված են և որից կանչվում են․

Գրքի code · PDF էջ 183

  >>> S = 'Code'
  >>> S.find('od')                 # Find the offse
  1
  >>> S
  'Code'
  >>> S.replace('od', 'abl')       # Replace all su
  'Cable'
  >>> S
  'Code'

Մեկնաբանություն, տող 2․ Գտնել շեղու…

Մեկնաբանություն, տող 6․ Փոխարինել բոլոր ենթա…

Սկզբնաղբյուրի PDF էջ 184

Կրկին՝ չնայած string-երի այս method-ների name-ներին, այստեղ մենք չենք փոխում սկզբնական string-երը, այլ որպես արդյունք ստեղծում ենք նոր string-եր․ քանի որ string-երն immutable են, սա միակ հնարավոր եղանակն է։ string method-ները Python-ում տեքստի մշակման գործիքների առաջին շարքն են։ Այլ method-ներ string-ը բաժանում են substring-երի՝ ըստ բաժանիչի (հարմար է որպես վերլուծության պարզ ձև), փոխարկում են տառերի մեծությունն ու փոքրությունը, ստուգում են string-ի պարունակությունը (թվանշաններ, տառեր և այլն) և string-ի ծայրերից հեռացնում են բացատային character-երը․

Գրքի code · PDF էջ 184

  >>> line = 'aaa,bbb,ccccc,dd'
  >>> line.split(',')              # Split on a del
  ['aaa', 'bbb', 'ccccc', 'dd']

Մեկնաբանություն, տող 2․ Բաժանել ըստ բաժա…

Գրքի code · PDF էջ 184

  >>> S = 'code'
  >>> S.upper()                    # Upper- and low
  'CODE'
  >>> S.isalpha()                  # Content tests
  True

Մեկնաբանություն, տող 2․ Մեծատառ և փոքրատ…

Մեկնաբանություն, տող 4․ Բովանդակության ստուգումներ

Գրքի code · PDF էջ 184

  >>> line = 'aaa,bbb,ccccc,dd\n'
  >>> line.rstrip()                # Remove whitesp
  'aaa,bbb,ccccc,dd'
  >>> line.rstrip().split(',')     # Combine two op
  ['aaa', 'bbb', 'ccccc', 'dd']

Մեկնաբանություն, տող 2․ Հեռացնել բացատային նիշե…

Մեկնաբանություն, տող 4․ Համադրել երկու գործո…

Սկզբնաղբյուրի PDF էջ 185

Ուշադրություն դարձրեք այստեղի վերջին հրամանին․ այն բաժանելուց առաջ մաքրում է ծայրերը, քանի որ Python-ն այն կատարում է ձախից աջ՝ ընթացքում ստեղծելով ժամանակավոր արդյունք։ method-ների կանչերը կարող եք այսպես շղթայել, եթե նախորդ կանչը վերադարձնում է method-ներ ունեցող object։

string method-ները նաև ձևաչափում կոչվող՝ փոխարինման առաջադեմ գործողություն կատարելու եղանակներից մեկն են․ այն հասանելի է որպես expression (սկզբնական տարբերակը), string method-ի կանչ (ավելի նորը) և f-string-եր կոչվող literal ձև (ամենանորը)։ Առաջին երկուսը key-ները փոխարինում են առանձին value-ներով, երրորդը built-in Python expression-ները փոխարինում է դրանց արդյունքներով, իսկ երեքն էլ գործարկվելիս որոշում են փոխարինման value-ները և կառուցում նոր string-եր․

Գրքի code · PDF էջ 185

  >>> tool  = 'Python'
  >>> major = 3
  >>> minor = 3

Գրքի code · PDF էջ 185

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> 'Using %s version %s.%s' % (tool, major, mino
  'Using Python version 3.12'

Գրքի code · PDF էջ 185

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> 'Using {} version {}.{}'.format(tool, major,
  'Using Python version 3.12'

Գրքի code · PDF էջ 185

  >>> f'Using {tool} version {major}.{minor + 9}'
  'Using Python version 3.12'

Սկզբնաղբյուրի PDF էջ 186

Եվ այո՛, այսօր սա երեք տարբերակ ունի։ Թեև ձեր սեփական code-ի համար գուցե ցանկանաք ընտրել դրանցից մեկը, երեքն էլ լիովին ընդունելի են այն code-ում, որը կարող եք կարդալ (և ընդգրկուն գրքերում)։ Յուրաքանչյուր ձև ունի հարուստ հնարավորություններ, որոնց քննարկումը կհետաձգենք մինչև գրքի հետագա մասերը, և որոնք սովորաբար ամենից կարևորն են, երբ պետք է ստանաք ընթեռնելի ելք և թվային հաշվետվություններ․

Գրքի code · PDF էջ 186

  >>> '%.2f | %+05d' % (3.14159, -62)
  '3.14 | −0062'

Գրքի code · PDF էջ 186

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> '{1:,.2f} | {0}'.format('sapp'[1:], 296999.25
  '296,999.26 | app'

Գրքի code · PDF էջ 186

  >>> f'{296999.256:,.2f} | {'sapp'[1:]}'
  '296,999.26 | app'

Թեև sequence-ների գործողություններն ընդհանուր են, method-ները՝ ոչ․ չնայած որոշ object-ներ ունեն method-ների մի քանի նույն name-ներ, string method-ների գործողություններն ընդհանուր առմամբ աշխատում են միայն string-երի և ուրիշ ոչ մի բանի վրա։ Որպես գործնական կանոն՝ Python-ի գործիքակազմը շերտավորված է․ object-ների մի քանի type ընդգրկող ընդհանուր գործողությունները հանդես են գալիս որպես built-in function-ներ կամ expression-ներ (օրինակ՝ len(X), X[0]), իսկ type-ին հատուկ գործողությունները method-ների կանչեր են (օրինակ՝ aString.upper())։ Այս բոլոր կատեգորիաներում ձեզ անհրաժեշտ գործիքները գտնելն ավելի բնական կդառնա

Սկզբնաղբյուրի PDF էջ 187

Python-ն օգտագործելուն զուգընթաց, բայց հաջորդ բաժինը տալիս է մի քանի խորհուրդ, որոնք կարող եք կիրառել հենց հիմա։

Նախորդ բաժնում ներկայացված method-ները string-ի object-ների համար հասանելի հնարավորությունների ներկայացուցչական, բայց փոքր նմուշն են։ Ընդհանուր առմամբ այս գիրքը object-ների method-ները սպառիչ չի ներկայացնում, բայց ավելի մանրամասն տեղեկությունների համար միշտ կարող եք կանչել built-in dir function-ը։ Առանց argument-ի կանչելիս այս function-ը թվարկում է կանչողի տեսանելիության տիրույթում արժեք ստացած variable-ները․ ավելի օգտակար տարբերակում այն վերադարձնում է իրեն փոխանցված ցանկացած object-ի համար հասանելի բոլոր attribute-ների list-ը։ Քանի որ method-ները կանչելի attribute-ներ են, դրանք կհայտնվեն այդ list-ում։ Ենթադրելով, որ S-ը դեռ 'Code' string-ն է՝ ահա դրա attribute-ները․

Գրքի code · PDF էջ 187

  >>> dir(S)
  ['__add__', '__class__', '__contains__', '__delat
  '__eq__', '__format__', '__ge__', '__getattribute
  …etc…
  'rindex', 'rjust', 'rpartition', 'rsplit', 'rstri
  'startswith', 'strip', 'swapcase', 'title', 'tran

Ամբողջական list-ը տեսնելու համար սա գործարկեք իրական միջավայրում․ այստեղ տեղ խնայելու համար դրա միջնամասը կտրված է …etc…-ի մոտ (այսօր string-երն ունեն 81 attribute)։ Այս list-ի երկրորդ կեսի այն name-ները,

Սկզբնաղբյուրի PDF էջ 188

որոնք ընդգծման character-եր չունեն, բոլորը string-ի object-ների կանչելի method-ներ են։ Կրկնակի ընդգծման character-երով name-ները կարևոր չեն լինի մինչև գրքի ավելի ուշ մասը, երբ ուսումնասիրենք class-երում operator-ների վերասահմանումը։ Կարճ ասած՝ դրանք ներկայացնում են string-ի object-ի implementation-ը և աջակցում հարմարեցմանը։ Օրինակ՝ string-երի __add__ method-ն այն եղանակն է, որով ի վերջո աշխատում է միակցումը․ Python-ը ներքին մակարդակում հետևյալներից առաջինը փոխակերպում է երկրորդին, թեև սովորաբար ինքներդ չպետք է օգտագործեք երկրորդ ձևը (այն պակաս հասկանալի է և կարող է նույնիսկ ավելի դանդաղ աշխատել)․

Գրքի code · PDF էջ 188

  >>> S + 'head!'
  'Codehead!'
  >>> S .__add__('head!')
  'Codehead!'

dir function-ը պարզապես տալիս է method-ների name-ները։ Հարցնելու համար, թե դրանք ինչ են անում, կարող եք դրանք փոխանցել help function-ին․

Գրքի code · PDF էջ 188

  >>> help(S.replace)                           # O
  Help on built-in function replace:
  replace(old, new, count=-1, /) method of builtins
      Return a copy with all occurrences of substri
  …etc…

Մեկնաբանություն, տող 1․ O [կտրված է]

Սկզբնաղբյուրի PDF էջ 189

Վահանակների մեծ մասում օգնության ցուցադրումից դուրս գալու համար սեղմեք Q ստեղնը։ help-ը Python-ի հետ մատակարարվող code համակարգի մի քանի interface-ներից մեկն է․ այդ համակարգը հայտնի է որպես Pydoc՝ object-ներից փաստաթղթավորում քաղելու գործիք։ Գրքի հետագա մասում կտեսնեք, որ Pydoc-ը կարող է իր հաշվետվությունները նաև ներկայացնել HTML ձևաչափով՝ վեբ զննարկիչում ցուցադրելու համար։

Կարող եք նաև help(S)-ով օգնություն խնդրել ամբողջ string-ի մասին, բայց դա գուցե չօգնի․ string-ի փոխարեն օգտագործվում է դրա value-ն, եթե այն դատարկ չէ։ Ավելի լավ արդյունքի համար պետք է իմանաք կա՛մ string-ի type-ի name-ը, կա՛մ այն, որ built-in type function-ը ցանկացած object-ի type-ը վերադարձնում է որպես մեկ այլ object․ help(str)-ը և help(type(S))-ը երկուսն էլ օգնություն են տալիս string-երի վերաբերյալ, բայց գուցե ավելին, քան ցանկանում եք, քանի որ նկարագրում են բոլոր method-ները․ help-ը թերևս ավելի լավ է կիրառել որոշակի method-ների համար։

Լրացուցիչ տեղեկությունների համար կարող եք նաև դիմել Python-ի standard library-ի տեղեկատու ձեռնարկին, բայց dir-ը և help-ը Python-ում փաստաթղթավորման առաջին մակարդակն են, հատկապես երբ աշխատում եք interactive environment-ում՝ REPL-ում։ Շուտով փորձեք դրանք ձեր ձեռքի տակ եղած որևէ object-ի վրա։

Մինչ այժմ դիտարկեցինք string-ի object-ի sequence-ի գործողություններն ու type-ին հատուկ method-ները։ Python-ը նաև տրամադրում է string-եր գրելու տարբեր

Սկզբնաղբյուրի PDF էջ 190

եղանակներ, որոնք ավելի խորությամբ կուսումնասիրենք հետագայում։ Օրինակ՝ հատուկ character-երը կարելի է ներկայացնել հակադարձ շեղագծով սկսվող escape sequence-ներով, որոնք Python-ը ցուցադրում է \xNN տասնվեցական փախուստային գրառմամբ, եթե դրանք չեն նշանակում արտածվող character-եր․

Գրքի code · PDF էջ 190

  >>> S = 'A\nB\tC'            # Escapes: \n is new
  >>> len(S)                   # Each stands for ju
  5

Մեկնաբանություն, տող 1․ Էկրանավորում. \n-ը նոր…

Մեկնաբանություն, տող 2․ Յուրաքանչյուրը նշանակում է ընդամե…

Գրքի code · PDF էջ 190

  >>> S = 'A\0B\0C'            # \0, a binary zero
  >>> len(S)
  5
  >>> S                        # Nonprintables are
  'A\x00B\x00C'

Մեկնաբանություն, տող 1․ \0՝ երկուական զրո

Մեկնաբանություն, տող 4․ Չարտածվող character-երը …

Ինչպես արդեն ակնարկվեց, Python-ը թույլ է տալիս string-երը վերցնել մեկական կամ կրկնակի չակերտների մեջ․ դրանք նույն իմաստն ունեն, բայց թույլ են տալիս մյուս տեսակի չակերտը ներառել առանց escape sequence-ի (programmer-ների մեծ մասը պակաս ծանրաբեռնված գրության համար նախընտրում է մեկական չակերտները, եթե չի կարոտում այլ լեզուներով իր անցյալը)։ Կարող եք նաև գրել multiline string literal-ներ՝ եռակի չակերտների մեջ (մեկական կամ կրկնակի)․ այդ դեպքում բոլոր line-երը միակցվում են, իսկ line break-երի տեղերում ավելացվում են newline character-եր (\n)։ Սա օգտակար է Python script-ում այնպիսի բաներ ներառելու համար, ինչպիսիք են multiline

Սկզբնաղբյուրի PDF էջ 191

HTML, YAML կամ JSON code-ը, ինչպես նաև code-ի line-երը ժամանակավորապես անգործուն դարձնելու համար․ պարզապես վերևում և ներքևում ավելացրեք երեք չակերտ․

Գրքի code · PDF էջ 191

  >>> msg = """
  ... aaaaaaaaaaaa
  ... bbb'''bbb""bbb
  ... cccccccc
  ... """
  >>> msg
  '\naaaaaaaaaaaa\nbbb\'\'\'bbb""bbb\ncccccccc\n'

Python-ը նաև աջակցում է չմշակված string-ի literal-ին, որն անջատում է հակադարձ շեղագծով փախուստային մեխանիզմը։ Նման literal-ները սկսվում են r տառով և օգտակար են, օրինակ, regular expression-ների նմուշներ պարունակող string-երի և Windows-ի directory-ների ուղիների համար՝ առանց հակադարձ շեղագծերը կրկնապատկելու (օրինակ՝ r'C:\Users\you\code')։

Python-ի string-երը նաև ունեն Unicode-ի լիարժեք աջակցություն, որն անհրաժեշտ է ոչ ASCII տեքստ մշակելու համար։ Այդպիսի տեքստը ներառում է ոչ անգլերեն լեզուների character-եր, ինչպես նաև խորհրդանիշներ ու էմոջիներ և այսօր տարածված է վեբ էջերում, էլեկտրոնային նամակներում, graphical interface-ներում, փաստաթղթերում և

Սկզբնաղբյուրի PDF էջ 192

տվյալներում։ Python-ի string object-ները թույլ են տալիս նման տեքստը մշակել անխափան․ սովորական str string-ը մշակում է Unicode տեքստը (ներառյալ ASCII-ն, որը պարզապես Unicode-ի պարզ տեսակ է), իսկ bytes string-ը, ավելի վաղ օգտագործված իր mutable ազգականի՝ bytearray-ի հետ միասին, մշակում է չմշակված byte-երի value-ները (ներառյալ մեդիա տվյալներն ու encoded տեքստը)․

Գրքի code · PDF էջ 192

  >>> 'hÄck'                   # Normal str strings
  'hÄck'
  >>> b'a\x01c'                # bytes strings are
  b'a\x01c'

Մեկնաբանություն, տող 1․ Սովորական str string-եր

Մեկնաբանություն, տող 3․ bytes string-երը … են

Ձևականորեն Python-ի byte string-երը 8-բիթանոց byte-երի sequence-ներ են, որոնք հնարավորության դեպքում արտածվում են ASCII character-երով, իսկ տեքստային string-երը Unicode code point-երի sequence-ներ են՝ character-երը նույնականացնող թվերի, որոնք արտածվում են մեզ ծանոթ սովորական նշանապատկերներով և memory-ի մեջ պահվելիս կամ file-երում կոդավորվելիս պարտադիր չէ, որ համապատասխանեն առանձին byte-երի։ Իրականում byte-երի գաղափարը լիովին կիրառելի չէ Unicode-ի նկատմամբ․ այն պարունակում է բազմաթիվ character-երի code point-եր, որոնք չափազանց մեծ են մեկ byte-ի մեջ տեղավորվելու համար, և սահմանում է պահպանման ու փոխանցման encoding-ներ, որոնցում character-երը կարող են ընդհանրապես ցանկացած չափ ունենալ․

Սկզբնաղբյուրի PDF էջ 193

Գրքի code · PDF էջ 193

  >>> 'Code'                              # Charact
  'Code'
  >>> 'Code'.encode('utf-8')              # Encoded
  b'Code'
  >>> 'Code'.encode('utf-16')             # But enc
  b'\xff\xfeC\x00o\x00d\x00e\x00'

Մեկնաբանություն, տող 1․ Նիշե…

Մեկնաբանություն, տող 3․ encoded

Մեկնաբանություն, տող 5․ Բայց կոդա…

Սա հատկապես ճիշտ է ավելի հարուստ տեքստի համար (ord-ը տալիս է character-ի code point-ը, իսկ hex-ը՝ դրա տասնվեցական string-ը)․

Գրքի code · PDF էջ 193

  >>> hex(ord('🐍'))                      # Code po
  '0x1f40d'
  >>> len('🐍hÄck👏')                     # One cha
  6
  >>> len('🐍hÄck👏'.encode('utf-8'))     # But enc
  13
  >>> len('🐍hÄck👏'.encode('utf-16'))
  18

Մեկնաբանություն, տող 1․ code կե…

Մեկնաբանություն, տող 3․ Մեկ նի…

Մեկնաբանություն, տող 5․ Բայց կոդա…

Տեքստային string-երում ոչ ASCII character-եր գրելու համար օգտագործեք \x տասնվեցական escape sequence-ներ, Unicode-ի կարճ \u կամ երկար \U escape sequence-ներ կամ անմիջական տեքստ, որը code-ը կարդալիս մեկնաբանվում է ըստ source code-ի encoding-ի՝ ընտրովի հայտարարված ծրագրային file-երում (code-ի լռելյայն encoding-ը

Սկզբնաղբյուրի PDF էջ 194

համընդհանուր UTF-8-ն է)։ Ցուցադրելու համար՝ ահա մեր ոչ ASCII Ä character-ը՝ երկու կետով A-ն, Python-ում գրված չորս եղանակով․

Գրքի code · PDF էջ 194

  >>> 'h\xc4\u00c4\U000000c4Äck'         # Coding n
  'hÄÄÄÄck'

Մեկնաբանություն, տող 1․ Գրառում՝ n… [կտրված է]

Տեքստային string-երում այս բոլոր ձևերը սահմանում են Unicode code point-եր, որոնք նշանակում են character-եր։ Ի հակադրություն՝ byte string-երն օգտագործում են միայն \x տասնվեցական escape sequence-ներ՝ չմշակված byte-երի value-ները ներառելու համար․ սա միշտ չէ, որ տեքստ է, բայց երբ տեքստ է, այն տեքստի encoded ձևն է, ոչ թե դրա decoded code point-երը, իսկ encoded byte-երը նույնն են, ինչ code point-երը, միայն պարզ տեքստի և encoding-ների դեպքում․

Գրքի code · PDF էջ 194

  >>> '\u00A3', '\u00A3'.encode('latin1'), b'\xA3'
  ('£', b'\xa3', '£')

Այս string type-երից բացի՝ Unicode-ի մշակումը հաճախ հանգում է տեքստային տվյալները file-երից ստանալուն և file-երին փոխանցելուն․ file-երը պահելիս տեքստն ինքնաշխատ կոդավորում են byte-երի, իսկ memory-ի մեջ հետ կարդալիս decoding են character-երի (այլ կերպ՝ code point-երի)։ Բեռնելուց հետո մենք տեքստը սովորաբար մշակում ենք միայն որպես decoded ձևի string-եր։ Դա հնարավոր դարձնելու համար text file-երն իրականացնում են encoding-ներ և

Սկզբնաղբյուրի PDF էջ 195

ընդունում ու վերադարձնում են տեքստային string-եր, իսկ բինար file-երը չմշակված տվյալների համար աշխատում են bytes string-երով։

Unicode-ին կրկին կհանդիպեք այս գլխում ավելի ուշ՝ file-երի քննարկման մեջ, բայց Unicode-ի պատմության մնացած մասը կթողնենք գրքի հետագա մասի համար։ Այն համառոտ երևում է Գլուխներ 7-ում, 9-ում և 15-ում, բայց հիմնականում հետաձգվում է մինչև այս գրքի առաջադեմ թեմաների մասը՝ Գլուխ 37-ը։ Unicode-ն այսօր վճռորոշ է շատ (կամ գրեթե բոլոր) ոլորտներում, բայց Python-ի շատ սկսնակների համար միայն մակերեսային ծանոթությունը կարող է բավարար լինել, մինչև յուրացնեն string-երի հիմունքները։

Բացի իր built-in string object-ներից՝ Python-ի ստանդարտ գործիքակազմը ներառում է տեքստային նմուշների համապատասխանեցման աջակցություն՝ re module-ով, ինչպես նաև JSON, CSV, XML և HTML տեսակի տեքստային տվյալների վերլուծություն։ Այս գործիքներից մի քանիսի լրացուցիչ օրինակների կհանդիպեք գրքում ավելի ուշ, բայց այս ուսուցողական ներածությունն արդեն բավական խոսեց string-երի մասին և պետք է առաջ անցնի։

Python-ի list-ի object-ը լեզվի տրամադրած ամենաընդհանուր sequence-ն է։ list-ները կամայական type-երի object-ների՝ ըստ դիրքի կարգավորված հավաքածուներ են և ֆիքսված չափ չունեն։ Դրանք նաև mutable են․ ի տարբերություն string-երի՝ list-ները կարելի է տեղում փոփոխել՝

Սկզբնաղբյուրի PDF էջ 196

ըստ դիրքերի assignment-ով, ինչպես նաև list-ի method-ների տարբեր կանչերով։ Հետևաբար դրանք շատ ճկուն գործիք են կամայական հավաքածուներ ներկայացնելու համար՝ directory-ի file-եր, ընկերության աշխատակիցներ, ձեր մուտքային նամակները և այլն։

Քանի որ sequence-ներ են, list-ներն աջակցում են sequence-ի բոլոր գործողություններին, որոնք քննարկեցինք string-երի համար․ միակ տարբերությունն այն է, որ դրանց մեծ մասը string-երի փոխարեն վերադարձնում է list-ներ։ Օրինակ՝ երեք տարրից կազմված list-ի դեպքում՝

Գրքի code · PDF էջ 196

  >>> L = [123, 'text', 1.23]            # A list o
  >>> len(L)                             # Number o
  3

Մեկնաբանություն, տող 1․ Մի list՝ …

Մեկնաբանություն, տող 2․ …-ի քանակը

կարող ենք կատարել indexing, slice և այլն՝ ճիշտ ինչպես string-երի դեպքում․

Գրքի code · PDF էջ 196

  >>> L[0]                               # Indexing
  123
  >>> L[:-1]                             # Slicing
  [123, 'text']

Մեկնաբանություն, տող 1․ indexing

Մեկնաբանություն, տող 3․ slicing

Գրքի code · PDF էջ 196

  >>> L + [4, 5, 6]                      # Concat/r
  [123, 'text', 1.23, 4, 5, 6]

Մեկնաբանություն, տող 1․ Կցում/կ… [կտրված է]

Սկզբնաղբյուրի PDF էջ 197

Գրքի code · PDF էջ 197

  >>> L * 2
  [123, 'text', 1.23, 123, 'text', 1.23]

Գրքի code · PDF էջ 197

  >>> L                                  # We're no
  [123, 'text', 1.23]

Մեկնաբանություն, տող 1․ Մենք … [no՝ կտրված է]

Python-ի list-ները կարող են հիշեցնել այլ լեզուների զանգվածները, բայց սովորաբար ավելի հզոր են։ Նախ՝ դրանք type-ի ֆիքսված սահմանափակում չունեն․ հենց նոր դիտարկած list-ը, օրինակ, պարունակում է բոլորովին տարբեր type-երի երեք object (ամբողջ թիվ, string և float)։ Բացի այդ՝ list-ները չունեն ֆիքսված չափ։ Այսինքն՝ ըստ պահանջի կարող են աճել ու փոքրանալ՝ list-ին հատուկ գործողություններին ի պատասխան․

Գրքի code · PDF էջ 197

  >>> L.append('Py')                     # Growing
  >>> L
  [123, 'text', 1.23, 'Py']

Մեկնաբանություն, տող 1․ Աճում

Գրքի code · PDF էջ 197

  >>> L.pop(2)                           # Shrinkin
  1.23
  >>> L                                  # "del L[2
  [123, 'text', 'Py']

Մեկնաբանություն, տող 1․ Փոքրացու…

Մեկնաբանություն, տող 3․ "del L[2 [կտրված է]

Սկզբնաղբյուրի PDF էջ 198

Այստեղ list-ի append method-ը մեծացնում է list-ը և տարր է ավելացնում վերջում․ հետո pop method-ը (կամ համարժեք del statement-ը) տվյալ դիրքից հեռացնում է տարր՝ փոքրացնելով list-ը։ list-ի այլ method-ներ տարր են տեղադրում կամայական դիրքում (insert), հեռացնում են տվյալ տարրը՝ ըստ value-ի (remove), վերջում ավելացնում են բազմաթիվ տարրեր (extend) և այլն։ Քանի որ list-ները mutable են, list-ի method-ների մեծ մասը նաև տեղում է փոխում list-ի object-ը՝ նորը ստեղծելու փոխարեն․

Գրքի code · PDF էջ 198

  >>> M = ['bb', 'aa', 'cc']
  >>> M.sort()
  >>> M
  ['aa', 'bb', 'cc']
  >>> M.reverse()
  >>> M
  ['cc', 'bb', 'aa']

Օրինակ՝ այստեղ list-ի sort method-ը լռելյայն կարգավորում է list-ն աճման կարգով, իսկ reverse-ը շրջում է այն․ երկու դեպքում էլ method-ներն ուղղակիորեն փոփոխում են list-ը (թեև նման անուններով function-ները, որոնք կուսումնասիրենք ավելի ուշ, այդպես չեն անում)։

Սկզբնաղբյուրի PDF էջ 199

Թեև list-ները ֆիքսված չափ չունեն, Python-ը միևնույն է թույլ չի տալիս դիմել չեղած տարրերի։ list-ի վերջից դուրս ինդեքսավորելը միշտ սխալ է, բայց նույնքան սխալ է վերջից դուրս արժեք վերագրելը (error message-ներն այստեղ և այլ տեղերում համառոտված են)․

Գրքի code · PDF էջ 199

  >>> L
  [123, 'text', 'Py']

Գրքի code · PDF էջ 199

  >>> L[99]
  IndexError: list index out of range

Գրքի code · PDF էջ 199

  >>> L[99] = 1
  IndexError: list assignment index out of range

Սա միտումնավոր է, քանի որ list-ի վերջից դուրս արժեք վերագրելու փորձը սովորաբար սխալ է (և հատկապես տհաճ՝ C լեզվում, որը Python-ի չափ սխալների ստուգում չի կատարում)։ Ի պատասխան list-ն անաղմուկ մեծացնելու փոխարեն՝ Python-ը հաղորդում է սխալ։ list-ը ընդլայնելու համար դրա փոխարեն կանչում ենք list-ի method-ներ, օրինակ՝ append-ը (կամ ստեղծում ենք նոր list)։ Ի տարբերություն indexing-ի՝ slicing-ը դիրքերի շեղումները հարմարեցնում է սահմանների մեջ, բայց սա պետք է սպասի ստորև եկող խորացված գլուխների քննարկմանը։

Սկզբնաղբյուրի PDF էջ 200

Python-ի հիմնական object type-երի հաճելի հատկություններից մեկն այն է, որ դրանք աջակցում են կամայական ներդրվածությանը․ կարող ենք դրանք ներդնել ցանկացած համակցությամբ և որքան խոր ուզենք։ Օրինակ՝ կարող ենք ունենալ list, որը պարունակում է dictionary, որն էլ պարունակում է մեկ այլ list և այդպես շարունակ՝ այնքան խոր և այնքան խառը, որքան պետք է մեր իրական աշխարհի բաները նկարագրելու համար։

Այս հատկության անմիջական կիրառություններից է Python-ում մատրիցներ կամ «բազմաչափ զանգվածներ» ներկայացնելը։ Հետևյալի նման ներդրված list-ներ պարունակող list-ը հիմնական կիրառությունների համար կբավարարի (code-ի մանրամասները․ այստեղ նահանջները կարևոր չեն, չփակված փակագծերով Python expression-ներն այսպես կարող են մի քանի line ընդգրկել, իսկ որոշ REPL-ներ ցույց են տալիս շարունակության line-երի «...» հրավերներ, որոնք այս գրքում հաճախ բաց են թողնվում՝ էլեկտրոնային նյութից պատճենելն ու տեղադրելը հեշտացնելու համար)․

Գրքի code · PDF էջ 200

  >>> M = [[1, 2, 3],               # A 3 × 3 matri
           [4, 5, 6],               # Code can span
           [7, 8, 9]]
  >>> M
  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Մեկնաբանություն, տող 1․ 3 × 3 մատրի…

Մեկնաբանություն, տող 2․ code-ը կարող է տարածվել…

Սկզբնաղբյուրի PDF էջ 201

Այստեղ գրել ենք list, որը պարունակում է ևս երեք list։ Արդյունքում ներկայացվում է թվերի 3 × 3 մատրից։ Նման կառուցվածքի տարրերին կարելի է հասնել տարբեր եղանակներով․

Գրքի code · PDF էջ 201

  >>> M[1]                          # Get row 2
  [4, 5, 6]

Մեկնաբանություն, տող 1․ Ստանալ 2-րդ row-ը

Գրքի code · PDF էջ 201

  >>> M[1][2]                       # Get row 2, th
  6

Մեկնաբանություն, տող 1․ Ստանալ 2-րդ row-ը, th… [կտրված է]

Այստեղ առաջին գործողությունը վերցնում է ամբողջ երկրորդ row-ը, իսկ երկրորդը՝ այդ row-ի երրորդ տարրը (այն կատարվում է ձախից աջ, ինչպես ավելի վաղ string-ի strip և split համակցությունը)։ indexing-ի գործողությունները շղթայելը մեզ տանում է ներդրված object-ների կառուցվածքի ավելի ու ավելի խորքը։ Հուշում․ մատրիցի այս կառուցվածքը հարմար է փոքրածավալ խնդիրների համար, բայց ավելի լուրջ թվային հաշվարկների դեպքում հավանաբար կցանկանաք օգտագործել Python-ի բաց code-ով NumPy ընդլայնումը, որը կարող է մեծ մատրիցները պահել և մշակել շատ ավելի արդյունավետ, քան մեր ներդրված list-ների կառուցվածքը (և այստեղի շրջանակներից շատ դուրս է․ տե՛ս Գլուխ 1-ը)։

Սկզբնաղբյուրի PDF էջ 202

sequence-ի գործողություններից և list-ի method-ներից բացի՝ Python-ը ներառում է ավելի առաջադեմ գործողություն, որը հայտնի է որպես list-ի comprehension (list comprehension)․ պարզվում է՝ այն մեր մատրիցի նման կառուցվածքներ մշակելու հզոր եղանակ է։ Ենթադրենք, օրինակ, որ պետք է առանձնացնենք նախորդ բաժնի մատրիցի երկրորդ սյունակը։ row-երը հեշտ է վերցնել պարզ indexing-ով, քանի որ մատրիցը պահվում է ըստ row-երի, բայց list-ի comprehension-ով սյունակ վերցնելը գրեթե նույնքան հեշտ է․

Գրքի code · PDF էջ 202

  >>> col2 = [row[1] for row in M]             # Co
  >>> col2
  [2, 5, 8]

Մեկնաբանություն, տող 1․ Co [կտրված է]

Գրքի code · PDF էջ 202

  >>> M                                        # Th
  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Մեկնաբանություն, տող 1․ Th [կտրված է]

list-ի comprehension-ները նոր list կառուցելու եղանակ են՝ expression կիրառելով sequence-ի յուրաքանչյուր տարրի վրա՝ մեկ առ մեկ, ձախից աջ։ Դրանք գրվում են քառակուսի փակագծերով (որպես հուշում, որ ստեղծում են list) և բաղկացած են expression-ից ու ցիկլային կառուցվածքից, որոնք օգտագործում են variable-ի նույն name-ը (այստեղ՝ row)։ Վերևի list-ի comprehension-ը ըստ էության նշանակում է

Սկզբնաղբյուրի PDF էջ 203

հենց այն, ինչ ասում է․ «Տուր ինձ row[1]-ը M մատրիցի յուրաքանչյուր row-ի համար՝ նոր list-ի մեջ»։ Արդյունքը մատրիցի 2-րդ սյունակը պարունակող նոր list է։

Գործնականում list-ի comprehension-ները կարող են ավելի բարդ լինել․

Գրքի code · PDF էջ 203

  >>> [row[1] + 1 for row in M]                 # A
  [3, 6, 9]

Մեկնաբանություն, տող 1․ Մի…

Գրքի code · PDF էջ 203

  >>> [row[1] for row in M if row[1] % 2 == 0]  # F
  [2, 8]

Մեկնաբանություն, տող 1․ F [կտրված է]

Օրինակ՝ այստեղ առաջին գործողությունը յուրաքանչյուր տարրին հավաքելու ընթացքում ավելացնում է 1, իսկ երկրորդն օգտագործում է if պայման՝ արդյունքից կենտ թվերը զտելու համար՝ % մնացորդի expression-ով (բաժանման մնացորդը)։ list-ի comprehension-ները ստեղծում են արդյունքների նոր list-ներ, բայց կարող են օգտագործվել ցանկացած iterable object-ի տարրերով անցնելու համար․ այս տերմինը գրքի հետագա մասում ավելի մանրամասն կբացենք, բայց այն պարզապես նշանակում է կա՛մ իրական sequence, կա՛մ վիրտուալ sequence, որն իր տարրերն արտադրում է ըստ պահանջի։ Օրինակ՝ այստեղ list-ի comprehension-ներով անցնում ենք code-ում ուղղակիորեն գրված կոորդինատների list-ով և string-ով․

Գրքի code · PDF էջ 203

  >>> diag = [M[i][i] for i in [0, 1, 2]]      # Co
  >>> diag

Մեկնաբանություն, տող 1․ Co [կտրված է]

Սկզբնաղբյուրի PDF էջ 204

Գրքի code · PDF էջ 204

  [1, 5, 9]

Գրքի code · PDF էջ 204

  >>> doubles = [c * 2 for c in 'hack']        # Re
  >>> doubles
  ['hh', 'aa', 'cc', 'kk']

Մեկնաբանություն, տող 1․ Re [կտրված է]

Այս expression-ները կարելի է նաև օգտագործել մի քանի value հավաքելու համար՝ պայմանով, որ այդ value-ները փաթաթենք ներդրված հավաքածուի մեջ։ Հետևյալը ցույց է տալիս range-ի կիրառումը․ սա built-in գործիք է, որը գեներացնում է հաջորդական ամբողջ թվեր և պահանջում է շրջապատող list, որպեսզի ստիպի այն տալ իր բոլոր value-ները REPL-ում ցուցադրելու համար (այս առեղծվածի մասին ավելին՝ ստորև)․

Գրքի code · PDF էջ 204

  >>> list(range(4))                           # In
  [0, 1, 2, 3]
  >>> list(range(−6, 7, 2))                    # −6
  [−6, −4, −2, 0, 2, 4, 6]

Մեկնաբանություն, տող 1․ In [կտրված է]

Գրքի code · PDF էջ 204

  >>> [[x ** 2, x ** 3] for x in range(4)]     # Mu
  [[0, 0], [1, 1], [4, 8], [9, 27]]

Մեկնաբանություն, տող 1․ Mu [կտրված է]

Գրքի code · PDF էջ 204

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> [[x, x // 2, x * 2] for x in range(-6, 7, 2)
  [[2, 1, 4], [4, 2, 8], [6, 3, 12]]

Սկզբնաղբյուրի PDF էջ 205

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

Իրականում comprehension-ի syntax-ը միայն list-ներ ստեղծելու համար չէ․ այն կլոր փակագծերի մեջ առնելով՝ կարելի է նաև ստեղծել generator անունով հայտնի iterable object, որն արդյունքներ է արտադրում ըստ պահանջի՝ Python-ի կրկնության արձանագրությամբ․ հետևյալում next-ի յուրաքանչյուր կանչի ժամանակ built-in sum-ի միջոցով գումարվում են մատրիցի row-ի տարրերը․

Գրքի code · PDF էջ 205

  >>> M
  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Գրքի code · PDF էջ 205

  >>> G = (sum(row) for row in M)              # Ma
  >>> next(G)                                  # Ru
  6
  >>> next(G)                                  # A
  15
  >>> next(G)                                  # Ro
  24

Մեկնաբանություն, տող 1․ Ma [կտրված է]

Մեկնաբանություն, տող 2․ Ru [կտրված է]

Մեկնաբանություն, տող 4․ Մի…

Մեկնաբանություն, տող 6․ Ro [կտրված է]

Սկզբնաղբյուրի PDF էջ 206

Իսկ comprehension-ի syntax-ը ձևավոր փակագծերի մեջ առնելիս կարելի է օգտագործել նաև set-ներ և dictionary-ներ ստեղծելու համար․

Գրքի code · PDF էջ 206

  >>> {sum(row) for row in M}                  # Ma
  {24, 6, 15}

Մեկնաբանություն, տող 1․ Ma [կտրված է]

Գրքի code · PDF էջ 206

  >>> {i: sum(M[i]) for i in range(3)}         # Ma
  {0: 6, 1: 15, 2: 24}

Մեկնաբանություն, տող 1․ Ma [կտրված է]

Բայց կրկնության արձանագրության նման հասկացություններն ու set-ների և dictionary-ների նման object-ներն ըմբռնելու համար պետք է առաջ շարժվենք։

Ի տարբերություն string-երի և list-ների՝ Python-ի dictionary-ներն ընդհանրապես sequence-ներ չեն, այլ արտապատկերումներ կոչվող կատեգորիայի միակ հիմնական ներկայացուցիչն են։ Արտապատկերումները ևս այլ object-ների հավաքածուներ են, բայց object-ները պահում են ըստ key-ի, այլ ոչ թե հարաբերական դիրքի։ Թեև dictionary-ներն այսօր պահպանում են իրենց key-ների key-ների ավելացման հերթականությունը, դա գուցե չվերաբերի ձեր նպատակներին, և դրանց գլխավոր դերը մնում է key-ը value-ին արտապատկերելը։ dictionary-ները նաև mutable են․ ինչպես list-ները, դրանք կարելի է փոխել տեղում, և դրանք կարող են աճել ու փոքրանալ ըստ պահանջի։ Նույնպես list-ների նման՝ դրանք հավաքածուներ գրելու ճկուն գործիք են, բայց

Սկզբնաղբյուրի PDF էջ 207

դրանց ավելի հեշտ հիշվող key-ներն ավելի հարմար են, երբ հավաքածուի տարրերն ունեն անուններ կամ պիտակներ, ինչպես տվյալների բազայի գրառման դաշտերը։

Որպես literal գրելիս dictionary-ները գրվում են ձևավոր փակագծերում և բաղկացած են «key: value» զույգերի հաջորդական շարքից։ dictionary-ներն օգտակար են ամեն անգամ, երբ պետք է value-ների հավաքածուն կապենք key-ների հետ՝ ինչ-որ բանի հատկությունները նկարագրելու համար։ Որպես օրինակ դիտարկենք հետևյալ երեք տարրանոց dictionary-ն՝ «name», «job» և «age» key-ներով, որոնք գրանցում են հորինված (և բոլորովին ընդհանրական ու չեզոք) աշխատողի attribute-ները․

Գրքի code · PDF էջ 207

  >>> D = {'name': 'Pat', 'job': 'dev', 'age': 40}

Այս dictionary-ն կարող ենք ինդեքսավորել ըստ key-ի՝ key-ների հետ կապված value-ները ստանալու և փոխելու համար։ dictionary-ի indexing-ի գործողությունն օգտագործում է նույն syntax-ը, ինչ sequence-ների դեպքում, բայց քառակուսի փակագծերի միջի տարրը key է, այլ ոչ թե հարաբերական դիրք․

Գրքի code · PDF էջ 207

  >>> D['name']                       # Fetch value
  'Pat'

Մեկնաբանություն, տող 1․ Ստանալ value-ն

Գրքի code · PDF էջ 207

  >>> D['job'] = 'mgr'                # Change Pat

Մեկնաբանություն, տող 1․ Փոխել Pat-ը

Սկզբնաղբյուրի PDF էջ 208

Գրքի code · PDF էջ 208

  >>> D
  {'name': 'Pat', 'job': 'mgr', 'age': 40}

Թեև ձևավոր փակագծերով literal ձևն իսկապես կիրառվում է, թերևս ավելի հաճախ dictionary-ները տեսնում ենք այլ եղանակներով կառուցված (վերջիվերջո հազվադեպ է պատահում, որ մինչև program-ի գործարկվելը իմանաք դրա բոլոր տվյալները)։ Օրինակ՝ հետևյալ code-ը սկսում է դատարկ dictionary-ից և այն լրացնում՝ մեկական key ավելացնելով։ Ի տարբերություն list-ների սահմաններից դուրս արժեք վերագրելուն, որն արգելված է, dictionary-ի նոր key-ներին արժեք վերագրելը ստեղծում է այդ key-ները․

Գրքի code · PDF էջ 208

  >>> D = {}
  >>> D['name'] = 'Pat'               # Create keys
  >>> D['job']  = 'dev'
  >>> D['age']  = 40
  >>> D
  {'name': 'Pat', 'job': 'dev', 'age': 40}

Մեկնաբանություն, տող 2․ Ստեղծել key-ներ

Այստեղ փաստորեն dictionary-ի key-ներն օգտագործում ենք որպես երևակայական անձ նկարագրող գրառման դաշտերի name-ներ։ Այլ դերերում dictionary-ները կարող են օգտագործվել նաև որոնման գործողությունները փոխարինելու համար․ dictionary-ն ըստ key-ի ինդեքսավորելը հաճախ Python-ում որոնում գրելու ամենաարագ եղանակն է։

Սկզբնաղբյուրի PDF էջ 209

Ինչպես կիմանաք ավելի ուշ, dictionary-ներ կարող ենք ստեղծել նաև՝ dict type-ի name-ին փոխանցելով կա՛մ անվանված argument-ներ (function call-երում հատուկ name=value syntax-ով), կա՛մ runtime (օրինակ՝ file-երից) ստացված key-ների և value-ների sequence-ները զույգավորելու արդյունքը։ Ստորև բերված երկուսն էլ ստեղծում են նույն dictionary-ն, ինչ նախորդ օրինակը և դրան համարժեք {} literal ձևը․ առաջինը պահանջում է string key-ներ, բայց սովորաբար ավելի քիչ մուտքագրում է պահանջում (և սուբյեկտիվորեն՝ ավելի քիչ ավելորդ նշաններ), իսկ երկրորդն օգտագործում է built-in zip գործիքը, որը կուսումնասիրենք գրքի այս մասում ավելի ուշ․

Գրքի code · PDF էջ 209

  >>> pat1 = dict(name='Pat', job='dev', age=40)
  >>> pat1
  {'name': 'Pat', 'job': 'dev', 'age': 40}

Գրքի code · PDF էջ 209

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> pat2 = dict(zip(['name', 'job', 'age'], ['Pat
  >>> pat2
  {'name': 'Pat', 'job': 'dev', 'age': 40}

Նկատեք, որ dictionary-ի key-ների՝ ձախից աջ հերթականությունը միշտ նույնն է։ Թեև sequence-ներ չեն, dictionary-ի key-ները պահպանում են իրենց key-ների ավելացման հերթականությունը նույնիսկ փոփոխությունների դեպքում․ key-ների հերթականությունն այն հերթականությունն է, որով դրանք ավելացվել են։ Սա սովորական չէր մինչև Python 3.7-ը, իսկ դրանից առաջ key-ների հերթականությունը խառնվում էր և երբեմն առանձին կարգավորում էր պահանջում։ Նոր

Սկզբնաղբյուրի PDF էջ 210

կարգը կարող է ավելի բնական թվալ և այս գրքում ենթադրվելու է, բայց dictionary-ներին հաղորդում է sequence-ի բնույթ, որը մյուս ոչ sequence-ները չունեն։ Փոփոխությունների մեծ մասի պես՝ այն նաև վերագրում է պատմությունը և անվավեր դարձնում Python-ի ուսումնական այն աղբյուրները, որոնք չեն կարող թարմացվել նույնքան հաճախ, որքան Python-ը։ Փոփոխությունը գրեթե միշտ երկսայրի սուր է։

Նախորդ օրինակում dictionary օգտագործեցինք ենթադրյալ անձին երեք key-ով նկարագրելու համար։ Բայց ենթադրենք՝ տեղեկությունն ավելի բարդ է։ Գուցե պետք է գրանցենք name-ն ու ազգանունը՝ աշխատանքային մի քանի պաշտոնների հետ միասին։ Սա հանգեցնում է Python-ի object-ների ներդրվածության ևս մեկ գործնական կիրառության։ Հետևյալ dictionary-ն, որը միանգամից գրված է որպես literal, ներկայացնում է ավելի կառուցվածքային տեղեկություն (այստեղ ևս նահանջները և որոշ REPL-ների «…»-ը էական չեն)․

Գրքի code · PDF էջ 210

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> rec = {'name': {'first': 'Pat', 'last': 'Smit
             'jobs': ['dev', 'mgr'],
             'age':  40.5}

Այստեղ վերին մակարդակում կրկին ունենք երեք key-ով dictionary («name», «jobs» և «age» key-ներով), բայց value-ները դարձել են ավելի

Սկզբնաղբյուրի PDF էջ 211

բարդ․ name-ի համար՝ ներդրված dictionary, որպեսզի աջակցի մի քանի մասերի, և աշխատանքների համար՝ ներդրված list, որպեսզի աջակցի մի քանի դերերի ու հետագա ընդլայնմանը։ Այս կառուցվածքի բաղադրիչներին կարող ենք հասնել գրեթե այնպես, ինչպես ավելի վաղ մեր list-ների վրա հիմնված մատրիցի դեպքում, բայց այս անգամ index-ների մեծ մասը dictionary-ի key-ներ են, ոչ թե list-ի դիրքերի շեղումներ․

Գրքի code · PDF էջ 211

  >>> rec['name']                         # 'name'
  {'first': 'Pat', 'last': 'Smith'}

Մեկնաբանություն, տող 1․ 'name'

Գրքի code · PDF էջ 211

  >>> rec['name']['last']                 # Index t
  'Smith'

Մեկնաբանություն, տող 1․ Ինդեքսավորել t… [կտրված է]

Գրքի code · PDF էջ 211

  >>> rec['jobs']                         # 'jobs'
  ['dev', 'mgr']
  >>> rec['jobs'][-1]                     # Index t
  'mgr'

Մեկնաբանություն, տող 1․ 'jobs'

Մեկնաբանություն, տող 3․ Ինդեքսավորել t… [կտրված է]

Գրքի code · PDF էջ 211

  >>> rec['jobs'].append('janitor')       # Expand
  >>> rec
  {'name': {'first': 'Pat', 'last': 'Smith'}, 'jobs

Մեկնաբանություն, տող 1․ Ընդլայնել

Նկատեք, թե ինչպես այստեղ վերջին գործողությունը ընդլայնում է աշխատանքների ներդրված list-ը․ քանի որ աշխատանքների list-ն այն պարունակող dictionary-ից առանձին memory-ի հատված է, այն կարող է ազատորեն աճել ու փոքրանալ (ավելի վաղ հանդիպած pop method-ը object-ները փոքրացնելու եղանակներից մեկն է)։ Սա

Սկզբնաղբյուրի PDF էջ 212

ավելի խիստ լեզուների փորձ ունեցող ընթերցողներին կարող է իսկական հնարք թվալ, բայց Python-ում բնական է։

Ավելի հիմնարար իմաստով՝ այս օրինակը ցուցադրում է Python-ի հիմնական object type-երի ճկունությունը։ Ինչպես տեսնում եք, ներդրվածությունը թույլ է տալիս ուղղակիորեն և հեշտությամբ կառուցել տեղեկության բարդ կառուցվածքներ։ C-ի նման ցածր մակարդակի լեզվում նույնպիսի կառուցվածք ստեղծելը հոգնեցուցիչ կլիներ և շատ ավելի code կպահանջեր․ պետք է նախագծեինք ու հայտարարեինք կառուցվածքներն ու զանգվածները, լրացնեինք value-ները, ամեն ինչ կապակցեինք իրար և այլն։ Python-ում այս ամենը ինքնաշխատ է․ expression-ը կատարելիս object-ների ամբողջ ներդրված կառուցվածքը ստեղծվում է մեզ համար։ Իրականում սա Python-ի նման scripting language-ների հիմնական առավելություններից մեկն է։

Նույնքան կարևոր է, որ ավելի ցածր մակարդակի լեզուներում գուցե ստիպված լինենք object-ների համար նախապես memory-ի տարածք հատկացնել և ուշադիր լինել՝ այն ազատելու համար, երբ այլևս պետք չէ։ Python-ում այս ամենը ինքնաշխատ է․ object-ի memory-ն հատկացվում է ըստ անհրաժեշտության և ազատվում, երբ կորցնում ենք object-ի վերջին reference-ը, օրինակ՝ դրա variable-ին մեկ այլ բան վերագրելով․

Գրքի code · PDF էջ 212

  >>> rec = 0           # Now the prior object's sp

Մեկնաբանություն, տող 1․ Այժմ նախորդ object-ի տարա…

Սկզբնաղբյուրի PDF էջ 213

Տեխնիկապես ասած՝ Python-ն օգտագործում է garbage collection կոչվող մեխանիզմ, որը ձեր program-ի աշխատանքի ընթացքում վերադարձնում է չօգտագործվող memory-ն և ազատում է ձեզ code-ում նման մանրամասներ կառավարելու անհրաժեշտությունից։ Ստանդարտ Python-ում (որը նաև կոչվում է CPython) սա հիմնականում օգտագործում է object-ների reference counter-ներ՝ cycle-երի համար լրացուցիչ garbage collector-ի հետ միասին։ Թե ինչպես է սա աշխատում, կուսումնասիրենք ավելի ուշ՝ Գլուխ 6-ում․ առայժմ բավական է իմանալ, որ կարող եք ազատորեն օգտագործել object-ներ, իսկ Python-ը կհոգա դրանց memory-ի մասին։

Հենց նոր գրածին նման գրառման կառուցվածքի սպասեք Գլուխներ 8-ում, 9-ում և 27-ում, որտեղ այն կօգտագործենք list-ները, dictionary-ները, tuple-ները, named tuple-ները և class-երը համեմատելու ու տարբերությունները ցույց տալու համար․ տվյալների կառուցվածքների մի շարք տարբերակներ՝ իրենց փոխզիջումներով, որոնք ավելի ուշ ամբողջությամբ կքննարկենք։ Նաև նկատենք, որ այստեղ օգտագործած գրառման կառուցվածքը Python-ում կարելի է file-ում պահել տարբեր եղանակներով, ներառյալ pickle module-ը և լեզվից անկախ JSON-ի աջակցությունը (տվյալների ձևաչափ, որն ապշեցուցիչ նման է Python-ի dictionary object-ներին)․ նման գործիքների մասին ավելին՝ այս գրքում ավելի ուշ։

Որպես արտապատկերումներ՝ dictionary-ներն աջակցում են տարրերին միայն ըստ key-ի հասնելուն՝ այնպիսի գործողություններով, որոնք հենց նոր տեսանք։ Բայց բացի այդ՝ դրանք նաև աջակցում են type-ին հատուկ գործողություններին՝ method-ներով, որոնք

Սկզբնաղբյուրի PDF էջ 214

օգտակար են տարբեր սովորական դերերում։ Օրինակ՝ dictionary-ի copy և update method-ները համապատասխանաբար պատճենում են dictionary-ն և մեկը տեղում միավորում մյուսի մեջ (| operator-ն անում է նույնը, բայց որպես արդյունք ստեղծում է նոր dictionary․ դա պարզապես պատճենում է՝ գումարած update)։

dictionary-ի method-ները դեր ունեն նաև key-ների օգտագործման տարածված դեպքերում։ Օրինակ՝ թեև dictionary-ն ընդլայնելու համար կարող ենք արժեք վերագրել նոր key-ի, գոյություն չունեցող key-ով արժեք ստանալը դեռ սխալ է․

Գրքի code · PDF էջ 214

  >>> D = {'a': 1, 'b': 2, 'c': 3}
  >>> D['d'] = 4                        # Assigning
  >>> D
  {'a': 1, 'b': 2, 'c': 3, 'd': 4}

Մեկնաբանություն, տող 2․ assignment

Գրքի code · PDF էջ 214

  >>> D['e']                            # Referenci
  …error text omitted…
  KeyError: 'e'

Մեկնաբանություն, տող 1․ Հղում անե…

Սա հենց այն է, ինչ ուզում ենք․ իրականում չեղած ինչ-որ բան վերցնելը սովորաբար programming-ի սխալ է։ Բայց ընդհանրացված program-երում code-ը գրելիս միշտ չէ, որ կարող ենք իմանալ, թե որ key-ները կլինեն առկա։ Ինչպե՞ս վարվել նման դեպքերում և խուսափել սխալներից։ Լուծումներից մեկը նախապես ստուգելն է։ dictionary-ի in

Սկզբնաղբյուրի PDF էջ 215

անդամության expression-ը թույլ է տալիս հարցնել key-ի գոյության մասին և արդյունքի հիման վրա ճյուղավորել աշխատանքը՝ Python-ի if statement-ով։

Սա մեզ բերում է Python-ի մեր առաջին բաղադրյալ statement-ին՝ ներդրված մասեր ունեցող statement-ին։ Եթե զուգահեռ փորձարկում եք, ահա մի քանի գործնական մանրուք․ հետևյալում if-ն ինտերակտիվ կատարելու համար code-ը մուտքագրելուց հետո երկու անգամ սեղմեք Enter (դատարկ line-ը REPL-ների մեծ մասում նշանակում է «սկսել», ինչպես բացատրվեց Գլուխ 3-ում)․ որոշ interface-ներում առաջին line-ից հետո հրավերը փոխվում է «...»-ի (ինչպես ավելի վաղ բազմատող dictionary-ների ու list-ների դեպքում)․ իսկ այս անգամ նահանջները կարևոր են (պատճառները՝ քիչ անց)․

Գրքի code · PDF էջ 215

  >>> 'e' in D                          # Boolean r
  False

Մեկնաբանություն, տող 1․ Boolean արդյու…

Գրքի code · PDF էջ 215

  >>> if not 'e' in D:                  # Python's
         print('missing key!')

Մեկնաբանություն, տող 1․ Python-ի

Գրքի code · PDF էջ 215

  missing key!

Այս գիրքը հետագա գլուխներում ավելին կասի if statement-ի մասին, բայց դրա syntax-ը պարզ է։ Այն բաղկացած է if բառից, որին հաջորդում է expression, որի արդյունքը մեկնաբանվում է որպես ճշմարիտ կամ կեղծ, ապա՝ code-ի block, որը պետք է կատարվի, եթե expression-ի արդյունքը ճշմարիտ է։ Իր ամբողջական տեսքով if

Սկզբնաղբյուրի PDF էջ 216

statement-ը կարող է ունենալ նաև else մաս՝ կեղծ դեպքի համար, և մեկ կամ մի քանի elif («else if») մաս՝ այլ ստուգումների համար։

Գործառութային առումով if-ը Python-ի ընտրության հիմնական գործիքն է և այն եղանակը, որով մեր script-ներում գրում ենք ընտրությունների ու որոշումների տրամաբանության մեծ մասը։ Դրան միանում են դրա ազգական եռամաս if / else expression-ը, որին քիչ անց կհանդիպեք, ավելի վաղ օգտագործած նմանատիպ if զտիչը comprehension-ներում և ավելի նոր match բազմակի ընտրության statement-ը, որին կհանդիպեք գրքում ավելի ուշ։

Եթե նախկինում օգտագործել եք programming-ի այլ լեզուներ, գուցե այժմ մտածում եք՝ Python-ն ինչպես է իմանում, թե որտեղ է ավարտվում if statement-ը։ Հետագա գլուխներում խորությամբ կուսումնասիրենք Python-ի շարահյուսական կանոնները, բայց կարճ ասած՝ եթե statement-ի block-ում ունեք կատարման ենթակա մեկից ավելի գործողություն, պարզապես դրանց բոլոր statement-ներին նույն նահանջն եք տալիս․ դա և՛ նպաստում է code-ի ընթեռնելիությանը, և՛ կրճատում է մուտքագրելիք character-երի քանակը։ Բոլոր բազմատող statement-ները հետևում են այս ձևին՝ «:»-ով ավարտվող վերնագրային line և (սովորաբար) նահանջով code-ի block՝ առանց block-ների շուրջ «{}»-ի և առանց statement-ներից հետո պարտադիր «;»-ի (թեև զգուշացնենք՝ «:»-ը մոռանալը Python-ի սկսնակների ամենատարածված սխալն է)․

Գրքի code · PDF էջ 216

  >>> if not 'e' in D:
          print('missing')              # Statement

Մեկնաբանություն, տող 2․ statement

Սկզբնաղբյուրի PDF էջ 217

Գրքի code · PDF էջ 217

          print('no, really...')        # (Unless t

Մեկնաբանություն, տող 1․ (Բացառությամբ, եթե t… [կտրված է]

Գրքի code · PDF էջ 217

  missing
  no, really...

Բացի in ստուգումից՝ մեր ստեղծած dictionary-ներում գոյություն չունեցող key-ներին դիմելուց խուսափելու տարբեր այլ եղանակներ կան․ dictionary-ի get method-ը, որը լռելյայն արժեքով պայմանական ինդեքսավորում է, if / else եռամաս expression-ը, որն ըստ էության մեկ line-ի մեջ սեղմված սահմանափակ if statement է, և try statement-ը, որը Գլուխ 10-ում առաջին անգամ օգտագործելու գործիք է՝ սխալները որսալու և դրանցից վերականգնվելու համար։ Ահա առաջին երկուսը գործողության մեջ․

Գրքի code · PDF էջ 217

  >>> D.get('a', 'missing')             # Like D['a
  1
  >>> D.get('e', 'missing')             # Default r
  'missing'

Մեկնաբանություն, տող 1․ Նման է D['a… [կտրված է]

Մեկնաբանություն, տող 3․ Լռելյայն արդյու…

Գրքի code · PDF էջ 217

  >>> D['e'] if 'e' in D else 0         # if/else t
  0

Մեկնաբանություն, տող 1․ if/else՝ t… [կտրված է]

Նման այլընտրանքների մանրամասները կթողնենք հետագա գլխի համար։ Առայժմ անդրադառնանք dictionary-ի այլ method-ների դերերին ևս մեկ

Սկզբնաղբյուրի PDF էջ 218

տարածված կիրառության դեպքում։

dictionary-ները շատ օգտակար տեղեկություն են հավաքում, բայց ի՞նչ անենք, եթե պետք է դրանց տարրերը մշակենք մեկ առ մեկ։ Պարզվում է՝ dictionary-ներն ունեն հենց այս աշխատանքի համար նախատեսված method-ներ․

Գրքի code · PDF էջ 218

  >>> D = dict(a=1, b=2, c=3)
  >>> D
  {'a': 1, 'b': 2, 'c': 3}

Գրքի code · PDF էջ 218

  >>> list(D.keys())                     # Keys, va
  ['a', 'b', 'c']
  >>> list(D.values())                   # list for
  [1, 2, 3]
  >>> list(D.items())
  [('a', 1), ('b', 2), ('c', 3)]

Մեկնաբանություն, տող 1․ key-ներ, արժե…

Մեկնաբանություն, տող 3․ list՝ … համար

Ինչպես ցույց է տրված, dictionary-ի keys, values և items method-ները վերադարձնում են դրա key-ները, value-ները և key/value զույգերը (վերջինները tuple-ներ են՝ այս շրջայցի հաջորդ թեման)։ Բայց իրականում այս method-ները բոլորը վերադարձնում են object, որն արդյունքներն արտադրում է մեկ առ մեկ․ դրա համար էլ դրանք փաթաթված են list կանչերով, ինչպես ավելի վաղ արեցինք range-ի համար։ Սա արտացոլում է Python-ի կրկնության արձանագրությունը՝ հասկացություն,

Սկզբնաղբյուրի PDF էջ 219

որը հետագայում ամբողջությամբ կուսումնասիրենք, բայց որը հանգում է iterable object-ի, որն ունի iterator object, որն էլ արձագանքում է next կանչերին՝ միաժամանակ մեկ արդյունք արտադրելով․

Գրքի code · PDF էջ 219

  >>> D.keys()                           # Get an i
  dict_keys(['a', 'b', 'c'])

Մեկնաբանություն, տող 1․ Ստանալ i… [կտրված է]

Գրքի code · PDF էջ 219

  >>> I = iter(D.keys())                 # Get an i
  >>> next(I)                            # Get one
  'a'
  >>> next(I)                            # This is
  'b'

Մեկնաբանություն, տող 1․ Ստանալ i… [կտրված է]

Մեկնաբանություն, տող 2․ Ստանալ մեկը

Մեկնաբանություն, տող 4․ Սա … է

Ավելի վաղ նույն built-in next գործիքն օգտագործեցինք generator comprehension-ից արդյունքներ ստանալու համար, բայց առանց iter քայլի․ քանի որ generator-ները չեն աջակցում բազմակի անցումների, դրանք իրենց իսկ iterator-ներն են, և iter-ը ոչինչ չի փոխում։

Այս արձանագրությունն աջակցող գործիքները կարող են և՛ memory խնայել, և՛ նվազեցնել ուշացումները, քանի որ իրենց բոլոր արդյունքները միանգամից չեն արտադրում։ Կրկնության արձանագրությունն աշխատում է Python-ի ամենատարբեր object-ների վրա, բայց սովորաբար կարող եք մոռանալ դրա մանրամասները, եթե օգտագործում եք Python-ի for loop-ը, որն ինքնաշխատ գործարկում է կրկնության արձանագրությունը՝ տարրերով մեկ առ մեկ անցնելու համար՝ թե՛

Սկզբնաղբյուրի PDF էջ 220

string-երի և list-ների նման իրական հավաքածուների, թե՛ generator-ների, range-ի և keys-ի նման վիրտուալ sequence-ների դեպքում․

Գրքի code · PDF էջ 220

  >>> for key in D.keys():               # Auto run
          print(key, '=>', D[key])       # Display

Մեկնաբանություն, տող 1․ Ավտոմատ գործարկում

Մեկնաբանություն, տող 2․ Ցուցադրել

Գրքի code · PDF էջ 220

  a => 1
  b => 2
  c => 3

for գրելու համար տվեք variable (օրինակ՝ key) և iterable object (օրինակ՝ D.keys())․ object-ի յուրաքանչյուր տարրի համար for-ը տարրը վերագրում է variable-ին և կատարում ներդրված (և սովորաբար նահանջով) code-ի block-ը, որն ամեն անցման ժամանակ variable-ն օգտագործում է ընթացիկ տարրին դիմելու համար։ for-ը Python-ի կրկնման հիմնական գործիքներից մեկն է՝ ավելի վաղ հանդիպած comprehension-ների և ավելի ընդհանուր նշանակության while loop-ի հետ միասին, որին կհանդիպեք այս գրքում ավելի ուշ։

Քանի որ dictionary-ի տարրերով անցնելը շատ տարածված է, for-ը և կրկնության նման գործիքները կարող են նաև անուղղակիորեն անցնել key-ներով, ինչպես նաև key/value զույգերով։ Օրինակ՝ հետևյալ loop-երն արտադրում են նույն ելքը, ինչ նախորդ օրինակը․ այս բոլոր ձևերի միջև ընտրությունը մասամբ անձնական նախընտրության հարց է, թեև բացահայտ ձևը սովորաբար ավելի լավն է․

Սկզբնաղբյուրի PDF էջ 221

Գրքի code · PDF էջ 221

  >>> for key in D:                      # Implicit
          print(key, '=>', D[key])

Մեկնաբանություն, տող 1․ Անբացահայտ

Գրքի code · PDF էջ 221

  >>> for (key, value) in D.items():     # Key/valu
          print(key, '=>', value)

Մեկնաբանություն, տող 1․ key/արժե…

Սրանցից վերջինն օգտագործում է այսպես կոչված կորտեժային assignment-ը, որն ինքնաբերաբար տարրերը փաթեթազերծում է variable-ների մեջ։ Բայց dictionary-ի items method-ից ստացվող տվյալների տեսակները լիովին հասկանալու համար պետք է առաջ անցնենք։

tuple object-ը, որի անգլերեն tuple անունը, կախված նրանից, թե ում եք հարցնում, արտասանում են «թուփլ» կամ «թափլ», մոտավորապես այնպիսի list է, որը հնարավոր չէ փոփոխել։ tuple-ները list-ների պես sequence-ներ են, բայց string-երի պես immutable են։ Գործնականում դրանք օգտագործվում են տարրերի ֆիքսված հավաքածուներ ներկայացնելու համար, օրինակ՝ օրացուցային որոշակի ամսաթվի բաղադրիչները։ Շարահյուսորեն դրանք սովորաբար գրվում են կլոր փակագծերով՝ քառակուսի փակագծերի փոխարեն, և աջակցում են կամայական type-ի object-ներ, կամայական ներդրվածություն և sequence-ների սովորական գործողությունները, որոնք ավելի վաղ օգտագործեցինք string-երի ու list-ների համար։

Սկզբնաղբյուրի PDF էջ 222

Գրքի code · PDF էջ 222

  >>> T = (1, 2, 3, 4)            # A 4-item tuple
  >>> len(T)                      # Length
  4

Մեկնաբանություն, տող 1․ 4 տարրով tuple

Մեկնաբանություն, տող 2․ Երկարություն

Գրքի code · PDF էջ 222

  >>> T + (5, 6)                  # Concatenation:
  (1, 2, 3, 4, 5, 6)

Մեկնաբանություն, տող 1․ Կցում՝

Գրքի code · PDF էջ 222

  >>> T[0], T[1:]                 # Indexing, slici
  (1, (2, 3, 4))

Մեկնաբանություն, տող 1․ indexing, հատո…

Ինչպես միշտ, tuple-ներն էլ ունեն type-ին հատուկ կանչվող method-ներ, բայց list-ների համեմատ՝ զգալիորեն ավելի քիչ։

Գրքի code · PDF էջ 222

  >>> T.index(4)                  # Tuple methods:
  3
  >>> T.count(4)                  # 4 appears once
  1

Մեկնաբանություն, տող 1․ tuple-ի method-ներ՝

Մեկնաբանություն, տող 3․ 4-ը հանդիպում է մեկ անգամ

tuple-ների հիմնական տարբերությունն այն է, որ ստեղծվելուց հետո դրանք հնարավոր չէ փոփոխել։ Այսինքն՝ դրանք immutable sequence-ներ են։ Մի առանձնահատկություն. մեկ տարր ունեցող tuple-ները, ինչպես այստեղ ներկայացվածը, պահանջում են վերջում դրված ստորակետ՝ սովորական expression-ներից տարբերվելու համար։

Սկզբնաղբյուրի PDF էջ 223

Գրքի code · PDF էջ 223

  >>> T[0] = 2                    # Tuples are immu
  TypeError: 'tuple' object does not support item a

Մեկնաբանություն, տող 1․ tuple-ներն անփոփոխե… են

Գրքի code · PDF էջ 223

  >>> T = (2,) + T[1:]            # Make a new tup
  >>> T
  (2, 2, 3, 4)

Մեկնաբանություն, տող 1․ Ստեղծել նոր կորտե…

list-ների և dictionary-ների նման՝ tuple-ներն աջակցում են խառը type-եր ու ներդրվածություն, բայց, ի տարբերություն list-ների և dictionary-ների, չեն աճում ու փոքրանում, քանի որ immutable են։

Գրքի code · PDF էջ 223

  >>> T = 'hack', 3.0, [11, 22, 33]
  >>> T
  ('hack', 3.0, [11, 22, 33])

Գրքի code · PDF էջ 223

  >>> T[1]
  3.0
  >>> T[2][1]
  22
  >>> T.append(4)
  AttributeError: 'tuple' object has no attribute

Ուշադրություն դարձրեք այստեղ առաջին line-ին. tuple-ի տարրերը պարփակող կլոր փակագծերը հաճախ կարելի է բաց թողնել, ինչպես արված է այստեղ։ Այն համատեքստերում, որտեղ

Սկզբնաղբյուրի PDF էջ 224

ստորակետերն այլ դեր չեն կատարում, հենց ստորակետերն են իրականում կառուցում tuple-ը։ Սա նաև բացատրում է, թե ինչու REPL-ները արդյունքները ցույց են տալիս կլոր փակագծերում, երբ մուտքագրում եք ստորակետերով բաժանված մի քանի տարր. մուտքագրվածն իրականում tuple է։

Այսպիսով՝ ինչո՞ւ ունենալ object-ի տեսակ, որը նման է list-ին, բայց աջակցում է ավելի քիչ գործողություններ։ Անկեղծ ասած՝ գործնականում tuple-ներն այնքան հաճախ չեն օգտագործվում, որքան list-ները, բայց ամբողջ իմաստը դրանց immutability-ն է։ Եթե object-ների հավաքածուն ձեր program-ում փոխանցում եք որպես list, այն կարող է փոփոխվել ցանկացած տեղում։ Եթե օգտագործում եք tuple, այն փոփոխվել չի կարող։ Այսինքն՝ tuple-ներն ապահովում են ամբողջականության մի տեսակ սահմանափակում, որը հարմար է այստեղ ներկայացվածներից ավելի մեծ program-երում։ Գրքում ավելի ուշ կխոսենք tuple-ների մասին ավելին, այդ թվում՝ դրանց վրա հիմնված ընդլայնման, որը կոչվում է named tuple-ներ։ Իսկ այժմ անցնենք այս շրջայցի վերջին հիմնական object-ին։

file object-ները հիմնական միջոցն են, որով ձեր Python code-ը կհասնի համակարգչի file-երի բովանդակությանը։ Դրանք կարող են օգտագործվել տեքստային գրառումներ, ձայնային հատվածներ, Excel փաստաթղթեր, պահպանված նամակներ և ձեր սարքում պահված ցանկացած այլ բան կարդալու ու գրելու համար։ file-երը

Սկզբնաղբյուրի PDF էջ 225

object-ների հիմնական type-երից են, բայց փոքր-ինչ արտասովոր են. դրանց ստեղծման համար հատուկ literal syntax չկա։ Փոխարենը file object եք ստեղծում՝ կանչելով built-in open function-ն արտաքին filename-ով և, կախված նպատակներից, գուցե նաև այլ argument-ներով։

Օրինակ՝ տեքստային ելքային file ստեղծելու համար փոխանցեք դրա name-ը և մշակման ռեժիմի 'w' string-ը՝ տեքստային տվյալներ գրելու համար։ Python-ն ինքնաբերաբար ապահովում է newline \n character-ի դյուրափոխադրելիությունը հարթակների միջև՝ այն file-եր գրելու և file-երից կարդալու ժամանակ։

Գրքի code · PDF էջ 225

  >>> f = open('data.txt', 'w')      # Open a new f
  >>> f.write('Hello\n')             # Write string
  6
  >>> f.write('world!\n')            # Return numbe
  7
  >>> f.close()                      # Close to flu

Մեկնաբանություն, տող 1․ Բացել նոր ֆ…

Մեկնաբանություն, տող 2․ Գրել string-ը

Մեկնաբանություն, տող 4․ Վերադարձնել քա…

Մեկնաբանություն, տող 6․ Փակել՝ flu… [կտրված է]

Սա ընթացիկ directory-ում ստեղծում է file և դրա մեջ գրում տեքստ։ filename-ը կարող է լինել directory-ի ամբողջական ուղի, եթե պետք է հասնեք ձեր սարքի մեկ այլ տեղում գտնվող file-ի։ Հենց նոր գրածը հետ կարդալու համար կրկին բացեք file-ը 'r' մշակման ռեժիմով՝ տեքստային մուտք կարդալու համար։ Սա նաև լռելյայն ռեժիմն է, եթե կանչում ռեժիմը բաց եք թողնում։ Ապա file-ի բովանդակությունը կարդացեք string-ի մեջ և դիմեք դրան։ file-ի

Սկզբնաղբյուրի PDF էջ 226

բովանդակությունը ձեր script-ում միշտ string է՝ անկախ նրանից, թե ինչ տեսակի տվյալներ է պարունակում file-ը։

Գրքի code · PDF էջ 226

  >>> f = open('data.txt')           # Open an exis
  >>> text = f.read()                # Read entire
  >>> text
  'Hello\nworld!\n'

Մեկնաբանություն, տող 1․ Բացել գոյություն ունեցո…

Մեկնաբանություն, տող 2․ Կարդալ ամբողջը

Գրքի code · PDF էջ 226

  >>> print(text)                    # print interp
  Hello
  world!

Մեկնաբանություն, տող 1․ print-ը մեկնա…

Գրքի code · PDF էջ 226

  >>> text.split()                   # File content
  ['Hello', 'world!']

Մեկնաբանություն, տող 1․ file-ի բովանդակություն

file object-ի այլ method-ներ աջակցում են լրացուցիչ հնարավորությունների, որոնք այստեղ ներկայացնելու ժամանակ չունենք։ Օրինակ՝ file object-ները տալիս են կարդալու և գրելու այլ եղանակներ. read-ն ընդունում է byte-երի կամ character-երի առավելագույն չափի ոչ պարտադիր argument, readline-ը յուրաքանչյուր անգամ կարդում է մեկ line և այդպես շարունակ։ Կան նաև այլ գործիքներ. seek-ը տեղափոխում է file-ի նոր դիրք։ Սակայն, ինչպես ավելի ուշ կտեսնեք, text file կարդալու լավագույն եղանակը սովորաբար այն ընդհանրապես չկարդալն է։ file-երն աջակցում են կրկնության արձանագրությանը՝ iterator-ով, որն ինքնաբերաբար line by line կարդում է for loop-երում և այլ համատեքստերում։

Սկզբնաղբյուրի PDF էջ 227

Գրքի code · PDF էջ 227

  >>> for line in open('data.txt'):       # Display
          print(line.rstrip())            # Single

Մեկնաբանություն, տող 1․ Ցուցադրել

Մեկնաբանություն, տող 2․ Մեկական

file-երի method-ների ամբողջ հավաքածուին կհանդիպեք գրքում ավելի ուշ, բայց եթե հիմա արագ նախնական պատկերացում եք ուզում, ցանկացած բաց file-ի համար կատարեք dir կանչ, իսկ վերադարձված method-ների name-ներից ցանկացածի համար՝ help, ինչպես ավելի վաղ սովորեցինք։

Նախորդ բաժնի օրինակները ցույց են տալիս file-երի հիմունքներ, որոնք բավարար են բազմաթիվ կիրառությունների համար։ Սակայն տեխնիկապես դրանք հիմնվում են հյուրընկալող հարթակի լռելյայն Unicode encoding-ի վրա։ Python-ի text file-երը միշտ օգտագործում են Unicode encoding՝ գրելիս string-երը կոդավորելու, իսկ կարդալիս՝ ապակոդավորելու համար։ Սա հաճախ նշանակություն չունի պարզ ASCII տեքստային տվյալների դեպքում, որոնք սովորաբար file-ի byte-երին ու դրանցից հետ են արտապատկերվում առանց փոփոխության։ Բայց տվյալների ավելի հարուստ տեսակների դեպքում file-երի interface-ները կարող են տարբերվել ըստ բովանդակության type-ի։

Ինչպես ավելի վաղ ակնարկեցինք Unicode string-երն ուսումնասիրելիս, Python-ը file-երում հստակ տարբերակում է տեքստային և երկուական տվյալները։ text file-երը բովանդակությունը ներկայացնում են որպես սովորական str string-եր և, ինչպես նշվեց, ինքնաբերաբար կատարում են Unicode encoding ու decoding, իսկ

Սկզբնաղբյուրի PDF էջ 228

binary file-երը բովանդակությունը ներկայացնում են հատուկ bytes string-ով և թույլ են տալիս file-ի բովանդակությանը հասնել անփոփոխ ձևով։

Օրինակ՝ binary file-երը օգտակար են մեդիա մշակելու, C program-երի ստեղծած տվյալներին հասնելու և այլ նպատակների համար։ Ձեր ուղարկածն ու ստացածը file-ի բառացի բովանդակությունն է՝ լինի դա encoded տեքստ, թե JPEG պատկեր։ binary mode միացնելու համար ռեժիմին ավելացրեք b։ Իսկ Windows-ում վերջում սպասեք \r\n-ի՝ \n-ի փոխարեն, քանի որ դրա նոր line-երը տարբերվում են Unix-ից։

Գրքի code · PDF էջ 228

  >>> bf = open('data.bin', 'wb')
  >>> bf.write(b'h\xFFa\xEEc\xDDk\n')     # Write b
  8
  >>> bf.close()
  >>> open('data.bin', 'rb').read()       # Read bi
  b'h\xffa\xeec\xddk\n'

Մեկնաբանություն, տող 2․ Գրել b… [կտրված է]

Մեկնաբանություն, տող 5․ Կարդալ երկո…

text file-երի դեպքում իրականում չենք կարող բովանդակության մասին խոսել՝ առանց նաև հարցնելու՝ «Ի՞նչ տեսակի»։ file-երը կարող են օգտագործել Unicode-ի ցանկացած encoding, հատկապես եթե եկել են մեկ այլ հարթակից կամ ընդհանրապես համացանցից։ Սա վերաբերում է նաև դյուրափոխադրելի program-երին. եթե ցանկանում եք, որ ձեր code-ն աշխատի տարբեր հարթակներում, սովորաբար պետք է encoding-ները բացահայտ նշել՝ տհաճ անակնկալներից խուսափելու համար։ Բարեբախտաբար, սա

Սկզբնաղբյուրի PDF էջ 229

ավելի հեշտ է, քան կարող է թվալ. encoding-ը պարտադրելու համար պարզապես open-ին փոխանցեք encoding-ի name-ը։

Գրքի code · PDF էջ 229

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> tf = open('unidata.txt', 'w', encoding='utf-8
  >>> tf.write('🐍h\u00c4ck👏')
  6
  >>> tf.close()

Եթե կարդում եք նույն կամ համատեղելի encoding-ով, հետ եք ստանում տեքստային character-երի նույն code point-երը, որոնք գրել էիք։ file-ի encoded byte-երը UTF-8 ձևաչափով են, բայց ձեր code-ը սովորաբար դրանով մտահոգվելու կարիք չունի։

Գրքի code · PDF էջ 229

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> open('unidata.txt', 'r', encoding='utf-8').re
  '🐍hÄck👏'

Գրքի code · PDF էջ 229

  >>> open('unidata.txt', 'rb').read()
  b'\xf0\x9f\x90\x8dh\xc3\x84ck\xf0\x9f\x91\x8f'

Թեև file-երը encoding-ների մեծ մասը կատարում են ինքնաբերաբար, կարող եք կոդավորել և ապակոդավորել նաև ձեռքով, եթե ձեր program-ը Unicode տվյալները ստանում է այլ աղբյուրից, օրինակ՝ էլեկտրոնային նամակից վերլուծելով կամ ցանցային կապով ստանալով։

Սկզբնաղբյուրի PDF էջ 230

Գրքի code · PDF էջ 230

  >>> 'hÄck'.encode('utf-8')
  b'h\xc3\x84ck'
  >>> b'h\xc3\x84ck'.decode('utf-8')
  'hÄck'

Python-ն աջակցում է նաև ոչ ASCII filename-ներ, ոչ միայն բովանդակություն, բայց դա մեծ մասամբ ավտոմատ է։ Python-ում Unicode-ի ամբողջական նկարագրությունը սպասում է ձեզ գլուխ 37-ում։

open function-ը Python-ում ձեր կատարելիք file մշակման մեծ մասի հիմնական աշխատող գործիքն է։ Սակայն ավելի առաջադեմ խնդիրների համար Python-ը տրամադրում է լրացուցիչ file-like գործիքներ՝ խողովակներ, FIFO-ներ, սոկետներ, key-ով հասանելի file-եր, object-ների մշտական պահոցներ՝ shelves, նկարագրիչների վրա հիմնված file-եր, հարաբերական և object-oriented տվյալների շտեմարանների interface-ներ և այլն։ Լեզվին նվիրված այս գրքում այս թեմաներից շատերը չենք ընդգրկի, բայց դրանք օգտակար կգտնեք, երբ սկսեք Python-ով լրջորեն ծրագրավորել։

Մինչ այժմ տեսած հիմնական object-ների type-երից բացի կան ուրիշները, որոնք ավելի քիչ ուշադրության են արժանանում, քան իրենց զուգընկերները, բայց միևնույն է օգտակար են իրենց

Սկզբնաղբյուրի PDF էջ 231

նախատեսված դերերում։ Արագ անցնենք այս կատեգորիայից մնացած մի քանիսի վրայով։

Python-ի set-ները ո՛չ արտապատկերումներ են, ո՛չ sequence-ներ։ Փոխարենը դրանք immutable, տեխնիկապես՝ «hashable» object-ների չկարգավորված հավաքածուներ են, որոնք յուրաքանչյուր object-ը պահում են միայն մեկ անգամ։ set-ներ ստեղծում եք՝ built-in set function-ը կանչելով sequence-ով կամ այլ iterable object-ով, կամ օգտագործելով set-ի literal expression։ set-ներն աջակցում են մաթեմատիկական set-ների սովորական գործողությունները։

Գրքի code · PDF էջ 231

  >>> X = set('hack')                    # Sequence
  >>> Y = {'a', 'p', 'p'}                # Set lite
  >>> X, Y
  ({'c', 'k', 'a', 'h'}, {'p', 'a'})

Մեկնաբանություն, տող 1․ sequence

Մեկնաբանություն, տող 2․ set-ի լիտե…

Գրքի code · PDF էջ 231

  >>> X & Y, X | Y                       # Intersec
  ({'a'}, {'p', 'c', 'k', 'h', 'a'})

Մեկնաբանություն, տող 1․ Հատու…

Գրքի code · PDF էջ 231

  >>> X - Y, X > Y                       # Differen
  ({'c', 'k', 'h'}, False)

Մեկնաբանություն, տող 1․ Տարբերու…

Նույնիսկ մաթեմատիկայով ավելի քիչ հետաքրքրվող programmer-ները հաճախ set-ներն օգտակար են գտնում այնպիսի սովորական խնդիրների համար, ինչպիսիք են կրկնվող տարրերը զտելը,

Սկզբնաղբյուրի PDF էջ 232

տարբերությունները մեկուսացնելը և առանց տեսակավորելու՝ հերթականությունից անկախ հավասարության ստուգումներ կատարելը։

Գրքի code · PDF էջ 232

  >>> list(set([3, 1, 2, 1, 3, 1]))      # Duplicat
  [1, 2, 3]
  >>> set('code') - set('hack')          # Collecti
  {'d', 'o', 'e'}
  >>> set('code') == set('deoc')         # Order-ne
  True

Մեկնաբանություն, տող 1․ Կրկն…

Մեկնաբանություն, տող 3․ Հավաքա…

Մեկնաբանություն, տող 5․ Հերթականությունից անկա…

Ինչպես կտեսնեք գրքի այս մասում ավելի ուշ, սովորական set-ներն իրենք mutable են և կարող են փոփոխվել, օրինակ՝ իրենց remove և add method-ներով, թեև դրանց ներսի immutable տարրերը, ըստ սահմանման, չեն կարող։

Python-ը տրամադրում է նաև Boolean արժեքներ՝ նախապես սահմանված True և False object-ներով, որոնք ըստ էության ընդամենը 1 և 0 ամբողջ թվերն են՝ ցուցադրման հատուկ տրամաբանությամբ։ Կա նաև None name-ով հատուկ տեղապահ object-ը, որը սովորաբար օգտագործվում է name-ներն ու object-ները սկզբնարժեքավորելու և function-ներում արդյունքի բացակայությունը նշելու համար։

Գրքի code · PDF էջ 232

  >>> 1 > 2, 1 < 2                    # Booleans
  (False, True)

Մեկնաբանություն, տող 1․ Boolean արժեքներ

Սկզբնաղբյուրի PDF էջ 233

Գրքի code · PDF էջ 233

  >>> bool('hack')                    # All objects
  True                                # Nonempty me

Մեկնաբանություն, տող 1․ Բոլոր object-ները

Մեկնաբանություն, տող 2․ Ոչ դատարկը նշա…

Գրքի code · PDF էջ 233

  >>> X = None                        # None placeh
  >>> print(X)                        # But None is
  None
  >>> L = [None] * 100                # Initialize
  >>> L
  [None, None, None, None, None, None, None, None,
  None, None, None, None, None, None, None, None, …

Մեկնաբանություն, տող 1․ None տեղապա…

Մեկնաբանություն, տող 2․ Բայց None-ը … է

Մեկնաբանություն, տող 4․ Սկզբնարժեքավորել

Այստեղ հիշատակման արժանի է ևս մեկ՝ վերջին հիմնական object-ը։ type-ի object-ը, որը վերադարձնում է built-in type function-ը, մեկ այլ object-ի type-ը ցույց տվող object է։ Այն ավելի վաղ օգտագործել ենք help function-ն ուսումնասիրելիս, բայց ահա դրա իրական արդյունքը։

Գրքի code · PDF էջ 233

  >>> L = [1, 2, 3]
  >>> type(L)                         # The type of
  <class 'list'>
  >>> type(type(L))                   # Even types
  <class 'type'>

Մեկնաբանություն, տող 2․ …-ի type-ը

Մեկնաբանություն, տող 4․ Նույնիսկ type-երը

Սկզբնաղբյուրի PDF էջ 234

Ինտերակտիվ ձևով ձեր object-ներն ուսումնասիրելու հնարավորությունից բացի, type-ի object-ն իր առավել գործնական կիրառությամբ թույլ է տալիս code-ին ստուգել մշակվող object-ների type-երը։ Իրականում Python script-ում դա անելու առնվազն երեք եղանակ կա։

Գրքի code · PDF էջ 234

  >>> type(L) == type([])             # Type testin
  True                                # Using a rea

Մեկնաբանություն, տող 1․ type-երի ստուգու…

Մեկնաբանություն, տող 2․ Օգտագործելով իրա…

Գրքի code · PDF էջ 234

  >>> type(L) == list                 # Using a typ
  True

Մեկնաբանություն, տող 1․ Օգտագործելով տի…

Գրքի code · PDF էջ 234

  >>> isinstance(L, list)             # The object-
  True

Մեկնաբանություն, տող 1․ object-ի …

Բայց հիմա, երբ այս գիրքը ցույց է տվել type-երը ստուգելու այս բոլոր եղանակները, Python-ի օրենքը պարտադրում է ասել ձեզ, որ Python program-ում այդպես վարվելը գրեթե միշտ սխալ է և հաճախ նշան է, որ Java-ի նախկին programmer-ը հենց նոր է սկսել Python օգտագործել։ Պատճառը լիովին պարզ կդառնա միայն գրքում ավելի ուշ, երբ սկսենք գրել function-ների նման ավելի մեծ code միավորներ, բայց սա Python-ի հիմնական հասկացություններից մեկն է, և գուցե հենց ամենահիմնականը։ Ձեր code-ում կոնկրետ type-եր ստուգելով՝ փաստորեն խաթարում եք դրա ճկունությունը. սահմանափակում եք այն միայն մեկ type-ի հետ աշխատելով։ Առանց

Սկզբնաղբյուրի PDF էջ 235

նման ստուգումների՝ ձեր code-ը կարող է ինքնաբերաբար աշխատել type-երի մի ամբողջ շարքի հետ։

Սա ավելի վաղ հիշատակված բազմաձևության մի մասն է և բխում է Python-ում type-երի հայտարարությունների բացակայությունից։ Ինչպես ավելին կիմանաք, երբ անցնենք function-ներ և class-եր գրելուն, Python-ում code-ը գրում ենք object-ների interface-ների՝ աջակցվող գործողությունների համար, ոչ թե type-երի։ Այսինքն՝ մեզ հետաքրքրում է, թե ինչ է անում object-ը, ոչ թե՝ ինչ է այն։ Կոնկրետ type-երով չսահմանափակվելը նշանակում է, որ code-ը կարող է կիրառվել դրանցից շատերի նկատմամբ. համատեղելի interface ունեցող ցանկացած object կաշխատի՝ անկախ իր կոնկրետ type-ից։ Թեև type-երի ստուգումն աջակցվում է և որոշ հազվադեպ դեպքերում նույնիսկ անհրաժեշտ է, կտեսնեք, որ դա սովորաբար «Python-ական» մտածելակերպը չէ։ Իրականում հավանաբար կհամոզվեք, որ բազմաձևությունը Python-ը լավ օգտագործելու key-ն է։

Այդուհանդերձ, Python-ն աստիճանաբար կուտակել է type-երի հայտարարման մի միջոց, որը հայտնի է որպես type hint-ներ։ Այն սկզբնապես հիմնված էր function-ների ավելի վաղ եղած անոտացիաների վրա և ներշնչված էր JavaScript-ի TypeScript տարատեսակից։ syntax-ի և module-ների այս ընդլայնումներով հնարավոր է նշել function-ների argument-ների ու արդյունքների, class-երի վրա հիմնված object-ների attribute-ների և

Սկզբնաղբյուրի PDF էջ 236

նույնիսկ Python code-ի սովորական variable-ների սպասվող object type-երը, իսկ այդ հուշումները կարող են օգտագործվել mypy-ի նման արտաքին type checker-ների կողմից։

Գրքի code · PDF էջ 236

  >>> x: int = 1           # Optional hint: x might
  >>> x = 'anything'       # But it doesn't have to

Մեկնաբանություն, տող 1․ Ոչ պարտադիր հուշում. x-ը կարող է…

Մեկնաբանություն, տող 2․ Բայց պարտադիր չէ

Սակայն էական է, որ Python-ի type hint-ները նախատեսված են միայն փաստագրման և երրորդ կողմի գործիքների օգտագործման համար։ Python լեզուն ինքը չի պարտադրում և չի օգտագործում type-երի հայտարարություններ ու երբևէ դա անելու program-եր չունի։ Հետևաբար, չափանիշների մեծ մասով type hint-ները հիմնականում տեսական բնույթ ունեն, ավելի օգտակար չեն, քան program-ի ներսի comment-ները, և տարօրինակ կերպով հակասում են Python-ի հիմնական գաղափարներին։ Այն փաստը, որ դրանք, այնուամենայնիվ, բարձրացվել են լեզվի syntax-ի և բարդ ենթաոլորտի մակարդակի, կարելի է համարել արջի ծառայություն ինչպես Python սովորողներին, այնպես էլ օգտագործողներին։ Հատկապես սկսնակների համար սա ոչ պարտադիր և ծայրամասային թեմա է, որը լավագույնն է հետաձգել, մինչև տիրապետեք Python-ի dynamic typing-ի ճկունությանը։ Այս գրքում այն կուսումնասիրենք միայն հակիրճ՝ գլուխ 6-ում։

Անշուշտ, type hint-ները չեն նշանակում, որ Python-ն այլևս dynamic typing-ով լեզու չէ։ Իսկապես, static typing-ով Python-ը, որը կպահանջեր type-երի հայտարարություններ, բոլորովին Python չէր լինի։ Սահմանափակող լեզուների սովոր որոշ programmer-ներ, ցավոք, կարող են ամեն դեպքում գրել Python-ի type hint-ներ՝ որպես դժվար հաղթահարվող

Սկզբնաղբյուրի PDF էջ 237

սովորություն կամ կարողությունը ցուցադրելու սխալ փորձ, բայց լավ programmer-ները փոխարենը կենտրոնանում են Python-ի բազմաձևության վրա։ Ինչպես կպարզեք, հենց այդպես է պետք Python-ը գրել Python-ով։

Python-ում object-oriented programming-ը՝ OOP-ը, և դրա class statement-ը չենք ուսումնասիրի մինչև գրքի ավելի ուշ մասը։ Սակայն վերացական իմաստով class-երը սահմանում են object-ների նոր type-եր, որոնք ընդլայնում են հիմնական հավաքածուն, ուստի արժանի են այստեղ հպանցիկ ուշադրության։ Ենթադրենք, օրինակ, ցանկանում եք ունենալ object-ի տեսակ, որը մոդելավորում է ընկերության աշխատողներին։ Թեև Python-ում նման հատուկ հիմնական object-ի type չկա՝ ի վերջո այն մարդկային ռեսուրսների կառավարման լեզու չէ, օգտագործողի սահմանած class-ը կարող է լուծել խնդիրը։

Գրքի code · PDF էջ 237

  >>> class Worker:
          …stay tuned for Part VI…

Այս code-ի մեծ մասը բաց է թողնված, քանի որ գրքի այս փուլում այն այնքան էլ հասկանալի չէր լինի, բայց նման class-ը կարող է սահմանել աշխատողների name և pay attribute-ներ, ինչպես նաև հատուկ method-ներով գրված վարք։ class-ը կանչելը կստեղծի մեր նոր type-ի instance-ներ հանդիսացող object-ներ, իսկ class-ի method-ները կմշակեն դրանք։

Սկզբնաղբյուրի PDF էջ 238

Գրքի code · PDF էջ 238

  >>> sue = Worker('Sue Jones', 60000)         # Ma
  >>> bob = Worker('Bob Smith', 50000)         # Ea
  >>> sue.lastName()                           # Ca
  'Jones'
  >>> bob.lastName()                           # Ca
  'Smith'
  >>> sue.giveRaise(.10)                       # Up
  >>> sue.pay                                  # Di
  66000.0

Մեկնաբանություն, տող 1․ Ma [կտրված է]

Մեկնաբանություն, տող 2․ Ea [կտրված է]

Մեկնաբանություն, տող 3․ Ca [կտրված է]

Մեկնաբանություն, տող 5․ Ca [կտրված է]

Մեկնաբանություն, տող 7․ Up [կտրված է]

Մեկնաբանություն, տող 8․ Di [կտրված է]

Սա կոչվում է object-oriented, քանի որ class-ի ներսի function-ներում միշտ կա ենթադրվող ենթակա։ class-երի վրա հիմնված object-ներն ի վերջո ներսում օգտագործում են built-in object-ներ, և աշխատողների նման բաները միշտ կարող ենք նկարագրել դրանց փոխարեն Python-ի built-in object-ներով, ինչպես ավելի վաղ արեցինք dictionary-ներով և list-ներով։ Սակայն class-երն իրականացնում են իմաստալից name-ներով գործողություններ, կառուցվածք են հաղորդում ձեր code-ին և ունեն inheritance-ի մեխանիզմներ, որոնք հարմար են ընդլայնման միջոցով հարմարեցնելու համար։ OOP-ում ձգտում ենք software-ը ընդլայնել՝ գրելով նոր class-եր, այլ ոչ թե փոխելով այն, ինչն արդեն աշխատում է։

Սակայն այս ամենը զգալիորեն դուրս է object-ների այս նախնական ծանոթացման սահմաններից, ուստի այստեղ պետք է կանգ առնենք։ class-երով գրված՝ օգտագործողի սահմանած object-ների type-երի ամբողջական բացատրության համար պետք է շարունակեք կարդալ։

Սկզբնաղբյուրի PDF էջ 239

Քանի որ class-երը հիմնվում են Python-ի այլ գործիքների վրա, դրանք այս գրքի ճանապարհորդության հիմնական նպատակակետերից մեկն են։

Ինչպես արդեն նշվեց, այն ամենը, ինչ կարող եք մշակել Python script-ում, որևէ type-ի object է, ուստի object-ների type-երի մեր շրջայցն անխուսափելիորեն թերի է։ Սակայն, թեև Python-ում ամեն ինչ «object» է, ամեն ինչ չէ, որ համարվում է Python-ի հիմնական գործիքակազմի մաս։ Python-ի այլ object-ների type-երը կա՛մ կապված են program-ի կատարման հետ, ինչպես function-ները, module-ները, class-երն ու compiled code-ը, կա՛մ իրականացվում են ներմուծված module-ների function-ներով, ոչ թե լեզվի syntax-ով։ Վերջիններս նաև սովորաբար ունեն կիրառությանը հատուկ դերեր՝ տեքստային ձևանմուշներ, տվյալների շտեմարանի interface-ներ, ցանցային կապեր և այլն։

Ավելին, հիշեք, որ այստեղ հանդիպած object-ներն object-ներ են, բայց պարտադիր չէ, որ object-oriented լինեն։ Վերջին հասկացությունը սովորաբար պահանջում է Python-ի class statement-ը, որին կրկին կհանդիպեք գրքում ավելի ուշ։ Այդուհանդերձ, Python-ի հիմնական object-ները ձեր հանդիպելիք բոլոր Python script-ների աշխատող հիմքն են և հաճախ հիմք են ծառայում ավելի մեծ՝ ոչ հիմնական object-ների համար։

Սկզբնաղբյուրի PDF էջ 240

Սրանով ավարտում ենք object-ների մեր շրջայցը։ Այս գլուխը նախնական պատկերացում տվեց Python-ի հիմնական object-ների type-երի և դրանց նկատմամբ կիրառելի գործողությունների տեսակների մասին։ Ուսումնասիրեցինք ընդհանուր գործողություններ, որոնք աշխատում են object-ների բազմաթիվ type-երի հետ, օրինակ՝ sequence-ների indexing-ն ու slicing-ը, ինչպես նաև type-ին հատուկ գործողություններ, որոնք հասանելի են որպես method-ների կանչեր, օրինակ՝ string-երի բաժանումը և list-ներին տարր ավելացնելը։ Սահմանեցինք նաև մի քանի առանցքային տերմին՝ immutability, sequence-ներ և բազմաձևություն։

Ընթացքում իմացանք, որ Python-ի հիմնական object-ների type-երն ավելի ճկուն ու հզոր են, քան ցածր մակարդակի լեզուներում հասանելիները։ Օրինակ՝ Python-ի list-ներն ու dictionary-ները կարող են ներդրվել միմյանց մեջ, աճել ու փոքրանալ և պարունակել ցանկացած type-ի object-ներ, իսկ դրանց memory-ի տարածքն աշխատանքի ընթացքում հատկացվում ու ազատվում է ինքնաբերաբար։ Նաև հպանցիկ տեսանք, թե ինչպես են string-երն ու file-երը համատեղ աջակցում երկուական և տեքստային տվյալները, հայացք գցեցինք կրկնության արձանագրությանն ու OOP-ին, քննարկեցինք type hint-ների վտանգները և ծանոթացանք if ու for statement-ներին, որոնք կօգտագործենք հետագայում։

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

Սկզբնաղբյուրի PDF էջ 241

խորանալ՝ երկրորդ անգամ անցնելով Python-ի object-ների type-երով, ինչը կլրացնի այստեղ բաց թողնված մանրամասները և ձեզ ավելի խոր պատկերացում կտա։ Հաջորդ գլուխը կսկսենք Python-ի թվերի մանրակրկիտ ուսումնասիրությամբ։ Բայց նախ՝ ևս մեկ հարցաշար՝ կրկնելու համար։

Այս գլխում ներկայացված հասկացություններն ավելի մանրամասն կուսումնասիրենք առաջիկա գլուխներում, ուստի այստեղ կանդրադառնանք միայն գլխավոր գաղափարներին։

Սկզբնաղբյուրի PDF էջ 242

1. Թվերը, string-երը, list-ները, dictionary-ները, tuple-ները, file-երն ու set-ները սովորաբար համարվում են object-ների հիմնական type-եր։ Boolean արժեքները, None-ը և հենց type-երը նույնպես դասակարգվում են այս կերպ։ Այս type-երից որոշներն իրականում կատեգորիաներ են. կան թվերի մի քանի type-եր՝ ամբողջ, floating-point, կոմպլեքս, սովորական կոտորակ և տասնորդական, և string-երի մի քանի type-եր՝ տեքստային string-եր, byte string-եր և mutable byte string-եր։

2. Դրանք հայտնի են որպես object-ների «հիմնական» type-եր, քանի որ հենց Python լեզվի մասն են և միշտ հասանելի են։ Այլ object-ներ ստեղծելու համար սովորաբար պետք է կանչեք ներմուծված module-ների function-ներ։ Հիմնական object-ների մեծ մասն ունի իր object-ները ստեղծելու հատուկ syntax. օրինակ՝ 'hack'-ը expression է, որը ստեղծում է string և որոշում դրա նկատմամբ կիրառելի գործողությունների հավաքածուն։ Այդ պատճառով հիմնական object-ներն անմիջապես ներառված են Python-ի syntax-ի մեջ։ Ի հակադրություն՝ file object ստեղծելու համար պետք է կանչեք built-in open function-ը, թեև սա նույնպես սովորաբար համարվում է հիմնական object-ի type։

3. «immutable» object-ն այն object-ն է, որը ստեղծվելուց հետո հնարավոր չէ փոփոխել։ Python-ում թվերը, string-երն ու tuple-ները պատկանում են այս կատեգորիային։ Թեև immutable object-ը տեղում փոփոխել չեք կարող, միշտ կարող եք նորը ստեղծել՝ կատարելով expression։ bytearrays-ը string-երին տալիս է mutability, բայց

Սկզբնաղբյուրի PDF էջ 243

դրանք ուղղակիորեն կիրառելի են տեքստի նկատմամբ միայն այն դեպքում, երբ այն պարզ 8-բիթանոց տեսակի է, օրինակ՝ ASCII։

4. «sequence-ը» object-ների՝ ըստ դիրքի կարգավորված հավաքածու է։ string-երը, list-ներն ու tuple-ները Python-ում բոլորը sequence-ներ են։ Դրանք ունեն sequence-ների ընդհանուր գործողություններ, օրինակ՝ indexing, կցում ու slicing, բայց ունեն նաև type-ին հատուկ method-ների կանչեր։ Կապակցված «կրկնելի» տերմինը նշանակում է կա՛մ ֆիզիկապես գոյություն ունեցող sequence, կա՛մ վիրտուալ sequence, որն իր տարրերը ստեղծում է պահանջի դեպքում։ sequence-ները կրկնելի են, բայց կրկնելի են նաև generator-ները, file-երը, range-ի նման function-ների արդյունքները և dictionary object-ը, որը կրկնության ժամանակ տալիս է իր key-ները՝ ճիշտ ինչպես իր keys method-ը։

5. «Արտապատկերում» տերմինը նշանակում է object, որը key-ները համապատասխանեցնում է դրանց հետ կապված value-ներին։ Python-ի հիմնական object-ների type-երի մեջ dictionary-ն միակ արտապատկերումն է։ Արտապատկերումները պահպանում են key-ների ավելացման հերթականությունը՝ սկսած Python 3.7-ից, և աջակցում են key-ով պահպանված տվյալներին հասանելիություն, ինչպես նաև type-ին հատուկ method-ների կանչեր, որոնք թույլ են տալիս key-ների ստուգումներ, կրկնություն և այլն։

6. «Բազմաձևությունը» նշանակում է, որ գործողության, օրինակ՝ +-ի իմաստը կախված է այն object-ներից, որոնց նկատմամբ այն կիրառվում է։ Պարզվում է՝ սա Python-ը լավ օգտագործելու հիմքում ընկած առանցքային, և գուցե ամենամեծ գաղափարն է. code-ը կոնկրետ type-երով չսահմանափակելը այն ինքնաբերաբար կիրառելի է դարձնում բազմաթիվ type-երի համար։ Սա ավելի ակնհայտ է դառնում Python-ում

Սկզբնաղբյուրի PDF էջ 244

function-ներ և class-եր գրելիս։ Թեև Python-ն այսօր ունի type hint-ներ, հենց Python-ը դրանք չի օգտագործում, և դրանք նախատեսված են միայն փաստագրման ու գործիքների համար։

5․ Թվեր և expression-ներ

0b1111 · 15 · 0o17 · 0xF · Սրանք նույն ամբողջ թվի տարբեր գրառումներ են։0b1111150o170xFՍրանք նույն ամբողջ թվի տարբեր գրառումներ են։

Սկզբնաղբյուրի PDF էջ 245

Այս գլխով սկսվում է Python լեզվի մեր խորացված շրջայցը։ Python-ում տվյալներն ունեն object-ների ձև՝ կա՛մ Python-ի տրամադրած built-in object-ներ, կա՛մ object-ներ, որոնք ստեղծում ենք Python-ի գործիքներով և C-ի նման այլ լեզուներով։ Իրականում object-ներն այն բոլոր Python program-երի հիմքն են, որոնք երբևէ կգրեք։ Քանի որ դրանք Python-ով programming-ի ամենահիմնարար հասկացությունն են, object-ները նաև այս գրքում մեր առաջին ուշադրության կենտրոնն են։

Նախորդ գլխում արագ առաջին անցում կատարեցինք Python-ի հիմնական object-ների type-երի վրայով։ Թեև այդ գլխում ներկայացվեցին կարևոր տերմիններ, ծավալը սահմանափակ պահելու համար խուսափեցինք չափազանց շատ մանրամասներից։ Այստեղ կսկսենք երկրորդ՝ ավելի ուշադիր հայացք գցել object-ների հասկացություններին, որպեսզի լրացնենք նախկինում հպանցիկ անցած մանրամասները։ Սկսենք մեր առաջին կատեգորիայի՝ Python-ի թվային object-ների և գործողությունների ուսումնասիրությունից։

Python-ի թվային հնարավորությունների մեծ մասը բավական սովորական է և, հավանաբար, ծանոթ կթվա, եթե նախկինում օգտագործել եք programming-ի գրեթե ցանկացած այլ

Սկզբնաղբյուրի PDF էջ 246

լեզու։ Դրանք կարող են օգտագործվել՝ ձեր բանկային հաշվի մնացորդը, մինչև Մարս հեռավորությունը, ձեր կայքի այցելուների թիվը և գրեթե ցանկացած այլ թվային մեծություն հաշվառելու համար։

Python-ում թվերն իրականում object-ի մեկ type չեն, այլ նմանատիպ type-երի կատեգորիա։ Python-ն աջակցում է թվերի սովորական type-երը՝ ամբողջ և floating-point թվեր, ինչպես նաև թվեր ստեղծելու literal-ներն ու դրանք մշակելու expression-ները։ Բացի այդ, Python-ը տրամադրում է թվային programming-ի ավելի առաջադեմ միջոցներ և object-ներ՝ ավելի բարդ կարիքների համար։ Python-ի թվային գործիքակազմի բավական ամբողջական ցանկը ներառում է՝

Ամբողջ և floating-point թվերի object-ներ
Կոմպլեքս թվերի object-ներ
Ֆիքսված ճշտությամբ Decimal object-ներ
Ռացիոնալ թվերի Fraction object-ներ
set-ների object-ներ և գործողություններ
Boolean և bitwise operation-ներ
built-in module-ներ, օրինակ՝ math, cmath, random և

Գրքի code · PDF էջ 246

  statistics

Երրորդ կողմի լրացումներ, այդ թվում՝ վեկտորներ, պատկերավորում, գրաֆիկների կառուցում և ընդլայնված ճշտություն

Սկզբնաղբյուրի PDF էջ 247

Քանի որ այս ցանկի առաջին կետում թվարկված object-ների type-երը սովորաբար ամենաշատն են գործածվում Python code-ում, այս գլուխը սկսվում է հիմնական թվերից և հիմունքներից, ապա անցնում է ցանկի այլ type-երի ուսումնասիրությանը, որոնք մասնագիտացված դերեր ունեն։ Այստեղ կուսումնասիրենք նաև set-ները, որոնք ունեն և՛ թվային, և՛ հավաքածուներին բնորոշ հատկանիշներ, բայց սովորաբար ավելի շատ համարվում են առաջինը, քան երկրորդը։ Սակայն մինչև code-ին անցնելը՝ հաջորդ մի քանի բաժինները մեզ կմեկնարկեն script-ներում թվերը գրելու ու մշակելու ձևերի համառոտ ակնարկով։

Իր հիմնական object-ների type-երի մեջ Python-ը տրամադրում է ամբողջ թվեր՝ դրական ու բացասական ամբողջական արժեքներ, և floating-point թվեր՝ կոտորակային մաս ունեցող թվեր, որոնք խոսքի հակիրճության համար երբեմն կոչվում են floats։ Python-ը նաև թույլ է տալիս ամբողջ թվերը գրել տասնվեցական, ութական և binary literal-ներով, առաջարկում է կոմպլեքս թվերի type և թույլ է տալիս ամբողջ թվերին ունենալ անսահմանափակ ճշտություն. դրանք կարող են աճել ու ունենալ այնքան թվանշան, որքան թույլ է տալիս memory-ի տարածքը։ Աղյուսակ 5-1-ը ցույց է տալիս, թե ինչ տեսք ունեն Python-ի numeric type-երը, երբ program-ում գրվում են որպես literal-ներ կամ constructor function-ների կանչեր։

Սկզբնաղբյուրի PDF էջ 248

Աղյուսակ 5-1. Թվային literal-ներ և constructor-ներ

Բացել այս աղյուսակի ընթեռնելի ուղեցույցը →

literal | interpretation

1234 , −24 , 0 , 9_999_999_9 | Ամբողջ թվեր՝ անսահմանափակ չափով

Գրքի code · PDF էջ 248

 99_999

1.23 , 1. , 3.14e-10 , 4E21 | floating-point թվեր

Գրքի code · PDF էջ 248

 0, 4.0e+210

0o177 , 0x9ff , 0b101010 | Ութական, տասնվեցական և binary literal-ներ

3+4j , 3.0+4.0j , 3J | Կոմպլեքս թվերի literal-ներ

set('hack') , {1, 2, 3, 4} | set-ներ՝ constructor-ներ և literal-ներ

Decimal('1.0') , Fraction (1, 3) | Տասնորդական և սովորական կոտորակների ընդլայնման type-եր

bool(X) , True , False | Boolean type և հաստատուններ

Ընդհանուր առմամբ Python-ի numeric type-երի literal-ները հեշտ է գրել, բայց արժե սկզբից ընդգծել encoding-ի մի քանի հասկացություն։

Ամբողջ և floating-point թվերի literal-ներ

Սկզբնաղբյուրի PDF էջ 249

Ամբողջ թվերը գրվում են որպես տասնորդական թվանշանների շղթաներ։ Ինչպես նշվեց, դրանց ճշտությունը՝ թվանշանների քանակը, սահմանափակվում է միայն ձեր սարքի հասանելի memory-ով։ Հեշտությամբ կարող եք հաշվել 1,000,000-րդ աստիճան բարձրացված 2-ը, թեև 300 հազար թվանշան ունեցող արդյունքն արտածելը կարող է որոշ ժամանակ պահանջել։ Եվ, ինչպես նշված է գլուխ 4-ում, ներկայում այն լռելյայն հնարավոր չէ վերածել արտածման string-ի։

floating-point թվերն ունեն տասնորդական կետ և/կամ ոչ պարտադիր նշանով աստիճանացուցիչ, որը սկսվում է e-ով կամ E-ով, որին կարող է հաջորդել նշան։ Եթե թիվը գրում եք տասնորդական կետով կամ աստիճանացուցիչով, Python-ն այն դարձնում է floating-point object և, երբ object-ն օգտագործվում է expression-ի մեջ, կիրառում է floating-point, ոչ թե ամբողջ թվերի թվաբանություն։ Ինչպես կսովորեք, float-ն ամբողջ թվի հետ խառնելը նույնպես հանգեցնում է floating-point թվաբանության՝ ամբողջ թիվը համապատասխան type-ին փոխակերպելուց հետո։

Տասնվեցական, ութական և binary literal-ներ

Ամբողջ թվերը կարելի է գրել տասնորդական՝ 10 հիմքով, տասնվեցական՝ 16 հիմքով, ութական՝ 8 հիմքով կամ երկուական՝ 2 հիմքով տեսքով։ Վերջին երեքը տարածված են programming-ի որոշ ոլորտներում։ Տասնվեցական գրառումները սկսվում են 0x-ով կամ 0X-ով, որոնց հաջորդում է տասնվեցական թվանշանների շղթա՝ 0–9 և A–F։ Տասնվեցական թվանշանները կարելի է գրել փոքրատառ կամ մեծատառ։ octal literal-ները սկսվում են 0o-ով կամ 0O-ով՝ զրո և փոքրատառ կամ մեծատառ o, որոնց հաջորդում է

Սկզբնաղբյուրի PDF էջ 250

ութական թվանշանների շղթա՝ 0–7։ binary literal-ները սկսվում են 0b-ով կամ 0B-ով, որոնց հաջորդում են երկուական թվանշաններ՝ 0–1։

Այս բոլոր literal-ները program-ի code-ում ստեղծում են ամբողջ թվերի object-ներ. դրանք ընդամենը value-ները նշելու այլընտրանքային syntax-ներ են։ built-in hex(I), oct(I) և bin(I) կանչերն ամբողջ թիվը փոխակերպում են այս երեք հիմքերով դրա ներկայացման string-ի, իսկ int(str, base)-ը runtime ստացված string-ը վերածում է ամբողջ թվի՝ ըստ տրված հիմքի։
Կոմպլեքս թվեր

Թեև ավելի հազվադեպ են օգտագործվում, Python-ի կոմպլեքս literal-ները գրվում են realpart+imaginarypart տեսքով, որտեղ imaginarypart-ն ավարտվում է j-ով կամ J-ով։ realpart-ը տեխնիկապես ոչ պարտադիր է, ուստի imaginarypart-ը կարող է հայտնվել առանձին։ Ներքին իրականացման մեջ կոմպլեքս թվերը ներկայացվում են floating-point թվերի զույգերով, բայց բոլոր թվային գործողությունները կոմպլեքս թվերի նկատմամբ կիրառվելիս կատարում են կոմպլեքս թվաբանություն։ Կոմպլեքս թվեր կարելի է ստեղծել նաև built-in complex(real, imag) կանչով։
Այլ numeric type-երի գրառում

Ինչպես կտեսնեք այս գլխում ավելի ուշ, աղյուսակ 5-1-ի վերջնամասում կան լրացուցիչ numeric type-եր, որոնք ծառայում են ավելի առաջադեմ կամ մասնագիտացված դերերի։ Դրանց մի մասը ստեղծում եք՝

Սկզբնաղբյուրի PDF էջ 251

կանչելով ներմուծված module-ների function-ներ, օրինակ՝ տասնորդական և սովորական կոտորակների համար։ Մյուսներն ունեն իրենց հատուկ literal syntax-ը, օրինակ՝ set-ները, իսկ Boolean արժեքները մասնագիտացված ամբողջ թվի տեսակ են։

Աղյուսակ 5-1-ում ցույց տրված built-in թվային literal-ներից և կառուցման կանչերից բացի Python-ը տրամադրում է թվային object-ները մշակելու գործիքների հավաքածու։

expression-ների operator-ներ

+ , - , * , / , >> , ** , & , % և այլն։
built-in մաթեմատիկական function-ներ

pow , abs , round , int , hex , bin և այլն։
Օժանդակ module-ներ

Գրքի code · PDF էջ 251

     random, math, statistics,etc.

Ընթացքում կհանդիպեք այս բոլորին։

Թեև թվերը հիմնականում մշակվում են expression-ներով, built-in գործիքներով ու module-ներով, այսօր դրանք ունեն նաև type-ին հատուկ մի քանի method-ներ, որոնց կհանդիպեք այս գլխում։ floating-point թվերը, օրինակ, ունեն as_integer_ratio method-ը, որն օգտակար է սովորական կոտորակների numeric type-ի համար, և is_integer method-ը՝ ստուգելու, թե արդյոք թիվն ամբողջ է։ Ամբողջ թվերի attribute-ների

Սկզբնաղբյուրի PDF էջ 252

մեջ կա bit_length method-ը, որը տալիս է object-ի value-ն ներկայացնելու համար անհրաժեշտ bit-երի քանակը, իսկ set-ները, որոնք մասամբ հավաքածու են, մասամբ՝ թիվ, նույնպես աջակցում են և՛ expression-ների, և՛ method-ների։

Սակայն, քանի որ numeric type-երի մեծ մասի համար expression-ներն ամենակարևոր գործիքն են, հաջորդիվ անցնենք դրանց։

Թվերը մշակող ամենահիմնարար գործիքը expression-ն է՝ թվերի կամ այլ object-ների և operator-ների համադրություն, որը Python-ի կողմից կատարվելիս հաշվում է մի value։ Python-ում expression-ներ գրում եք սովորական մաթեմատիկական գրառմամբ և operator-ների նշաններով։ Օրինակ՝ երկու՝ X և Y թվերը գումարելու համար կգրեք X + Y, ինչը Python-ին ասում է + operator-ը կիրառել X և Y name-ներով նշվող value-ների նկատմամբ։ expression-ի արդյունքը X-ի և Y-ի գումարն է՝ մեկ այլ թվային object։

Աղյուսակ 5-2-ը վերացական ձևով թվարկում է Python-ում հասանելի operator-ներով բոլոր expression-ները։ Շատերն ինքնին հասկանալի են. օրինակ՝ աջակցվում են սովորական մաթեմատիկական operator-ները՝ +, −, *, / և այլն։ Մի քանիսը ծանոթ կլինեն, եթե նախկինում այլ լեզուներ

Սկզբնաղբյուրի PDF էջ 253

եք օգտագործել. %-ը հաշվում է բաժանման մնացորդը, <<-ը կատարում է բիթային ձախ տեղաշարժ, &-ը հաշվում է բիթային AND-ի արդյունքը և այլն։ Մյուսներն ավելի բնորոշ են Python-ին, և բոլորը չէ, որ թվային բնույթ ունեն։ Օրինակ՝ is operator-ը ստուգում է object-ների identity-ն՝ memory-ի նույն հասցեն, հավասարության խիստ ձևը, իսկ lambda-ն ստեղծում է անանուն function-ներ։

Սկզբնաղբյուրի PDF էջ 254

Աղյուսակ 5-2. Python-ի expression-ների operator-ները՝ ըստ precedence-ի աճի՝ ավելի ուժեղ կապակցման

Բացել այս աղյուսակի ընթեռնելի ուղեցույցը →

operator-ներ | Նկարագրություն

yield x , yield from | generator function-ի ուղարկման արձանագրություն

Գրքի code · PDF էջ 254

 x

x := y | assignment-ի expression

lambda args: expre | Անանուն function-ի ստեղծում

Գրքի code · PDF էջ 254

 ssion

x if y else z | Եռանդամ ընտրություն. x-ը հաշվարկվում է միայն, եթե y-ը ճշմարիտ է

x or y | Տրամաբանական OR. y-ը հաշվարկվում է միայն, եթե x-ը կեղծ է

x and y | Տրամաբանական AND. y-ը հաշվարկվում է միայն, եթե x-ը ճշմարիտ է

not x | Տրամաբանական ժխտում

x in y , x not in y | Պատկանելություն՝ iterable object-ներում
x is y , x is not y | object-ների identity-ի ստուգումներ
x < y , x <= y , x > y , x >= y | Մեծությունների համեմատում, set-ի subset և superset
x == y , x != y | value-ների հավասարության operator-ներ

Սկզբնաղբյուրի PDF էջ 255

operator-ներ | Նկարագրություն

x | y — Բիթային OR, set union, dictionary-ների միաձուլում

x ^ y | Բիթային XOR, set-ների սիմետրիկ տարբերություն

x & y | Բիթային AND, set intersection

x << y , x >> y | x-ի տեղաշարժը ձախ կամ աջ՝ y bit-ով

x + y | Գումարում, կցում
x – y | Հանում, set difference

x * y | Բազմապատկում, կրկնում
x % y | Մնացորդ, ձևաչափում
x / y, x // y | Բաժանում՝ իրական և դեպի ներքև կլորացվող
x @ y | Մատրիցային բազմապատկում՝ Python-ի կողմից չօգտագործվող

−x , +x , ˜x | Նշանի հակադարձում, նույնություն
Բիթային NOT՝ շրջում

x ** y | Աստիճան՝ աստիճան բարձրացնելը

await x | Սպասման expression՝ ասինխրոն function-ներ

Սկզբնաղբյուրի PDF էջ 256

operator-ներ | Նկարագրություն

x[i] | indexing՝ sequence, արտապատկերում և այլ object-ներ
x[i:j:k] | slicing
x(...) | Կանչ՝ function, method, class, այլ callable object
x.attr | reference attribute-ին

(...) | tuple, expression, generator expression
[...] | list, list comprehension (comprehension)
{...} | dictionary, set, dictionary և set comprehension-ներ (comprehensions)

Թեև աղյուսակ 5-2-ը կարող է ծառայել որպես տեղեկատու, դրա որոշ operator-ներ հասկանալի չեն դառնա, մինչև չտեսնեք դրանք գործի մեջ, իսկ որոշներն ավելի նուրբ առանձնահատկություններ ունեն, քան աղյուսակից կարող է թվալ։ Օրինակ՝

yield-ի համար փակագծերը պարտադիր են, եթե այն միայնակ չէ assignment-ի statement-ի աջ կողմում։ Նույնը վերաբերում է := անվանական assignment-ի operator-ին՝ որոշ համատեքստերում օգտագործվելիս։
Համեմատման operator-ներն ինքնաբերաբար համեմատում են հավաքածուների բոլոր մասերը և կարող են շղթայվել՝ որպես կրճատ գրառում և

Սկզբնաղբյուրի PDF էջ 257

հնարավոր օպտիմացում։ Օրինակ՝ X < Y < Z-ն տալիս է նույն արդյունքը, ինչ X < Y and Y < Z-ն։
Python-ը սահմանում է @ operator՝ նախատեսված մատրիցային բազմապատկման համար, բայց դրա implementation չի տրամադրում։ Քանի դեռ այն չեք գրել որևէ class-ում կամ չեք օգտագործել դա իրականացնող library, այս operator-ը ոչինչ չի անում։
tuple-ների, expression-ների և generator-ների համար օգտագործվող փակագծերը երբեմն կարելի է բաց թողնել։ Երբ դրանք բաց են թողնվում tuple-ների դեպքում, տարրերը բաժանող ստորակետը գործում է որպես ամենացածր precedence-ով operator, եթե այլ նշանակություն չունի։
Որոշ operator-ներ, օրինակ՝ yield-ը, lambda-ն և await-ը, կապված են ավելի մեծ թեմաների հետ, որոնք քիչ կապ ունեն թվերի հետ, և Python-ի հետ ձեր աշխատանքի այս վաղ փուլում կարող են հանգիստ անտեսվել։

Այլ մանրուքների համար այս գիրքը կվերահղի Python-ի ձեռնարկներին, բայց աղյուսակ 5-2-ի operator-ների մեծ մասին հետագայում կտեսնեք գործի մեջ։ Սակայն նախ պետք է արագ դիտարկենք, թե ինչպես կարելի է այս operator-ները համադրել expression-ներում։

Սկզբնաղբյուրի PDF էջ 258

ՆՇՈՒՄ
Ծանոթացեք Python-ի ոչինչ չանող գործիքներին. @ character-ը Python-ն օգտագործում է function-ների դեկորատորները սկսելու համար, որոնք նկարագրվում են այս գրքում ավելի ուշ, բայց ոչ որպես expression-ի operator՝ չնայած այն այդպիսին սահմանված լինելուն։ Վերջին դերում @-ը միանում է Ellipsis-ին ( ... ) և type hint-ներին՝ որպես սահմանված, բայց հենց Python-ի կողմից ամբողջովին չօգտագործվող գործիքներ։ Կարծես իսկապես գործող բաների մեջ սովորելու բաներն արդեն քիչ լինեին։

Ինչպես լեզուների մեծ մասում, Python-ում էլ ավելի բարդ expression-ներ գրում եք՝ իրար շղթայելով աղյուսակ 5-2-ի operator-ներով expression-ները։ Օրինակ՝ երկու արտադրյալների գումարը կարելի է գրել variable-ների և operator-ների խառնուրդի տեսքով։

Գրքի code · PDF էջ 258

  A * B + C * D

Այստեղ հարց է առաջանում. ինչպե՞ս է Python-ն իմանում, թե որ գործողությունը կատարել առաջինը։ Պատասխանը operator-ների precedence-ի մեջ է։ Երբ գրում եք մեկից ավելի operator պարունակող expression, Python-ը դրա մասերը խմբավորում է ըստ այսպես կոչված precedence-ի կանոնների, և այդ խմբավորումը որոշում է expression-ի մասերի հաշվարկման հերթականությունը։ Սա ցույց տալու համար աղյուսակ 5-2-ը դասավորված է ըստ operator-ների precedence-ի։

Սկզբնաղբյուրի PDF էջ 259

Աղյուսակում ավելի ներքև գտնվող operator-ներն ավելի բարձր precedence ունեն, ուստի խառը expression-ներում ավելի սերտ են կապակցվում։ Այլ կերպ ասած՝ աղյուսակում ավելի վերև գտնվող operator-ներն ավելի ցածր precedence ունեն և ավելի թույլ են կապակցվում, քան դրանցից ներքև գտնվողները։
Աղյուսակի նույն row-ում գտնվող operator-ները համադրվելիս ընդհանուր առմամբ խմբավորվում են ձախից աջ։ exception-ներ են աստիճան բարձրացնելը, որը խմբավորվում է աջից ձախ, և համեմատությունները, որոնք շղթայվում են ձախից աջ։

Այսպիսով, օրինակ, եթե գրում եք X + Y * Z, Python-ը նախ հաշվում է բազմապատկումը՝ Y * Z, ապա այդ արդյունքը գումարում X-ին, քանի որ *-ն ավելի բարձր precedence ունի՝ աղյուսակում ավելի ներքև է, քան +-ը։ Նույն կերպ՝ այս բաժնի սկզբնական օրինակում երկու բազմապատկումները՝ A * B և C * D, կկատարվեն նախքան դրանց արդյունքների գումարումը, քանի որ +-ը *-ից վերև է։

precedence-ի կանոնների մասին մեծ մասամբ կարող եք մոռանալ, եթե ուշադիր խմբավորեք expression-ների մասերը փակագծերով։ Երբ subexpression-ները պարփակում եք փակագծերում, գերակայում եք Python-ի precedence-ի կանոններին։ Python-ը միշտ նախ հաշվում է փակագծերում գտնվող expression-ները, հետո դրանց արդյունքներն օգտագործում պարփակող expression-ներում։

Սկզբնաղբյուրի PDF էջ 260

Օրինակ՝ X + Y * Z գրելու փոխարեն կարող եք գրել ստորև բերվածներից մեկը՝ Python-ին ստիպելով expression-ը հաշվել երկու հնարավոր ցանկալի հերթականություններից որևէ մեկով։

Գրքի code · PDF էջ 260

  (X + Y) * Z
  X + (Y * Z)

Առաջին դեպքում +-ը նախ կիրառվում է X-ի և Y-ի նկատմամբ, քանի որ այս subexpression-ը պարփակված է փակագծերում։ Երկրորդ դեպքում *-ը կատարվում է առաջինը՝ ճիշտ այնպես, ինչպես կլիներ ընդհանրապես առանց փակագծերի։ Ընդհանուր առմամբ մեծ expression-ներում փակագծեր ավելացնելը լավ միտք է. դա ոչ միայն պարտադրում է ձեր ուզած հաշվարկման հերթականությունը, այլև օգնում է ընթեռնելիությանը։

expression-ներում operator-ները խառնելուց բացի կարող եք խառնել նաև numeric type-երը։ Օրինակ՝ կարող եք ամբողջ թիվը գումարել floating-point թվին։

Գրքի code · PDF էջ 260

  40 + 3.14

Բայց սա հանգեցնում է մեկ այլ հարցի. ի՞նչ type-ի է արդյունքը՝ ամբո՞ղջ, թե՞ float։ Պատասխանը պարզ է, հատկապես եթե

Սկզբնաղբյուրի PDF էջ 261

եթե նախկինում օգտագործել եք գրեթե ցանկացած այլ լեզու. խառը type-երով թվային expression-ներում operand-ները՝ expression-ի այն մասերը, որոնք operator-ներ չեն, նախ բարձրացվում են ամենաբարդ operand-ի type-ին, ապա մաթեմատիկական գործողությունը կատարվում է նույն type-ի operand-ների վրա։ Արդյունքն ունի բարձրացված operand-ների type-ը։

Դրա համար Python-ը numeric type-երի բարդությունը դասակարգում է այսպես. ամբողջ թվերն ավելի պարզ են, քան floating-point թվերը, որոնք էլ ավելի պարզ են, քան կոմպլեքս թվերը։ Ուստի երբ ամբողջ թիվը խառնվում է floating-point թվի հետ, ինչպես նախորդ օրինակում, այն նախ փոխակերպվում է floating-point value-ի, և floating-point մաթեմատիկան տալիս է floating-point արդյունք։ Ինքներդ ստուգեք Python-ի ձեր տեղական REPL-ում.

Գրքի code · PDF էջ 261

  >>> 40 + 3.14       # Integer to float, float mat
  43.14

Մեկնաբանություն, տող 1․ Ամբողջից floating-point թվի, floating-point թվաբա…

Նմանապես՝ ցանկացած խառը type-երով expression-ում, որտեղ operand-ներից մեկը կոմպլեքս թիվ է, մյուս operand-ը բարձրացվում է կոմպլեքս թվի, և expression-ը տալիս է կոմպլեքս արդյունք։ Փոխակերպումներ կատարվում են նաև հավասարության և մեծության համեմատություններում. 3 == 3.0-ը ճշմարիտ է, իսկ 3 > 3.0-ը՝ ոչ։

Սկզբնաղբյուրի PDF էջ 262

Կարող եք դա հարկադրել՝ կանչելով built-in function-ներ՝ type-երը ձեռքով փոխակերպելու համար.

Գրքի code · PDF էջ 262

  >>> int(3.1415)     # Truncates float to integer
  3
  >>> float(3)        # Converts integer to float
  3.0

Մեկնաբանություն, տող 1․ float-ը կտրում է մինչև ամբողջ թիվ

Մեկնաբանություն, տող 3․ Ամբողջ թիվը փոխակերպում է floating-point թվի

Սակայն սովորաբար դա անելու կարիք չի լինի. քանի որ Python-ն expression-ի ներսում ինքնաբերաբար փոխակերպում է ավելի բարդ type-ի, արդյունքները սովորաբար հենց այն են, ինչ ցանկանում եք։

Թեև ավտոմատ փոխակերպումները կատարվում են և՛ թվային, և՛ համեմատման operator-ների համար, հիշեք, որ դրանք կիրառվում են միայն այն դեպքում, երբ expression-ում խառնվում են թվային object-ներ, օրինակ՝ ամբողջ թիվ և float։ Ընդհանուր առմամբ՝ Python-ը որևէ այլ type-երի միջև ինքնաբերաբար չի փոխակերպում։ Օրինակ՝ թվանշաններից կազմված string-ն ամբողջ թվին գումարելը հանգեցնում է սխալի, եթե մեկը կամ մյուսը ձեռքով չփոխակերպեք. օրինակի և հիմնավորման կհանդիպենք Գլուխ 7-ում՝ string-երն ուսումնասիրելիս։ Հավասարության ստուգումներն աշխատում են խառը type-երի հետ, օրինակ՝ string-ը երբեք հավասար չէ որևէ ամբողջ թվի, սակայն մեծության համեմատությունները չեն աշխատում։

Սկզբնաղբյուրի PDF էջ 263

Թեև հիմա կենտրոնանում ենք built-in թվերի վրա, Python-ի բոլոր operator-ները կարող են գերբեռնվել, այսինքն՝ իրականացվել, Python-ի class-երով և C ընդլայնումների type-երով՝ ձեր ստեղծած object-ների հետ աշխատելու համար։ Օրինակ՝ հետագայում կտեսնեք, որ class-երով encoded object-ները կարելի է գումարել կամ կցել x+y expression-ներով, ինդեքսավորել x[i] expression-ներով և այլն։

Ավելին, հենց Python-ն ինքնաբերաբար գերբեռնում է որոշ operator-ներ, այնպես որ դրանք տարբեր գործողություններ են կատարում՝ կախված մշակվող built-in object-ների type-ից։ Օրինակ՝ + operator-ը թվերի նկատմամբ կիրարկելիս կատարում է գումարում, իսկ string-երի ու list-ների նման sequence-ի object-ների նկատմամբ՝ կցում։ Իրականում, class-երով ձեր սահմանած object-ների նկատմամբ կիրառվելիս + կարող է նշանակել ցանկացած բան։

Ինչպես տեսանք նախորդ գլխում, այս հատկությունը սովորաբար կոչվում է բազմաձևություն. եզրույթը ցույց է տալիս, որ գործողության իմաստը կախված է մշակվող object-ների type-ից։ Այս հասկացությանը կվերադառնանք Գլուխ 16-ում՝ function-ներն ուսումնասիրելիս, քանի որ այդ համատեքստում այն շատ ավելի ակնհայտ հատկություն է դառնում։

Սկզբնաղբյուրի PDF էջ 264

Անցնենք code-ին։ Թվային object-ներն ու expression-ները հասկանալու հավանաբար լավագույն եղանակը դրանք գործողության մեջ տեսնելն է, ուստի, տիրապետելով նախորդ բոլոր հիմունքներին, եկեք գործարկենք ինտերակտիվ command line-ը և փորձենք մի քանի պարզ, բայց ցուցադրական գործողություններ (եթե REPL գործարկելու համար օգնություն է պետք, անպայման տե՛ս Գլուխ 3-ի ցուցումները)։

Նախ՝ եկեք հաշվարկներ անենք՝ որոշ հիմունքներ ցուցադրելու համար։ Հետևյալ փոխազդեցության մեջ նախ երկու variable-ի՝ a-ին և b-ին, վերագրում ենք ամբողջ թվեր, որպեսզի հետագայում կարողանանք դրանք օգտագործել ավելի մեծ expression-ում։ variable-ները պարզապես name-ներ են՝ ձեր կամ Python-ի ստեղծած, որոնք օգտագործվում են ձեր program-ում տեղեկությանը հետևելու համար։ Սրա մասին ավելին կասենք հաջորդ գլխում, սակայն Python-ում՝

variable-ները ստեղծվում են, երբ դրանց առաջին անգամ value-ներ են վերագրվում։
expression-ներում օգտագործվելիս variable-ները փոխարինվում են իրենց value-ներով։
variable-ներին պետք է value վերագրված լինի՝ նախքան դրանք expression-ներում օգտագործելը։
variable-ները հղվում են object-ների և նախապես հայտարարվելու կարիք չունեն։

Սկզբնաղբյուրի PDF էջ 265

Այլ կերպ ասած՝ այս assignment-ները հանգեցնում են a և b variable-ների ինքնաբերաբար առաջանալուն.

Գրքի code · PDF էջ 265

  $ python3                  # Fire up a REPL
  >>> a = 3                  # Name created: no nee
  >>> b = 4

Մեկնաբանություն, տող 1․ Մեկնարկել interactive environment (REPL)

Մեկնաբանություն, տող 2․ name-ը ստեղծված է. կարիք չ…

Այս code-ը նաև օգտագործում է comment-ներ։ Հիշեք Գլուխ 3-ից, որ Python-ի code-ում # նշանից հետո մինչև line-ի վերջը շարունակվող տեքստը համարվում է comment և անտեսվում է Python-ի կողմից։ comment-ները ձեր code-ի համար մարդու համար ընթեռնելի փաստաթղթավորում գրելու եղանակներից մեկն են և programming-ի կարևոր մաս։ Դրանք նկարագրում են code-ի՝ ակնհայտ կամ նուրբ կողմերը՝ օգնելով ուրիշներին և ձեզ՝ վեց ամիս անց։ Գրքի հաջորդ մասում կհանդիպեք նաև հարակից հնարավորության՝ docstring-ներին, որոնք փաստաթղթավորումը կցում են object-ներին, որպեսզի այն հասանելի լինի code-ը բեռնելուց հետո։

Սակայն կրկին՝ քանի որ ինտերակտիվ մուտքագրված code-ը ժամանակավոր է, այս համատեքստում սովորաբար comment-ներ չեք գրի։ Եթե զուգահեռ աշխատում եք, սա նշանակում է, որ REPL-ում կարիք չկա մուտքագրելու comment-ի որևէ տեքստ՝ #-ից մինչև line-ի վերջը. այն այս ձևով կատարվող statement-ների պարտադիր մասը չէ։

Սկզբնաղբյուրի PDF էջ 266

Այժմ եկեք մեր նոր ամբողջ թվի object-ներն օգտագործենք expression-ներում։ Այս պահին a-ի և b-ի value-ները դեռ համապատասխանաբար 3 և 4 են։ Այսպիսի variable-ները expression-ի ներսում օգտագործվելիս միշտ փոխարինվում են իրենց value-ներով, և երբ աշխատում ենք ինտերակտիվ, expression-ների արդյունքներն անմիջապես ու ինքնաբերաբար արտապատկերվում են.

Գրքի code · PDF էջ 266

  >>> a + 1, a − 1           # Addition (3 + 1), su
  (4, 2)
  >>> b * 3, b / 2           # Multiplication (4 *
  (12, 2.0)
  >>> a % 2, b ** 2          # Modulus (remainder),
  (1, 16)
  >>> 2 + 4.0, 2.0 ** b      # Mixed-type conversio
  (6.0, 16.0)

Մեկնաբանություն, տող 1․ Գումարում (3 + 1), հա…

Մեկնաբանություն, տող 3․ Բազմապատկում (4 * [կտրված է]

Մեկնաբանություն, տող 5․ module-ով բաժանում՝ մնացորդ, …

Մեկնաբանություն, տող 7․ Խառը type-երի փոխակեր…

Ինչպես նշվեց Գլուխ 3-ում, այստեղ արտապատկերվող արդյունքները երկու value-ից կազմված tuple-ներ են, քանի որ prompt-ի մոտ մուտքագրված line-երը պարունակում են ստորակետերով բաժանված երկու expression. այդ պատճառով արդյունքները ցուցադրվում են փակագծերում։ Ավելի կարևորն այն է, որ այս expression-ներն աշխատում են, քանի որ դրանցում առկա a և b variable-ներին value-ներ են վերագրված։ Եթե օգտագործեք մեկ այլ variable, որին դեռ value չի վերագրվել, Python-ը որևէ լռելյայն value լրացնելու փոխարեն սխալ է հաղորդում.

Սկզբնաղբյուրի PDF էջ 267

Գրքի code · PDF էջ 267

  >>> c * 2
  NameError: name 'c' is not defined

Ինչպես նաև նախնականորեն տեսանք Գլուխ 3-ում, Python-ում variable-ները նախապես հայտարարելու կարիք չկա, սակայն դրանք օգտագործելուց առաջ դրանց առնվազն մեկ անգամ պետք է արժեք վերագրված լինի։ Գործնականում սա նշանակում է, որ հաշվիչներին պետք է սկզբնական զրո արժեք տալ՝ նախքան դրանց գումարելը, list-ներին՝ դատարկ list-ի արժեք՝ նախքան դրանց տարրեր ավելացնելը և այլն։

Ահա երկու փոքր-ինչ ավելի մեծ expression՝ operator-ների խմբավորումը և փոխակերպումների լրացուցիչ կողմերը ցուցադրելու համար.

Գրքի code · PDF էջ 267

  >>> b / 2 + a              # Same as ((4 / 2) + 3
  5.0
  >>> b / (2 + a)            # Same as (4 / (2 + 3)
  0.8

Մեկնաբանություն, տող 1․ Նույնն է, ինչ ((4 / 2) + 3 [կտրված է]

Մեկնաբանություն, տող 3․ Նույնն է, ինչ (4 / (2 + 3) [կտրված է]

Առաջին expression-ում փակագծեր չկան, ուստի Python-ն ինքնաբերաբար խմբավորում է բաղադրիչները՝ ըստ իր precedence-ի կանոնների. քանի որ /-ը Աղյուսակ 5-2-ում ավելի ներքև է, քան +-ը, այն ավելի սերտ է կապակցվում և այդ պատճառով հաշվարկվում է առաջինը։ Արդյունքն այնպիսին է, կարծես expression-ը կազմակերպված լիներ փակագծերով՝ code-ի աջ կողմի comment-ի մեջ ցույց տրված ձևով։ Երկրորդ

Սկզբնաղբյուրի PDF էջ 268

expression-ում + մասի շուրջ փակագծեր են ավելացված՝ Python-ին ստիպելու այն առաջինը հաշվարկել, այսինքն՝ /-ից առաջ։

Նկատեք նաև, որ այս օրինակներից յուրաքանչյուրում բոլոր թվերն ամբողջ թվեր են։ Python-ի /-ը կատարում է իրական բաժանում, որը միշտ պահպանում է կոտորակային մնացորդները և տալիս է floating-point արդյունք, ինչն իր հերթին արտացոլվում է ամբողջ expression-ի արդյունքում։ Կարող եք հարկադրել կոտորակային արդյունք՝ 2-ի փոխարեն գրելով 2.0, սակայն պարտավոր չեք։ Կարող եք նաև ընտրել դեպի ներքև կլորացմամբ բաժանումը՝ այս օրինակներում /-ի փոխարեն գրելով //, և Python-ն արդյունքից կհեռացնի տասնորդական թվանշանները։ Քանի որ արդյունքներն արտացոլում են operand-ների type-երը, floating-point թվերի համար կստանաք կտրված floating-point արդյունք.

Գրքի code · PDF էջ 268

  >>> a, b                   # Same, original value
  (3, 4)

Մեկնաբանություն, տող 1․ Նույնը՝ սկզբնական արժե…

Գրքի code · PDF էջ 268

  >>> b // 2 + a             # Floor division: inte
  5
  >>> b // (2 + a)           # Truncates fraction
  0

Մեկնաբանություն, տող 1․ Դեպի ներքև կլորացվող բաժանում՝ ամբո…

Մեկնաբանություն, տող 3․ Կտրում է կոտորակային մասը

Գրքի code · PDF էջ 268

  >>> b // 2.0 + a           # Auto-conversions: f
  5.0

Մեկնաբանություն, տող 1․ Ավտոմատ փոխակերպումներ՝ f… [կտրված է]

Սկզբնաղբյուրի PDF էջ 269

Գրքի code · PDF էջ 269

  >>> b // (2.0 + a)
  0.0

Բաժանման մասին ավելին կիմանաք այս բաժնում ավելի ուշ։

Երբ սկսեք լրջորեն փորձարկել Python-ի թվերը, որոշ expression-ների արդյունքներն առաջին անգամ տեսնելիս կարող են մի փոքր տարօրինակ թվալ.

Գրքի code · PDF էջ 269

  >>> 1.1 + 2.2               # What's up with the
  3.3000000000000003
  >>> print(1.1 + 2.2)        # Same for prints
  3.3000000000000003

Մեկնաբանություն, տող 1․ Ի՞նչ է կատարվում …

Մեկնաբանություն, տող 3․ Նույնը նաև արտածումների համար

Այս տարօրինակ արդյունքի ամբողջական բացատրությունը կապված է floating-point սարքակազմի սահմանափակումների և որոշ value-ներ սահմանափակ թվով bit-երով ճշգրիտ ներկայացնելու անկարողության հետ։ Python-ի floating-point թվերը արտապատկերվում են ձեր սարքի հիմքում ընկած չիպերին և ունեն միայն այն ճշտությունը, որը թույլ են տալիս այդ չիպերը։ Սա ֆիզիկական սահմանափակում է, որը կարելի է հաղթահարել լողացող ստորակետի ճշտությունն ընդլայնող հավելումներով, ինչպես նաև «floating-point թվերի հավասարություն» բաժնում քննարկվող եղանակներով։

Սկզբնաղբյուրի PDF էջ 270

Սակայն, քանի որ համակարգչային ճարտարապետությունն այս գրքի շրջանակից շատ դուրս է, հարցը կշրջանցենք՝ ասելով, որ ձեր համակարգչի floating-point սարքակազմն անում է առավելագույնը, և այստեղ ո՛չ այն, ո՛չ Python-ը չեն սխալվում։ Իրականում սա մասամբ ցուցադրման խնդիր է. Python-ի floating-point թվերի ցուցադրման տրամաբանությունը փորձում է խելամիտ լինել և սովորաբար ցույց է տալիս ավելի քիչ տասնորդական թվանշաններ, սակայն երբեմն չի կարող։ Մեր նախորդ օրինակներն ինքնաբերաբար ավելի քիչ թվանշաններ էին տալիս, իսկ program-երում միշտ կարող եք դա հարկադրել string-երի ձևաչափմամբ.

Գրքի code · PDF էջ 270

  >>> num = 1.1 + 2.2
  >>> num                          # Auto-echoes (a
  3.3000000000000003

Մեկնաբանություն, տող 2․ Ինքնաբերաբար ցուցադրում է (a… [կտրված է]

Գրքի code · PDF էջ 270

  >>> '%e' % num                   # String-formatt
  '3.300000e+00'
  >>> '%.1f' % num                 # Alternative fl
  '3.3'

Մեկնաբանություն, տող 1․ string-ի ձևաչա…

Մեկնաբանություն, տող 3․ Այլընտրանքային լողա…

Գրքի code · PDF էջ 270

  >>> f'{num:e}', f'{num:.1f}'     # F-strings (see
  ('3.300000e+00', '3.3')

Մեկնաբանություն, տող 1․ F-string-եր (տե՛ս …

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

Սկզբնաղբյուրի PDF էջ 271

ՑՈՒՑԱԴՐՄԱՆ ՁԵՎԱՉԱՓԵՐ. STR ԵՎ REPR
Թեև այս գլխում դա դեռ ակնհայտ չէ, ինտերակտիվ արտապատկերման և print-ի լռելյայն ելքային ձևաչափերը տեխնիկապես համապատասխանում են համապատասխանաբար built-in repr և str function-ներին.

Գրքի code · PDF էջ 271

  >>> repr('hack')           # Used by echoes: as-c
  "'hack'"
  >>> str('hack')            # Used by print: user-
  'hack'

Մեկնաբանություն, տող 1․ Օգտագործվում է ավտոմատ ցուցադրման համար՝ code-ի տես…

Մեկնաբանություն, տող 3․ Օգտագործվում է print-ի կողմից՝ օգտագործողի…

Երկուսն էլ կամայական object-ները փոխակերպում են դրանց string ներկայացումների. repr-ը և լռելյայն ինտերակտիվ արտապատկերումը տալիս են արդյունքներ, որոնք կարծես code լինեն, իսկ str-ը և print գործողությունը փոխակերպում են սովորաբար օգտատիրոջ համար ավելի հարմար ձևաչափի, եթե այն առկա է։ Որոշ object-ներ ունեն երկուսն էլ՝ str ընդհանուր օգտագործման համար և repr՝ լրացուցիչ մանրամասներով։ Այս գաղափարը կրկին ի հայտ կգա, երբ ուսումնասիրենք և՛ string-երը, և՛ class-երում operator-ների գերբեռնումը։

Կամայական object-ների տպման string-եր տրամադրելուց բացի՝ built-in str-ը նաև string-ի object-ի type-ի name-ն է, որը կարելի է կանչել encoding-ի name-ով՝ byte string-ից Unicode string վերծանելու համար՝ որպես bytes.decode method-ի այլընտրանք,

Սկզբնաղբյուրի PDF էջ 272

որը համառոտ ներկայացվեց Գլուխ 4-ում։ str-ի այս առաջադեմ դերի մասին ավելին կիմանաք Գլուխ 37-ում։

Մինչ այժմ գործ ունեինք ստանդարտ թվային գործողությունների հետ, օրինակ՝ գումարման և բազմապատկման, սակայն թվերը, ինչպես Python-ի բոլոր object-ները, կարելի է նաև համեմատել։ Սովորական համեմատությունները թվերի համար աշխատում են ճիշտ այնպես, ինչպես կսպասեիք. դրանք համեմատում են operand-ների հարաբերական մեծությունները և վերադարձնում Boolean արդյունք, որը սովորաբար կստուգեինք ու դրա հիման վրա գործողություն կկատարեինք ավելի մեծ statement-ում ու program-ում (օրինակ՝ տե՛ս Գլուխ 4-ում if-ի ներածությունը).

Գրքի code · PDF էջ 272

  >>> 1 < 2                  # Less than (magnitude
  True
  >>> 2.0 >= 1               # Greater than or equa
  True
  >>> 2.0 == 2.0             # Equal value
  True
  >>> 2.0 != 2.0             # Not equal value
  False

Մեկնաբանություն, տող 1․ Փոքր է (մեծության …

Մեկնաբանություն, տող 3․ Մեծ է կամ հավասա…

Մեկնաբանություն, տող 5․ Հավասար value

Մեկնաբանություն, տող 7․ Ոչ հավասար value

Կրկին նկատեք, թե ինչպես են խառը type-երը թույլատրվում միայն թվային expression-ներում. այստեղ երկրորդ ստուգման մեջ Python-ն value-ները համեմատում է ավելի բարդ type-ի՝ float-ի հիման վրա։

Սկզբնաղբյուրի PDF էջ 273

Հետաքրքրական է, որ Python-ը նաև թույլ է տալիս մի քանի համեմատություն շղթայել՝ միջակայքի ստուգումներ կատարելու համար։ Շղթայված համեմատություններն ավելի մեծ Boolean expression-ների մի տեսակ կրճատ գրառում են։ Համառոտ՝ Python-ը թույլ է տալիս իրար կապել մեծության համեմատման ստուգումները՝ միջակայքի ստուգումների պես շղթայված համեմատություններ գրելու համար։ Օրինակ՝ (A < B < C) expression-ը ստուգում է՝ արդյոք B-ն A-ի և C-ի միջև է՝ առանց սահմանները ներառելու. այն համարժեք է (A < B and B < C) Boolean ստուգմանը, սակայն ավելի հեշտ է և՛ կարդալ, և՛ մուտքագրել։ Օրինակ՝ ենթադրենք հետևյալ assignment-ները.

Գրքի code · PDF էջ 273

  >>> X = 2
  >>> Y = 4
  >>> Z = 6

Հետևյալ երկու expression-ներն ունեն նույն ազդեցությունը, սակայն առաջինն ավելի կարճ է մուտքագրելու համար և կարող է փոքր-ինչ ավելի արագ աշխատել, քանի որ Python-ը Y-ը պետք է հաշվարկի միայն մեկ անգամ. սա կարող է կարևոր լինել, եթե Y-ը բարդ function call է.

Գրքի code · PDF էջ 273

  >>> X < Y < Z              # Chained comparisons
  True

Մեկնաբանություն, տող 1․ Շղթայված համեմատություններ

Սկզբնաղբյուրի PDF էջ 274

Գրքի code · PDF էջ 274

  >>> X < Y and Y < Z
  True

Նույն համարժեքությունը գործում է նաև կեղծ արդյունքների համար, և թույլատրվում են կամայական երկարության շղթաներ.

Գրքի code · PDF էջ 274

  >>> X < Y > Z
  False
  >>> X < Y and Y > Z
  False

Գրքի code · PDF էջ 274

  >>> 1 < 2 < 3.0 < 4
  True
  >>> 1 > 2 > 3.0 > 4
  False

Շղթայված ստուգումներում կարող եք օգտագործել այլ համեմատություններ, սակայն ստացված expression-ները կարող են ոչ ակնհայտ դառնալ, եթե դրանք չհաշվարկեք այնպես, ինչպես Python-ը։ Օրինակ՝ հետևյալներից առաջինը կեղծ է պարզապես այն պատճառով, որ 1-ը հավասար չէ 2-ի.

Գրքի code · PDF էջ 274

  >>> 1 == 2 < 3               # Same as: (1 == 2)
  False

Մեկնաբանություն, տող 1․ Նույնն է, ինչ (1 == 2)

Սկզբնաղբյուրի PDF էջ 275

Գրքի code · PDF էջ 275

  >>> True is False is True    # Same as: (True is
  False

Մեկնաբանություն, տող 1․ Նույնն է, ինչ (True is [կտրված է]

Python-ը 1 == 2 expression-ի False արդյունքը չի համեմատում 3-ի հետ. դա տեխնիկապես նույնը կնշանակեր, ինչ 0 < 3-ը, որը կլիներ True (True և False object-ների մասին ավելին կիմանաք այս գլխում ավելի ուշ, իսկ հազվադեպ օգտագործվող is նույնության operator-ը կուսումնասիրեք հաջորդ գլխում)։

Շարունակելուց առաջ՝ մի վերջին նշում այստեղ. շղթայումը մի կողմ թողած՝ թվային համեմատությունները հիմնվում են մեծությունների վրա, որոնք հիմնականում պարզ են, թեև floating-point թվերը միշտ չէ, որ աշխատում են ձեր ակնկալած ձևով և իմաստալից համեմատման համար կարող են պահանջել փոխակերպումներ կամ այլ մշակում.

Գրքի code · PDF էջ 275

  >>> 1.1 + 2.2 == 3.3              # Shouldn't thi
  False
  >>> 1.1 + 2.2                     # Close to 3.3,
  3.3000000000000003

Մեկնաբանություն, տող 1․ Մի՞թե սա չպետք է…

Մեկնաբանություն, տող 3․ Մոտ է 3.3-ին, …

Սա կապված է թվերի ցուցադրման ձևաչափերի ավելի վաղ քննարկման հետ և բխում է այն փաստից, որ floating-point թվերը

Սկզբնաղբյուրի PDF էջ 276

չեն կարող որոշ value-ներ ճշգրիտ ներկայացնել՝ իրենց bit-երի սահմանափակ քանակի պատճառով. սա թվային programming-ի հիմնարար խնդիր է, որը հատուկ չէ միայն Python-ին։ Հավասարության ստուգումներում այս անճշտությունը հաշվի առնելու համար կա՛մ կտրեք, կա՛մ կլորացրեք, կա՛մ կիրառեք ներքև կլորացում, կա՛մ, սկսած Python 3.5-ից, ներմուծեք և կանչեք standard library-ի math module-ի isclose-ը, որը ճշմարիտ է, եթե value-ների տարբերությունը թույլատրելի շեղման սահմաններում է (math-ի և ներքև կլորացման մասին ավելին՝ առջևում, իսկ isclose-ի մասին՝ Python-ի ձեռնարկներում).

Գրքի code · PDF էջ 276

  >>> int(1.1 + 2.2) == int(3.3)        # OK if con
  True
  >>> round(1.1 + 2.2, 1) == round(3.3, 1)
  True
  >>> import math                       # Import mo
  >>> math.isclose(1.1 + 2.2, 3.3)      # Within de
  True

Մեկնաբանություն, տող 1․ Ճիշտ է, եթե փոխա…

Մեկնաբանություն, տող 5․ Ներմուծել մոդու…

Մեկնաբանություն, տող 6․ de…-ի սահմաններում [կտրված է]

Այս հարցին կվերադառնանք այս գլխում ավելի ուշ, երբ հանդիպենք տասնորդական թվերին ու կոտորակներին, որոնք նույնպես կարող են հաղթահարել նման սահմանափակումները։ Սակայն նախ եկեք շարունակենք Python-ի հիմնական թվային գործողությունների մեր շրջայցը՝ ավելի խորությամբ նայելով բաժանմանը։

Սկզբնաղբյուրի PDF էջ 277

Python-ն ունի ավելի վաղ ներկայացված բաժանման երկու operator, ինչպես նաև դրանց սերտորեն կապված ևս մեկը։ Ահա ամբողջ խումբը.

Գրքի code · PDF էջ 277

  X / Y

Սա կոչվում է իրական բաժանում և միշտ պահպանում է մնացորդները floating-point արդյունքներում՝ անկախ type-երից։

Գրքի code · PDF էջ 277

  X // Y

Սա կոչվում է դեպի ներքև կլորացմամբ բաժանում և միշտ կտրում է կոտորակային մնացորդները դեպի ներքև՝ մինչև դրանց ամբողջ ստորին սահմանը, անկախ type-երից, իսկ դրա արդյունքի type-ը կախված է operand-ների type-երից։

Գրքի code · PDF էջ 277

  X % Y

Սա կոչվում է մնացորդի հաշվարկ և վերադարձնում է բաժանման մնացորդը՝ արդյունքի type-ով, որը տարբերվում է ըստ operand-ների type-երի։ string-երի նկատմամբ կիրառվելիս այն նաև ձևաչափում է կատարում՝ ինչպես կտեսնենք Գլուխ 7-ում։

Հետևյալը ցուցադրում է բաժանման երկու operator-ների աշխատանքը.

Գրքի code · PDF էջ 277

  >>> 10 / 4              # True div: keeps remaind
  2.5
  >>> 10 / 4.0            # Same for floats
  2.5
  >>> 10 // 4             # Floor div: drops remain
  2

Մեկնաբանություն, տող 1․ Իրական բաժանում. պահպանում է մնացո…

Մեկնաբանություն, տող 3․ Նույնը floating-point թվերի համար

Մեկնաբանություն, տող 5․ Դեպի ներքև կլորացվող բաժանում. հեռացնում է մնացո…

Սկզբնաղբյուրի PDF էջ 278

Գրքի code · PDF էջ 278

  >>> 10 // 4.0           # Same for floats, but ty
  2.0

Մեկնաբանություն, տող 1․ Նույնը floating-point թվերի համար, բայց տի…

Նկատեք, որ //-ի արդյունքի object-ի type-ը կախված է դրա operand-ների type-երից. եթե որևէ մեկը float է, արդյունքը float է, հակառակ դեպքում՝ ամբողջ թիվ։ Եթե ցանկանում եք ապահովել ամբողջ թվային արդյունք, պարզապես expression-ը պարփակեք int-ի մեջ՝ այն փոխակերպելու համար.

Գրքի code · PDF էջ 278

  >>> int(10 // 4.0)
  2

Հարակից մնացորդի հաշվարկը վերադարձնում է բաժանման մնացորդը՝ operand-ներին համապատասխան type-ով (օգտակար է, երբ ձեր code-ը պետք է իմանա՝ //-ից հետո որքան է «մնացել»), իսկ built-in divmod function-ն անհրաժեշտության դեպքում տալիս է երկու մասերն էլ.

Գրքի code · PDF էջ 278

  >>> 10 % 3, 10 % 3.0    # Remainder of division:
  (1, 1.0)
  >>> divmod(10, 3)       # Both parts of division
  (3, 1)

Մեկնաբանություն, տող 1․ Բաժանման մնացորդ՝

Մեկնաբանություն, տող 3․ Բաժանման երկու մասերն էլ

Սկզբնաղբյուրի PDF էջ 279

Այստեղ մի նրբություն կա. // operator-ը ոչ պաշտոնական կերպով կոչվում է կտրող բաժանում, սակայն ավելի ճշգրիտ է այն անվանել դեպի ներքև կլորացմամբ բաժանում. այն արդյունքը կտրում է մինչև ստորին ամբողջ սահմանը, այսինքն՝ իրական արդյունքից ցածր ամենամոտ ամբողջ թիվը։ Վերջնական ազդեցությունը ներքև կլորացնելն է, այլ ոչ խիստ իմաստով կտրելը, և սա կարևոր է բացասական թվերի համար։ Տարբերությունը կարող եք ինքներդ տեսնել Python-ի math module-ով (ինչպես սովորել եք, module-ները պետք է ներմուծվեն՝ նախքան դրանց բովանդակությունն օգտագործելը).

Գրքի code · PDF էջ 279

  >>> import math
  >>> math.floor(2.5)           # Closest number be
  2
  >>> math.floor(-2.5)          # But not truncatio
  -3
  >>> math.trunc(2.5)           # Truncate fraction
  2
  >>> math.trunc(-2.5)          # And is truncation
  -2

Մեկնաբանություն, տող 2․ Ամենամոտ թիվը՝ ներք…

Մեկնաբանություն, տող 4․ Բայց ոչ կտրու…

Մեկնաբանություն, տող 6․ Կտրել կոտորակային մասը

Մեկնաբանություն, տող 8․ Եվ սա կտրում է

Բաժանման operator-ները կատարելիս իրականում կտրում եք միայն դրական արդյունքների դեպքում, քանի որ այդ ժամանակ կտրումը նույնն է, ինչ դեպի ներքև կլորացումը, իսկ բացասականների համար արդյունքը ներքև կլորացվածն է։ Իրականում երկուսն էլ ներքև կլորացում են, պարզապես դրականների համար այն համընկնում է կտրման հետ (պատճենողներին

Սկզբնաղբյուրի PDF էջ 280

ու տեղադրողներին. եթե այս գրքում մինուսի նշանները վերածվեն Unicode գծիկների, գործարկելու համար դրանք փոխարինեք սովորական ASCII «-» գծիկներով. Python-ը մինուսի նշանի համար պահանջում է վերջիններս, իսկ գործիքները տխրահռչակ են սա խաթարելու հարցում).

Գրքի code · PDF էջ 280

  >>> 5 / 2, 5 / -2             # True division kee
  (2.5, −2.5)

Մեկնաբանություն, տող 1․ Իրական բաժանումը պահպա…

Գրքի code · PDF էջ 280

  >>> 5 // 2, 5 // -2           # Truncates to floo
  (2, −3)

Մեկնաբանություն, տող 1․ Կտրում է դեպի ներքև կլորացվա…

Գրքի code · PDF էջ 280

  >>> 5 / 2.0, 5 / -2.0         # Ditto for floats
  (2.5, −2.5)

Մեկնաբանություն, տող 1․ Նույնը floating-point թվերի համար

Գրքի code · PDF էջ 280

  >>> 5 // 2.0, 5 // -2.0       # Though result is
  (2.0, −3.0)

Մեկնաբանություն, տող 1․ Թեև արդյունքը … է

Եթե իսկապես ցանկանում եք կտրում դեպի զրո՝ անկախ նշանից, միշտ կարող եք իրական բաժանման արդյունքը փոխանցել math.trunc-ին (ինչպես ավելի վաղ ցուցադրվեց, built-in round-ն ունի հարակից գործառույթ, իսկ built-in int-ն ունի նույն ազդեցությունը, և երկուսն էլ ներմուծում չեն պահանջում).

Գրքի code · PDF էջ 280

  >>> import math
  >>> 5 / −2                    # Keep remainder

Մեկնաբանություն, տող 2․ Պահել մնացորդը

Սկզբնաղբյուրի PDF էջ 281

Գրքի code · PDF էջ 281

  −2.5
  >>> 5 // −2                   # Floor below resul
  -3
  >>> math.trunc(5 / −2)        # Truncate instead
  −2

Մեկնաբանություն, տող 2․ Դեպի ներքև կլորացում՝ արդյու…-ից ներքև

Մեկնաբանություն, տող 4․ Փոխարենը կտրել

Այսպիսով՝ ինչո՞ւ այսքան աղմուկ կտրման շուրջ։ Սա ակնհայտ չի լինի, մինչև այս գրքում ավելի ուշ անցնեք ավելի մեծ Python program-եր գրելուն, սակայն որոշ կիրառություններում այն էական գործիք է։ Ուշադրություն դարձրեք Գլուխ 13-ի պարզ թվերի while loop-ի օրինակին և Մաս IV-ի վերջի համապատասխան վարժությանը, որոնք ամբողջությամբ հիմնվում են //-ի կտրող վարքի վրա։

Python-ում բաժանումը կարող է մի քանի տարբերակ ունենալ, սակայն programming language-ների չափանիշներով այն դեռ բավական ստանդարտ է։ Ահա մի փոքր ավելի անսովոր բան։ Ինչպես նշվեց ավելի վաղ, Python-ի ամբողջ թվերն աջակցում են անսահմանափակ չափի.

Գրքի code · PDF էջ 281

  >>> 999999999999999999999999999999 + 1
  1000000000000000000000000000000

Անսահմանափակ ճշտությամբ ամբողջ թվերը հարմար built-in գործիք են։ Օրինակ՝ դրանցով կարող եք Python-ում հաշվել ձեր երկրի պետական

Սկզբնաղբյուրի PDF էջ 282

պարտքը՝ առանց թվային value-ի գերլցման (ինչն, իհարկե, որոշ վայրերում ավելի տպավորիչ և ռեսուրսատար է, քան մյուսներում)։ Ավելի համընդհանուր օրինակով՝ 2-ի 269 աստիճանն առանձնապես մեծ չէ, սակայն գրեթե դուրս է գալիս այս էջի լայնության սահմաններից, իսկ շատ ավելի մեծ թվերն աշխատում են Գլուխ 4-ում նշված DOS հարձակումների դեմ պաշտպանական միջոցները հեռացնելուց հետո.

Գրքի code · PDF էջ 282

  >>> 2 ** 269
  9485687950320942729098935091911713411339877143809

Գրքի code · PDF էջ 282

  >>> x = 2 ** 1000000
  >>> x
  ValueError: Exceeds the limit (4300 digits) for i
  use sys.set_int_max_str_digits() to increase the

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

Թեև ավելի քիչ են օգտագործվում, քան մինչ այժմ ուսումնասիրած type-երը, կոմպլեքս թվերը Python-ում object-ի առանձին հիմնական

Սկզբնաղբյուրի PDF էջ 283

type են։ Դրանք սովորաբար օգտագործվում են ճարտարագիտական և գիտական կիրառություններում։ Եթե գիտեք՝ ինչ են դրանք, գիտեք նաև՝ ինչու են օգտակար. եթե ոչ, այս բաժնի ընթերցումը համարեք ոչ պարտադիր՝ մինչև դրանք հայտնվեն code-ում, որը պետք է կրկնակի օգտագործեք։

Կոմպլեքս թվերը ներկայացվում են երկու floating-point թվերով՝ իրական և կեղծ մասերով, և դրանք գրում եք՝ կեղծ մասին ավելացնելով j կամ J վերջածանցը։ Ոչ զրոյական իրական մասով կոմպլեքս թվերը կարող ենք գրել նաև երկու մասերը +-ով գումարելով։ Օրինակ՝ 2 իրական մասով և −3 կեղծ մասով կոմպլեքս թիվը գրվում է 2 + −3j։ Ահա կոմպլեքս մաթեմատիկայի աշխատանքի մի քանի օրինակ.

Գրքի code · PDF էջ 283

  >>> 1j * 1J
  (-1+0j)
  >>> 2 + 1j * 3
  (2+3j)
  >>> (2 + 1j) * 3
  (6+3j)

Կոմպլեքս թվերը նաև թույլ են տալիս իրենց մասերն առանձնացնել որպես attribute-ներ՝ real և imag attribute-ների միջոցով, աջակցում են բոլոր սովորական մաթեմատիկական expression-ներին և կարող են մշակվել ստանդարտ cmath module-ի գործիքներով՝ ստանդարտ math module-ի կոմպլեքս համարժեքով։ Սակայն, քանի որ կոմպլեքս թվերը

Սկզբնաղբյուրի PDF էջ 284

programming-ի ոլորտների մեծ մասում հազվադեպ են, պատմության մնացած մասն այստեղ բաց կթողնենք։ Լրացուցիչ մանրամասների համար ստուգեք Python-ի լեզվի տեղեկատու ձեռնարկը։

Ինչպես նախնականորեն ներկայացվեց այս գլխի սկզբում, Python-ի ամբողջ թվերը կարելի է գրել տասնվեցական, ութական և երկուական գրառմամբ՝ ի լրումն մինչ այժմ օգտագործած սովորական 10 հիմքով տասնորդական գրառման։ Առաջին երեքը տասը մատ ունեցող էակներին սկզբում կարող են խորթ թվալ, սակայն որոշ programmer-ներ դրանք համարում են value-ներ նշելու հարմար այլընտրանքներ, հատկապես երբ կարևոր է դրանց արտապատկերումը byte-երի ու bit-երի վրա։ Գրառման կանոններն ավելի վաղ մանրամասն ներկայացրինք. եկեք այժմ կենդանի փորձենք դրանք։

Ինչպես նշվեց ավելի վաղ, այլ հիմքերով այս literal-ները պարզապես ամբողջ թվի object-ի value-ն նշելու այլընտրանքային syntax են։ Օրինակ՝ հետևյալ literal-ներն առաջացնում են սովորական ամբողջ թվեր՝ նշված value-ներով։ memory-ի մեջ ամբողջ թվի value-ն նույնն է՝ անկախ նրանից, թե մեր code-ում այն նշելու համար ինչ հիմք ենք օգտագործում.

Գրքի code · PDF էջ 284

  >>> 0x01, 0x10, 0xFF            # Hex literals: b
  (1, 16, 255)
  >>> 0o1, 0o20, 0o377            # Octal literals
  (1, 16, 255)

Մեկնաբանություն, տող 1․ hexadecimal literal-ներ՝ b… [կտրված է]

Մեկնաբանություն, տող 3․ octal literal-ներ

Սկզբնաղբյուրի PDF էջ 285

Գրքի code · PDF էջ 285

  >>> 0b1, 0b10000, 0b11111111    # Binary literals
  (1, 16, 255)

Մեկնաբանություն, տող 1․ binary literal-ներ

Այստեղ տասնվեցական 0xFF value-ն, ութական 0o377 value-ն և երկուական 0b11111111 value-ն բոլորը տասնորդական 255-ն են։ Օրինակ՝ տասնվեցական value-ի F թվանշաններից յուրաքանչյուրը նշանակում է տասնորդական 15 և երկուական 4-բիթանոց 1111, իսկ դրանց դիրքերն արտացոլում են 16-ի աստիճանները։ Այսպիսով՝ տասնվեցական 0xFF value-ն և մյուսները տասնորդական value-ների են փոխակերպվում հետևյալ կերպ.

Գրքի code · PDF էջ 285

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> 0xFF, (15 * (16 ** 1)) + (15 * (16 ** 0))
  (255, 255)
  >>> 0x2F, (2  * (16 ** 1)) + (15 * (16 ** 0))
  (47, 47)
  >>> 0xF, 0b1111, (1*(2**3) + 1*(2**2) + 1*(2**1)
  (15, 15, 15)

Python-ը լռելյայն ամբողջ թվային value-ները տպում է տասնորդական՝ 10 հիմքով, սակայն նաև տրամադրում է built-in function-ներ, որոնք ամբողջ թվերը փոխակերպում են այլ հիմքերի թվանշանային string-երի՝ ձևաչափված Python-ի literal-ի syntax-ով։ Սա օգտակար է, երբ program-երը կամ օգտատերերն ակնկալում են value-ները տեսնել տվյալ հիմքով.

Գրքի code · PDF էջ 285

  >>> oct(64), hex(64), bin(64)               # Num
  ('0o100', '0x40', '0b1000000')

Մեկնաբանություն, տող 1․ Թվ…

Սկզբնաղբյուրի PDF էջ 286

oct function-ը տասնորդականը փոխակերպում է ութականի, hex-ը՝ տասնվեցականի, իսկ bin-ը՝ երկուականի. բոլորը՝ որպես string-եր։ Հակառակ ուղղությամբ անցնելու համար built-in int function-ը թվանշանների string-ը փոխակերպում է ամբողջ թվի, իսկ ոչ պարտադիր երկրորդ argument-ը թույլ է տալիս նշել թվային հիմքը։ Սա օգտակար է այն թվերի համար, որոնք file-երից կարդացվել են որպես string-եր՝ script-ներում գրված լինելու փոխարեն.

Գրքի code · PDF էջ 286

  >>> 64, 0o100, 0x40, 0b1000000              # Dig
  (64, 64, 64, 64)

Մեկնաբանություն, տող 1․ Թվանշա…

Գրքի code · PDF էջ 286

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> int('64'), int('100', 8), int('40', 16), int
  (64, 64, 64, 64)

Գրքի code · PDF էջ 286

  >>> int('0x40', 16), int('0b1000000', 2)    # Lit
  (64, 64)

Մեկնաբանություն, տող 1․ Լիտե…

eval function-ը նույնպես կարելի է օգտագործել թվանշանային string-երը թվերի փոխակերպելու համար, քանի որ այն string-երի հետ վարվում է այնպես, կարծես դրանք Python-ի code լինեն։ Հետևաբար այն ունի նման ազդեցություն, սակայն սովորաբար ավելի դանդաղ է աշխատում. այն իրականում string-ը կոմպիլացնում ու կատարում է որպես program-ի մի հատված և ենթադրում է, որ կատարվող string-ը վստահելի աղբյուրից է։ Հնարամիտ օգտատերը գուցե կարողանա ուղարկել մի string, որը ջնջում է ձեր համակարգչի file-երը։ Այլ կերպ ասած՝ այս կանչն օգտագործեք չափավոր և զգուշությամբ.

Սկզբնաղբյուրի PDF էջ 287

Գրքի code · PDF էջ 287

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> eval('64'), eval('0o100'), eval('0x40'), eval
  (64, 64, 64, 64)

Վերջապես, ամբողջ թվերը կարող եք փոխակերպել տվյալ հիմքի string-երի նաև Python-ի string-երի ձևաչափման երեք գործիքներից ցանկացածով, թեև մինչև Գլուխ 7-ում string-երի ամբողջական քննարկմանը հասնելը սա մասամբ ստիպված կլինեք ընդունել հավատով.

Գրքի code · PDF էջ 287

  >>> '%o, %x, %#X' % (64, 255, 255)          # Num
  '100, ff, 0XFF'

Մեկնաբանություն, տող 1․ Թվ…

Գրքի code · PDF էջ 287

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> '{:o}, {:b}, {:x}, {:#X}'.format(64, 64, 255
  '100, 1000000, ff, 0XFF'

Գրքի code · PDF էջ 287

  >>> f'{64:o}, {64:b}, {255:x}, {255:#X}'    # The
  '100, 1000000, ff, 0XFF'

Մեկնաբանություն, տող 1․ The [կտրված է]

Այս code-ում o-ն, b-ն և x-ը ձևաչափում են համապատասխանաբար որպես ութական, երկուական և տասնվեցական, իսկ #X-ն ավելացնում է հիմքի նախածանց և օգտագործում մեծատառեր։ Ի միջի այլոց՝ ձևաչափման այս երեք գործիքներից յուրաքանչյուրում կարող եք խուսափել կրկնվող մուտքային արժեքներից (սակայն հավանաբար արդեն սկսում եք տեսնել, թե ինչու դրանցից միայն մեկն ընտրելը հիմնականում լավ գաղափար է, և ինչու հնարավորությունների կրկնօրինակումը հիմնականում վատ գաղափար է).

Սկզբնաղբյուրի PDF էջ 288

Գրքի code · PDF էջ 288

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> '%(i)o, %(j)x, %(j)#X' % dict(i=64, j=255)
  '100, ff, 0XFF'
  >>> '{0:o}, {0:b}, {1:x}, {1:#X}'.format(64, 255
  '100, 1000000, ff, 0XFF'
  >>> f'{(i:=64):o}, {i:b}, {(i:=255):x}, {i:#X}'
  '100, 1000000, ff, 0XFF'

Շարունակելուց առաջ հիշեք, որ այլ հիմքերի literal-ներն ու փոխակերպիչները նույնպես աջակցում են կամայականորեն մեծ ամբողջ թվերին։ Օրինակ՝ հետևյալը ամբողջ թիվ է ստեղծում տասնվեցական տեսքով և փոխակերպիչներով այն ցուցադրում տասնորդական, ութական ու երկուական տեսքերով.

Գրքի code · PDF էջ 288

  >>> X = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFF
  >>> X
  5192296858534827628530496329220095
  >>> oct(X)
  '0o17777777777777777777777777777777777777'
  >>> bin(X)
  '0b1111111111111111111111111111111111111111111111

Երկուական թվանշանների մասին խոսելիս՝ հաջորդ բաժինը մեզ տանում է թվերի առանձին bit-երը մշակող գործիքների շրջայցի։

Սկզբնաղբյուրի PDF էջ 289

Բացի սովորական թվային գործողություններից՝ գումարում, հանում և այլն, Python-ն աջակցում է C լեզվում հասանելի թվային expression-ների մեծ մասին։ Սա ներառում է operator-ներ, որոնք ամբողջ թվերը դիտարկում են որպես երկուական bit-երի string-եր և կարող են օգտակար լինել, եթե ձեր Python-ի code-ը պետք է աշխատի այնպիսի բաների հետ, ինչպիսիք են ցանցային package-ները, հաջորդական պորտերը կամ C program-ի ստեղծած կամ դրա համար նախատեսված փաթեթավորված երկուական տվյալները։

Boolean մաթեմատիկայի հիմունքների վրա այստեղ չենք կարող երկար կանգ առնել. կրկին՝ նրանք, ում այն պետք է, հավանաբար արդեն գիտեն՝ ինչպես է այն աշխատում, իսկ մյուսները հաճախ կարող են թեման ընդհանրապես հետաձգել։ Սակայն հիմունքները պարզ են։ Օրինակ՝ ահա Python-ի բիթային expression-ների operator-ներից մի քանիսը՝ ամբողջ թվերի վրա bitwise shift-ի և Boolean գործողություններ կատարելիս.

Գրքի code · PDF էջ 289

  >>> x = 1                # 1 decimal is 0001 in b
  >>> x << 2               # Shift left 2 bits: 010
  4
  >>> x | 3                # Bitwise OR (either bit
  3
  >>> x & 3                # Bitwise AND (both bits
  1

Մեկնաբանություն, տող 1․ Տասնորդական 1-ը երկուա… տեսքով 0001 է

Մեկնաբանություն, տող 2․ Տեղաշարժ ձախ՝ 2 bit-ով. 010 [կտրված է]

Մեկնաբանություն, տող 4․ Բիթային OR (bit-երից որևէ մեկը…

Մեկնաբանություն, տող 6․ Բիթային AND (երկու bit-երն էլ…

Սկզբնաղբյուրի PDF էջ 290

Առաջին expression-ում երկուական 1-ը՝ 2 հիմքով 0001-ը, երկու դիրքով ձախ է տեղաշարժվում՝ ստեղծելով երկուական 4՝ 0100։ Վերջին երկու գործողությունները կատարում են երկուական OR՝ bit-երը միավորելու համար (0001|0011 = 0011), և երկուական AND՝ ընդհանուր bit-երն ընտրելու համար (0001&0011 = 0001)։ Բիթային դիմակավորման այսպիսի գործողությունները թույլ են տալիս մեկ ամբողջ թվի մեջ կոդավորել ու առանձնացնել բազմաթիվ դրոշակներ և այլ value-ներ։

Սա այն ոլորտներից է, որտեղ Python-ի երկուական և տասնվեցական թվերի աջակցությունը հատկապես օգտակար է դառնում. այն թույլ է տալիս թվերը գրել ու ուսումնասիրել բիթային string-երով.

Գրքի code · PDF էջ 290

  >>> X = 0b0001           # Binary literals
  >>> X << 2               # Shift left
  4
  >>> bin(X << 2)          # Binary digits string
  '0b100'

Մեկնաբանություն, տող 1․ binary literal-ներ

Մեկնաբանություն, տող 2․ Տեղաշարժ ձախ

Մեկնաբանություն, տող 4․ Երկուական թվանշանների string

Գրքի code · PDF էջ 290

  >>> bin(X | 0b0011)      # Bitwise OR: either
  '0b11'
  >>> bin(X & 0b11)        # Bitwise AND: both
  '0b1'

Մեկնաբանություն, տող 1․ Բիթային OR՝ որևէ մեկը

Մեկնաբանություն, տող 3․ Բիթային AND՝ երկուսն էլ

Սա ճիշտ է նաև այն value-ների համար, որոնք սկզբնապես hexadecimal literal-ներ են կամ ենթարկվում են հիմքերի փոխակերպումների.

Սկզբնաղբյուրի PDF էջ 291

Գրքի code · PDF էջ 291

  >>> X = 0xFF             # Hex literals
  >>> bin(X)
  '0b11111111'
  >>> X ^ 0b10101010       # Bitwise XOR: either bu
  85
  >>> bin(X ^ 0b10101010)
  '0b1010101'

Մեկնաբանություն, տող 1․ hexadecimal literal-ներ

Մեկնաբանություն, տող 4․ Բիթային XOR՝ որևէ մեկը, բա…

Գրքի code · PDF էջ 291

  >>> int('01010101', 2)   # Digits=>number: string
  85
  >>> hex(85)              # Number=>digits: Hex di
  '0x55'

Մեկնաբանություն, տող 1․ Թվանշաններ=>թիվ՝ string

Մեկնաբանություն, տող 3․ Թիվ=>թվանշաններ՝ տասնվեցական թվանշա…

Նույն ոլորտում Python-ի ամբողջ թվերն ունեն bit_length method-ը, որը թույլ է տալիս պարզել թվի value-ն երկուական ներկայացնելու համար պահանջվող bit-երի քանակը։ Ուշադիր ընթերցողները գուցե նշեն, որ հաճախ նույն արդյունքին կարելի է հասնել՝ bin string-ի երկարությունից 2 հանելով՝ built-in len function-ով, որն առաջին անգամ օգտագործեցինք Գլուխ 4-ում (սկզբի «0b»-ն հաշվի առնելու համար), թեև դրա ժամանակավոր string արդյունքը կարող է այն պակաս արդյունավետ դարձնել.

Գրքի code · PDF էջ 291

  >>> X = 99
  >>> bin(X), X.bit_length(), len(bin(X)) - 2
  ('0b1100011', 7, 7)

Սկզբնաղբյուրի PDF էջ 292

Գրքի code · PDF էջ 292

  >>> bin(256), (256).bit_length(), len(bin(256))
  ('0b100000000', 9, 9)

Նման «բիթային մանրախնդրության» մանրամասների մեջ այստեղ ավելի չենք մտնի։ Այն աջակցվում է, եթե պետք է ձեզ, սակայն bitwise operation-ները Python-ի նման բարձր մակարդակի լեզվում հաճախ այնքան կարևոր չեն, որքան C-ի նման ցածր մակարդակի լեզվում։ Որպես գործնական կանոն՝ եթե նկատում եք, որ Python-ում ցանկանում եք bit-եր շրջել, մտածեք, թե իրականում որ լեզվով եք code գրում։ Ինչպես կտեսնեք առաջիկա գլուխներում, Python-ի list-ները, dictionary-ները և նմանները տեղեկությունը կոդավորելու ավելի հարուստ եղանակներ են տրամադրում, քան բիթային string-երը, հատկապես երբ ձեր տվյալների լսարանը ներառում է մարդ ընթերցողների։

Եթե դժվարանում եք կարդալ այս գլխի ավելի երկար թվանշանային string-երը, լավ լուր կա. սկսած 3.6-ից՝ Python-ի թվային literal-ները կարելի է գրել ներդրված ընդգծումներով («_»)՝ թվանշանները խմբավորելու և ընթերցումը հեշտացնելու համար։ Այս ընդգծումները չեն փոխում թվերի value-ները. Python-ը պարզապես հեռացնում է դրանք ձեր code-ը կարդալուց հետո։ Սակայն դրանք աշխատում են մեր հանդիպած բոլոր թվերի ու հիմքերի հետ, ներառյալ կոմպլեքս թվերի մասերը և floating-point թվերի տասնորդական թվանշանները, և կարող են բարելավել ձեր script-ների թվային

Սկզբնաղբյուրի PDF էջ 293

literal-ների ընթեռնելիությունը։ Ահա դրանց տեսքը՝ նախկին տարբերակը ձախում, իսկ նորը՝ աջում.

Գրքի code · PDF էջ 293

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> 9999999999999 == 9_999_999_999_999
  True
  >>> 0xFFFFFFFF == 0xFF_FF_FF_FF
  True
  >>> 0o777777777777 == 0o777_777_777_777
  True
  >>> 0b1111111111111111 == 0b1111_1111_1111_1111
  True
  >>> 3.141592653589793 == 3.141_592_653_589_793
  True
  >>> 123456789.123456789 == 123_456_789.123_456_78
  True

Թեև սա օգտակար հնարավորություն է, պետք է հիշել, որ այն միայն արտաքին է։ Օրինակ՝ կարդալուց հետո թվերը կորցնում են իրենց ընդգծումները։ Կարող եք ստորակետ ու ընդգծում բաժանարարները կրկին ավելացնել string-երի ձևաչափման method-ով և f-string-ով, որոնք կուսումնասիրենք Գլուխ 7-ում, սակայն սա հիմնականում միայն ցուցադրման համար է, իսկ սկզբնական բաժանարարները կորչում են.

Գրքի code · PDF էջ 293

  >>> x = 9_999_998              # Your number with
  >>> x                          # But dropped when

Մեկնաբանություն, տող 1․ Ձեր թիվը՝ …-ով

Մեկնաբանություն, տող 2․ Բայց հեռացվում է, երբ…

Սկզբնաղբյուրի PDF էջ 294

Գրքի code · PDF էջ 294

  9999998
  >>> x + 1                      # Ditto for derive
  9999999

Մեկնաբանություն, տող 2․ Նույնը նաև ստացվա… համար

Գրքի code · PDF էջ 294

  >>> f'{x:,} and {x:_}'         # Formatting adds
  '9,999,998 and 9_999_998'

Մեկնաբանություն, տող 1․ Ձևաչափումն ավելացնում է…

Ավելին, Python-ը ընդգծումների նպատակահարմարության որևէ ստուգում չի կատարում՝ բացի սկզբում, վերջում և բազմակի կրկնությամբ օգտագործումն արգելելուց։ Ընդգծումներն իրականում պարզապես թվանշանային «բացատիչներ» են, որոնք կարելի է կամայականորեն օգտագործել և չարաշահել.

Գրքի code · PDF էջ 294

  >>> 99_9                       # No position-erro
  999
  >>> 1_23_456_7890              # Hmm…
  1234567890

Մեկնաբանություն, տող 1․ Դիրքային սխալի … չկա

Մեկնաբանություն, տող 3․ Հմմ…

Գրքի code · PDF էջ 294

  >>> _9
  NameError: name '_9' is not defined. Did you mean
  >>> 9_
  SyntaxError: invalid decimal literal
  >>> 9_9__9
  SyntaxError: invalid decimal literal

Գրքի code · PDF էջ 294

  >>> 9_9_9                      # Syntax oddities
  999

Մեկնաբանություն, տող 1․ syntax-ի տարօրինակություններ

Սկզբնաղբյուրի PDF էջ 295

Գրքի code · PDF էջ 295

  >>> hex(0xf_ff_fff_f_f)        # And Python won't
  '0xffffffff'

Մեկնաբանություն, տող 1․ Եվ Python-ը չի…

Հիշեք նաև, որ ձեր գրած թվային literal-ներում ստորակետեր օգտագործել չի կարելի. չնայած նմանությանը՝ ընդգծումները հիմնականում անտեսվում են որպես փաստաթղթավորում, իսկ սխալմամբ օգտագործված ստորակետերը դիտարկվում են որպես tuple-ի տարրերի բաժանարարներ.

Գրքի code · PDF էջ 295

  >>> 12_345_678                 # Underscores are
  12345678
  >>> 12,345,678                 # But commas mean
  (12, 345, 678)

Մեկնաբանություն, տող 1․ Ընդգծման character-երը … են

Մեկնաբանություն, տող 3․ Բայց ստորակետերը նշանակում են…

Ընդգծումները, անշուշտ, կարող են բարելավել ընթեռնելիությունը, սակայն դրանք մեծ մասամբ արտաքին ձևավորում են և կիրառվում են միայն ձեր code-ի մեծ թվային literal-ների նկատմամբ։ Քանի որ Python-ի սովորական program-երը թվերի մեծ մասը հաշվարկում են՝ code-ում ամրագրելու փոխարեն, գործնականում սա հավանաբար հազվադեպ կլինի։ Ավելի խոստումնալից կիրառություն է մուտքը. string-ից թիվ փոխակերպիչները նույնպես թույլ են տալիս ընդգծումներ.

Գրքի code · PDF էջ 295

  >>> int('1_234_567')           # Works in text re
  1234567
  >>> eval('1_234_567')          # But does raw-dat
  1234567

Մեկնաբանություն, տող 1․ Աշխատում է տեքստային ներկայա…

Մեկնաբանություն, տող 3․ Բայց կատարում է չմշակված տվյա…

Սկզբնաղբյուրի PDF էջ 296

Գրքի code · PDF էջ 296

  >>> float('1_2_34.567_8_90')
  1234.56789

Սակայն դժվար է ընդգծումները հիմնավորել միայն տվյալներով՝ հաշվի առնելով, որ script-ները կարող են պարզապես իրենք հեռացնել դրանք։ Ինչպես բոլոր նման գործիքների դեպքում՝ օգտագործեք, երբ դա իմաստ ունի, և մի՛ զարմացեք, եթե սա հանդիպի անարդար հարցազրույցային հարցերում։

Իր հիմնական object-ների type-երից բացի՝ Python-ը թվային մշակման համար նաև տրամադրում է և՛ built-in function-ներ, և՛ standard library-ի module-ներ։ Օրինակ՝ built-in pow և abs function-ները հաշվարկում են համապատասխանաբար աստիճաններն ու բացարձակ value-ները։ Ահա built-in math module-ի տարածված գործիքների համառոտ ակնարկը (այն պարունակում է C լեզվի մաթեմատիկական library-ի գործիքների մեծ մասը)՝ մի քանի built-in թվային function-ների հետ միասին.

Գրքի code · PDF էջ 296

  >>> import math
  >>> math.pi, math.e
  (3.141592653589793, 2.718281828459045)

Գրքի code · PDF էջ 296

  >>> math.sin(2 * math.pi / 180)
  0.03489949670250097

Սկզբնաղբյուրի PDF էջ 297

Գրքի code · PDF էջ 297

  >>> math.sqrt(144), math.sqrt(2)
  (12.0, 1.4142135623730951)

Գրքի code · PDF էջ 297

  >>> pow(2, 4), 2 ** 4, 2.0 ** 4.0
  (16, 16, 16.0)

Գրքի code · PDF էջ 297

  >>> abs(-62.0), sum((1, 2, 3, 4))
  (62.0, 10)

Գրքի code · PDF էջ 297

  >>> min(3, 1, 2, 4), max(3, 1, 2, 4)
  (1, 4)

Այստեղ ցուցադրված sum function-ն աշխատում է թվերի sequence-ի, իրականում՝ iterable object-ի հետ, իսկ min-ն ու max-ն ընդունում են կա՛մ հավաքածու, կա՛մ առանձին argument-ներ։ Կան նաև floating-point թվերի տասնորդական թվանշանները հեռացնելու մի քանի եղանակներ՝ թե՛ հաշվարկների, թե՛ ցուցադրման համար. դրանցից որոշներն ավելի հարուստ հնարավորություններ ունեն, քան նախկինում ներկայացվածները.

Գրքի code · PDF էջ 297

  >>> math.floor(2.567), math.floor(-2.567)
  (2, −3)

Գրքի code · PDF էջ 297

  >>> math.trunc(2.567), math.trunc(−2.567)
  (2, −2)

Գրքի code · PDF էջ 297

  >>> int(2.567), int(−2.567)

Սկզբնաղբյուրի PDF էջ 298

Գրքի code · PDF էջ 298

  (2, −2)

Գրքի code · PDF էջ 298

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> round(2.567), round(2.567, 2), round(2567, -3
  (3, 2.57, 3000)

Գրքի code · PDF էջ 298

  >>> '%.1f' % 2.567, '{0:.2f}'.format(2.567)
  ('2.6', '2.57')

Ինչպես ավելի վաղ ցույց տրվեց, դրանցից վերջինը ստեղծում է string-եր, որոնք սովորաբար կտպեինք, և աջակցում է ձևաչափման տարբերակների բազմազանությանը։ Սակայն string-երի ձևաչափումը դեռ մի նուրբ տարբերություն ունի. round-ը կլորացնում և հեռացնում է տասնորդական թվանշանները, բայց memory-ի մեջ դեռ թիվ է ստեղծում, մինչդեռ string-երի ձևաչափումը ստեղծում է string, ոչ թե թիվ.

Գրքի code · PDF էջ 298

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> (1 / 3.0), round(1 / 3.0, 2), f'{(1 / 3.0):.2
  (0.3333333333333333, 0.33, '0.33')

Հետաքրքրական է, որ Python-ում քառակուսի արմատները հաշվարկելու երեք եղանակ կա՝ module-ի function-ով, expression-ով կամ built-in function-ով (եթե ձեզ հետաքրքրում է կատարողականությունը, Մաս IV-ի վերջի վարժություններից մեկում և դրա լուծման մեջ կվերադառնանք դրանց՝ տեսնելու, թե որն է ավելի արագ աշխատում).

Սկզբնաղբյուրի PDF էջ 299

Գրքի code · PDF էջ 299

  >>> import math
  >>> math.sqrt(144)              # Module
  12.0
  >>> 144 ** .5                   # Expression
  12.0
  >>> pow(144, .5)                # Built-in
  12.0

Մեկնաբանություն, տող 2․ module

Մեկնաբանություն, տող 4․ expression

Մեկնաբանություն, տող 6․ built-in գործիք

Նկատեք, որ math-ի նման standard library-ի module-ները պետք է ներմուծվեն, սակայն abs-ի և round-ի նման built-in function-ները միշտ հասանելի են առանց ներմուծումների։ Պատճառն այն է, որ module-ներն արտաքին բաղադրիչներ են, իսկ built-in function-ները գտնվում են ենթադրվող namespace-ում, որտեղ Python-ն ինքնաբերաբար որոնում է՝ ձեր program-ում օգտագործված name-ները գտնելու համար։ Այս namespace-ը պարզապես համապատասխանում է standard library-ի builtins կոչվող module-ին, իսկ name-ների լուծման մասին շատ ավելին կա այս գրքի function-ների և module-ների մասերում։ Առայժմ, երբ լսում եք «module», մտածեք «ներմուծում»։

standard library-ի statistics և random module-ները նույնպես պետք է ներմուծվեն։ Երկու module-ներն էլ տրամադրում են գործիքների մի շարք. statistics-ն աջակցում է հաշվիչներում սովորաբար հանդիպող գործողություններին, իսկ random-ը հնարավոր է դարձնում այնպիսի առաջադրանքներ, ինչպիսիք են 0-ի և 1-ի միջև պատահական թիվ ընտրելը և երկու թվերի միջև պատահական ամբողջ թիվ ընտրելը.

Սկզբնաղբյուրի PDF էջ 300

Գրքի code · PDF էջ 300

  >>> import statistics
  >>> statistics.mean([1, 2, 4, 5, 7])        # Ave
  3.8
  >>> statistics.median([1, 2, 4, 5, 7])      # And
  4

Մեկնաբանություն, տող 2․ Միջի…

Մեկնաբանություն, տող 4․ Եվ

Գրքի code · PDF էջ 300

  >>> import random
  >>> random.random()
  0.5566014960423105
  >>> random.random()              # Random floats,
  0.051308506597373515

Մեկնաբանություն, տող 4․ Պատահական floating-point թվեր, …

Գրքի code · PDF էջ 300

  >>> random.randint(1, 10)
  5
  >>> random.randint(1, 10)
  9

random module-ը կարող է նաև sequence-ից պատահականորեն տարր ընտրել և տարրերի list-ը պատահականորեն խառնել.

Գրքի code · PDF էջ 300

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> random.choice(['Pizza', 'Tacos', 'Tikka', 'La
  'Tikka'
  >>> random.choice(['Pizza', 'Tacos', 'Tikka', 'La
  'Lasagna'

Գրքի code · PDF էջ 300

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> suits = ['hearts', 'clubs', 'diamonds', 'spad

Սկզբնաղբյուրի PDF էջ 301

Գրքի code · PDF էջ 301

  >>> random.shuffle(suits)
  >>> suits
  ['spades', 'hearts', 'diamonds', 'clubs']
  >>> random.shuffle(suits)
  >>> suits
  ['clubs', 'diamonds', 'hearts', 'spades']

Թեև այստեղ սա ավելի շոշափելի դարձնելու համար լրացուցիչ code պետք կլիներ, random module-ը կարող է օգտակար լինել խաղերում քարտերը խառնելու, սլայդների ցուցադրման graphical interface-ում պատահական պատկերներ ընտրելու, վիճակագրական մոդելավորումներ կատարելու և շատ այլ նպատակներով։ Այս գրքում այն կրկին կկիրառենք ավելի ուշ (օրինակ՝ Գլուխ 20-ի տեղափոխությունների գործնական ուսումնասիրության մեջ), իսկ ավելի մանրամասն տեղեկությունների համար դիմեք Python-ի library-ի ձեռնարկին։

Մինչ այժմ այս գլխում օգտագործում էինք Python-ի հիմնական numeric type-երը՝ ամբողջ, floating-point և կոմպլեքս թվերը։ Դրանք կբավարարեն թվային հաշվարկների մեծ մասի համար, որոնք շատ programmer-ների երբևէ պետք կգան։ Սակայն Python-ն ունի նաև մի քանի ավելի արտասովոր numeric type-եր, որոնք արժե այստեղ համառոտ դիտարկել։

Սկզբնաղբյուրի PDF էջ 302

Առաջինը Python-ի հատուկ նշանակության թվային object-ն է, որը պաշտոնապես հայտնի է որպես Decimal (իսկ ոչ պաշտոնապես՝ decimal)։ Շարահյուսական առումով՝ decimal թվերը ստեղծվում են ներմուծված standard library-ի module-ի function կանչելով, այլ ոչ թե literal expression կատարելով։ Գործառութային առումով դրանք նման են floating-point թվերին, բայց ունեն տասնորդական թվանշանների ֆիքսված և կարգավորվող քանակ։ Հետևաբար decimal թվերը ֆիքսված ճշտությամբ floating-point value-ներ են։

Օրինակ՝ decimal թվերով կարող ենք ունենալ floating-point value, որը միշտ պահպանում է տասնորդական ընդամենը երկու թվանշան։ Ավելին՝ կարող ենք նշել, թե ինչպես կլորացնել կամ կտրել object-ի սահմանը գերազանցող լրացուցիչ տասնորդական թվանշանները։ Թեև սովորական floating-point թվերի համեմատ սա ընդհանուր առմամբ արտադրողականության կորուստ է բերում, decimal-ը լավ է համապատասխանում դրամական գումարների նման ֆիքսված ճշտությամբ մեծություններ ներկայացնելուն և որոշ պայմաններում կարող է ապահովել ավելի բարձր թվային ճշտություն։

Ինչպես իմացանք համեմատություններն ուսումնասիրելիս, floating-point թվերով մաթեմատիկան լիովին ճշգրիտ չէ՝ value-ները պահելու համար օգտագործվող սահմանափակ տարածքի պատճառով։ Օրինակ՝ հետևյալը պետք է տար զրո, բայց այդպես

Սկզբնաղբյուրի PDF էջ 303

չի լինում։ Արդյունքը մոտ է զրոյին, բայց այստեղ ճշգրիտ լինելու համար bit-երը բավարար չեն․

Գրքի code · PDF էջ 303

  >>> 0.1 + 0.1 + 0.1 - 0.3                       #
  5.551115123125783e-17

Օգտատիրոջ համար հարմար ցուցադրման ձևաչափ ստանալու նպատակով print օգտագործելն այստեղ չի օգնում, քանի որ floating-point հաշվարկների hardware-ն իր բնույթով սահմանափակ է ճշտության առումով։ Սակայն decimal թվերով արդյունքը կարող է լիովին ճշգրիտ լինել․

Գրքի code · PDF էջ 303

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> from decimal import Decimal
  >>> Decimal('0.1') + Decimal('0.1') + Decimal('0
  Decimal('0.0')

Ինչպես այստեղ է ցույց տրված, decimal object-ներ կարող ենք ստեղծել՝ կանչելով decimal module-ի Decimal կոնստրուկտոր function-ը և փոխանցելով string-եր, որոնք պարունակում են ստացվող object-ի համար տասնորդական թվանշանների ցանկալի քանակը (անհրաժեշտության դեպքում floating-point value-ները string-երի վերածելու համար օգտագործելով str function-ը)։ Երբ expression-ներում խառնվում են տարբեր ճշտությամբ decimal թվեր, Python-ն ինքնաշխատ բերում է տասնորդական թվանշանների ամենամեծ քանակին․

Սկզբնաղբյուրի PDF էջ 304

Գրքի code · PDF էջ 304

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> Decimal('0.1') + Decimal('0.10') + Decimal('0
  Decimal('0.0000')

Հնարավոր է նաև decimal object ստեղծել floating-point object-ից՝ կա՛մ Decimal.from_float կանչով, կա՛մ floating-point թվերն անմիջապես փոխանցելով․

Գրքի code · PDF էջ 304

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) -
  Decimal('2.775557561565156540423631668E-17')

Փոխարկումը ճշգրիտ է, բայց լռելյայն կարող է տալ թվանշանների մեծ քանակ, եթե դրանք չֆիքսվեն հաջորդ բաժնի համաձայն։

decimal module-ի մյուս գործիքներով կարելի է սահմանել բոլոր decimal թվերի ճշտությունը, կազմակերպել սխալների մշակումը և ավելին։ Օրինակ՝ այս module-ի համատեքստի object-ը թույլ է տալիս նշել ճշտությունը (տասնորդական թվանշանների քանակը) և կլորացման ռեժիմները (ներքև, դեպի վերևի ամբողջը և այլն)։ Ճշտությունը կիրառվում է համընդհանուր՝ կանչողի ստեղծած բոլոր decimal թվերի համար․

Սկզբնաղբյուրի PDF էջ 305

Գրքի code · PDF էջ 305

  >>> import decimal
  >>> decimal.Decimal(1) / decimal.Decimal(7)
  Decimal('0.1428571428571428571428571429')

Գրքի code · PDF էջ 305

  >>> decimal.getcontext().prec = 4
  >>> decimal.Decimal(1) / decimal.Decimal(7)
  Decimal('0.1429')

Գրքի code · PDF էջ 305

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) -
  Decimal('1.110E-17')

Տեխնիկապես նշանակալի թվանշանների քանակը որոշվում է մուտքագրված թվանշաններով, իսկ ճշտությունը կիրառվում է մաթեմատիկական գործողությունների ժամանակ։ Թեև սա ավելի նուրբ հարց է, քան կարող ենք ուսումնասիրել այս համառոտ ակնարկում, այդ հատկությունը կարող է decimal թվերը օգտակար դարձնել որպես դրամական որոշ կիրառությունների հիմք և երբեմն ծառայել որպես ձեռքով կլորացման ու string ձևաչափման այլընտրանք։

Սակայն քանի որ decimal type-ի օգտագործումը գործնականում համեմատաբար հազվադեպ է, այս գիրքը լրացուցիչ մանրամասների համար ձեզ կուղղորդի Python-ի ինտերակտիվ help function-ին և standard library-ի ձեռնարկներին։ Իսկ քանի որ decimal թվերը լուծում են floating-point հաշվարկների ճշտության այն խնդիրներից մի քանիսը, որոնք լուծում է նաև կոտորակի type-ը, անցնենք հաջորդ բաժնին՝ տեսնելու, թե դրանք ինչպես են համեմատվում։

Սկզբնաղբյուրի PDF էջ 306

Python-ի standard library-ի fractions module-ն իրականացնում է ռացիոնալ թվի object։ Այն ըստ էության բացահայտ պահում է և՛ համարիչը, և՛ հայտարարը՝ floating-point հաշվարկների որոշ անճշտություններից ու սահմանափակումներից խուսափելու համար։ Decimal թվերի նման՝ կոտորակներն այնքան սերտ չեն համապատասխանում համակարգչի hardware-ին, որքան floating-point թվերը։ Սա նշանակում է, որ դրանց արտադրողականությունը կարող է այնքան լավը չլինել, բայց նաև թույլ է տալիս օգտակար դեպքերում լրացուցիչ հնարավորություններ տրամադրել ստանդարտ գործիքի մեջ։

Fraction-ը գործառութային առումով նախորդ բաժնի ֆիքսված ճշտությամբ Decimal object-ի ազգականն է, քանի որ երկուսն էլ կարող են օգտագործվել floating-point object-ի թվային անճշտությունները հաղթահարելու համար։ Այն նաև նման ձևերով է օգտագործվում․ Decimal-ի պես Fraction-ը գտնվում է module-ում․ այն ստեղծելու համար, ի թիվս այլ եղանակների, ներմուծեք դրա կոնստրուկտորը և փոխանցեք համարիչ ու հայտարար։ Հետևյալ փոխգործակցությունը ցույց է տալիս՝ ինչպես․

Գրքի code · PDF էջ 306

  >>> from fractions import Fraction
  >>> x = Fraction(1, 3)                    # Numer
  >>> y = Fraction(4, 6)                    # Simpl

Մեկնաբանություն, տող 2․ Համարի…

Մեկնաբանություն, տող 3․ Պարզե…

Սկզբնաղբյուրի PDF էջ 307

Գրքի code · PDF էջ 307

  >>> x
  Fraction(1, 3)
  >>> y
  Fraction(2, 3)
  >>> print(y)
  2/3

Ստեղծվելուց հետո Fraction object-ները սովորականի պես կարելի է օգտագործել մաթեմատիկական expression-ներում․

Գրքի code · PDF էջ 307

  >>> x + y
  Fraction(1, 1)
  >>> x − y                           # Results are
  Fraction(−1, 3)
  >>> x * y
  Fraction(2, 9)

Մեկնաբանություն, տող 3․ Արդյունքները … են

Fraction object-ներ կարելի է նաև ստեղծել floating-point թվեր ներկայացնող string-երից՝ decimal թվերի նման․

Գրքի code · PDF էջ 307

  >>> Fraction('.25')
  Fraction(1, 4)
  >>> Fraction('1.25')
  Fraction(5, 4)

Սկզբնաղբյուրի PDF էջ 308

Գրքի code · PDF էջ 308

  >>> Fraction('.25') + Fraction('1.25')
  Fraction(3, 2)

Կոտորակներով հաշվարկը տարբերվում է floating-point type-ի հաշվարկից, որը սահմանափակված է floating-point hardware-ի հիմքում ընկած սահմանափակումներով։ Համեմատելու համար ահա նույն գործողությունները՝ կատարված floating-point object-ներով, և նշումներ դրանց սահմանափակ ճշտության մասին․ Python-ի նոր տարբերակներում դրանք կարող են ավելի քիչ թվանշաններով ցուցադրվել, քան նախկինում, բայց memory-ի մեջ միևնույն է ճշգրիտ value-ներ չեն․

Գրքի code · PDF էջ 308

  >>> a = 1 / 3                       # Only as acc
  >>> b = 4 / 6                       # Can lose pr
  >>> a
  0.3333333333333333
  >>> b
  0.6666666666666666

Մեկնաբանություն, տող 1․ Միայն այնքան ճշգր…

Մեկնաբանություն, տող 2․ Կարող է կորցնել ճշտու…

Գրքի code · PDF էջ 308

  >>> a + b
  1.0
  >>> a - b
  -0.3333333333333333

Սկզբնաղբյուրի PDF էջ 309

Գրքի code · PDF էջ 309

  >>> a * b
  0.2222222222222222

floating-point թվերի այս սահմանափակումը հատկապես ակնհայտ է այն value-ների համար, որոնք հնարավոր չէ ճշգրիտ ներկայացնել՝ հաշվի առնելով memory-ի մեջ դրանց bit-երի սահմանափակ քանակը։ Թե՛ Fraction-ը, թե՛ Decimal-ը ճշգրիտ արդյունքներ ստանալու եղանակներ են տալիս, թեև որոշ արագության կորստի և code-ի ծավալի ավելացման գնով։ Օրինակ՝ հետևյալ օրինակում (կրկնված նախորդ բաժնից) floating-point թվերը ճշգրիտ չեն տալիս ակնկալվող զրո պատասխանը, բայց մյուս երկու type-երն էլ տալիս են․

Գրքի code · PDF էջ 309

  >>> 0.1 + 0.1 + 0.1 - 0.3           # This should
  5.551115123125783e-17

Մեկնաբանություն, տող 1․ Սա պետք է…

Գրքի code · PDF էջ 309

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> from fractions import Fraction
  >>> Fraction(1, 10) + Fraction(1, 10) + Fraction
  Fraction(0, 1)

Գրքի code · PDF էջ 309

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> from decimal import Decimal
  >>> Decimal('0.1') + Decimal('0.1') + Decimal('0
  Decimal('0.0')

Սկզբնաղբյուրի PDF էջ 310

Ավելին՝ կոտորակներն ու decimal թվերը երկուսն էլ տարբեր եղանակներով թույլ են տալիս երբեմն ավելի բնական ու ճշգրիտ արդյունքներ ստանալ, քան հնարավոր է floating-point թվերով՝ ռացիոնալ ներկայացում օգտագործելով և ճշտությունը սահմանափակելով․

Գրքի code · PDF էջ 310

  >>> 1 / 3                           # Normal floa
  0.3333333333333333

Մեկնաբանություն, տող 1․ Սովորական լողա…

Գրքի code · PDF էջ 310

  >>> Fraction(1, 3)                  # Numeric acc
  Fraction(1, 3)

Մեկնաբանություն, տող 1․ Թվային ճշտու…

Գրքի code · PDF էջ 310

  >>> import decimal
  >>> decimal.getcontext().prec = 2
  >>> Decimal(1) / Decimal(3)
  Decimal('0.33')

Իրականում կոտորակները և՛ պահպանում են ճշտությունը, և՛ ինքնաշխատ կրճատում արդյունքները։ Շարունակենք նախորդ փոխգործակցությունը․

Գրքի code · PDF էջ 310

  >>> (1 / 3) + (6 / 12)
  0.8333333333333333

Գրքի code · PDF էջ 310

  >>> Fraction(1, 3) + Fraction(6, 12)
  Fraction(5, 6)

Սկզբնաղբյուրի PDF էջ 311

Գրքի code · PDF էջ 311

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> decimal.Decimal(1 / 3) + decimal.Decimal(6 /
  Decimal('0.83')

Փոխարկումներն աջակցելու համար floating-point object-ներն ունեն ավելի վաղ նշված as_integer_ratio method-ը, որը տալիս է համարիչն ու հայտարարը․ կոտորակներն ունեն from_float method-ը, իսկ float-ն ընդունում է Fraction՝ որպես argument։ Սակայն քանի որ Fraction-ը նույնպես քիչ օգտագործվող օժանդակ գործիք է, այստեղ էլ կսահմանափակվենք այսքանով․ Fraction-ի մասին ավելի շատ իմանալու համար ինքնուրույն շարունակեք փորձարկումները և դիմեք Python-ի փաստաթղթավորմանը։

Բացի մեր ուսումնասիրած բոլոր թվային object-ներից՝ Python-ն ունի set-ների built-in աջակցություն․ set-ը եզակի և immutable object-ների չկարգավորված հավաքածու է, որն աջակցում է set-ների մաթեմատիկական տեսությանը համապատասխանող գործողություններին։ set-ները գտնվում են հավաքածուների ու մաթեմատիկայի սահմանագծին, բայց բավական հակված են վերջինիս կողմը՝ այս գլխում քննարկվելու համար։

Ըստ սահմանման՝ տարրը set-ի մեջ հայտնվում է միայն մեկ անգամ՝ անկախ այն բանից, թե քանի անգամ է ավելացվում։ Հետևաբար set-ներն ունեն տարբեր կիրառություններ, հատկապես թվային հաշվարկներին և տվյալների բազաներին ուղղված աշխատանքներում։

Սկզբնաղբյուրի PDF էջ 312

Մյուս կողմից՝ քանի որ set-ներն այլ object-ների հավաքածուներ են, որոշ վարքագիծ կիսում են list-ների ու dictionary-ների նման object-ների հետ, որոնց նախնական ծանոթացանք Գլուխ 4-ում։ Օրինակ՝ set-ները կրկնելի են, կարող են աճել ու փոքրանալ ըստ պահանջի և կարող են պարունակել տարբեր type-երի object-ներ։

Այնուամենայնիվ, քանի որ set-ները չկարգավորված են և key-ներն value-ներին չեն արտապատկերում, դրանք ո՛չ sequence-ի, ո՛չ էլ արտապատկերման type-եր են․ դրանք ինքնուրույն type կատեգորիա են։ Ավելին՝ քանի որ set-ները սովորաբար նաև շատ ավելի հազվադեպ են օգտագործվում, քան list-ների ու dictionary-ների նման ամենուր հանդիպող object-ները, ընթերցողների մեծ մասին համառոտ ծանոթությունը պետք է բավարարի․ այստեղ սկսենք REPL-ի սովորական շրջայցից։

Նախ՝ set ստեղծելու երկու եղանակ կա՝ կանչով և literal-ով։ literal-ն օգտագործում է նույն «{}» ձևավոր փակագծերը, ինչ dictionary-ները, բայց պարզապես թվարկում է տարրերը (key չկա) և թույլ է տալիս set-ը սկզբնարժեքավորել առանձին object-ներով։ set-ի կանչն ընդունում է տարրերի առկա sequence (կամ այլ iterable object)՝ նոր set-ի մեջ ավելացնելու համար, և պարտադիր է դատարկ set ստեղծելիս ({}-ը վերապահված է դատարկ dictionary-ին)։ Արտածվելիս set-ները նախընտրում են literal ձևը, բացառությամբ դատարկ լինելու դեպքի․

Սկզբնաղբյուրի PDF էջ 313

Գրքի code · PDF էջ 313

  >>> x = set('abcde')                    # Make a
  >>> y = {99, 'b', 'y', 'd', 1.2}        # Make a

Մեկնաբանություն, տող 1․ Ստեղծել մի…

Մեկնաբանություն, տող 2․ Ստեղծել մի…

Գրքի code · PDF էջ 313

  >>> x
  {'d', 'c', 'e', 'a', 'b'}               # Order i
  >>> y
  {1.2, 99, 'y', 'd', 'b'}

Մեկնաբանություն, տող 2․ Հերթականությունը … [i՝ կտրված է]

Նկատեք, որ set-ները չեն պահպանում key-ների ավելացման հերթականությունը՝ ի տարբերություն dictionary-ի key-ների (տե՛ս Գլուխ 4-ի ներածությունը)։ Սա ըստ սահմանման է․ set-ները պարզապես տարրերի խմբեր են, բայց դիրքային կարգի բացակայությունը նշանակում է, որ sequence-ի գործողությունները set-ների վրա չեն աշխատի։ Ինչպես ցույց է տրված ստորև, դատարկ set-ները պահանջում են կանչ, literal-ի *-ը բացում է տարրերը, և՛ կանչը, և՛ *-ն ընդունում են ցանկացած iterable object, իսկ set-ները միշտ զտում են կրկնվող տարրերը․ կրկին՝ set-ներն այսպես են աշխատում Python-ում և այլուր․

Գրքի code · PDF էջ 313

  >>> z = set()                           # Make em
  >>> z
  set()

Մեկնաբանություն, տող 1․ Ստեղծել դատա…

Գրքի code · PDF էջ 313

  >>> z = set([1.2, 'a', 3, 1.2, 'a'])    # Any seq
  >>> z
  {'a', 1.2, 3}

Մեկնաբանություն, տող 1․ Ցանկացած հաջորդա…

Սկզբնաղբյուրի PDF էջ 314

Գրքի code · PDF էջ 314

  >>> {1, *'abc', *[1, 2, 3]}             # Litera
  {1, 2, 3, 'c', 'b', 'a'}

Մեկնաբանություն, տող 1․ Լիտերա…

set-ներ ունենալուց հետո expression-ների operator-ները կատարում են set-ների գործողությունները։ Ահա ամենատարածվածները գործողության մեջ․ դրանցից որևէ մեկը string-երի ու list-ների նման սովորական sequence-ների վրա կատարելու համար նախ պետք է ստեղծեք դրանց տարրերի set-ը․

Գրքի code · PDF էջ 314

  >>> x = set('abcd')
  >>> y = set('bdxy')

Գրքի code · PDF էջ 314

  >>> x – y                           # Difference:
  {'a', 'c'}

Մեկնաբանություն, տող 1․ Տարբերություն՝

Գրքի code · PDF էջ 314

  >>> x | y                           # Union: in e
  {'y', 'd', 'x', 'c', 'a', 'b'}

Մեկնաբանություն, տող 1․ union՝ որևէ մե…-ում

Գրքի code · PDF էջ 314

  >>> x & y                           # Intersectio
  {'d', 'b'}

Մեկնաբանություն, տող 1․ Հատու…

Գրքի code · PDF էջ 314

  >>> x ^ y                           # Symmetric d
  {'y', 'x', 'c', 'a'}

Մեկնաբանություն, տող 1․ Սիմետրիկ տարբե…

Գրքի code · PDF էջ 314

  >>> x < y, x > y                    # Superset, s
  (False, False)

Մեկնաբանություն, տող 1․ superset, ենթա…

Սկզբնաղբյուրի PDF էջ 315

Մի exception․ set-ի անդամության ստուգման in expression-ը սահմանված է նաև հավաքածուների մյուս բոլոր type-երի համար, որտեղ նույնպես ստուգում է անդամությունը (կամ կատարում է որոնում, եթե նախընտրում եք մտածել ընթացակարգային տերմիններով)։ Հետևաբար այս ստուգումը կատարելու համար string-երի ու list-ների նման բաները set-ների վերածելու կարիք չկա․

Գրքի code · PDF էջ 315

  >>> 'd' in x
  True

Գրքի code · PDF էջ 315

  >>> 'd' in 'code', 2 in [1, 2, 3]
  (True, True)

Բացի expression-ներից՝ set-ի object-ը տրամադրում է այս և այլ գործողություններին համապատասխանող method-ներ, որոնք աջակցում են նաև set-ի փոփոխություններին։ Օրինակ՝ set-ի add method-ն ավելացնում է մեկ տարր, update-ը տեղում միավորում է, իսկ remove-ը ջնջում է տարրը՝ ըստ value-ի (նախորդ գլխի համաձայն՝ բոլոր հասանելի method-ները տեսնելու համար dir կանչեք set-ի որևէ instance-ի կամ set type-ի name-ի վրա)։ Ենթադրելով, որ x-ը և y-ը դեռ նույնն են, ինչ նախորդ փոխգործակցության մեջ․

Գրքի code · PDF էջ 315

  >>> z = x.intersection(y)
  >>> z
  {'d', 'b'}

Սկզբնաղբյուրի PDF էջ 316

Գրքի code · PDF էջ 316

  >>> z.add('HACK')
  >>> z
  {'HACK', 'd', 'b'}
  >>> z.update(set(['X', 'Y']))
  >>> z
  {'X', 'HACK', 'd', 'b', 'Y'}
  >>> z.remove('b')
  >>> z
  {'X', 'HACK', 'd', 'Y'}

set-ները նաև կրկնելի են (այսինքն՝ աջակցում են նախորդ գլխում ներկայացված կրկնության արձանագրությանը), ուստի կարող են օգտագործվել նաև այնպիսի գործողություններում, ինչպիսիք են len-ը, for loop-երը և list-ի comprehension-ները։ Բայց քանի որ չկարգավորված են, չեն աջակցում sequence-ի այնպիսի գործողությունների, ինչպիսիք են indexing-ը, slicing-ը կամ միակցումը․

Գրքի code · PDF էջ 316

  >>> for item in set('abc'):
          print(item * 3)

Գրքի code · PDF էջ 316

  aaa
  ccc
  bbb
  >>> {'a', 'b', 'c'} + {'d'}
  TypeError: unsupported operand type(s) for +: 'se

Սկզբնաղբյուրի PDF էջ 317

Վերջապես, թեև ավելի վաղ ցուցադրված set-ի expression-ներն ընդհանուր առմամբ պահանջում են երկու set, դրանց method համարժեքները հաճախ կարող են աշխատել նաև ցանկացած iterable object-ի հետ և դրա շնորհիվ կարող են ավելի արագ աշխատել (թեև Python-ում արագության մասին կռահումները վտանգավոր են)․

Գրքի code · PDF էջ 317

  >>> S = set([1, 2, 3])
  >>> S | set([3, 4])                # Expressions
  {1, 2, 3, 4}
  >>> S | [3, 4]
  TypeError: unsupported operand type(s) for |: 'se

Մեկնաբանություն, տող 2․ expression-ներ

Գրքի code · PDF էջ 317

  >>> S.union([3, 4])                # But their me
  {1, 2, 3, 4}
  >>> S.intersection((1, 3, 5))
  {1, 3}
  >>> S.issubset(range(-5, 5))       # Subset of ra
  True

Մեկնաբանություն, տող 1․ Բայց դրանց մե…

Մեկնաբանություն, տող 5․ Միջակա…-ի subset

Գրքի code · PDF էջ 317

  >>> S = set([1, 2, 3])
  >>> S.intersection_update((1, 2, 5))
  >>> S
  {1, 2}
  >>>
  >>> S |= {1, 2, 4}
  >>> S
  {1, 2, 4}

Սկզբնաղբյուրի PDF էջ 318

set-ի գործողությունների մասին լրացուցիչ մանրամասների համար տե՛ս Python-ի library-ի ձեռնարկը։ Այստեղ բաց թողնված թեմաների թվում set-ներն աջակցում են նաև տեղում փոփոխություններին՝ լրացուցիչ method-ներով, ինչպես նաև assignment-ի operator-ներով, որոնք կուսումնասիրենք ավելի ուշ (օրինակ՝ &= և |=)։ Թեև Python-ում set-ները կարելի է ձեռքով իրականացնել list-ների և dictionary-ների նման այլ type-երով (և անցյալում հաճախ այդպես էլ արվել է), Python-ի built-in set-ներն օգտագործում են արդյունավետ algorithm-ներ ու implementation-ի method-ներ՝ արագ և ստանդարտ գործողություններ ապահովելու համար։

set-ները հզոր և ճկուն object-ներ են, բայց ունեն մեկ սահմանափակում, որը պետք է հիշեք․ մեծ մասամբ իրենց implementation-ի պատճառով set-ները կարող են պարունակել միայն immutable object type-եր (Python-ը սա անվանում է «hashable», ինչը բավական մոտ է «immutable-ին», որպեսզի այստեղ օգտագործենք վերջին տերմինը)։ Հետևաբար list-ներն ու dictionary-ները չեն կարող ներդրվել set-ների մեջ, բայց այլ immutable object-ներից կազմված tuple-ները կարող են, եթե պետք է պահպանեք բաղադրյալ value-ներ։ set-ներում օգտագործվելիս tuple-ները համեմատվում են իրենց ամբողջական value-ներով․

Գրքի code · PDF էջ 318

  >>> S = {1.23}

Գրքի code · PDF էջ 318

  >>> S.add([1, 2, 3])                   # Only imm
  TypeError: unhashable type: 'list'
  >>> S.add({'a':1})

Մեկնաբանություն, տող 1․ Միայն անփոփո…

Սկզբնաղբյուրի PDF էջ 319

Գրքի code · PDF էջ 319

  TypeError: unhashable type: 'dict'

Գրքի code · PDF էջ 319

  >>> S.add((1, 2, 3))
  >>> S                                  # No list
  {1.23, (1, 2, 3)}

Մեկնաբանություն, տող 2․ list չկա

Գրքի code · PDF էջ 319

  >>> S | {(4, 5, 6), (1, 2, 3)}         # Union: s
  {1.23, (4, 5, 6), (1, 2, 3)}

Մեկնաբանություն, տող 1․ union՝ s… [կտրված է]

Գրքի code · PDF էջ 319

  >>> (1, 2, 3) in S                     # Membersh
  True
  >>> (1, 4, 3) in S
  False

Մեկնաբանություն, տող 1․ Պատկանելու…

Օրինակ՝ set-ի մեջ tuple-ները կարող են օգտագործվել ամսաթվեր, գրառումներ, IP հասցեներ և այլն ներկայացնելու համար (tuple-ների մասին ավելին՝ գրքի այս մասում ավելի ուշ)։ set-ները կարող են պարունակել նաև module-ներ, type-երի object-ներ և ավելին։ set-ներն իրենք էլ mutable են, ուստի չեն կարող ուղղակիորեն ներդրվել այլ set-ների մեջ․ եթե անհրաժեշտ է մի set-ը պահել մյուսի մեջ, built-in frozenset կանչն աշխատում է ճիշտ set-ի պես, բայց ստեղծում է immutable set, որը չի կարող փոխվել և այդ պատճառով կարող է ներդրվել այլ set-ների մեջ․

Գրքի code · PDF էջ 319

  >>> S.add(frozenset('app'))
  >>> S

Սկզբնաղբյուրի PDF էջ 320

Գրքի code · PDF էջ 320

  {1.23, (1, 2, 3), frozenset({'a', 'p'})}

literal-ներից ու կանչերից բացի՝ set-ներ կարելի է ստեղծել նաև comprehension-ներ կատարելով, որոնց համառոտ ծանոթացանք Գլուխ 4-ում։ comprehension-ներն աշխատում են նաև list-ների, dictionary-ների ու generator-ների համար և բոլորում հիմնականում նույն կերպ են վարվում։ set-ների դեպքում դրանք գրվում են ձևավոր փակագծերով։ Կատարվելիս իրականացնում են loop, որն ամեն կրկնության ընթացքում հավաքում է expression-ի արդյունքը․ loop-ի variable-ը հասանելի է դարձնում ընթացիկ կրկնության value-ն՝ հավաքման expression-ի մեջ օգտագործելու համար։ Արդյունքը սովորական set-ի բոլոր հատկություններով նոր set է։ Օրինակ՝

Գրքի code · PDF էջ 320

  >>> {x ** 2 for x in [1, 2, 3, 4]}         # Make
  {16, 1, 4, 9}

Մեկնաբանություն, տող 1․ Ստեղծել

Այս expression-ի մեջ loop-ը գրված է աջում, իսկ հավաքման expression-ը՝ ձախում (x ** 2)։ Ինչպես list-ի comprehension-ների դեպքում, ստանում ենք գրեթե հենց այն, ինչ ասում է այս expression-ը․ «Տուր ինձ նոր set, որը պարունակում է X-ի քառակուսին՝ list-ի յուրաքանչյուր X-ի համար»։ comprehension-ները կարող են նաև անցնել այլ տեսակի object-ներով, օրինակ՝ string-երով․ հետևյալ օրինակներից առաջինը նաև

Սկզբնաղբյուրի PDF էջ 321

ցույց է տալիս առկա iterable object-ից set ստեղծելու՝ comprehension-ի վրա հիմնված եղանակը․

Գրքի code · PDF էջ 321

  >>> {x for x in 'py3X'}                    # Same
  {'p', 'X', '3', 'y'}

Մեկնաբանություն, տող 1․ Նույնը

Գրքի code · PDF էջ 321

  >>> {c * 4 for c in 'py3X'}                # Set
  {'yyyy', '3333', 'XXXX', 'pppp'}
  >>> {c * 4 for c in 'py3X' + 'py2X'}       # Expr
  {'yyyy', '3333', 'XXXX', '2222', 'pppp'}

Մեկնաբանություն, տող 1․ set

Մեկնաբանություն, տող 3․ Արտա…

Գրքի code · PDF էջ 321

  >>> S = {c * 4 for c in 'py3X'}            # All
  >>> S | {'zzzz', 'XXXX'}
  {'yyyy', '3333', 'XXXX', 'pppp', 'zzzz'}
  >>> S & {'zzzz', 'XXXX'}
  {'XXXX'}

Մեկնաբանություն, տող 1․ Բոլորը

Քանի որ comprehension-ների մնացած պատմությունը հիմնվում է հիմքում ընկած այնպիսի հասկացությունների վրա, որոնց դեռ պատրաստ չենք անդրադառնալ, հետագա մանրամասները կհետաձգենք մինչև գրքի ավելի ուշ մասը։ Գլուխ 8-ում կհանդիպեք դրանց մերձավոր ազգականներին՝ list-ի և dictionary-ի comprehension-ներին, իսկ բոլոր comprehension-ների՝ set-ի, list-ի, dictionary-ի և generator-ի մասին շատ ավելին կիմանաք ավելի ուշ, հատկապես Գլուխներ 14-ում և 20-ում։ Ինչպես կտեսնեք, բոլոր comprehension-ներն աջակցում են այստեղ չցուցադրված լրացուցիչ syntax-ի, ներառյալ ներդրված loop-երն ու if ստուգումները,

Սկզբնաղբյուրի PDF էջ 322

որոնք կարող են դժվար լինել, մինչև հնարավորություն ունենաք ուսումնասիրելու ավելի մեծ statement-ներ։

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

Գրքի code · PDF էջ 322

  >>> L = [1, 2, 1, 3, 2, 4, 5]
  >>> set(L)
  {1, 2, 3, 4, 5}
  >>> L = list(set(L))
  >>> L
  [1, 2, 3, 4, 5]

Գրքի code · PDF էջ 322

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> list(set(['yy', 'cc', 'aa', 'xx', 'dd', 'aa'
  ['xx', 'cc', 'yy', 'aa', 'dd']

set-ները կարելի է օգտագործել նաև list-ների, string-երի և այլ iterable object-ների տարբերությունները առանձնացնելու համար․ պարզապես վերածեք set-ների և վերցրեք

Սկզբնաղբյուրի PDF էջ 323

տարբերությունը․ թեև կրկին՝ set-ների չկարգավորված բնույթը նշանակում է, որ արդյունքների կարգը կարող է չհամընկնել սկզբնականների կարգի հետ․

Գրքի code · PDF էջ 323

  >>> set([1, 3, 5, 7]) - set([1, 2, 4, 5, 6])
  {3, 7}
  >>> set('abcdefg') - set('abdghij')
  {'c', 'e', 'f'}
  >>> set('code') - set(['t', 'o', 'e'])
  {'c', 'd'}

set-ները կարող եք նաև օգտագործել հերթականությունից անկախ հավասարության ստուգումներ կատարելու համար՝ ստուգումից առաջ set-ի փոխարկելով, քանի որ set-ի մեջ հերթականությունը կարևոր չէ։ Ավելի ձևականորեն՝ երկու set-ներ հավասար են այն և միայն այն դեպքում, երբ յուրաքանչյուր set-ի բոլոր տարրերը պարունակվում են մյուսում, այսինքն՝ յուրաքանչյուրը մյուսի subset-ն է՝ անկախ կարգից։ Օրինակ՝ սա կարող եք օգտագործել այն program-երի ելքերը համեմատելու համար, որոնք պետք է նույն կերպ աշխատեն, բայց կարող են արդյունքները տարբեր հերթականությամբ ստեղծել։ Ստուգումից առաջ Python-ի built-in sorted-ով տեսակավորելը հավասարության համար նույն ազդեցությունն ունի․ set-ները չեն հիմնվում ծախսատար տեսակավորման վրա, բայց նաև չեն կարգավորում տարրերը․

Գրքի code · PDF էջ 323

  >>> L1, L2 = [1, 3, 5, 2, 4], [2, 5, 3, 4, 1]
  >>> L1 == L2
  False
  >>> set(L1) == set(L2)

Սկզբնաղբյուրի PDF էջ 324

Գրքի code · PDF էջ 324

  True
  >>> sorted(L1) == sorted(L2)
  True
  >>> 'code' == 'edoc', set('code') == set('edoc')
  (False, True, True)

set-ները կարելի է օգտագործել նաև գրաֆով կամ այլ ցիկլային կառուցվածքով անցնելիս արդեն այցելած տեղերին հետևելու համար։ Օրինակ՝ module-ների անցումային վերաբեռնիչի և inheritance-ի ծառը թվարկող գործիքի օրինակները, որոնք համապատասխանաբար կգրենք Գլուխներ 25-ում և 31-ում, պետք է հետևեն այցելած տարրերին՝ cycle-երից խուսափելու համար, ինչպես Գլուխ 19-ն է քննարկում վերացական մակարդակում։ Այս համատեքստում list օգտագործելն անարդյունավետ է, քանի որ որոնումները պահանջում են գծային անցումներ։ Թեև այցելած վիճակները որպես dictionary-ի key-ներ գրանցելն արդյունավետ է, set-ներն առաջարկում են ըստ էության համարժեք այլընտրանք, որը կարող է ավելի բնական լինել։

Վերջապես, set-ները հարմար են նաև, երբ աշխատում եք տվյալների մեծ հավաքածուների հետ, օրինակ՝ տվյալների բազայի հարցումների արդյունքների․ երկու set intersection-ը պարունակում է երկու կատեգորիաների համար ընդհանուր object-ները, իսկ union-ը՝ բոլոր տարրերը, որոնք կան դրանցից որևէ մեկում։ Ցուցադրելու համար ահա գործողության մեջ set-ների գործողությունների ավելի շոշափելի օրինակ՝ կիրառված ենթադրյալ ընկերության մարդկանց վրա (ինչպես այս գրքի բոլոր օրինակներում, իրական աշխարհի հետ ցանկացած նմանություն զուտ պատահական է)․

Սկզբնաղբյուրի PDF էջ 325

Գրքի code · PDF էջ 325

  >>> engineers = {'pat', 'ann', 'bob', 'sue'}
  >>> managers  = {'sue', 'tom'}

Գրքի code · PDF էջ 325

  >>> 'pat' in engineers                   # Is pat
  True

Մեկնաբանություն, տող 1․ Արդյոք pat-ը …

Գրքի code · PDF էջ 325

  >>> engineers & managers                 # Who is
  {'sue'}

Մեկնաբանություն, տող 1․ Ո՞վ է…

Գրքի code · PDF էջ 325

  >>> engineers | managers                 # All pe
  {'ann', 'sue', 'pat', 'tom', 'bob'}

Մեկնաբանություն, տող 1․ Բոլոր մար…

Գրքի code · PDF էջ 325

  >>> engineers - managers                 # Engine
  {'pat', 'ann', 'bob'}

Մեկնաբանություն, տող 1․ Ինժե…

Գրքի code · PDF էջ 325

  >>> managers - engineers                 # Manage
  {'tom'}

Մեկնաբանություն, տող 1․ Կառավար…

Գրքի code · PDF էջ 325

  >>> engineers > managers                 # Are al
  False

Մեկնաբանություն, տող 1․ Արդյոք բոլո…

Գրքի code · PDF էջ 325

  >>> {'sue', 'bob'} < engineers           # Are bo
  True

Մեկնաբանություն, տող 1․ Արդյոք երկո…

Գրքի code · PDF էջ 325

  >>> (managers | engineers) > managers    # All pe
  True

Մեկնաբանություն, տող 1․ Բոլոր մար…

Սկզբնաղբյուրի PDF էջ 326

Գրքի code · PDF էջ 326

  >>> managers ^ engineers                 # Who is
  {'ann', 'pat', 'tom', 'bob'}

Մեկնաբանություն, տող 1․ Ո՞վ է…

set-ների գործողությունների մասին ավելի շատ մանրամասներ կարող եք գտնել Python-ի library-ի ձեռնարկում և մաթեմատիկայի ու տվյալների բազաների որոշ գրքերում։ Սպասեք նաև Գլուխ 8-ում այստեղ տեսած set-ի գործողությունների վերադարձին՝ dictionary-ի դիտման object-ների համատեքստում։ Այստեղ ժամանակ ունենք ընդամենը մեկ վերջին թվային object type-ի համար։

Թեև հարցը որոշ չափով անորոշ է, Python-ի bool Boolean type-ը, կարելի է ասել, իր բնույթով թվային է, քանի որ դրա երկու value-ները՝ True-ն ու False-ը, պարզապես 1 և 0 ամբողջ թվերի հարմարեցված տարբերակներն են, որոնք այլ կերպ են արտածվում։ Ինչպես programming-ի շատ լեզուներ, Python-ը 1-ը և 0-ն ընդունում է որպես ճշմարիտ և կեղծ, բայց դրա True-ն ու False-ը Boolean դերերն ավելի բացահայտ են դարձնում։ Թեև որոշ programmer-ների համար այսքանը կարող է բավարար լինել, համառոտ բացահայտենք այս type-ի նմանակումը։

Ճշմարտային value-ները ներկայացնելու համար Python-ն ունի bool կոչվող բացահայտ Boolean type, որից ստեղծվում են built-in True և False name-ներին նախապես վերագրված object-ները։ Այսինքն՝ True-ն ու False-ը bool-ի instance-ներ են, որն էլ իր հերթին built-in int ամբողջ numeric type-ի ընդամենը subclass է (object-oriented

Սկզբնաղբյուրի PDF էջ 327

իմաստով)։ True-ն ու False-ը վարվում են ճիշտ 1 և 0 ամբողջ թվերի պես՝ բացառությամբ այն բանի, որ ունեն արտածման հարմարեցված տրամաբանություն․ դրանք իրենց արտածում են որպես True և False բառեր՝ 1 և 0 թվանշանների փոխարեն։ bool-ը դրան հասնում է՝ իր երկու object-ների համար վերասահմանելով str և repr string ձևաչափերը (ներկայացված այս գլխում ավելի վաղ), և բոլոր տրամաբանական ստուգումներն իրենց արդյունքներում տալիս են True կամ False։

Այս հարմարեցման շնորհիվ interactive prompt-ի մոտ մուտքագրված Boolean expression-ներն արդյունքներն արտածում են որպես True և False բառեր՝ պակաս ակնհայտ 1-ի և 0-ի փոխարեն։ Բացի այդ՝ Boolean value-ներն ավելի տեսանելի են դարձնում ճշմարտային value-ները ձեր code-ում։ Օրինակ՝ անվերջ loop-ը կարելի է գրել while True:՝ պակաս բնական while 1:-ի փոխարեն, իսկ դրոշները կարելի է ավելի պարզ սկզբնարժեքավորել flag = False-ով։ Այս statement-ներն ավելի մանրամասն կքննարկենք Մաս III-ում։

Բայց կրկին՝ գործնական նպատակների մեծ մասի համար կարող եք True-ին և False-ին վերաբերվել այնպես, կարծես դրանք նախապես սահմանված variable-ներ են՝ 1 և 0 ամբողջ թվերին հավասար։ Սակայն այս implementation-ը կարող է հետաքրքիր արդյունքների բերել․ քանի որ True-ն պարզապես ցուցադրման հարմարեցված ձևաչափով 1 ամբողջ թիվն է, Python-ում True + 4-ը տալիս է 5 ամբողջ թիվը․

Գրքի code · PDF էջ 327

  >>> type(True)               # True is a bool
  <class 'bool'>

Մեկնաբանություն, տող 1․ True-ը bool է

Սկզբնաղբյուրի PDF էջ 328

Գրքի code · PDF էջ 328

  >>> isinstance(True, int)    # As well as an int
  True
  >>> True == 1                # Same value
  True
  >>> True is 1                # But a different ob
  False
  >>> True or False            # Same as: 1 or 0
  True
  >>> True + 4                 # (Hmmm)
  5

Մեկնաբանություն, տող 1․ Ինչպես նաև int

Մեկնաբանություն, տող 3․ Նույն value-ն

Մեկնաբանություն, տող 5․ Բայց այլ օբ…

Մեկնաբանություն, տող 7․ Նույնն է, ինչ 1 or 0

Մեկնաբանություն, տող 9․ (Հմմմ)

Քանի որ իրական Python code-ում հավանաբար չեք հանդիպի այս վերջինի նման expression-ի, կարող եք հանգիստ անտեսել դրա բոլոր ավելի խոր մետաֆիզիկական հետևանքները։ Boolean արժեքներին կվերադառնանք Գլուխ 9-ում՝ սահմանելու Python-ի ճշմարտության գաղափարը, և կրկին Գլուխ 12-ում՝ տեսնելու, թե ինչպես են աշխատում and-ի ու or-ի նման Boolean operator-ները։

Վերջապես, թեև Python-ի հիմնական թվային object-ները կիրառությունների մեծ մասի համար բավական մեծ հնարավորություններ են առաջարկում, հասանելի է նաև երրորդ կողմի բաց code-ով ընդլայնումների մեծ ցանկ՝ առավել մասնագիտացված թվային կարիքները բավարարելու համար։

Սկզբնաղբյուրի PDF էջ 329

Այս ոլորտի գործիքներն ամփոփեցինք Գլուխ 1-ի «Ի՞նչ կարող եմ անել Python-ով» բաժնում։ Կարճ ասած՝ Python-ով առաջադեմ թվային programming-ի համար այսօր կա արդեն տարածված գործիքների ամբողջություն, որը ներառում է NumPy, SciPy, pandas, matplotlib, Jupyter և ավելին, իսկ լրացուցիչ գործիքներ սպասարկում են վիճակագրության, աստղագիտության և արհեստական բանականության նման ենթաոլորտները։

Այս գործիքակազմն օգտագործվում է ամբողջ աշխարհի հետազոտական կազմակերպություններում, ֆինանսական կառույցներում և օդատիեզերական խմբերում ու կատարում է այնպիսի խնդիրներ, որոնք նախկինում գրվում էին C++-ի կամ Fortran-ի նման լեզուներով։ Այս ոլորտում աշխատողներից շատերը Python-ի և թվային ընդլայնումների համադրությունը համարում են MATLAB-ի նման համակարգերի անվճար, ճկուն ու հզոր այլընտրանք։

Թեև հանրաճանաչ ու հետաքրքիր ոլորտ է, Python-ով թվային programming-ը լեզուն օգտագործելու ընդամենը մեկ եղանակ է (օրինակ՝ Python-ով վեբ մշակումը մոտավորապես նույն ծավալն ունի) և ինքնին հեշտությամբ կարող է ամբողջ գրքեր լցնել։ Ուստի այս գիրքը չի քննարկում թվային ընդլայնումները և փոխարենը կենտրոնանում է բոլոր ոլորտներում օգտագործվող Python լեզուն ձեզ սովորեցնելու վրա։ Երբ սովորեք բուն Python-ը և պատրաստ լինեք հաջորդ մակարդակ անցնելու, հավելումների մասին առատ նյութեր կգտնեք և՛ համացանցում, և՛ ձեր մոտակա գրախանութներում։

Սկզբնաղբյուրի PDF էջ 330

Այս գլուխը շրջայց կատարեց Python-ի թվային object type-երով և դրանց նկատմամբ կիրառելի գործողություններով։ Ընթացքում ծանոթացանք հուսալի ամբողջ և floating-point object-ներին, ինչպես նաև ավելի արտասովոր և քիչ օգտագործվող մի քանի type-երի՝ կոմպլեքս թվերին, decimal թվերին, կոտորակներին ու set-ներին։ Նաև ուսումնասիրեցինք Python-ի expression-ների syntax-ը, type-երի փոխարկումները, bitwise operation-ները և script-ներում թվեր գրելու տարբեր literal ձևերը։

Գրքի այս մասում ավելի ուշ կշարունակենք object-ների մեր խորացված շրջայցը՝ լրացնելով հաջորդ object type-ի՝ string-ի մանրամասները։ Սակայն հաջորդ գլխում որոշ ժամանակ կհատկացնենք variable-ներին արժեք վերագրելու մեխանիզմներն ավելի մանրամասն ուսումնասիրելուն, քան այստեղ արեցինք։ Պարզվում է՝ սա թերևս Python-ի ամենահիմնարար գաղափարն է, ուստի առաջ անցնելուց առաջ անպայման կարդացեք հաջորդ գլուխը։ Բայց նախ ժամանակն է անցնել գլխի սովորական հարցաշարին։

Սկզբնաղբյուրի PDF էջ 331

1. value-ն կլինի 14՝ 2 * 7-ի արդյունքը, քանի որ փակագծերը պարտադրում են գումարումը կատարել բազմապատկումից առաջ։

2. value-ն կլինի 10՝ 6 + 4-ի արդյունքը։ Փակագծերի բացակայության դեպքում կիրառվում են Python-ի operator-ների precedence-ի կանոնները, և բազմապատկումն ավելի բարձր precedence ունի, քան գումարումը (այսինքն՝ կատարվում է դրանից առաջ), ինչպես ցույց է տրված Աղյուսակ 5-2-ում։

Սկզբնաղբյուրի PDF էջ 332

3. Այս expression-ը տալիս է 14՝ 2 + 12-ի արդյունքը, նույն precedence-ի պատճառներով, ինչ նախորդ հարցում։

4. Քառակուսի արմատը, ինչպես նաև pi-ն, տանգենսները և ավելին ստանալու function-ները հասանելի են ներմուծվող math module-ում։ Թվի քառակուսի արմատը գտնելու համար կատարեք import math և կանչեք math.sqrt(N)։ Թվի քառակուսին ստանալու համար օգտագործեք կա՛մ X 2 աստիճանի expression-ը, կա՛մ built-in pow(X, 2) function-ը։ Վերջին երկուսից յուրաքանչյուրը կարող է նաև քառակուսի արմատ հաշվել, եթե տրվի 0.5 աստիճան (օրինակ՝ X .5)։

5. Արդյունքը կլինի float․ ամբողջ թվերը փոխարկվում են floating-point type-ի՝ expression-ի ամենաբարդ type-ին, և այն հաշվելու համար օգտագործվում է floating-point մաթեմատիկա։

6. int(N) և math.trunc(N) function-ները կտրում են, իսկ round(N, digits) function-ը կլորացնում է։ Կարող ենք նաև math.floor(N)-ով հաշվել ներքև կլորացված ամբողջը և ցուցադրման համար կլորացնել string-ի ձևաչափման գործողություններով։

7. float(I) function-ն ամբողջ թիվը փոխարկում է floating-point թվի․ expression-ի մեջ ամբողջ և floating-point թվերը խառնելն էլ կհանգեցնի փոխարկման։ Ինչ-որ իմաստով Python-ի / իրական բաժանումը նույնպես փոխարկում է․ այն միշտ վերադարձնում է մնացորդը ներառող floating-point արդյունք, նույնիսկ եթե երկու operand-ներն էլ ամբողջ թվեր են։

8. built-in oct(I), hex(I) և bin(I) function-ները վերադարձնում են ամբողջ թվի ութական, տասնվեցական և երկուական string

Սկզբնաղբյուրի PDF էջ 333

ձևերը։ string-ի ձևաչափման բոլոր երեք տարբերակները (expression, method և f-string) նույնպես տրամադրում են ձևաչափման նշումներ այսպիսի որոշ փոխարկումների համար։

9. int(S, base) function-ը կարելի է օգտագործել ութական, տասնվեցական և երկուական թվանշանների string-երը սովորական ամբողջ թվերի փոխարկելու համար (base-ի համար փոխանցեք 8, 16 կամ 2)։ eval(S) function-ը նույնպես կարող է օգտագործվել այս նպատակով, բայց դրա կատարումն ավելի ծախսատար է և կարող է անվտանգության ռիսկեր ունենալ։ Որոշ չափով ձեր code-ի՝ այլ հիմքերով literal-ները, օրինակ՝ 0xFFFF-ն ու 0b1111-ը, նույնպես այս աշխատանքն անում են, երբ Python-ը կարդում է դրանք։ Նկատի ունեցեք, որ ամբողջ թվերը համակարգչի memory-ի մեջ միշտ պահվում են երկուական ձևով․ սրանք ընդամենը ցուցադրման string ձևաչափերի փոխարկումներ են։

6․ dynamic typing-ի միջանկյալ քննարկում

a · b · list [1, 2] · c → [1, 2] · Նույն արժեքը և նույն object-ը նույն հարցը չեն։ablist [1, 2]c → [1, 2]Նույն արժեքը և նույն object-ը նույն հարցը չեն։

Սկզբնաղբյուրի PDF էջ 334

Նախորդ գլխում սկսեցինք խորությամբ ուսումնասիրել Python-ի հիմնական object type-երը՝ դիտարկելով Python-ի թվերն ու դրանց գործողությունները։ object type-երի մեր շրջայցը կվերսկսենք հաջորդ գլխում, բայց առաջ անցնելուց առաջ կարևոր է, որ հասկանաք այն գաղափարը, որը թերևս Python-ով programming-ի ամենահիմնարարն է և հաստատ Python լեզվի թե՛ հակիրճության, թե՛ ճկունության զգալի մասի հիմքն է․ dynamic typing-ը և դրանից բխող բազմաձևությունը։

Ինչպես կտեսնեք այստեղ և ամբողջ գրքում, Python-ում կարիք չկա հայտարարելու մեր script-ների օգտագործած object-ների կոնկրետ type-երը։ Իրականում program-երի մեծ մասը դիտավորյալ չպետք է մտահոգվի կոնկրետ type-երով։ Այս կերպ սահմանափակումներից խուսափելով՝ code-ը բնականորեն աշխատում է բազմաթիվ համատեքստերում և հաճախ՝ սպասվածից ավելի շատ դեպքերում։ Քանի որ dynamic typing-ն այս ճկունության հիմքն է և միաժամանակ հնարավոր դժվարություն է սկսնակների համար, այստեղ համառոտ շեղվենք՝ մոդելն ուսումնասիրելու համար։ Այդ շրջայցի վերջում նաև կարճ կանգ կառնենք type hint-ների պարադոքսի մոտ՝ իմանալու, թե ինչու պետք է խուսափեք դրանցից։

Սկզբնաղբյուրի PDF էջ 335

Եթե փորձ ունեք C-ի, C++-ի կամ Java-ի նման ստատիկ typed լեզուներով, գրքի այս պահին կարող եք մի փոքր շփոթված լինել։ Մինչ այժմ variable-ներ էինք օգտագործում՝ առանց դրանց գոյությունը կամ type-երը հայտարարելու, և ինչ-որ կերպ դա աշխատում է։ Օրինակ՝ երբ ինտերակտիվ նիստում կամ program-ի file-ում մուտքագրում ենք a = 3, Python-ն ինչպե՞ս է իմանում, որ a-ն պետք է ամբողջ թիվ նշանակի։ Եվ առհասարակ՝ Python-ն ինչպե՞ս է իմանում, թե a-ն ընդհանրապես ինչ է։

Երբ սկսում եք նման հարցեր տալ, արդեն մտել եք Python-ի dynamic typing-ի մոդելի տիրույթ։ Python-ում type-երն ինքնաշխատ որոշվում են runtime («դինամիկորեն»), այլ ոչ թե code-ում նախապես ավելացված հայտարարությունների հիման վրա («ստատիկորեն»)։ Սա նշանակում է, որ երբեք կարիք չկա variable-ներ հայտարարելու․ գաղափար, որը գուցե ավելի հեշտ լինի հասկանալ, եթե հիշեք, որ ամեն ինչ հանգում է variable-ներին, object-ներին և դրանց միջև կապերին, ինչպես բացատրում է հաջորդ բաժինը։

Սկզբնաղբյուրի PDF էջ 336

Ինչպես տեսել եք այս գրքում մինչ այժմ օգտագործված բազմաթիվ օրինակներում, երբ Python-ում կատարում եք a = 3-ի նման assignment-ի statement, այն աշխատում է, նույնիսկ եթե Python-ին երբեք չեք ասել, որ a name-ն օգտագործի որպես variable կամ որ a-ն պետք է նշանակի ամբողջ numeric type-ի object։ Python լեզվում այս ամենն իրականացվում է շատ բնական ձևով՝ հետևյալ կերպ․

variable-ի ստեղծումը

a-ի նման variable-ը (որը Python-ում նաև կոչվում է name) ստեղծվում է, երբ ձեր code-ն առաջին անգամ դրան value է assignment։ Հետագա assignment-ները փոխում են արդեն ստեղծված name-ի value-ն։ Տեխնիկապես Python-ը որոշ name-ներ հայտնաբերում է նախքան code-ի կատարումը (օրինակ՝ function-ների տեղային name-ները), բայց կարող եք պատկերացնել, որ հենց առաջին assignment-ներն են ստեղծում variable-ները։
variable-ների type-երը

variable-ն ինքնին երբեք իր հետ կապված type տեղեկություն կամ սահմանափակումներ չունի։ Python-ում type-ի գաղափարը վերաբերում է object-ներին, ոչ թե name-ներին։ variable-ներն իրենց բնույթով ընդհանուր են․ դրանք միշտ պարզապես հղվում են ժամանակի տվյալ պահին որոշակի object-ի։
variable-ի օգտագործումը

Սկզբնաղբյուրի PDF էջ 337

Երբ variable-ը հայտնվում է expression-ի մեջ, այն անմիջապես փոխարինվում է այն object-ով, որին տվյալ պահին հղվում է՝ ինչ էլ այն լինի։ Բացի այդ՝ բոլոր variable-ներին օգտագործելուց առաջ պետք է բացահայտ արժեք վերագրել․ արժեք չստացած variable-ներին դիմելը հանգեցնում է սխալների։

Ամփոփելով՝ variable-ները ստեղծվում են assignment-ի ժամանակ, կարող են հղվել ցանկացած type-ի object-ի, և դրանց պետք է արժեք վերագրել նախքան դրանց դիմելը։ Սա նշանակում է, որ երբեք կարիք չկա հայտարարելու ձեր script-ի օգտագործած name-ները, բայց դրանք թարմացնելուց առաջ պետք է սկզբնարժեքավորեք․ օրինակ՝ հաշվիչները պետք է սկզբնարժեքավորել զրոյով, մինչև կարողանաք դրանց գումարել։

dynamic typing-ի այս մոդելն ակնհայտորեն տարբերվում է ավանդական լեզուների typing-ի մոդելից։ Երբ նոր եք սկսում, մոդելը սովորաբար ավելի հեշտ է հասկանալ, եթե հստակ տարբերակեք name-ներն ու object-ները։ Օրինակ՝ երբ Python-ի REPL-ում կամ script-ում variable-ին value վերագրելու համար ասում ենք հետևյալը՝

Գրքի code · PDF էջ 337

  >>> a = 3                # Assign a name to an ob

Մեկնաբանություն, տող 1․ name-ը վերագրել օբ…

առնվազն գաղափարական մակարդակում Python-ը հարցումն իրականացնելու համար կկատարի երեք առանձին քայլ։ Այս քայլերն արտացոլում են Python լեզվի բոլոր assignment-ների աշխատանքը․

Սկզբնաղբյուրի PDF էջ 338

1. Ստեղծել object՝ 3 value-ն ներկայացնելու համար։

2. Ստեղծել a variable-ը, եթե այն դեռ գոյություն չունի։

3. a variable-ը կապել նոր 3 object-ին։

Վերջնական արդյունքը կլինի Python-ի ներսում Նկար 6-1-ին նման կառուցվածք։ Ինչպես պատկերված է, variable-ներն ու object-ները պահվում են memory-ի տարբեր մասերում և կապվում են կապերով (նկարում կապը ցուցադրված է որպես ցուցիչ)։ variable-ները միշտ կապված են object-ների, երբեք՝ այլ variable-ների հետ, բայց ավելի մեծ object-ները կարող են կապված լինել այլ object-ների հետ (օրինակ՝ list-ի object-ն ունի կապեր իր պարունակած object-ներին)։

Սկզբնաղբյուրի պատկեր, PDF էջ 338
Սկզբնաղբյուրի պատկեր · PDF էջ 338

Նկար 6-1. name-ները (այլ կերպ՝ variable-ները) և object-ները a = 3 assignment-ը կատարելուց հետո

variable-ներից դեպի object-ներ այս կապերը Python-ում կոչվում են reference-ներ․ սա կապի տեսակ է, որն իրականացված է որպես object-ի հասցե memory-ի մեջ։ Ամեն անգամ, երբ հետագայում variable-ներն օգտագործվում են (այսինքն՝

Սկզբնաղբյուրի PDF էջ 339

դրանց դիմում են), Python-ն ինքնաշխատ հետևում է variable-ից object կապերին։ Այս ամենն ավելի պարզ է, քան տերմինաբանությունը կարող է ենթադրել։ Մասնավորապես՝

variable-ները համակարգային աղյուսակի անվանված տարրեր են՝ object-ներին տանող կապերի համար տեղերով։
object-ները հատկացված memory-ի մասեր են՝ իրենց ներկայացրած value-ները պահելու բավարար տարածքով։
reference-ները variable-ներից object-ներ տանող ցուցիչներ են, որոնց ինքնաշխատ հետևում են։

Առնվազն գաղափարական մակարդակում՝ ամեն անգամ, երբ ձեր script-ում expression կատարելով նոր value եք ստեղծում, Python-ն այդ value-ն ներկայացնելու համար ստեղծում է նոր object (այսինքն՝ memory-ի հատված)։ Որպես օպտիմալացում՝ Python-ը ներքին մակարդակում caching և վերօգտագործում է որոշ տեսակի immutable object-ներ, օրինակ՝ փոքր ամբողջ թվերն ու string-երը (յուրաքանչյուր 0-ն իրականում memory-ի նոր հատված չէ․ այս caching-ի վարքագծի մասին ավելին՝ ավելի ուշ)։ Բայց տրամաբանական տեսանկյունից այն աշխատում է այնպես, կարծես յուրաքանչյուր expression-ի արդյունքի value-ն առանձին object է, իսկ յուրաքանչյուր object՝ memory-ի առանձին հատված։

Տեխնիկապես ասած՝ object-ներն ավելի շատ կառուցվածք ունեն, քան պարզապես իրենց value-ները ներկայացնելու բավարար տարածքը։ Յուրաքանչյուր object ունի նաև վերնամասի երկու ստանդարտ դաշտ՝ type-ի նշանակիչ, որն օգտագործվում է object-ի type-ը նշելու համար, և reference counter, որն օգտագործվում է որոշելու, թե երբ

Սկզբնաղբյուրի PDF էջ 340

կարելի է ազատել object-ի memory-ն։ Հասկանալու համար, թե վերնամասի այս երկու դաշտերն ինչպես են մասնակցում մոդելին, պետք է առաջ անցնենք։

PYTHON-Ի reference-ները՝ C programmer-ների ՀԱՄԱՐ
C-ի փորձ ունեցող ընթերցողներին Python-ի reference-ները կարող են նման թվալ C-ի ցուցիչներին (այսինքն՝ memory-ի հասցեներին)։ Իրականում CPython-ի ներսում reference-ներն իրականացվում են որպես ցուցիչներ, և դրանք հաճախ նույն դերերն են կատարում, հատկապես տեղում mutable object-ների հետ (այս մասին ավելին՝ հետագայում)։

Բայց քանի որ օգտագործվելիս reference-ներով միշտ ինքնաշխատ անցում է կատարվում դեպի object-ը, reference-ի հետ անմիջապես երբեք չեք կարող իրականում օգտակար բան անել։ Ինչպես նշվում է ստորև, built-in id գործիքը կարող է որպես եզակի նույնացուցիչ վերադարձնել հղվող object-ի հասցեն, բայց նույնիսկ սա երաշխավորված չէ․ տե՛ս Python-ի ձեռնարկները։

Ցուցիչների այս բացակայությունը վերացնում է C-ի տխրահռչակ սխալների մի ամբողջ կատեգորիա։ Բայց առանց ճշմարտությունից շատ հեռանալու՝ Python-ի reference-ները կարող եք պատկերացնել որպես C-ի «void*» ցուցիչներ, որոնց օգտագործելիս ինքնաշխատ հետևում են։

Սկզբնաղբյուրի PDF էջ 341

Տեսնելու համար, թե ինչպես են դեր խաղում object-ների type-երը, հետևեք՝ ինչ է տեղի ունենում, երբ variable-ին մի քանի անգամ արժեք ենք assignment։

Գրքի code · PDF էջ 341

  >>> a = 3              # It's an integer
  >>> a = 'hack'         # Now it's a string
  >>> a = 1.23           # Now it's a floating poin

Մեկնաբանություն, տող 1․ Այն ամբողջ թիվ է

Մեկնաբանություն, տող 2․ Հիմա այն string է

Մեկնաբանություն, տող 3․ Հիմա այն լողացող կե…

Սա Python-ի բնորոշ code չէ, բայց աշխատում է. a-ն սկզբում ամբողջ թիվ է, հետո դառնում է string, իսկ վերջում՝ float։ Այս օրինակը հատկապես տարօրինակ է թվում C-ի նախկին programmer-ներին, քանի որ թվում է՝ a-ի type-ն ամբողջ թվից փոխվում է string-ի, երբ գրում ենք a = 'hack'։

Սակայն իրականում տեղի ունեցողը դա չէ։ Python-ում ամեն ինչ ավելի պարզ է աշխատում։ name-ները type-եր չունեն. ինչպես արդեն ասվեց, type-երը պատկանում են object-ներին, ոչ թե name-ներին։ Նախորդ list-ում մենք պարզապես փոխեցինք a-ն այնպես, որ այն հղվի տարբեր object-ների։ Քանի որ variable-ները type չունեն, իրականում a variable-ի type-ը չենք փոխել. պարզապես variable-ը դարձրել ենք այլ type-ի object-ի reference։ Իրականում կրկին՝ Python-ում variable-ի մասին երբևէ կարող ենք ասել միայն այն, որ ժամանակի որոշակի պահին այն հղվում է որոշակի object-ի։

Սկզբնաղբյուրի PDF էջ 342

Մինչդեռ object-ները գիտեն իրենց type-ը. յուրաքանչյուր object պարունակում է գլխամասի դաշտ, որը նշում է դրա type-ը։ Օրինակ՝ ամբողջ թվի 3 object-ը կպարունակի 3 value-ն և նշիչ, որը Python-ին ասում է, որ object-ն ամբողջ թիվ է։ Խիստ ասած՝ դա ցուցիչ է դեպի int կոչվող object-ը՝ ամբողջ թվերի type-ի name-ը։ Իսկ 'hack' string object-ի type-ի նշիչը հղվում է string-ի type-ին՝ str name-ով, իսկ 1.23-ինը՝ float-ին։ Քանի որ object-ները գիտեն իրենց type-երը, variable-ներն իմանալու կարիք չունեն։

Կրկնենք՝ Python-ում type-երը կապված են object-ների, ոչ թե variable-ների հետ։ Սովորական code-ում տվյալ variable-ը սովորաբար կհղվի object-ների միայն մեկ տեսակի։ Սակայն, քանի որ սա պահանջ չէ, կտեսնեք, որ Python code-ը սովորաբար զգալիորեն ավելի ճկուն է, քան գուցե սովոր եք։ Եթե Python-ը լավ օգտագործեք, ձեր code-ը կարող է ինքնաբերաբար աշխատել բազմաթիվ type-երի հետ։

Ինչպես նշվեց, object-ների գլխամասում կա երկու դաշտ՝ type-ի նշիչ և reference counter։ Վերջինս հասկանալու համար պետք է առաջ անցնենք և հակիրճ նայենք, թե ինչ է տեղի ունենում object-ի կյանքի վերջում։

Սկզբնաղբյուրի PDF էջ 343

Նախորդ բաժնի list-ներում յուրաքանչյուր assignment-ի ժամանակ a variable-ը կապակցում էինք տարբեր type-երի object-ների։ Բայց variable-ին նոր value վերագրելիս ի՞նչ է լինում այն value-ի հետ, որին այն նախկինում հղվում էր։ Օրինակ՝ հետևյալ statement-ներից հետո ի՞նչ է լինում 3 object-ի հետ։

Գրքի code · PDF էջ 343

  >>> a = 3
  >>> a = 'text'

Պատասխանն այն է, որ Python-ում, երբ name-ը վերագրվում է նոր object-ի, նախկին object-ի զբաղեցրած տարածքն ազատվում է, եթե դրան չի հղվում որևէ այլ name կամ object։ object-ների տարածքի այս ավտոմատ ազատումը հայտնի է որպես garbage collection և կյանքը շատ ավելի հեշտ է դարձնում այն աջակցող լեզուների, օրինակ՝ Python-ի programmer-ների համար։

Պարզաբանելու համար դիտարկեք հետևյալ օրինակը, որը յուրաքանչյուր assignment-ի ժամանակ x name-ը կապակցում է մեկ այլ object-ի։

Գրքի code · PDF էջ 343

  >>> x = 99
  >>> x = 'Python'               # Reclaim 99 now

Մեկնաբանություն, տող 2․ Հիմա ազատել 99-ը

Սկզբնաղբյուրի PDF էջ 344

Գրքի code · PDF էջ 344

  >>> x = 3.1415                 # Reclaim 'Python
  >>> x = [1, 2, 3]              # Reclaim 3.1415 n

Մեկնաբանություն, տող 1․ Ազատել 'Python [կտրված է]

Մեկնաբանություն, տող 2․ Ազատել 3.1415-ը n… [կտրված է]

Նախ նկատեք, որ x-ն ամեն անգամ կապակցվում է այլ type-ի object-ի։ Կրկին՝ ազդեցությունն այնպիսին է, կարծես x-ի type-ը ժամանակի ընթացքում փոխվում է, բայց իրականում այդպես չէ։ Հիշեք՝ Python-ում type-երը պատկանում են object-ներին, ոչ թե name-ներին։ Քանի որ name-ներն ընդամենը object-ների ընդհանուր նշանակության reference-ներ են, այսպիսի code-ը բնականորեն աշխատում է։

Երկրորդ՝ նկատեք, որ ընթացքում object-ների reference-ները դեն են նետվում։ Ամեն անգամ, երբ x-ը վերագրվում է նոր object-ի, Python-ն ազատում է նախկին object-ի տարածքը։ Օրինակ՝ երբ դրան վերագրվում է 'Python' string-ը, 99 object-ն անմիջապես ազատվում է՝ ենթադրելով, որ ուրիշ տեղից դրան reference չկա։ Այսինքն՝ object-ի տարածքն ինքնաբերաբար վերադարձվում է ազատ տարածքի պաշարին՝ ապագա object-ի համար կրկին օգտագործվելու նպատակով։

Ներքին իրականացման մեջ Python-ն այս ամենն անում է՝ յուրաքանչյուր object-ում պահելով հաշվիչ, որը հետևում է տվյալ պահին այդ object-ին ուղղված reference-ների քանակին։ Հենց այս հաշվիչը զրո է դառնում, և ճիշտ այդ պահին, object-ի memory-ի տարածքն ինքնաբերաբար ազատվում է։ Նախորդ list-ում ենթադրում ենք, որ ամեն անգամ, երբ x-ը վերագրվում է նոր object-ի,

Սկզբնաղբյուրի PDF էջ 345

նախկին object-ի reference counter-ը դառնում է զրո՝ հանգեցնելով դրա ազատմանը։

garbage collection-ի ամենաանմիջական ու շոշափելի առավելությունն այն է, որ կարող եք object-ներն ազատորեն օգտագործել՝ երբեք կարիք չունենալով ձեր script-ում տարածք հատկացնել կամ ազատել։ program-ի աշխատանքի ընթացքում Python-ը ձեր փոխարեն կհոգա object-ների չօգտագործվող տարածքի մաքրման մասին։ Գործնականում սա վերացնում է հաշվառման code-ի զգալի մասը, որն անհրաժեշտ է C-ի և C++-ի նման ցածր մակարդակի լեզուներում։

Սկզբնաղբյուրի PDF էջ 346

ԱՎԵԼԻՆ PYTHON-Ի garbage collection-ի ՄԱՍԻՆ
Տեխնիկապես Python-ի garbage collection-ը հիմնականում հիմնված է reference counter-ների վրա, ինչպես նկարագրված է այստեղ, բայց այն ունի նաև բաղադրիչ, որը ժամանակի ընթացքում հայտնաբերում և ազատում է circular reference-ներով object-ները։ Այս բաղադրիչը կարելի է անջատել, եթե վստահ եք, որ ձեր code-ը cycle-եր չի ստեղծում, բայց լռելյայն այն միացված է։ Ե՛վ reference-ների հաշվառումը, և՛ այս ոչ պարտադիր բաղադրիչը կատարում են garbage collection, բայց վերջինը կարող է լինել այն, ինչ reference counter-ներ չունեցող որոշ այլ լեզուների օգտագործողները հասկանում են «garbage collection» ասելով։

Շրջանաձև reference-ները դասական խնդիր են reference counter-ների վրա հիմնված garbage collector-ներում։ Քանի որ reference-ներն իրականացված են որպես ցուցիչներ, object-ը կարող է հղվել ինքն իրեն կամ հղվել մեկ այլ object-ի, որն իր հերթին հղվում է նրան։ Օրինակ՝ «Ստուգեք ձեր գիտելիքները. մաս I-ի վարժություններ» բաժնի 6-րդ վարժությունն ու դրա լուծումը հավելված B-ում ցույց են տալիս, թե ինչպես հեշտությամբ ստեղծել cycle՝ list-ի մեջ ներդնելով հենց այդ list-ի reference-ը, օրինակ՝ L.append(L)։ Նույն երևույթը կարող է առաջանալ օգտագործողի սահմանած class-երից ստեղծված object-ների attribute-ներին արժեք վերագրելիս։ Թեև համեմատաբար հազվադեպ են հանդիպում, նման object-ների reference counter-ները երբեք զրո չեն դառնում, ուստի դրանց հետ պետք է հատուկ կերպով վարվել։

Python-ի cycle-երի հայտնաբերիչի և garbage collector-ի մասին ավելի մանրամասն տեղեկությունների համար տե՛ս gc module-ի փաստաթղթերը Python-ի library-ի

Սկզբնաղբյուրի PDF էջ 347

ձեռնարկում։ Այստեղ ամենակարևոր միտքն այն է, որ Python-ում garbage collection-ի վրա հիմնված memory management-ն իրականացված է ձեր փոխարեն՝ այդ գործում բարձր հմտություն ունեցող մարդկանց կողմից։ Այն լավ է աշխատում՝ նույնիսկ cycle-երի դեպքում։

Նկատեք նաև, որ Python-ի garbage collector-ի՝ այս գլխի նկարագրությունը լեզվի սահմանման մաս չէ և վերաբերում է միայն Python-ի ստանդարտ implementation-ին՝ նաև CPython կոչվողին։ Գլուխ 2-ի այլընտրանքային implementation-ները, օրինակ՝ Jython-ը, IronPython-ը և PyPy-ն, կարող են օգտագործել այլ սխեմաներ, թեև բոլորի վերջնական ազդեցությունը նման է. չօգտագործվող տարածքը ձեր փոխարեն ազատվում է ինքնաբերաբար, թեկուզ ոչ միշտ նույնքան անմիջապես։

Մինչ այժմ ուսումնասիրել ենք, թե ինչ է տեղի ունենում, երբ մեկ variable-ի վերագրվում են object-ների reference-ներ։ Այժմ մեր փոխազդեցության մեջ ներմուծենք ևս մեկ variable և հետևենք, թե ինչ է լինում name-ների ու object-ների հետ։

Գրքի code · PDF էջ 347

  >>> a = 3
  >>> b = a

Սկզբնաղբյուրի PDF էջ 348

Այս երկու statement-ները մուտքագրելը ստեղծում է նկար 6-2-ում ներկայացված պատկերը։ Երկրորդ հրամանը ստիպում է Python-ին ստեղծել b variable-ը։ Այստեղ a variable-ն օգտագործվում է, ոչ թե արժեք ստանում, ուստի փոխարինվում է այն object-ով, որին հղվում է՝ 3-ով, և b-ն դարձվում է այդ object-ի reference։ Վերջնական արդյունքն այն է, որ a և b variable-ները հղվում են նույն object-ին, այսինքն՝ մատնանշում են memory-ի նույն հատվածը։

Սկզբնաղբյուրի պատկեր, PDF էջ 348
Սկզբնաղբյուրի պատկեր · PDF էջ 348

Նկար 6-2. name-ներն ու object-ները հաջորդ՝ b = a assignment-ը կատարելուց հետո

Python-ում այս իրավիճակը, երբ մի քանի name հղվում է նույն object-ին, սովորաբար կոչվում է shared reference, երբեմն էլ, գուցե ավելի ճշգրիտ, համատեղ object։ Նկատեք, որ երբ դա տեղի է ունենում, a և b name-ներն անմիջապես միմյանց չեն կապվում։ Իրականում Python-ում երբեք հնարավոր չէ մի

Սկզբնաղբյուրի PDF էջ 349

variable-ն ուղղակիորեն կապել մեկ այլ variable-ի։ Փոխարենը երկու variable-ներն էլ իրենց reference-ներով մատնանշում են նույն object-ը։

Այժմ ենթադրենք՝ սեանսն ընդլայնում ենք ևս մեկ statement-ով։

Գրքի code · PDF էջ 349

  >>> a = 3
  >>> b = a
  >>> a = 'hack'

Ինչպես Python-ի բոլոր assignment-ները, այս statement-ը պարզապես նոր object է ստեղծում 'hack' string value-ն ներկայացնելու համար և a-ն կապակցում է այդ նոր object-ին։ Սակայն այն չի փոխում b-ի value-ն. b-ն շարունակում է հղվել սկզբնական object-ին՝ ամբողջ թվի 3-ին։ Ստացված reference-ների կառուցվածքը ցույց է տրված նկար 6-3-ում։

Սկզբնաղբյուրի PDF էջ 350

Սկզբնաղբյուրի պատկեր, PDF էջ 350
Սկզբնաղբյուրի պատկեր · PDF էջ 350

Նկար 6-3. name-ներն ու object-ները վերջին՝ a = 'hack' assignment-ը կատարելուց հետո

Նույն բանը տեղի կունենար, եթե փոխարենը b-ն փոխեինք 'hack'-ի. assignment-ը կփոխեր միայն b-ն, ոչ թե a-ն։ Այս վարքը գործում է նաև այն դեպքում, երբ type-երի տարբերություն ընդհանրապես չկա։ Օրինակ՝ դիտարկեք այս երեք statement-ները։

Գրքի code · PDF էջ 350

  >>> a = 3
  >>> b = a
  >>> a = a + 2

Այս sequence-ի մեջ տեղի են ունենում նույն իրադարձությունները։ Python-ը a variable-ը դարձնում է 3 object-ի reference, իսկ b-ն՝ նույն object-ի reference, ինչ a-ն, ինչպես նկար 6-2-ում։ Ինչպես նախկինում, վերջին assignment-ն ապա a-ն կապակցում է բոլորովին այլ object-ի՝ այս

Սկզբնաղբյուրի PDF էջ 351

դեպքում ամբողջ թվի 5-ին, որը + expression-ի արդյունքն է։ Այն որպես կողմնակի ազդեցություն չի փոխում b-ն։ Իրականում 3 object-ի value-ն վերագրելու որևէ եղանակ երբեք չկա. ինչպես ներկայացվել է գլուխ 4-ում, ամբողջ թվերն immutable են, ուստի երբեք չեն կարող տեղում փոփոխվել։ Տեսնո՞ւմ եք՝ ինչու են այս մանրամասները կարևոր։ Միակ բանը, որ երբևէ կարող ենք անել, ամբողջ թվի նոր object ստեղծելն է։

Սա պատկերացնելու մի եղանակն այն է, որ, ի տարբերություն որոշ լեզուների, Python-ում variable-ները միշտ object-ների ցուցիչներ են, ոչ թե mutable memory-ի հատվածների պիտակներ։ variable-ին նոր value տալը սկզբնական object-ը չի փոխում, այլ variable-ը դարձնում է բոլորովին այլ object-ի reference։ Վերջնական արդյունքն այն է, որ հենց variable-ին value վերագրելը կարող է ազդել միայն այն մեկ variable-ի վրա, որն value է ստանում։ Սակայն, երբ գործի մեջ են մտնում mutable object-ներն ու տեղում փոփոխությունները, պատկերը փոքր-ինչ փոխվում է։ Տեսնելու համար, թե ինչպես, առաջ անցնենք։

Ինչպես ավելի մանրամասն կսովորեք այս մասի առաջիկա գլուխներում, որոշ գործողություններ իսկապես տեղում փոփոխում են object-ները, բայց դրանք աջակցվում են միայն Python-ի mutable type-երի կողմից՝ ներառյալ list-ները, dictionary-ներն ու set-ները։ Օրինակ՝ list-ի որևէ շեղման դիրքին արժեք վերագրելը իրականում տեղում փոխում է հենց list-ի object-ը՝ լրիվ նոր list-ի object ստեղծելու փոխարեն։

Սկզբնաղբյուրի PDF էջ 352

Թեև գրքի այս պահին սա որոշ չափով պետք է ընդունեք վստահությամբ, այս տարբերակումը կարող է շատ կարևոր լինել ձեր program-երում։ Նման տեղում փոփոխություններ աջակցող object-ների դեպքում պետք է ավելի ուշադիր լինեք shared reference-ների նկատմամբ, քանի որ մեկ name-ով կատարված փոփոխությունը կարող է ազդել մյուսների վրա։ Հակառակ դեպքում կարող է թվալ, թե ձեր object-ները փոփոխվում են առանց ակնհայտ պատճառի։ Հաշվի առնելով, որ բոլոր assignment-ները հիմնված են reference-ների վրա՝ ներառյալ function-ի argument-ների փոխանցումը, սա ամենուր հանդիպող երևույթ է։

Պարզաբանելու համար ևս մեկ անգամ նայենք գլուխ 4-ում ներկայացված list object-ներին։ Հիշեք, որ list-ները, որոնք իսկապես աջակցում են դիրքերին արժեքների տեղում assignment, պարզապես այլ object-ների հավաքածուներ են՝ գրված քառակուսի փակագծերով։

Գրքի code · PDF էջ 352

  >>> L1 = [2, 3, 4]
  >>> L2 = L1

Այստեղ L1-ը 2, 3 և 4 object-ները պարունակող list է։ list-ի ներսի տարրերին դիմում են ըստ դրանց դիրքային շեղումների, ուստի L1[0]-ն հղվում է 2 object-ին՝ L1 list-ի առաջին տարրին։ Իհարկե, list-ներն իրենք էլ ինքնուրույն object-ներ են՝ ճիշտ ինչպես ամբողջ թվերն ու string-երը։ Նախորդ երկու assignment-ները կատարելուց հետո L1-ը և L2-ը հղվում են նույն համատեղ object-ին՝ ճիշտ ինչպես նախորդ օրինակի a-ն և b-ն

Սկզբնաղբյուրի PDF էջ 353

(տե՛ս նկար 6-2)։ Այժմ պատկերացրեք, որ, ինչպես նախկինում, այս փոխազդեցությունն ընդլայնում ենք հետևյալով։

Գրքի code · PDF էջ 353

  >>> L1 = 24

Այս assignment-ը պարզապես L1-ը կապակցում է այլ object-ի։ L2-ը շարունակում է հղվել սկզբնական list-ին՝ մոտավորապես ինչպես նախորդ բաժնում։ Սակայն, եթե այս statement-ի syntax-ը մի փոքր փոխենք, դրա ազդեցությունն արմատապես կփոխվի։

Գրքի code · PDF էջ 353

  >>> L1 = [2, 3, 4]         # A mutable object
  >>> L2 = L1                # Make a reference to
  >>> L1[0] = 24             # An in-place change

Մեկնաբանություն, տող 1․ mutable object

Մեկնաբանություն, տող 2․ Ստեղծել reference դեպի…

Մեկնաբանություն, տող 3․ Տեղում փոփոխություն

Գրքի code · PDF էջ 353

  >>> L1                     # L1 is different
  [24, 3, 4]
  >>> L2                     # But so is L2!
  [24, 3, 4]

Մեկնաբանություն, տող 1․ L1-ն այլ է

Մեկնաբանություն, տող 3․ Բայց L2-ը նույնպես։

Իրականում այստեղ երրորդ line-ում հենց L1-ը չենք փոխել. փոխել ենք այն object-ի բաղադրիչը, որին հղվում է L1-ը։ Այսպիսի փոփոխությունը տեղում վերագրում է list-ի object-ի value-ի մի մասը։ Սակայն, քանի որ list object-ը համատեղ օգտագործվում է այլ variable-ների կողմից, այսինքն՝ դրանք հղվում են դրան, այսպիսի տեղում փոփոխությունը չի ազդում

Սկզբնաղբյուրի PDF էջ 354

միայն L1-ի վրա։ Այսինքն՝ պետք է գիտակցեք, որ նման փոփոխություններ անելիս դրանք կարող են ազդել ձեր program-ի այլ մասերի վրա։ Այս օրինակում ազդեցությունը երևում է նաև L2-ում, քանի որ այն հղվում է նույն object-ին, ինչ L1-ը։ Կրկին՝ իրականում L2-ն էլ չենք փոխել, բայց դրա value-ն այլ կթվա, քանի որ այն հղվում է մի object-ի, որը տեղում վերագրվել է։

Այս վարքն առաջանում է միայն տեղում փոփոխություններ աջակցող mutable object-ների դեպքում և սովորաբար հենց ձեր ուզածն է, բայց պետք է իմանաք՝ ինչպես է այն աշխատում, որպեսզի անակնկալ չլինի։ Սա նաև ընդամենը լռելյայն վարքն է. եթե այն չեք ուզում, կարող եք Python-ին խնդրել object-ները պատճենել՝ reference-ներ ստեղծելու փոխարեն։ list-ը պատճենելու տարբեր եղանակներ կան, ներառյալ built-in list function-ը, list-ի copy method-ը և standard library-ի copy module-ը։ Թերևս ամենատարածված եղանակը սկզբից մինչև վերջ slicing-ն է։ slicing-ի մասին ավելին՝ գլուխներ 4-ում և 7-ում։

Գրքի code · PDF էջ 354

  >>> L1 = [2, 3, 4]
  >>> L2 = L1[:]             # Make a copy of L1 (o
  >>> L1[0] = 24

Մեկնաբանություն, տող 2․ Ստեղծել L1-ի պատճենը (o… [կտրված է]

Գրքի code · PDF էջ 354

  >>> L1
  [24, 3, 4]

Սկզբնաղբյուրի PDF էջ 355

Գրքի code · PDF էջ 355

  >>> L2                     # L2 is not changed th
  [2, 3, 4]

Մեկնաբանություն, տող 1․ L2-ը չի փոխվում՝ th… [կտրված է]

Այստեղ L1-ի միջոցով կատարված փոփոխությունը չի արտացոլվում L2-ում, քանի որ L2-ը հղվում է L1-ի հղված object-ի պատճենին, ոչ թե բնօրինակին։ Այսինքն՝ երկու variable-ները մատնանշում են տարբեր object-ներ և memory-ի տարբեր հատվածներ։

Նկատեք, որ slicing-ի այս հնարքը չի աշխատի մյուս հիմնական mutable type-երի՝ dictionary-ների և set-ների համար, քանի որ դրանք sequence-ներ չեն։ dictionary կամ set պատճենելու համար փոխարենը օգտագործեք դրանց X.copy() method call-ը, որն ունեն նաև list-ները, կամ սկզբնական object-ը փոխանցեք դրանց type-երի name-ներին՝ dict և set։ Նաև նկատեք, որ standard library-ի copy module-ն ունի ցանկացած type-ի object ընդհանուր ձևով պատճենելու կանչ, ինչպես նաև ներդրված object կառուցվածքներ պատճենելու կանչ, օրինակ՝ ներսում list-ներ պարունակող dictionary-ն։

Գրքի code · PDF էջ 355

  import copy
  X = copy.copy(Y)          # Make top-level "shall
  X = copy.deepcopy(Y)      # Make deep copy of any

Մեկնաբանություն, տող 2․ Ստեղծել վերին մակարդակի «մակերե…

Մեկնաբանություն, տող 3․ Ստեղծել ցանկացած …-ի deep copy

list-ներն ու dictionary-ներն ավելի խորությամբ կուսումնասիրենք և shared reference-ների ու պատճենների գաղափարին կվերադառնանք գլուխներ 8-ում և

9-ում։ Առայժմ հիշեք, որ այն object-ները, որոնք հնարավոր է փոփոխել

Սկզբնաղբյուրի PDF էջ 356

տեղում, այսինքն՝ mutable object-ները, միշտ ենթակա են այսպիսի ազդեցությունների այն ցանկացած code-ում, որով անցնում են։ Python-ում սա ներառում է list-ները, dictionary-ները, set-ները և class statement-ներով սահմանված որոշ object-ներ։ Եթե նման վարքը ցանկալի չէ, պարզապես անհրաժեշտության դեպքում պատճենեք ձեր object-ները։

Ամբողջ պատկերը ներկայացնելու համար հարկ է նշել, որ այս գլխում ավելի վաղ նկարագրված garbage collection-ի վարքը որոշ type-երի համար կարող է ավելի շատ գաղափարական լինել, քան բառացի։ Դիտարկեք այս statement-ները։

Գրքի code · PDF էջ 356

  >>> x = 99
  >>> x = 'Python'          # Reclaim 99 now?

Մեկնաբանություն, տող 2․ Հիմա ազատե՞լ 99-ը

Քանի որ Python-ը, ինչպես ավելի վաղ նշվեց, caching և կրկին օգտագործում է փոքր ամբողջ թվերն ու կարճ string-երը, այստեղ 99 object-ը հավանաբար բառացիորեն չի ազատվում։ Փոխարենը այն, ամենայն հավանականությամբ, կմնա համակարգային աղյուսակում՝ կրկին օգտագործվելու հաջորդ անգամ, երբ ձեր code-ում ստեղծեք 99։ Սակայն object-ների մեծ մասը ազատվում է անմիջապես, երբ այլևս reference-ներ չկան։ Իսկ չազատվողների դեպքում caching-ի մեխանիզմը ձեր code-ի համար նշանակություն չունի, եթե չեք օգտագործում ոչ բնորոշ գործիքներ։

Սկզբնաղբյուրի PDF էջ 357

Օրինակ՝ Python-ի reference-ների մոդելի պատճառով Python program-ում հավասարությունը ստուգելու երկու տարբեր եղանակ կա։ Ցույց տալու համար ստեղծենք shared reference։

Գրքի code · PDF էջ 357

  >>> L = [1, 2, 3]
  >>> M = L                 # Make M and L referenc
  >>> L == M                # Same values
  True
  >>> L is M                # Same objects
  True

Մեկնաբանություն, տող 2․ M-ը և L-ը դարձնել հղո…

Մեկնաբանություն, տող 3․ Նույն value-ները

Մեկնաբանություն, տող 5․ Նույն object-ները

Այստեղ առաջին եղանակը՝ == operator-ը, ստուգում է, թե արդյոք երկու հղված object-ներն ունեն նույն value-ները։ Python-ում հավասարության ստուգումների համար գրեթե միշտ օգտագործվում է այս եղանակը։ Երկրորդը՝ is operator-ը, փոխարենը ստուգում է object-ների identity-ն։ Այն վերադարձնում է True միայն այն դեպքում, երբ երկու name-ներն էլ մատնանշում են հենց նույն object-ը։ Ուստի սա հավասարության ստուգման շատ ավելի խիստ ձև է և program-երի մեծ մասում հազվադեպ է կիրառվում՝ բացառությամբ նախորդ գլխում տեսած None-ի, True-ի և False-ի նման single-instance object-ների։

Իրականում is-ը պարզապես համեմատում է reference-ներն իրականացնող ցուցիչները և անհրաժեշտության դեպքում ծառայում է որպես ձեր code-ում shared reference-ները հայտնաբերելու միջոց։ Այն վերադարձնում է False, եթե name-ները մատնանշում են

Սկզբնաղբյուրի PDF էջ 358

համարժեք, բայց տարբեր object-ներ, ինչպես լինում է, երբ կատարում ենք երկու տարբեր literal expression։

Գրքի code · PDF էջ 358

  >>> L = [1, 2, 3]
  >>> M = [1, 2, 3]         # Make M and L referenc
  >>> L == M                # Same values
  True
  >>> L is M                # Different objects
  False

Մեկնաբանություն, տող 2․ M-ը և L-ը դարձնել հղո…

Մեկնաբանություն, տող 3․ Նույն value-ները

Մեկնաբանություն, տող 5․ Տարբեր object-ներ

Բայց հիմա տեսեք, թե ինչ է տեղի ունենում, երբ նույն գործողությունները կատարում ենք immutable object-ի՝ օրինակ ամբողջ թվի նկատմամբ։

Գրքի code · PDF էջ 358

  >>> X = 99
  >>> Y = 99                # Should be two differe
  >>> X == Y
  True
  >>> X is Y                # Same object anyhow: c
  True

Մեկնաբանություն, տող 2․ Պետք է լինեն երկու տարբե…

Մեկնաբանություն, տող 5․ Ամեն դեպքում նույն object-ը՝ c… [կտրված է]

Այս փոխազդեցության մեջ X-ը և Y-ը պետք է լինեն ==՝ նույն value-ով, բայց ոչ is՝ նույն object-ը, քանի որ կատարել ենք երկու տարբեր literal expression՝ 99։ Սակայն, քանի որ որոշ ամբողջ թվեր ու string-եր քեշավորվում

Սկզբնաղբյուրի PDF էջ 359

և կրկին օգտագործվում են, is-ը մեզ ասում է, որ դրանք հղվում են նույն՝ մեկ object-ին։

Եթե իսկապես ցանկանում եք նայել ներքին մեխանիզմներին, built-in id-ը object-ների identity-ն ստուգելու ևս մեկ միջոց է և կարող է վերադարձնել կամ չվերադարձնել object-ի հասցեն memory-ի մեջ։ Իսկ ստանդարտ sys module-ի getrefcount function-ը վերադարձնում է փոխանցված object-ի reference-ների քանակը։ Սակայն Python 3.12-ից սկսած՝ վերջինս այնքան հետաքրքիր չէ, որքան նախկինում, քանի որ շատ մեծ քանակ է վերադարձնում անմահ համարվող object-ների համար, ինչը Python-ում պարզապես նշանակում է cached՝ կրկին օգտագործվելու նպատակով։

Գրքի code · PDF էջ 359

  >>> import sys
  >>> sys.getrefcount(99)            # 99 is immort
  4294967295
  >>> sys.getrefcount(2 ** 1000)     # But this is
  1
  >>> id(99) == id(99)               # Same ID/same
  True

Մեկնաբանություն, տող 2․ 99-ն անմա… է

Մեկնաբանություն, տող 4․ Բայց սա … է

Մեկնաբանություն, տող 6․ Նույն ID-ն/նույն…

object-ների այս caching-ն ու վերաօգտագործումը ձեր code-ի համար նշանակություն չունեն, եթե is ստուգում չեք կատարում։ Քանի որ immutable թվերը կամ string-երը չեք կարող տեղում փոխել, կարևոր չէ, թե քանի reference կա նույն object-ին։ Յուրաքանչյուր reference միշտ կտեսնի նույն՝ չփոփոխվող value-ն, նույնիսկ եթե բոլորը

Սկզբնաղբյուրի PDF էջ 360

հղվում են նույն cached object-ին։ Այդուհանդերձ, այս վարքը ցույց է տալիս այն բազմաթիվ եղանակներից մեկը, որոնցով Python-ն օպտիմացնում է իր մոդելը կատարման արագության համար։

Իհարկե, Python օգտագործելու համար իրականում կարիք չկա շրջաններով և սլաքներով name-ների ու object-ների գծապատկերներ նկարելու։ Սակայն սկզբնական շրջանում անսովոր դեպքերը հասկանալուն երբեմն օգնում է, եթե կարողանում եք հետևել դրանց reference-ների կառուցվածքներին, ինչպես արեցինք այստեղ։ Օրինակ՝ եթե mutable object-ը ձեր program-ում փոխանցվելիս անսպասելիորեն փոխվում է, հավանաբար այս գլխի թեմաներից մեկին ականատես եք լինում անմիջականորեն։

Ավելին, նույնիսկ եթե dynamic typing-ն այս պահին մի փոքր վերացական է թվում, հավանաբար ի վերջո այն ձեզ համար կարևոր կդառնա։ Քանի որ Python-ում ամեն ինչ, կարծես, աշխատում է assignment-ների ու reference-ների միջոցով, այս մոդելի հիմունքները հասկանալն օգտակար է բազմաթիվ տարբեր համատեքստերում։ Ինչպես կտեսնեք, այն նույն կերպ է աշխատում assignment-ի statement-ներում, function-ների argument-ներում, for loop-ի variable-ներում, module-ների ներմուծումներում, class-երի attribute-ներում և այլուր։ Լավ լուրն այն է, որ Python-ում assignment-ի ընդամենը մեկ մոդել կա. երբ հասկանաք dynamic typing-ը, կտեսնեք, որ այն լեզվում ամենուր նույն կերպ է աշխատում։

Սկզբնաղբյուրի PDF էջ 361

Ամենագործնական մակարդակում dynamic typing-ը նշանակում է, որ դուք ավելի քիչ code ունեք գրելու։ Սակայն նույնքան կարևոր է, որ dynamic typing-ը նաև Python-ի բազմաձևության հիմքն է՝ հասկացություն, որը ներկայացվել է գլուխ 4-ում և որին գրքում ավելի ուշ կրկին կվերադառնանք։ Քանի որ Python code-ում type-երը չենք սահմանափակում, այն և՛ հակիրճ է, և՛ շատ ճկուն։ Ինչպես կտեսնեք, լավ օգտագործվելիս dynamic typing-ը և դրանից բխող բազմաձևությունը տալիս են code, որն ինքնաբերաբար հարմարվում է նոր պահանջներին՝ ձեր համակարգերի զարգացման ընթացքում։

Վերջում՝ սյուժեի անհավանական շրջադարձ։ Եթե կարդացել եք վերջին տարիներին գրված Python code, գուցե հանդիպած լինեք variable-ների name-ների համար type-երի որոշ հայտարարությունների, որոնք նման են ստորև բերվածին։ Դրանք տարօրինակ և անտեղի են թվում Python-ի նման dynamic typing-ով լեզվի համար և առաջին հայացքից հակասում են այս գլխի որոշ պնդումների։

Գրքի code · PDF էջ 361

  >>> a: int
  >>> b: int = 0
  >>> c: list[int] = [1, 2, 3]

Սկզբնաղբյուրի PDF էջ 362

Ինչպես նախապես տեսանք գլուխ 4-ում, սա հայտնի է որպես type hint-ներ։ Շարահյուսորեն այն ունենում է variable-ի և ոչ պարտադիր assignment-ի միջև դրված երկու կետի ու object-ի type-ի ձև։ object-ի type-ը կարող է լինել name կամ հավաքածուները նշող expression. list[int]-ը նշանակում է ամբողջ թվերի list։ Այն կարող է օգտագործել standard library-ի typing module-ում նախապես սահմանված name-ներ, օրինակ՝ Iterable, Union և Any, որպեսզի մշակված տեսության համաձայն արտահայտի ավելի հարուստ type-եր։ Python 3.12-ից սկսած՝ նոր type statement-ը նույնիսկ կարող է սահմանել type-երի այլանուններ՝ հուշումներում օգտագործելու համար, թեև դա կարող են անել նաև դրան նախորդած սովորական assignment-ները։

Գրքի code · PDF էջ 362

  >>> type Data = list[float]
  >>> Data = list[float]

Սակայն, ինչպես նաև նշվել է գլուխ 4-ում, type hint-ները ոչ պարտադիր են, չօգտագործվող և մեծ մասամբ տեսական բնույթի։ Python-ը դրանք չի պահանջում և որևէ կերպ չի օգտագործում ու երբևէ դա անելու մտադրություն չունի։ Դրանք նախատեսված են բացառապես երրորդ կողմի գործիքներում, օրինակ՝ type checker-ներում օգտագործելու և որպես փաստագրման ձև՝ code-ի comment-ներին այլընտրանք լինելու համար։ Նույն բաները կարող եք ավելի պարզ ասել և՛ # comment-ներում, և՛ փաստագրման string-երում, որոնց կհանդիպեք ավելի ուշ։

Սկզբնաղբյուրի PDF էջ 363

Նույնիսկ օգտագործվելիս՝ type hint-ները ձեր code-ի type-երը որևէ կերպ չեն սահմանափակում։ Օրինակ՝ a-ի համար նախորդ type hint-ը a name-ը չի ստեղծում. դա անում է միայն assignment-ը, իսկ b-ի և c-ի հուշումները նվազագույն չափով անգամ չեն պարտադրվում։

Գրքի code · PDF էջ 363

  >>> a
  NameError: name 'a' is not defined
  >>> b = 'hack'
  >>> c = 'code'
  >>> b, c
  ('hack', 'code')

type hint-ները կարող են հայտնվել նաև function-ների և class-երի method-ների սահմանումներում՝ parameter-երի ու արդյունքների type-երը փաստագրելու համար՝ իրենց ծառայեցնելով ավելի վաղ եղած մի հնարավորություն, որը հայտնի է որպես function-ների անոտացիաներ։ Սրանց դեռ չենք անդրադարձել, բայց որպես նախնական օրինակ՝ հետևյալ function-ը հուշում է, որ ընդունում է ամբողջ թիվ և string-երի list ու վերադարձնում float։ Այս լրացուցիչ տեղեկությունը հայտնվում է դրանք պարունակող object-ների __annotations__ dictionary-ներում։

Գրքի code · PDF էջ 363

  >>> def func(a: int, b: list[str]) -> float:
          return 'anything' + a + b

Սակայն, ինչպես սովորական variable-ների դեպքում, այս հուշումները բոլորովին չեն օգտագործվում, և function-ն իրականում կատարելիս ամեն ինչ թույլատրելի է։ Օրինակ՝ string-երը

Սկզբնաղբյուրի PDF էջ 364

լավ են աշխատում թե՛ մուտքերի, թե՛ ելքերի համար՝ չնայած առերևույթ խիստ հուշումներին։

Գրքի code · PDF էջ 364

  >>> func('You', 'Want')
  'anythingYouWant'

Այսինքն՝ type hint-ները գաղափարական առումով ծանր գործիք են, որը Python-ն ընդունել է, բայց ընդհանրապես չի օգտագործում։ Հենց Python-ում դրանք լավագույն դեպքում փաստագրման ևս մեկ ձև են, թեև ուղեկցվում են բարդ կանոններով։ Արտաքին գործիքները կարող են օգտագործել type hint-ները՝ type-երի անհամապատասխանություններ ստուգելու, օրինակ՝ mypy-ն, կամ արդյունավետությունը բարձրացնելու համար, բայց նման գործիքները նույնպես ոչ պարտադիր են, ոչ տարածված և լիովին առանձին են Python լեզվից։ Ավելին, ցանկացած լեզվով program-երը պահանջում են փորձարկում runtime, իսկ գլուխ 2-ում ներկայացված օպտիմացված Python-ները ներկայում type hint-ներ չեն օգտագործում և որոշ դեպքերում չեն էլ կարող. տե՛ս PyPy-ն։

Սակայն առավել էականն այն է, որ type hint-ները նաև լիովին հակասում են Python-ի հիմնական՝ dynamic typing-ի գաղափարին։ dynamic typing-ով լեզվում type-երի հայտարարություններն անիմաստ պարադոքս են, որը չեզոքացնում է Python-ի առաջարկած value-ի մեծ մասը։ Այս տարօրինակ ընդլայնումը Python սովորողներին ուսուցանելը արջի ծառայություն կլիներ և՛ Python-ին, և՛ սովորողներին։

Սկզբնաղբյուրի PDF էջ 365

Ուստի այս գիրքը սկսնակներին խորհուրդ է տալիս խուսափել type hint-ներից առնվազն մինչև Python-ի dynamic typing-ի մոտեցմանը վարժվելը։ Այս գիրքը նաև այլևս չի անդրադառնա դրանց, քանի որ դրանք չափազանց մեծ լրացուցիչ ծանրություն են՝ առանց օգուտի այն նորեկների համար, որոնք փորձում են յուրացնել Python-ի առանց այդ էլ ծավալուն հիմունքները։ Եթե և երբ որոշեք խորանալ Python-ի այս անմիտ, բայց խճճված անկյունում, լրացուցիչ տեղեկությունների համար դիմեք դրա փաստաթղթերին։

Ի վերջո, և չնայած նրան, ինչ կարող եք տեսնել այլ լեզուներից եկած programmer-ների գրած Python code-ում, type hint-ները չեն նշանակում, որ Python-ը static typing-ով լեզու է։ Python-ը շարունակում է օգտագործել միայն dynamic typing և, հուսանք, միշտ էլ այդպես կլինի։ Ի վերջո, սա է այլ գործիքների նկատմամբ նրա առավելությունների մեծ մասի հիմքը։ Հուսանք՝ ապագայի Python մշակողները սա լավ կսովորեն, նախքան ուռճացնելը կամ վնասելը մի գործիք, որը միլիոնավոր մարդիկ օգտագործում ու սիրում են։

Սկզբնաղբյուրի PDF էջ 366

Այս գլուխը խորությամբ դիտարկեց Python-ի dynamic typing-ի մոդելը, այսինքն՝ այն եղանակը, որով Python-ը մեր փոխարեն ինքնաբերաբար հետևում է object-ների type-երին՝ մեզնից մեր script-ներում հայտարարման statement-ներ գրելը պահանջելու փոխարեն։

Ընթացքում իմացանք, թե Python-ում variable-ներն ու object-ներն ինչպես են կապվում type-երի ճկունություն ապահովող reference-ներով։ Ուսումնասիրեցինք նաև garbage collection-ի թեման, իմացանք, թե ինչպես կարող են mutable object-ների shared reference-ներն ազդել մի քանի variable-ի վրա, և տեսանք, թե ինչպես են reference-ներն ազդում Python-ում հավասարության գաղափարի վրա։ Վերջում հակիրճ ծանոթացանք type hint-ներին՝ ենթաոլորտի, որը տարօրինակ կերպով dynamic typing-ով լեզվին ավելացնում է չօգտագործվող type-երի հայտարարություններ։

Քանի որ Python-ում assignment-ի ընդամենը մեկ մոդել կա, և assignment-ը լեզվում հանդիպում է ամենուր, կարևոր է, որ առաջ անցնելուց առաջ հասկանաք այդ մոդելը։ Հաջորդ հարցաշարը կօգնի կրկնել այս գլխի որոշ գաղափարներ։ Դրանից հետո հաջորդ գլխում կշարունակենք հիմնական object-ների մեր շրջայցը՝ string-երով։

Սկզբնաղբյուրի PDF էջ 367

Գրքի code · PDF էջ 367

    A = 'code'
    B = A
    B = 'Python'

Գրքի code · PDF էջ 367

    A = ['code']
    B = A
    B[0] = 'Python'

Գրքի code · PDF էջ 367

    A = ['code']
    B = A[:]
    B[0] = 'Python'

Սկզբնաղբյուրի PDF էջ 368

1. Ոչ. A-ն շարունակում է արտածվել որպես 'code'։ Երբ B-ին վերագրվում է 'Python' string-ը, տեղի է ունենում միայն այն, որ B variable-ը փոխվում է՝ մատնանշելու նոր string object-ը։ A-ն և B-ն սկզբում համատեղ օգտագործում են, այսինքն՝ հղվում են կամ մատնանշում, նույն մեկ 'code' string object-ը, բայց Python-ում երկու name երբեք իրար չեն կապակցվում։ Ուստի B-ն այլ object-ի կապակցելը A-ի վրա ազդեցություն չունի։ Ի դեպ, նույնը ճիշտ կլիներ, եթե այստեղ վերջին statement-ը լիներ B = B + 'coding'. կցումը իր արդյունքի համար կստեղծեր նոր object, որն ապա կվերագրվեր միայն B-ին։ Երբեք չենք կարող տեղում վերագրել string-ը, թիվը կամ tuple-ը, քանի որ string-երն immutable են։

2. Այո. A-ն այժմ արտածվում է որպես ['Python']։ Տեխնիկապես իրականում չենք փոխել ո՛չ A-ն, ո՛չ B-ն։ Փոխարենը փոխել ենք այն object-ի մի մասը, որին երկուսն էլ հղվում են կամ որը մատնանշում են՝ B variable-ի միջոցով տեղում վերագրելով այդ object-ը։ Քանի որ A-ն հղվում է նույն object-ին, ինչ B-ն, թարմացումն արտացոլվում է նաև A-ում։

3. Ոչ. A-ն շարունակում է արտածվել որպես ['code']։ B-ի միջոցով տեղում assignment-ն այս անգամ ազդեցություն չունի, քանի որ slice-ի expression-ը list-ի object-ի պատճենն ստեղծեց՝ նախքան այն B-ին վերագրելը։ assignment-ի երկրորդ statement-ից հետո կան երկու տարբեր list object-ներ, որոնք նույն value-ն ունեն։

Սկզբնաղբյուրի PDF էջ 369

Python-ում ասում ենք՝ դրանք == են, բայց ոչ is։ Երրորդ statement-ը փոխում է B-ի մատնանշած list object-ի value-ն, բայց ոչ A-ի մատնանշածինը։

Սկզբնաղբյուրի PDF էջ 370

ԵՐԲ reference-ները «ԹՈՒՅԼ» ԵՆ
Python-ի աշխարհում երբեմն կարող եք հանդիպել «թույլ reference» տերմինին։ Ոչ, այս տերմինն անորակ լինելու մասին գնահատական չէ։ Այն նշանակում է մի փոքր անհայտ և առաջադեմ գործիք, որը կապված է այստեղ ուսումնասիրած reference-ների մոդելի հետ և, is operator-ի նման, իրականում չի կարող հասկանալի լինել առանց այդ մոդելի։

Հակիրճ՝ թույլ reference-ը, որն իրականացվում է standard library-ի weakref module-ով, reference է դեպի object, որն ինքնին չի խոչընդոտում հղված object-ի garbage collection-ին։ Եթե object-ին մնացած վերջին reference-ները բոլորը թույլ reference-ներ են, object-ը կարող է ազատվել։ Երբ դա տեղի ունենա, դրա թույլ reference-ները կտեղեկացվեն, որ object-ն այլևս գոյություն չունի, և կարող են արձագանքել ըստ անհրաժեշտության։

Որպես օգտակարության օրինակ՝ սա կարող է պետք գալ հիմնականում այլ տեղում օգտագործվող մեծ object-ների ոչ էական cache-երում։ Եթե նման cache-ն օգտագործի սովորական reference-ներ, միայն cache-ի reference-ներն object-ներն անորոշ ժամանակով կպահեն memory-ի մեջ։ Թույլ reference-ներ օգտագործելիս object-ի տարածքը կարող է ազատվել, երբ այն այլևս պետք չէ իր հիմնական դերի համար, իսկ cache-ը դրա անհետացման մասին կտեղեկացվի կա՛մ հաջորդ դիմման պահին, կա՛մ հետադարձ կանչով։

object-ների ոչ բոլոր type-երին կարելի է թույլ reference ստեղծել, թեև որոշների համար այդ աջակցությունը կարելի է ավելացնել OOP-ի հնարքներով, որոնք չենք ուսումնասիրի մինչև

Սկզբնաղբյուրի PDF էջ 371

գրքի ավելի ուշ մասը։ Այդուհանդերձ, սա իրականում ընդամենը այստեղ հանդիպած reference-ների մոդելի հատուկ դեպքի ընդլայնում է։ Թույլ reference-ների մասին ավելի մանրամասն տեղեկությունների համար տե՛ս Python-ի library-ի ձեռնարկում weakref-ի նկարագրությունը՝ օգտակար, թեև անհաջող անվանված մի գործիքի։

7․ string-երի հիմունքները՝ մինչև String Formatting

P · 0 · -6 · y · 1 · -5 · t · 2 · -4 · h · 3 · -3 · o · 4 · -2 · n · 5 · -1 · "Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։P0-6y1-5t2-4h3-3o4-2n5-1"Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։

Սկզբնաղբյուրի PDF էջ 372

Մինչ այժմ ուսումնասիրել ենք թվերը և Python-ի dynamic typing-ի մոդելը։ object-ների մեր խորացված շրջայցի հաջորդ հիմնական type-ը Python-ի string-ն է՝ character-երի կարգավորված հավաքածու, որն օգտագործվում է տեքստի ու byte-երի վրա հիմնված տեղեկությունները պահելու և ներկայացնելու համար։ string-երին հակիրճ անդրադարձել ենք գլուխ 4-ում։ Այստեղ կրկին կվերադառնանք դրանց՝ լրացնելու նախկինում բաց թողած մանրամասները։

Մինչ սկսելը՝ հստակեցնենք, թե ինչ չենք ընդգրկի այստեղ։ Գլուխ 4-ը նաև հակիրճ նախնական պատկերացում տվեց Unicode string-երի ու file-երի մասին՝ ոչ ASCII տեքստով աշխատելու գործիքների։ Unicode-ը programmer-ների, հատկապես համացանցի ոլորտում աշխատողների համար առանցքային գործիք է։ Այն կարող է հանդիպել, օրինակ, վեբ էջերում, էլեկտրոնային նամակներում, graphical interface-ների գործիքակազմերում, file-երի մշակման գործիքներում, XML և JSON տեքստում և այլուր։ Միևնույն ժամանակ Unicode-ը կարող է ծանր թեմա լինել սկսնակ programmer-ների համար, և դրա ամբողջական ըմբռնումը հենվում է գործիքների վրա, որոնք դեռ ամբողջությամբ չենք ուսումնասիրել, օրինակ՝ file-երը։

Դա հաշվի առնելով՝ այս գիրքը string-երի նկարագրությունը բաժանում է այստեղ ներկայացվող հիմնական գիտելիքների և առաջադեմ թեմաների մասի գլուխ 37-ում դրանց՝ Unicode ու byte string-երի ընդլայնման միջև։ Այսինքն՝ այս գլուխը պատմում է Python-ի string-երի պատմության միայն մի մասը՝ այն մասը, որն օգտագործում են script-ների մեծ մասը, և որը Python սովորողների մեծ մասը պետք է սկզբից իմանա։

Սկզբնաղբյուրի PDF էջ 373

Չնայած այս սահմանափակ շրջանակին՝ այստեղ սովորած ամեն ինչն ուղղակիորեն կիրառելի կլինի նաև Unicode-ի ու byte-երի մշակման համար, քանի որ Python-ի տեքստային string-երը Unicode են, նույնիսկ եթե պարզ ASCII տեքստ են, իսկ byte string-երը պարզապես byte value-ներով սահմանափակված string-եր են։

Այստեղ հիմունքները սովորելուց հետո string-երի պատմության մնացած մասի համար խորհուրդ է տրվում կարդալ գլուխ 37-ը, և programmer-ների մեծ մասն ի վերջո կցանկանա շարունակել դրա բովանդակությամբ։ Այսօրվա programming-ի մեջ Unicode-ը հազվադեպ է ոչ պարտադիր, թեև այն լավագույնն է հետաձգել, մինչև ընդհանուր առմամբ string-երին տիրապետելու հնարավորություն ունենաք։ Այսպիսով՝ սկսենք։

Գործնական տեսանկյունից string-երը կարող են օգտագործվել գրեթե այն ամենը ներկայացնելու համար, ինչը հնարավոր է կոդավորել որպես տեքստ կամ byte-եր։ Տեքստային ոլորտում սա ներառում է նշաններ ու բառեր, օրինակ՝ ձեր name-ը, memory-ի մեջ բեռնված text file-երի բովանդակությունը, համացանցային հասցեները, Python-ի source code-ը և այլն։ string-երը կարող են օգտագործվել նաև media file-երի ու ցանցային փոխանցումների համար գործածվող չմշակված byte-երը, ինչպես նաև ոչ ASCII Unicode տեքստի թե՛ encoded, թե՛ decoded ձևերը պահելու համար։

Գուցե string-եր օգտագործել եք նաև այլ լեզուներում։ Python-ի string-երը ծառայում են նույն դերին, ինչ character-երի զանգվածները այնպիսի լեզուներում,

Սկզբնաղբյուրի PDF էջ 374

ինչպիսին C-ն է, բայց զանգվածների համեմատ փոքր-ինչ ավելի բարձր մակարդակի գործիք են։ Ի տարբերություն C-ի՝ Python-ի string-երը տրամադրվում են մշակման նախապես գրված գործիքների հզոր հավաքածուով։ Նաև, ի տարբերություն C-ի նման լեզուների, Python-ը չունի առանձին type մեկական character-երի համար. մեկ character-ից բաղկացած տեղեկության համար պարզապես օգտագործում եք մեկ նիշանոց string-եր։

Խիստ ասած՝ Python-ի string-երը դասակարգվում են որպես immutable sequence-ներ։ Սա նշանակում է, որ դրանց պարունակած character-երն ունեն ձախից աջ դիրքային հերթականություն և չեն կարող տեղում փոփոխվել։ Իրականում string-երը sequence-ներ կոչվող object-ների ավելի մեծ class-ի առաջին ներկայացուցիչն են, որն այստեղ կուսումնասիրենք։ Ուշադրություն դարձրեք այս գլխում ներկայացվող sequence-ների գործողություններին, քանի որ դրանք նույն կերպ կաշխատեն նաև sequence-ների այլ type-երի համար, որոնց կհանդիպեք հետագայում, օրինակ՝ list-ների և tuple-ների։

Որպես առաջին քայլ՝ աղյուսակ 7-1-ը վերացական օրինակներով նախապես ներկայացնում է այս գլխում քննարկվող տարածված string literal-ներն ու գործողությունները։ Մի՛ սպասեք, որ դրա code-ի հատվածները կաշխատեն։ Ինչպես այն ցույց է տալիս, դատարկ string-երը գրվում են զույգ չակերտներով՝ մեկական կամ կրկնակի, որոնց միջև ոչինչ չկա, և string-երը գրելու տարբեր եղանակներ կան։ Մշակման համար string-երն աջակցում են այնպիսի expression-ների գործողություններ, ինչպիսիք են կցումը՝ string-երը միավորելը, slicing-ը՝ հատվածներ դուրս բերելը, indexing-ը՝ ըստ շեղման ստանալը, և այլն։ expression-ներից բացի Python-ը տրամադրում է նաև string method-ների հավաքածու, որոնք

Սկզբնաղբյուրի PDF էջ 375

իրականացնում են string-երին հատուկ տարածված խնդիրներ, ինչպես նաև module-ներ՝ տեքստի մշակման ավելի առաջադեմ խնդիրների համար, օրինակ՝ ձևանմուշի համապատասխանեցումը։

Սկզբնաղբյուրի PDF էջ 376

Աղյուսակ 7-1. Տարածված string literal-ներ և գործողություններ

Բացել այս աղյուսակի ընթեռնելի ուղեցույցը →

Գործողություն | interpretation

S = '' | Դատարկ string

S = "app's" | Կրկնակի չակերտներ՝ նույնը, ինչ մեկականները

S = 'c\no\td\x00e' | escape sequence-ներ

S = """… multilin | Եռակի չակերտներով block string-եր

Գրքի code · PDF էջ 376

 e…"""

S = r'\temp\data.tx | Չմշակված string-եր՝ էկրանավորումն անտեսող

Գրքի code · PDF էջ 376

 t'

B = b'h\xc4ck' | byte string-եր՝ գլուխ 4, գլուխ 37

S = 'py\U0001F40D' | Unicode string-եր՝ գլուխ 4, գլուխ 37

S = u'py\U0001F40D' | Համատեղելիություն Python 2.X-ի հետ՝ գլուխ 37

S1 + S2 | Կցում, կրկնում

Գրքի code · PDF էջ 376

 S * 3

Սկզբնաղբյուրի PDF էջ 377

Գործողություն | interpretation

S[i] | indexing, slice, երկարություն

Գրքի code · PDF էջ 377

 S[i:j]
 len(S)

S1 > S2, S1 == S2 | Համեմատություններ՝ մեծություն, հավասարություն

'a %s coder' % kind | string-ի ձևաչափման expression

'a {0} coder'.format | string-ի ձևաչափման method

Գրքի code · PDF էջ 377

 (kind)

f'a {kind} coder' | string-ի ձևաչափման literal՝ 3.6+

S.find('od') | string method-ներ. բոլոր 43-ը՝ ստորև։ Որոնում
S.rstrip() | Բացատային character-երի հեռացում
S.replace('od', 'ood') | Փոխարինում
S.split(',') | Բաժանում ըստ բաժանիչի
S.isdigit() | Բովանդակության ստուգում
S.lower() | Տառաչափի փոխարկում
S.endswith('thon') | Վերջավորության ստուգում
S.join(strlist) | Միավորում բաժանիչով
Unicode encoding,

Սկզբնաղբյուրի PDF էջ 378

Գործողություն | interpretation

S.encode('utf8')
B.decode('latin1') | Unicode decoding և այլն. տե՛ս աղյուսակ 7-3

'py' in S.lower() | Պատկանելություն, կրկնություն

Գրքի code · PDF էջ 378

 for x in S: print
 (x)
 [c * 2 for c in S]
 map(ord, S)

re.match('Py(.*)on', | Ձևանմուշի համապատասխանեցում՝ library-ի module

Գրքի code · PDF էջ 378

 line)

Աղյուսակ 7-1-ի string գործիքների հիմնական հավաքածուից բացի Python-ն աջակցում է նաև ձևանմուշների վրա հիմնված string-երի ավելի առաջադեմ մշակմանը՝ standard library-ի re՝ «regular expression», այսինքն՝ regular expression նշանակող module-ով, որը ցուցադրվում է գլուխ 37-ում, և նույնիսկ ավելի բարձր մակարդակի տեքստի մշակման գործիքներով, օրինակ՝ HTML, JSON և XML վերլուծիչներով։ Սակայն այս գիրքն ու այս գլուխը կենտրոնացած են աղյուսակ 7-1-ում ներկայացված հիմունքների վրա։

Այս գլուխը սկսվում է string literal-ների ձևերի և string expression-ների ակնարկով, ապա անցնում է ավելի առաջադեմ գործիքների դիտարկմանը, օրինակ՝ string method-ներին ու ձևաչափմանը։ Python-ն ունի

Սկզբնաղբյուրի PDF էջ 379

string բազմաթիվ գործիքներ, և այստեղ չենք ընդգրկի դրանք բոլորը. ամբողջ պատմությունը նկարագրված է Python-ի library-ի ձեռնարկում։ Այստեղ մեր նպատակն է ուսումնասիրել բավականաչափ տարածված գործիքներ՝ ձեզ ներկայացուցչական ընտրանի տալու համար։ method-ները, որոնց այստեղ գործի մեջ չենք տեսնի, նման են նրանց, որոնք կտեսնենք։

Ընդհանուր առմամբ Python-ում string-երը բավական հեշտ է օգտագործել։ Սակայն դրանց մասին առաջին բանը, որ պետք է իմանաք, այն է, որ code-ում դրանք գրելու բազմաթիվ եղանակներ կան։

Մեկական չակերտներ: 'cod"e'
Կրկնակի չակերտներ: "cod'e"
Եռակի չակերտներ: '''…code…''' , """…code…"""
escape sequence-ներ: "c\to\nd\0e"
Չմշակված string-եր: r"C:\new\test.bin"
(Գլուխ 37) byte literal-ներ: b'co\x01de'
(Գլուխ 37) Unicode literal-ներ: 'h\u00c4ck'

Մեկական և կրկնակի չակերտներով ձևերը անհամեմատ ամենատարածվածն են։ Մյուսները ծառայում են մասնագիտացված դերերի, իսկ վերջին երկու առաջադեմ ձևերի հետագա քննարկումը հետաձգում ենք

Սկզբնաղբյուրի PDF էջ 380

մինչև գլուխ 37-ը։ Մնացած բոլոր տարբերակներին հերթով արագ նայենք։

Python-ի string-երի շուրջ մեկական և կրկնակի չակերտների character-երը փոխարինելի են, թեև պետք է համապատասխանեն միմյանց և ուղիղ չակերտներ լինեն։ Զգուշացեք գործիքներից, որոնք դրանք ինքնաբերաբար ուղղում են թեք չակերտների։ Այսինքն՝ string literal-ները կարող են գրվել կա՛մ երկու մեկական, կա՛մ երկու կրկնակի ուղիղ չակերտների մեջ։ Երկու ձևերն էլ նույն կերպ են աշխատում և վերադարձնում են նույն type-ի object։ Օրինակ՝ սովորական REPL-ում գրված հետևյալ երկու string-երը Python-ի կողմից կարդացվելուց հետո նույնական են։

Գրքի code · PDF էջ 380

  $ python3
  >>> 'python', "python"
  ('python', 'python')

Երկուսն էլ աջակցելու պատճառն այն է, որ դա թույլ է տալիս string-ի ներսում ներդնել մյուս տեսակի չակերտի character-ը՝ առանց այն հետադարձ շեղագծով էկրանավորելու։ Մեկական չակերտների մեջ առնված string-ում կարող եք ներդնել կրկնակի չակերտի character և հակառակը՝ առանց մի պահից ներկայացվող էկրանավորումն օգտագործելու անհրաժեշտության։

Սկզբնաղբյուրի PDF էջ 381

Գրքի code · PDF էջ 381

  >>> 'python"s', "python's"                  # Mix
  ('python"s', "python's")

Մեկնաբանություն, տող 1․ Խառնել

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

Նկատեք, որ նախորդ code-ում ստորակետը կարևոր է։ Առանց դրա Python-ն ինքնաբերաբար կցում է ցանկացած տեսակի հարևան string literal-ները։ Դրանց միջև + operator ավելացնելը գրեթե նույնքան հեշտ է՝ կցումը բացահայտ կանչելու համար, սակայն հարևան literal-ները կցվում են վաղ փուլում՝ ձեր code-ը կարդալիս (և, ինչպես կիմանաք առջևում, այս ձևը փակագծերով պարփակելը նաև թույլ է տալիս այն տարածել մի քանի line-ի վրա՝ տեքստի ավելի մեծ block-ների համար, որտեղ հնարավոր չէ օգտագործել եռակի չակերտներ).

Գրքի code · PDF էջ 381

  >>> title = "Learning " 'Python' " 6E"      # Imp
  >>> title
  'Learning Python 6E'

Մեկնաբանություն, տող 1․ Imp… [կտրված է]

Սկզբնաղբյուրի PDF էջ 382

Այս string-երի միջև ստորակետեր ավելացնելը կստեղծեր tuple, ոչ թե string։ Այս բոլոր ելքերում նաև նկատեք, որ Python-ը string-երը տպում է մեկական չակերտներով, եթե դրանք իրենց մեջ այդպիսի չակերտ չեն պարունակում։ Անհրաժեշտության դեպքում չակերտների character-երը կարող եք ներդնել նաև հակադարձ շեղագծով էկրանավորելով.

Գրքի code · PDF էջ 382

  >>> 'python\'s', "python\"s"
  ("python's", 'python"s')

Պատճառը հասկանալու համար պետք է շարունակեք և սովորեք, թե ընդհանուր առմամբ ինչպես են աշխատում escape sequence-ները։

Նախորդ օրինակը string-ի մեջ չակերտ էր ներդնում՝ դրա առջև դնելով հակադարձ շեղագիծ (\)։ Սա string-երի ընդհանուր օրինաչափության դրսևորում է. հակադարձ շեղագծերն օգտագործվում են character-երի հատուկ encoding-ներ սկսելու համար, որոնք կոչվում են escape sequence-ներ։

escape sequence-ները թույլ են տալիս string-երի մեջ ներդնել այնպիսի character-եր, որոնք հեշտ չէ տեղադրել string literal-ում կամ մուտքագրել ստեղնաշարով։ \ character-ը և string literal-ում դրան հաջորդող մեկ կամ մի քանի character-երը ստացված string-ի object-ում փոխարինվում են մեկ character-ով, որն ունի

Սկզբնաղբյուրի PDF էջ 383

escape sequence-ով նշված արժեքը։ Օրինակ՝ ահա հինգ character-ից կազմված string, որը պարունակում է newline և tab character-եր.

Գրքի code · PDF էջ 383

  >>> s = 'a\nb\tc'

Երկու՝ \n character-երը նշանակում են մեկ character՝ newline character-ը (տեխնիկապես՝ 10 code point-ի value-ն, որը Unicode-ում և դրա ASCII subset-ում նշանակում է newline)։ Նմանապես՝ \t sequence-ը փոխարինվում է ներդիրի character-ով՝ 9 code point-ով։ Տպելիս այս string-ի տեսքը կախված է նրանից, թե ինչպես եք այն տպում։ Ինտերակտիվ արտապատկերումը հատուկ character-երը ցույց է տալիս որպես escape sequence-ներ, իսկ print-ը դրանց փոխարեն մեկնաբանում է դրանք.

Գրքի code · PDF էջ 383

  >>> s
  'a\nb\tc'
  >>> print(s)
  a
  b       c

Լիովին համոզվելու համար, թե այս string-ում իրականում քանի character կա, օգտագործեք built-in len function-ը. այն վերադարձնում է string-ի character-երի իրական քանակը՝ անկախ դրանց գրառման կամ ցուցադրման ձևից.

Սկզբնաղբյուրի PDF էջ 384

Գրքի code · PDF էջ 384

  >>> len(s)
  5

Այս string-ի երկարությունը հինգ character է. այն պարունակում է ASCII a, newline character, ASCII b և այդպես շարունակ։

ՆՇՈՒՄ
Սակայն երկարությունը byte-երի քանակը չէ. եթե սովոր եք ամբողջությամբ ASCII տեքստի, գայթակղիչ է կարծել, թե len-ի այս արդյունքը նաև հինգ byte է նշանակում, սակայն հավանաբար չպետք է այդպես մտածեք։ Իրականում այսօրվա Unicode աշխարհում «byte-եր» բառն այլևս չունի նախկին իմաստը։ Նախ՝ Python-ի string-ի object-ը ներառում է կառավարման տվյալներ, որոնք memory-ի մեջ այն ավելի մեծ են դարձնում, քան միայն դրա տեքստը։

Բացի այդ, string-ի և՛ բովանդակությունը, և՛ երկարությունն արտացոլում են Unicode-ի նշանակած code point-երը՝ նույնականացնող թվերը, իսկ մեկ character-ի code point-ը պարտադիր չէ, որ համապատասխանի մեկ byte-ի՝ թե՛ memory-ի մեջ decoded, թե՛ file-երում encoded վիճակում։ Օրինակ՝ UTF-16 encoding-ի դեպքում ASCII character-երը file-երում մի քանի byte են, իսկ memory-ի մեջ կարող են ունենալ ցանկացած չափ՝ կախված նրանից, թե Python-ն ինչպես է դրանց համար տարածք հատկացնում։ Ավելին, 🐍 և 👍 նման ոչ ASCII character-երի code point-երի value-ները չափազանց մեծ են՝ որևէ ձևով 8-բիթանոց byte-ի մեջ տեղավորվելու համար։

Իրականում սա հստակ դարձնելու համար Python-ը str string-երը ձևականորեն սահմանում է որպես Unicode code point-երի sequence-ներ, այլ ոչ byte-երի։ Թե ինչպես է Unicode տեքստը վերացնում byte-երով մտածելու անհրաժեշտությունը՝ շատ ավելի մանրամասն քննարկվում է Գլուխ 37-ում, երբ պատրաստ լինեք խորանալու։ Առայժմ շփոթությունից խուսափելու համար string-երում մտածեք character-երի, ոչ թե byte-երի մասին։

Սկզբնաղբյուրի PDF էջ 385

Նկատեք, որ նախորդ օրինակների սկզբնական հակադարձ շեղագծի character-երն իրականում string-ի հետ memory-ի մեջ չեն պահվում. դրանք օգտագործվում են միայն string-ում պահվելիք հատուկ character-երի value-ները նկարագրելու համար։ Նման հատուկ character-երը գրելու համար Python-ը ճանաչում է էկրանավորման code sequence-ների ամբողջական հավաքածու, որը որպես տեղեկատու թվարկված է Աղյուսակ 7-2-ում։

Սկզբնաղբյուրի PDF էջ 386

Աղյուսակ 7-2. string-ի հակադարձ շեղագծով character-երը

Բացել այս աղյուսակի ընթեռնելի ուղեցույցը →

escape sequence | Նշանակություն

\\ | Հակադարձ շեղագիծ (պահում է մեկ \)

\' | Մեկական չակերտ (պահում է ')

\" | Կրկնակի չակերտ (պահում է ")

\n | newline (նաև կոչվում է line feed)

\r | Կառեթի վերադարձ (օրինակ՝ Windows-ի \r\n-ում)

\t | Հորիզոնական ներդիր

\v | Ուղղահայաց ներդիր

\a | Զանգ (որտեղ աջակցվում է)

\b | Հետադարձ քայլ

\f | Էջանցում

\x hh | code point-ի կամ byte-ի տասնվեցական value (ճիշտ 2 տասնվեցական թվանշան)

\ ooo | code point-ի կամ byte-ի ութական value (մինչև 3 թվանշան, առավելագույնը՝ 377)

Սկզբնաղբյուրի PDF էջ 387

escape sequence | Նշանակություն

\0 | Զրոյական character. ութական երկուական 0 character (չի ավարտում string-ը)

\u hhhh | character-ի Unicode code point՝ 16-բիթանոց value (ճիշտ 4 տասնվեցական թվանշան)

\U hhhhhhhh | character-ի Unicode code point՝ 32-բիթանոց value (ճիշտ 8 տասնվեցական թվանշան)

\N{ name } | Unicode շտեմարանում name նույնացուցիչով character

\ նոր line | Անտեսվում է (նախորդում է շարունակության line-ին)

\ այլ character | Պահպանվում է բառացի, սակայն 3.12-ում առաջացնում է զգուշացում, իսկ ապագայում՝ սխալ

Աղյուսակ 7-2-ի էկրանավորման որոշ հաջորդականություններ ունեն օգտագործման կանոններ։ Կրկին որպես տեղեկատու՝ ահա նրբությունները.

\x, \u և \U escape sequence-ները պահանջում են համապատասխանաբար ճիշտ երկու, չորս և ութ տասնվեցական թվանշան։ h-ի համար օգտագործեք 0 – 9 և A – F character-երը՝ մեծատառ կամ փոքրատառ։
\o էկրանավորումն ընդունում է մեկից երեք ութական թվանշան և Python 3.12-ում զգուշացում է տալիս \377-ից բարձր value-ների համար, քանի որ

Սկզբնաղբյուրի PDF էջ 388

byte-ի համար չափազանց մեծ value-ները byte string-երում խնդիրներ են առաջացնում։ o-ի համար օգտագործեք 0 – 7 թվանշանները։
Ե՛վ \u-ն, և՛ \U-ն ճանաչվում են միայն str տեքստային string-երի literal-ներում, օրինակ՝ '…', որտեղ տալիս են character-ի Unicode code point-ի value-ն։ Սա code point-ի decoded value-ն է։
\x և \o էկրանավորումները գործում են թե՛ bytes byte string-երի literal-ներում (b'…'), որտեղ տալիս են byte-ի բացարձակ value-ն, թե՛ str տեքստային string-երի literal-ներում, որտեղ տալիս են character-ի Unicode code point-ի value-ն։
\n-ի նման տառային էկրանավորումները տեքստում նշանակում են իրենց Unicode code point-երը, իսկ byte-երում՝ ASCII encoding-ները, նույնիսկ եթե այդ երկու value-ները համընկնում են (Unicode էկրանավորումների մասին ավելին՝ Գլուխ 37-ում)։

Եկեք վերադառնանք code-ի կատարմանը։ string-երի էկրանավորման որոշ sequence-ներ թույլ են տալիս բացարձակ value-ները ներդնել որպես string-ի character-եր։ Երբ այդպես եք անում, իրականում տալիս եք ցանկալի character-ի code point-ի value-ն։ Օրինակ՝ ահա հինգ character-ից կազմված string, որը ներդնում է զրոյական value-ներով երկու character՝ գրված որպես մեկ թվանշանով ութական էկրանավորումներ.

Գրքի code · PDF էջ 388

  >>> s = 'a\0b\0c'
  >>> s
  'a\x00b\x00c'

Սկզբնաղբյուրի PDF էջ 389

Գրքի code · PDF էջ 389

  >>> len(s)
  5

0 code point-ին համապատասխանող character-ը ընդհանուր առմամբ հայտնի է որպես NULL կամ NUL։ Կարևոր է, որ Python-ում նման character-ը չի ավարտում string-ն այնպես, ինչպես C-ում սովորաբար անում է «զրոյական byte-ը»։ Փոխարենը Python-ը memory-ի մեջ պահում է string-ի և՛ երկարությունը, և՛ տեքստը։ Իրականում Python-ում որևէ character չի ավարտում string-ը։ Ահա մի string, որն ամբողջությամբ կազմված է բացարձակ էկրանավորման code-երից՝ բացարձակ 1 և 2՝ գրված ութականով, ապա բացարձակ 3՝ գրված տասնվեցականով. բոլորը՝ չտպվող character-եր.

Գրքի code · PDF էջ 389

  >>> s = '\001\002\x03'
  >>> s
  '\x01\x02\x03'
  >>> len(s)
  3

Նկատեք, որ Python-ը չտպվող character-երը ցուցադրում է տասնվեցական տեսքով՝ անկախ դրանց սկզբնական գրառման ձևից։ Անհրաժեշտության դեպքում կարող եք ազատորեն համադրել character-եր, բացարձակ value-ի էկրանավորումներ և Աղյուսակ 7-2-ի ավելի խորհրդանշական էկրանավորումները։ Որպես ցուցադրում՝ հետևյալ string-ը պարունակում է «HACK» character-երը, tab և newline, ինչպես նաև տասնվեցականով գրված բացարձակ զրոյական character.

Սկզբնաղբյուրի PDF էջ 390

Գրքի code · PDF էջ 390

  >>> S = 'H\tA\nC\x00K'
  >>> S
  'H\tA\nC\x00K'
  >>> len(S)
  7
  >>> print(S)
  H   A
  CK

Սա ավելի կարևոր է իմանալ, երբ Python-ում երկուական տվյալների file-եր եք մշակում։ Քանի որ ձեր script-ներում դրանց բովանդակությունը ներկայացվում է string-երով, կարելի է մշակել ցանկացած տեսակի երկուական byte value-ներ պարունակող binary file-եր։ binary mode-ներով բացվելիս file-երը արտաքին file-ից վերադարձնում են չմշակված byte-եր՝ որպես bytes. սա string-ի տարբերակ է, որն աջակցում է այս գլխի syntax-ի և գործիքների մեծ մասին (file-երի և bytes-ի մասին ավելին կգտնեք Գլուխներ 4-ում, 9-ում և 37-ում)։

Աղյուսակ 7-2-ի երկու սահմանափակում արժե առանձին ընդգծել։ Նախ՝ byte-ի համար չափազանց մեծ value-ներով ութական էկրանավորումները Python 3.12-ից սկսած զգուշացումներ են տալիս և շուտով սխալներ կլինեն՝ չնայած այն փաստին, որ տեքստային string-երում այս էկրանավորումները նշանակում են code point-եր, այլ ոչ byte-եր.

Գրքի code · PDF էջ 390

  >>> '\400'
  <stdin>:1: SyntaxWarning: invalid octal escape se

Սկզբնաղբյուրի PDF էջ 391

Գրքի code · PDF էջ 391

  'Ā'

Սա կարծես դժվար թե մեծ ծավալի code խաթարի, սակայն Աղյուսակ 7-2-ի վերջին string-ը կարող է. եթե Python-ը \-ից հետո character-ը չի ճանաչում որպես վավեր էկրանավորման code, այն պարզապես պահպանում է հակադարձ շեղագիծը ստացված string-ում՝ առնվազն առայժմ.

Գրքի code · PDF էջ 391

  >>> x = 'C:\py\code'
  <stdin>:1: SyntaxWarning: invalid escape sequence

Գրքի code · PDF էջ 391

  >>> x                         # Keeps \ literally
  'C:\\py\\code'
  >>> len(x)                    # But not for long
  10

Մեկնաբանություն, տող 1․ Պահպանում է \-ը բառացիորեն

Մեկնաբանություն, տող 3․ Բայց ոչ երկար ժամանակ

Չնայած այս վարքը երեք տասնամյակ սպասելի էր, և նույնիսկ դրա վրա հենվում էին, վերջերս այն վատ է գնահատվել և օգտագործվելիս սկսել է զգուշացում տալ։ Python 3.12-ում այն առաջացնում է շարահյուսական զգուշացում, որը չի կանգնեցնում ձեր program-ը, սակայն ելքը ծանրաբեռնում է հուշումներով։ Ավելի վատ՝ Python-ի ապագա տարբերակում սա կդիտարկվի որպես program-ն ավարտող սխալ, ուստի հետագայում չպետք է օգտագործեք այն, և ձեզանից ակնկալվում է փոխել անցյալում գրած ամբողջ code-ը, որն օգտագործում է դա։

Սկզբնաղբյուրի PDF էջ 392

Սակայն նույնիսկ առանց Python-ի հետադարձ անհամատեղելի այս փոփոխության՝ այս վարքին ապավինող string-երում հակադարձ շեղագծերը էկրանավորումներում կորցնելու հավանականությունը կարծես նույնքան մեծ է, որքան դրանք այլ տեղերում պահելու հավանականությունը։ Փոխարենը՝ բառացի հակադարձ շեղագծերը գրեք բացահայտ այնպես, որ դրանք պահպանվեն ձեր string-երում Python-ի բոլոր տարբերակներում՝ կա՛մ կրկնապատկելով դրանք \\-ով՝ մեկ \-ի էկրանավորմամբ, կա՛մ օգտագործելով raw string-եր՝ հաջորդ բաժնի թեման։

Ինչպես արդեն տեսանք, escape sequence-ները հարմար են string-երի մեջ հատուկ character-եր ներդնելու համար։ Սակայն երբեմն էկրանավորումներ սկսող հակադարձ շեղագծերի հատուկ մշակումը կարող է խնդիրների հանգեցնել։ Օրինակ՝ զարմանալիորեն հաճախ կարելի է տեսնել Python-ի նորեկների, որոնք Windows-ում փորձում են file բացել մոտավորապես այսպիսի filename-ի argument-ով.

Գրքի code · PDF էջ 392

  myfile = open('C:\new\text.dat', 'w')

կարծելով, թե կբացեն C:\new directory-ի text.dat file-ը։ Խնդիրն այն է, որ \n-ը դիտարկվում է որպես նոր line-ի character, իսկ \t-ն փոխարինվում է ներդիրով։ Փաստորեն՝ կանչը փորձում է բացել C:(newline)ew(tab)ext.dat անունով file՝ սովորաբար ոչ այնքան հաջող արդյունքներով։

Սկզբնաղբյուրի PDF էջ 393

raw string-երը նախատեսված են հենց այսպիսի հարցերը լուծելու համար։ Եթե r տառը՝ մեծատառ կամ փոքրատառ, բայց սովորաբար վերջինը, հայտնվում է այս գլխում քննարկվող ցանկացած string literal-ի բացող չակերտից անմիջապես առաջ, այն անջատում է էկրանավորման մեխանիզմը։ Արդյունքում Python-ը հակադարձ շեղագծերը պահպանում է բառացի՝ ճիշտ այնպես, ինչպես դրանք երևում են string-ում։ Ուստի filename-ի խնդիրը շտկելու համար Windows-ում պարզապես հիշեք ավելացնել r տառը.

Գրքի code · PDF էջ 393

  myfile = open(r'C:\new\text.dat', 'w')         #

Այլընտրանքորեն՝ քանի որ, ինչպես նշվեց նախորդ բաժնում, երկու հակադարձ շեղագիծն իրականում մեկ հակադարձ շեղագծի escape sequence է, կարող եք պահպանել ձեր հակադարձ շեղագծերը՝ պարզապես կրկնապատկելով դրանք, երբ պետք է բառացի ընկալվեն.

Գրքի code · PDF էջ 393

  myfile = open('C:\\new\\text.dat', 'w')        #

Իրականում հենց Python-ը երբեմն օգտագործում է կրկնապատկման այս սխեման, երբ տպում է ներդրված հակադարձ շեղագծերով string-եր.

Գրքի code · PDF էջ 393

  >>> path = r'C:\new\text.dat'                  #
  >>> path                                       #

Սկզբնաղբյուրի PDF էջ 394

Գրքի code · PDF էջ 394

  'C:\\new\\text.dat'
  >>> print(path)                                #
  C:\new\text.dat
  >>> len(path)                                  #
  15

Ինչպես քննարկվեց Գլուխ 5-ում, ինտերակտիվ prompt-ի լռելյայն ձևաչափը արդյունքները տպում է այնպես, կարծես դրանք code լինեն, և հետևաբար ելքում էկրանավորում է հակադարձ շեղագծերը։ print statement-ը տրամադրում է օգտատիրոջ համար ավելի հարմար ձևաչափ, որը ցույց է տալիս, որ յուրաքանչյուր տեղում իրականում միայն մեկ հակադարձ շեղագիծ կա։ Սա հաստատելու համար կարող եք ստուգել built-in len function-ի արդյունքը, որը վերադարձնում է string-ի character-երի քանակը՝ անկախ ցուցադրման ձևաչափերից։ Եթե հաշվեք print(path)-ի ելքի character-երը, կտեսնեք, որ յուրաքանչյուր հակադարձ շեղագծին իսկապես համապատասխանում է միայն 1 character՝ ընդհանուր 15։

Բացի Windows-ի directory-ների ուղիներից՝ raw string-երը հաճախ օգտագործվում են նաև տեքստային ձևանմուշների համադրման regular expression-ներում, որոնց աջակցում է Գլուխ 37-ում ներկայացվող re module-ը։ Նկատեք նաև, որ Python-ի script-ները սովորաբար կարող են directory-ների ուղիներում օգտագործել ուղիղ շեղագծեր և՛ Windows-ում, և՛ Unix-ում, քանի որ այս շեղագիծը մեկնաբանվում է տեղափոխելի ձևով (օրինակ՝ 'C:/new/text.dat'-ը նույնպես աշխատում է Windows-ի file-երը բացելիս)։ Սակայն raw string-երն օգտակար են Windows-ին բնորոշ

Սկզբնաղբյուրի PDF էջ 395

հակադարձ շեղագծերով ուղիների համար, ինչպես նաև ցանկացած այլ դեպքում, երբ ցանկանում եք ապահովել, որ Python-ը ձեր \-ը հանգիստ թողնի։ Դրանք գործում են նաև եռակի չակերտներով string-երի համար՝ էկրանավորումները և ապագա անվավեր էկրանավորման սխալները ճնշելու նպատակով հաջորդիվ ներկայացվող տեքստի պես նյութերում։

ՆՇՈՒՄ
raw string-ի յուրահատկություն. չնայած իր դերին՝ նույնիսկ raw string-ը չի կարող ավարտվել մեկ հակադարձ շեղագծով, քանի որ հակադարձ շեղագիծն էկրանավորում է հաջորդող չակերտի character-ը։ Այսինքն՝ r'…\'-ը վավեր string literal չէ. string-ը շրջապատող չակերտի character-ը ներսում ներդնելու համար դեռ պետք է էկրանավորեք այն, և Python-ը ենթադրում է, որ հենց դա եք ցանկանում։ Արդյունքում raw string-ը չի կարող ավարտվել հակադարձ շեղագծերի կենտ քանակով, ներառյալ մեկով։ Եթե պետք է raw string-ն ավարտել մեկ հակադարձ շեղագծով, կարող եք օգտագործել երկուսը և slice-ով հեռացնել երկրորդը (r'…\\'[:-1]), մեկը ձեռքով կցել (r'…' + '\\') կամ բաց թողնել raw string-ի syntax-ն ու սովորական string-ում պարզապես կրկնապատկել հակադարձ շեղագծերը ('…\\')։ Այս երեք ձևերն էլ ստեղծում են նույն՝ երկու character-ից կազմված string-ը՝ Unicode բազմակետով և մեկ հակադարձ շեղագծով։

Մինչ այժմ գործողության մեջ տեսաք մեկական չակերտներ, կրկնակի չակերտներ, էկրանավորումներ և raw string-եր։ Python-ն ունի նաև եռակի չակերտներով string literal-ի ձևաչափ, որը երբեմն կոչվում է block string և բազմատող տվյալներ գրելու շարահյուսական հարմարություն է։ Այս ձևը սկսվում է երեք չակերտով՝ մեկական կամ կրկնակի տեսակի, որոնց հաջորդում է

Սկզբնաղբյուրի PDF էջ 396

ցանկացած քանակի text line, և փակվում է այն նույն եռակի չակերտների sequence-ով, որով բացվել էր։ string-ի տեքստում ներդրված մեկական ու կրկնակի չակերտները կարելի է էկրանավորել, սակայն պարտադիր չէ. string-ը չի ավարտվում, մինչև Python-ը չտեսնի literal-ը սկսելու համար օգտագործված նույն տեսակի երեք չէկրանավորված չակերտ։ Օրինակ՝

Գրքի code · PDF էջ 396

  >>> quip = """Python strings
  ...   sure have
  ... a lot of options"""
  >>>
  >>> quip
  'Python strings\n  sure have\na lot of options'

Այս string-ը զբաղեցնում է երեք line։ Ինչպես սովորեցիք Գլուխ 3-ում, որոշ interface-ներում նման continuation line-երում ինտերակտիվ prompt-ը փոխվում է ...-ի, իսկ մյուսներում՝ ոչ։ Որոշ օրինակներում այս գիրքը բաց է թողնում կետերը՝ պատճենել-տեղադրելը հնարավոր դարձնելու համար, սակայն ինքներդ մի՛ մուտքագրեք դրանք, եթե նշված են, ինչպես այստեղ, բայց ձեր REPL-ում բացակայում են, և անհրաժեշտության դեպքում համապատասխանեցրեք։

prompt-երը մի կողմ՝ Python-ն այս օրինակի եռակի չակերտներով ամբողջ տեքստը հավաքում է մեկ multiline string-ի մեջ՝ ներդրված newline character-ներով (\n) այն տեղերում, որտեղ ձեր code-ում physical line-ի

Սկզբնաղբյուրի PDF էջ 397

ընդհատումներ կան։ Նկատեք, որ ինչպես literal-ում, այնպես էլ արդյունքում երկրորդ line-ն ունի սկզբնական բացատներ, իսկ երրորդը՝ ոչ. ձեր մուտքագրածն իսկապես այն է, ինչ ստանում եք։ newline-երը մեկնաբանված տեսքով string-ը տեսնելու համար արտապատկերելու փոխարեն տպեք այն.

Գրքի code · PDF էջ 397

  >>> print(quip)
  Python strings
    sure have
  a lot of options

Իրականում եռակի չակերտներով string-երը պահպանում են ներսի ամբողջ տեքստը՝ ներառյալ ձեր code-ի աջ կողմում եղած այն տեքստը, որը գուցե նախատեսել եք որպես comment։ Ուստի այդպես մի՛ արեք. comment-ները դրեք չակերտներով տեքստից վերև կամ ներքև, կամ օգտագործեք ավելի վաղ նշված հարևան string-երի ավտոմատ կցումը՝ անհրաժեշտության դեպքում բացահայտ newline character-ներով և ընդգրկող փակագծերով, որոնք թույլ են տալիս մի քանի line զբաղեցնել (այս վերջին ձևի մասին ավելին կիմանաք, երբ Գլուխներ 10-ում և 12-ում ուսումնասիրեք շարահյուսական կանոնները).

Գրքի code · PDF էջ 397

  >>> menu = """
  ... Open           # Comments here added to strin
  ... Save           # Ditto
  ... """
  >>> menu
  '\nOpen           # Comments here added to string

Սկզբնաղբյուրի PDF էջ 398

Գրքի code · PDF էջ 398

  >>> menu = (
  ... 'Open\n'       # Comments here ignored
  ... 'Save\n'       # But newlines not automatic
  ... )
  >>> menu
  'Open\nSave\n'

Մեկնաբանություն, տող 2․ comment-ներն այստեղ անտեսվում են

Մեկնաբանություն, տող 3․ Բայց նոր line-երն ավտոմատ չեն

Այսպիսով՝ ինչո՞ւ օգտագործել եռակի չակերտներով string-եր։ Նախ՝ դրանք օգտակար են ամեն անգամ, երբ ձեր program-ում multiline տեքստ է անհրաժեշտ, օրինակ՝ ձեր Python-ի source code-ի file-երում multiline error message-ներ կամ HTML, XML, JSON կամ YAML code ներդնելու համար։ Սովորաբար նման block-ները կարող եք անմիջապես ներդնել ձեր script-ներում՝ եռակի չակերտներով պարփակելով, առանց արտաքին text file-երի կամ կցման ու newline character-երի դիմելու։

Եռակի չակերտներով string-երը նաև հաճախ օգտագործվում են docstring-ների՝ documentation string-երի համար. սրանք string literal-ներ են, որոնք ձեր file-ի որոշակի տեղերում հայտնվելիս դիտարկվում են որպես comment-ներ (և ամբողջությամբ քննարկվում են Գլուխ 15-ում)։ Դրանք պարտադիր չէ, որ եռակի չակերտներով block-ներ լինեն, սակայն սովորաբար այդպիսին են՝ multiline comment-ներ թույլ տալու համար, և գուցե պետք է լինեն եռակի չակերտներով raw string-եր, օրինակ՝ r''', որպեսզի ապագայում խուսափեք անվավեր էկրանավորման սխալներից (տե՛ս ավելի վաղ նշված 3.12-ի շարահյուսական զգուշացումները)։

Սկզբնաղբյուրի PDF էջ 399

Վերջապես, եռակի չակերտներով string-երը երբեմն օգտագործվում են նաև որպես մշակման ընթացքում code line-երը ժամանակավորապես անջատելու «սարսափելի հնարամիտ շրջանցում»։ Իրականում դա այնքան էլ սարսափելի չէ և այսօր բավական տարածված գործելակերպ է, սակայն literal-ի սկզբնական նպատակը դա չէր։ Եթե ցանկանում եք code-ի մի քանի line անջատել և script-ը նորից գործարկել, պարզապես դրանց վերևում ու ներքևում երեք չակերտ դրեք՝ այսպես.

Գրքի code · PDF էջ 399

  X = 1
  """
  import os                            # Disable th
  print(os.getcwd())
  """
  Y = 2

Սա «շրջանցում» էր անվանվել, քանի որ Python-ն իսկապես կարող է այս կերպ անջատված code line-երից string object ստեղծել, սակայն կատարողականության առումով դա հավանաբար նշանակալի չէ։ code-ի մեծ հատվածների համար սա նաև ավելի հեշտ է, քան ամեն line-ի առջև ձեռքով ցանցանշաններ ավելացնելն ու հետագայում հեռացնելը։ Սա հատկապես ճիշտ է, եթե օգտագործում եք text editor, որը հատուկ Python-ի code-ի խմբագրման աջակցություն չունի։ Python-ում գործնականությունը հաճախ գերազանցում է գեղագիտությանը։

Սկզբնաղբյուրի PDF էջ 400

Երբ string ստեղծեք հենց նոր հանդիպած literal expression-ներով, գրեթե անպայման կցանկանաք դրա հետ գործողություններ կատարել։ Այս և հաջորդ երկու բաժինները ցուցադրում են string-երի expression-ները, method-ներն ու ձևաչափումը՝ Python լեզվի տեքստի մշակման առաջին շարքի գործիքները։

Եկեք սկսենք Python-ի interpreter-ի հետ փոխազդելով՝ ավելի վաղ Աղյուսակ 7-1-ում թվարկված string-երի հիմնական գործողությունները ցուցադրելու համար։ string-երը կարող եք կցել՝ օգտագործելով + operator-ը, և կրկնել՝ օգտագործելով * operator-ը.

Գրքի code · PDF էջ 400

  >>> len('abc')            # Length: number of ite
  3
  >>> 'abc' + 'def'         # Concatenation: a new
  'abcdef'
  >>> 'Py!' * 4             # Repetition: like 'Py
  'Py!Py!Py!Py!'

Մեկնաբանություն, տող 1․ Երկարություն՝ տարրե…-ի քանակ

Մեկնաբանություն, տող 3․ Կցում՝ նոր…

Մեկնաբանություն, տող 5․ Կրկնում՝ նման է 'Py… [կտրված է]

Այստեղ built-in len function-ը վերադարձնում է string-ի կամ երկարություն ունեցող ցանկացած այլ object-ի երկարությունը։ Ձևականորեն՝ երկու string-ի

Սկզբնաղբյուրի PDF էջ 401

object-ները +-ով գումարելը ստեղծում է string-ի նոր object՝ միավորված operand-ների բովանդակությամբ, իսկ *-ով կրկնումը նման է string-ն ինքն իրեն տրված քանակով՝ մեկով պակաս, գումարելուն։ Երկու դեպքում էլ Python-ը թույլ է տալիս ստեղծել կամայական չափի string-եր. Python-ում որևէ բան, ներառյալ տվյալների կառուցվածքների չափերը, նախապես հայտարարելու կարիք չկա։ Պարզապես կառուցում եք string-ի object-ներն ըստ անհրաժեշտության և Python-ին թողնում հիմքում ընկած memory-ի տարածքի ավտոմատ կառավարումը, ինչպես սովորեցինք Գլուխ 6-ում։

Կրկնումը սկզբում կարող է մի փոքր անհասկանալի թվալ, սակայն այն օգտակար է զարմանալիորեն մեծ թվով իրավիճակներում։ Օրինակ՝ 80 գծիկից կազմված line տպելու համար կարող եք հաշվել մինչև 80 կամ թողնել, որ Python-ը հաշվի ձեր փոխարեն.

Գրքի code · PDF էջ 401

  >>> print('------ …more… ------')        # 80 das
  >>> print('-' * 80)                      # 80 das

Մեկնաբանություն, տող 1․ 80 գծի…

Մեկնաբանություն, տող 2․ 80 գծի…

Նկատեք, որ Գլուխ 5-ում և ավելի վաղ ընդգծված operator-ների գերբեռնումն ու բազմաձևությունն այստեղ արդեն գործում են. օգտագործում ենք նույն + և * operator-ները, որոնք թվերի դեպքում կատարում են գումարում ու բազմապատկում։ Python-ը կատարում է ճիշտ գործողությունը, քանի որ գիտի գումարվող և բազմապատկվող object-ների type-երը։ Սակայն զգույշ եղեք. կանոններն այնքան ազատ չեն, որքան գուցե սպասում եք։ Օրինակ՝ Python-ը թույլ չի տալիս

Սկզբնաղբյուրի PDF էջ 402

+ expression-ներում խառնել թվերն ու string-երը. 'abc'+9-ը սխալ է առաջացնում՝ 9-ն ինքնաբերաբար string-ի փոխակերպելու փոխարեն (սա կշտկենք առջևում)։

Ինչպես ցույց է տրված Աղյուսակ 7-1-ի վերջի մոտ, կարող եք նաև loop-երում անցնել string-երի վրայով՝ օգտագործելով գործողությունները կրկնող for statement-ներ, և ստուգել թե՛ character-երի, թե՛ substring-երի անդամակցությունը in expression-ի operator-ով, որն ըստ էության որոնում է։ substring-երի համար in-ը շատ նման է այս գլխում ավելի ուշ քննարկվող str.find() method-ին, սակայն վերադարձնում է Boolean արդյունք՝ substring-ի դիրքի փոխարեն (մի՛ անհանգստացեք, եթե ստորևի print-ը prompt-ը շեղի. դրա end=' '-ը ցուցադրման վերջի լռելյայն newline character-ը փոխում է բացատի).

Գրքի code · PDF էջ 402

  >>> myjob = 'hacker'
  >>> for c in myjob:                     # Step th
  ...     print(c, end=' ')               # Suppres
  ...
  h a c k e r
  >>> 'k' in myjob                        # Found
  True
  >>> 'z' in myjob                        # Not fou
  False
  >>> 'HACK' in 'abcHACKdef'              # Substri
  True

Մեկնաբանություն, տող 2․ Հերթով անցնե…

Մեկնաբանություն, տող 3․ Կանխե…

Մեկնաբանություն, տող 6․ Գտնված է

Մեկնաբանություն, տող 8․ Չի գտնվե…

Մեկնաբանություն, տող 10․ Ենթատո…

Սկզբնաղբյուրի PDF էջ 403

Գլուխ 4-ում նախնականորեն ներկայացված for loop-ը variable-ին հաջորդաբար վերագրում է sequence-ի, այստեղ՝ string-ի, տարրերը և յուրաքանչյուր տարրի համար կատարում մեկ կամ մի քանի statement՝ սովորաբար նահանջով գրված։ Փաստորեն՝ c variable-ը դառնում է string-ի character-երով քայլող կուրսոր։ Քանի որ կրկնությունը Python-ում մեծ գաղափար է, այս և Աղյուսակ 7-1-ում թվարկված այլ կրկնության գործիքները ավելի մանրամասն կքննարկենք գրքում ավելի ուշ (տե՛ս Գլուխներ 14 և 20)։

Քանի որ string-երը character-երի կարգավորված հավաքածուներ են, որոնք նաև կոչվում են sequence-ներ, կարող ենք դրանց բաղադրիչներին դիմել ըստ դիրքի։ Ինչպես ներկայացվեց Գլուխ 4-ում, string-ի character-երը ստացվում են indexing-ով՝ string-ից հետո քառակուսի փակագծերում տալով ցանկալի բաղադրիչի թվային շեղումը։ Հետ եք ստանում նշված դիրքի մեկ character-ից կազմված string-ը։

Ինչպես C-ի նման լեզուների մեծ մասում, Python-ի շեղումները սկսվում են 0-ից և ավարտվում string-ի երկարությունից մեկով պակաս թվով («0-ից սկսելը» կարող է կարճատև խոչընդոտ լինել, եթե սովոր եք հաշվել 1-ից)։ Սակայն, ի տարբերություն C-ի, Python-ը նաև թույլ է տալիս string-երի նման sequence-ներից տարրեր ստանալ բացասական շեղումներով։ Տեխնիկապես բացասական շեղումը գումարվում է string-ի երկարությանը՝ դրական շեղում ստանալու համար, սակայն բացասական

Սկզբնաղբյուրի PDF էջ 404

շեղումները կարող եք նաև պատկերացնել որպես վերջից հետընթաց հաշվել։ Հետևյալ փոխազդեցությունը դա ցուցադրում է.

Գրքի code · PDF էջ 404

  >>> S = 'code'
  >>> S[0], S[-2]                         # Indexin
  ('c', 'd')
  >>> S[1:3], S[1:], S[:-1]               # Slicing
  ('od', 'ode', 'cod')

Մեկնաբանություն, տող 2․ Ինդեքսավո…

Մեկնաբանություն, տող 4․ slicing

Այս code-ում առաջին line-ը սահմանում է չորս character-ից կազմված string և այն վերագրում S name-ին։ Հաջորդ line-ն այն ինդեքսավորում է երկու եղանակով. S[0]-ը ստանում է ձախից 0 շեղման տարրը՝ սկզբի մեկ character-ից կազմված 'c' string-ը, իսկ S[−2]-ը ստանում է վերջից 2 շեղումով հետ գտնվող տարրը կամ, համարժեքորեն, սկզբից (4 + (−2)) շեղումով տարրը։

Նախորդ օրինակի վերջին line-ը ցուցադրում է slicing-ը՝ indexing-ի ընդհանրացված ձևը, որը մեկ տարրի փոխարեն վերադարձնում է ամբողջ հատված։ Այն կարելի է օգտագործել տվյալների սյունակներ առանձնացնելու, նախածանցներն ու վերջածանցները հեռացնելու և այլ նպատակներով։ slicing-ը կարելի է նաև դիտարկել որպես վերլուծության՝ բովանդակության բաժանման տեսակ, հատկապես string-երի նկատմամբ կիրառվելիս, քանի որ դա substring-եր առանձնացնելու հեշտ եղանակ է։ Իրականում slicing-ն այս գլխում ավելի ուշ կուսումնասիրենք տեքստի վերլուծության համատեքստում։

Սկզբնաղբյուրի PDF էջ 405

slicing-ն աշխատում է այսպես. երբ string-ի նման sequence-ի object-ն ինդեքսավորում եք երկու կետով բաժանված զույգ շեղումներով, Python-ը վերադարձնում է նոր object, որը պարունակում է այդ զույգով որոշված անընդմեջ հատվածը։ Ձախ շեղումը դիտարկվում է որպես ստորին սահման՝ ներառյալ, իսկ աջը՝ որպես վերին սահման՝ առանց այն ներառելու։ Այսինքն՝ Python-ը ստանում է բոլոր տարրերը ստորին սահմանից մինչև վերինը՝ վերջինս չներառելով, և վերադարձնում է ստացված տարրերը պարունակող նոր object։ Բաց թողնելու դեպքում ձախ ու աջ սահմանները լռելյայն համապատասխանաբար 0-ն ու հատվող object-ի երկարությունն են։

Օրինակ՝ հենց նոր կատարած օրինակում S[1:3]-ը առանձնացնում է 1 և 2 շեղումներում եղած տարրերը. վերցնում է երկրորդ ու երրորդ տարրերը և կանգ առնում չորրորդ՝ 3 շեղման տարրից առաջ։ Այնուհետև S[1:]-ը ստանում է առաջինից հետո եղած բոլոր տարրերը. չնշված վերին սահմանը լռելյայն string-ի երկարությունն է՝ վերջից դուրս դիրքը։ Վերջապես S[:−1]-ը ստանում է բոլոր տարրերը՝ բացի վերջինից. ստորին սահմանը լռելյայն 0 է, իսկ −1-ը հղվում է վերջին տարրին՝ առանց այն ներառելու։ Ավելի պատկերավոր՝ index-ներն ու slice-ները համապատասխանում են բջիջներին այնպես, ինչպես ցույց է տրված Նկար 7-1-ում։

Սկզբնաղբյուրի PDF էջ 406

Սկզբնաղբյուրի պատկեր, PDF էջ 406
Սկզբնաղբյուրի պատկեր · PDF էջ 406

Նկար 7-1. index-ներ և slice-ներ. դրականները սկսվում են ձախից (0), իսկ բացասականները՝ աջից (–1)

Այս ամենն առաջին հայացքից կարող է շփոթեցնող թվալ, սակայն indexing-ն ու slicing-ը պարզ և հզոր գործիքներ են, երբ վարժվում եք դրանց։ Հիշեք՝ եթե վստահ չեք slice-ի ազդեցության մեջ, փորձեք այն ինտերակտիվ ձևով։ Հաջորդ գլխում կտեսնեք, որ նույնիսկ հնարավոր է մեկ քայլով փոխել մեկ այլ object-ի ամբողջ հատվածը՝ slice-ին արժեք վերագրելով, թեև ոչ այստեղ ուսումնասիրվող string-երի պես immutable object-ների համար։ Առայժմ՝ ահա մանրամասների հակիրճ հուշաթերթը՝ որպես տեղեկատու.

indexing-ը՝ S[I], ստանում է sequence-ների բաղադրիչները՝ ըստ շեղումների.

Առաջին տարրը 0 շեղման մեջ է։
Բացասական index-ները նշանակում են վերջից կամ աջից հետընթաց հաշվել։
Սահմաններից դուրս շեղումները սխալ են։
S[0]-ը ստանում է առաջին տարրը։
S[−2]-ը ստանում է վերջից երկրորդ տարրը՝ ինչպես S[len(S)−2]-ը։

Սկզբնաղբյուրի PDF էջ 407

slicing-ը՝ S[I:J], առանձնացնում է sequence-ների անընդմեջ հատվածներ.

Վերին սահմանը չի ներառվում։
Բաց թողնելու դեպքում slice-ի սահմանները լռելյայն 0-ն ու sequence-ի երկարությունն են։
Սահմաններից դուրս շեղումները հարմարեցվում են՝ սահմանների մեջ տեղավորվելու համար։
S[1:3]-ը ստանում է 1 շեղումից մինչև 3 շեղումը եղած տարրերը՝ 3-ը չներառելով։
S[1:]-ը ստանում է 1 շեղումից մինչև վերջ՝ sequence-ի երկարությունը եղած տարրերը։
S[:3]-ը ստանում է 0 շեղումից մինչև 3 շեղումը եղած տարրերը՝ 3-ը չներառելով։
S[:−1]-ը ստանում է 0 շեղումից մինչև վերջին տարրը եղած տարրերը՝ վերջինը չներառելով։
S[:]-ը ստանում է 0 շեղումից մինչև վերջ եղած տարրերը՝ ստեղծելով S-ի վերին մակարդակի պատճենը։

Ընդլայնված slicing-ը՝ S[I:J:K], ընդունում է K քայլը կամ քայլաչափը, որը լռելյայն +1 է.

Թույլ է տալիս տարրեր բաց թողնել և հերթականությունը շրջել. տե՛ս հաջորդ բաժինը։

Այստեղ թվարկված նախավերջին կետը, պարզվում է, տարածված եղանակ է. S[:]-ը ստեղծում է sequence-ի object-ի վերին մակարդակի ամբողջական պատճեն՝ նույն value-ով, սակայն memory-ի առանձին հատվածում գտնվող object (պատճենների մասին ավելին կգտնեք Գլուխ 9-ում)։ Սա այնքան էլ օգտակար չէ string-երի նման immutable object-ների համար, սակայն

Սկզբնաղբյուրի PDF էջ 408

օգտակար է տեղում փոփոխվող object-ների, օրինակ՝ list-ների համար. պատճեն ստեղծելը կարող է կանխել Գլուխ 6-ում ցուցադրված ընդհանուր reference-ների կողմնակի ազդեցությունները։

Ինչպես նաև նշված է հուշաթերթում, slice-ներն index-ներից տարբերվում են սահմաններից՝ վերջից դուրս շեղումների նկատմամբ մոտեցմամբ. indexing-ի դեպքում դրանք միշտ սխալ են, քանի որ շեղումը գոյություն չունի, իսկ slicing-ի դեպքում հարմարեցվում են սահմանների մեջ տեղավորվելու համար, քանի որ սա կարող է օգտակար լինել այն program-երում, որոնք պետք է ճկուն կերպով հարմարվեն չափերին.

Գրքի code · PDF էջ 408

  >>> S = 'code'
  >>> S[99]
  IndexError: string index out of range
  >>> S[1:99]
  'ode'

Սակայն, քանի որ այս յուրահատկությունն ուսումնասիրելու ենք մասի վերջի վարժություններից մեկում, այստեղ պատմությունը կկարճենք։

Թեև հաճախ չի օգտագործվում, slice-ի expression-ները նաև աջակցում են ոչ պարտադիր երրորդ index-ի, որն օգտագործվում է որպես քայլ՝ երբեմն կոչվող քայլաչափ։ Քայլը գումարվում է յուրաքանչյուր առանձնացված տարրի index-ին։ Դրանով

Սկզբնաղբյուրի PDF էջ 409

slice-ի ամբողջական ձևը S[I:J:K]-ն է, որը նշանակում է՝ «առանձնացրու S-ի բոլոր տարրերը I շեղումից մինչև J −1՝ K քայլով»։ Երրորդ սահմանը՝ K-ն, լռելյայն +1 է, և այդ պատճառով սովորաբար slice-ի բոլոր տարրերն առանձնացվում են ձախից աջ։ Սակայն բացահայտ value նշելու դեպքում երրորդ սահմանը կարող եք օգտագործել՝ տարրեր բաց թողնելու կամ դրանց հերթականությունը շրջելու համար։

Օրինակ՝ S[1:10:2]-ը կստանա S-ի յուրաքանչյուր երկրորդ տարրը 1–9 շեղումներից, այսինքն՝ կհավաքի 1, 3, 5, 7 և

9 շեղումների տարրերը։ Ինչպես միշտ, առաջին և երկրորդ սահմանները լռելյայն համապատասխանաբար 0-ն ու sequence-ի երկարությունն են, ուստի X[::2]-ը ստանում է sequence-ի սկզբից մինչև վերջ յուրաքանչյուր երկրորդ տարրը.

Գրքի code · PDF էջ 409

  >>> S = 'abcdefghijklmnop'
  >>> S[1:10:2]                          # Skipping
  'bdfhj'
  >>> S[::2]
  'acegikmo'

Մեկնաբանություն, տող 2․ Բաց թողնելը

Կարող եք նաև օգտագործել բացասական քայլաչափ՝ տարրերը հակառակ հերթականությամբ հավաքելու համար։ Օրինակ՝ S[::−1] slicing-ի expression-ում առաջին երկու սահմանները լռելյայն sequence-ի երկարություն–1-ն ու –1-ն են (իրականում դրանք լռելյայն None և None են, սակայն այստեղ դա կարևոր չէ), իսկ −1 քայլաչափը ցույց է տալիս, որ slice-ը պետք է ընթանա աջից

Սկզբնաղբյուրի PDF էջ 410

ձախ՝ սովորական ձախից աջի փոխարեն։ Շատ ավելի պարզ ասած՝ արդյունքը sequence-ի շրջումն է.

Գրքի code · PDF էջ 410

  >>> S = 'hello'
  >>> S[::−1]                            # Reversin
  'olleh'

Մեկնաբանություն, տող 2․ Հակադարձու…

Բացասական քայլաչափի դեպքում առաջին երկու սահմանների իմաստներն ըստ էության շրջվում են։ Այսինքն՝ S[5:1:−1] slice-ը ստանում է 2-ից մինչև 5 տարրերը՝ հակառակ հերթականությամբ (արդյունքը պարունակում է 5, 4, 3 և 2 շեղումների տարրերը).

Գրքի code · PDF էջ 410

  >>> S = 'abcedfg'
  >>> S[5:1:−1]                          # Bounds r
  'fdec'

Մեկնաբանություն, տող 2․ Սահմանները՝ r… [կտրված է]

Այսպիսի բացթողումն ու շրջումը երեք սահմանով slice-ների ամենատարածված կիրառություններն են, սակայն լրացուցիչ մանրամասների համար տե՛ս Python-ի standard library-ի ձեռնարկը կամ մի քանի փորձարկում կատարեք ինտերակտիվ ձևով։ Գրքում ավելի ուշ նորից կվերադառնանք երեք սահմանով slice-ներին՝ for loop-ի statement-ի հետ համատեղ։

Գրքում ավելի ուշ նաև կիմանաք, որ slicing-ը համարժեք է slice object-ով indexing-ին. սա կարևոր բացահայտում է class-եր

Սկզբնաղբյուրի PDF էջ 411

գրողների համար, որոնք ցանկանում են աջակցել երկու գործողություններին էլ.

Գրքի code · PDF էջ 411

  >>> 'code'[1:3]                       # Slicing s
  'od'
  >>> 'code'[slice(1, 3)]               # Slice obj
  'od'
  >>> 'code'[::-1]
  'edoc'
  >>> 'code'[slice(None, None, -1)]
  'edoc'

Մեկնաբանություն, տող 1․ slicing՝ s… [կտրված է]

Մեկնաբանություն, տող 3․ slice-ի օբ…

Սկզբնաղբյուրի PDF էջ 412

ԻՆՉՈՒ ԴԱ ՁԵԶ ԿՀԵՏԱՔՐՔՐԻ. slice-ներ
Այս գրքի ամբողջ ընթացքում կհանդիպեք այսպիսի տարածված կիրառությունների ներդիրների, որոնք պատկերացում են տալիս, թե քննարկվող լեզվական որոշ հնարավորությունները սովորաբար ինչպես են օգտագործվում իրական program-երում։ Քանի որ իրատեսական կիրառությունները լավ չեք կարող հասկանալ, մինչև Python-ի ավելի մեծ պատկերին չծանոթանաք, այս ներդիրներն անխուսափելիորեն պարունակում են բազմաթիվ reference-ներ դեռ չներկայացված թեմաներին։ Առավելագույնը դրանք համարեք նախադիտումներ այն եղանակների, որոնցով լեզվի այս վերացական հասկացությունները կարող են օգտակար լինել գործնական programming-ի առաջադրանքների համար։

Օրինակ՝ հետագայում կտեսնեք, որ Python-ի program գործարկող համակարգային command line-ում նշված argument-ի բառերը հասանելի են դառնում built-in sys module-ի argv attribute-ում.

Գրքի code · PDF էջ 412

  # File echo.py
  import sys
  print(sys.argv)

Մեկնաբանություն, տող 1․ echo.py file

Գրքի code · PDF էջ 412

  $ python3 echo.py −a −b −c
  ['echo.py', '−a', '−b', '−c']

Սովորաբար հետաքրքրված եք միայն program-ի name-ին հաջորդող argument-ների ուսումնասիրությամբ։ Սա հանգեցնում է

Սկզբնաղբյուրի PDF էջ 413

slice-ների տիպիկ կիրառության. մեկ slice-ի expression-ով կարելի է վերադարձնել list-ի բոլոր տարրերը՝ բացի առաջինից։ Այստեղ sys.argv[1:]-ը վերադարձնում է ցանկալի list-ը՝ ['−a', '−b', '−c']։ Այնուհետև կարող եք մշակել այս list-ը՝ առանց սկզբում եղած program-ի name-ը հաշվի առնելու անհրաժեշտության։

slice-ները հաճախ օգտագործվում են նաև մուտքային file-երից կարդացված line-երը մաքրելու համար՝ այն տեսակի file-երից, որոնք կուսումնասիրենք Գլուխ 9-ում։ Եթե գիտեք, որ line-ի վերջում կլինի newline character՝ \n, կարող եք այն հեռացնել մեկ expression-ով, օրինակ՝ line[:−1], որն առանձնացնում է line-ի բոլոր character-երը՝ բացի վերջինից։ Երկու դեպքում էլ slice-ները կատարում են այն տրամաբանության աշխատանքը, որը ավելի ցածր մակարդակի լեզվում պետք է բացահայտ գրվի։

Այդուհանդերձ, newline character-երը հեռացնելու համար հաճախ նախընտրելի է կանչել line.rstrip method-ը, քանի որ այս կանչը line-ն անփոփոխ է թողնում, եթե վերջում newline character չկա. սա տարածված դեպք է որոշ տեքստային խմբագրման գործիքներով ստեղծված file-երում։ slicing-ն աշխատում է միայն այն դեպքում, երբ վստահ եք, որ line-ը պատշաճ կերպով ավարտված է։

Python-ի նախագծման կարգախոսներից մեկն այն է, որ այն մերժում է գուշակելու գայթակղությունը։ Որպես վառ օրինակ՝ Python-ում չեք կարող իրար գումարել թիվն ու string-ը, նույնիսկ եթե string-ը թվի տեսք ունի, այսինքն՝ ամբողջությամբ թվանշաններից է.

Սկզբնաղբյուրի PDF էջ 414

Գրքի code · PDF էջ 414

  >>> '62' + 1
  TypeError: can only concatenate str (not "int") t

Սա միտումնավոր է. քանի որ +-ը կարող է նշանակել և՛ գումարում, և՛ կցում, փոխակերպման ընտրությունը երկիմաստ կլիներ. ուզում եք '621', թե՞ 63։ Փոխարենը Python-ը սա համարում է սխալ։ Python-ում կախարդանքը հիմնականում բաց է թողնվում, եթե այն ավելի բարդ կդարձնի ձեր programmer-ի կյանքը։

Ուրեմն ի՞նչ անել, եթե ձեր script-ը file-ից կամ օգտատիրական interface-ից թիվ է ստանում որպես տեքստային string։ Հնարքն այն է, որ պետք է պարզապես օգտագործեք փոխակերպման գործիքներ՝ նախքան string-ին թվի պես վերաբերվելը կամ հակառակը։ Օրինակ՝

Գրքի code · PDF էջ 414

  >>> int('62'), str(62)          # Convert from/to
  (62, '62')

Մեկնաբանություն, տող 1․ Փոխակերպել …-ից/…-ի

int function-ը string-ը փոխակերպում է թվի, իսկ str function-ը թիվը՝ դրա string ներկայացման, այսինքն՝ հիմնականում այն տեսքի, որն այն ունի տպվելիս։ Այժմ, թեև +-ի նման operator-ների շուրջ չեք կարող խառնել string-երն ու numeric type-երը, անհրաժեշտության դեպքում կարող եք այդ գործողությունից առաջ operand-ները ձեռքով փոխակերպել.

Սկզբնաղբյուրի PDF էջ 415

Գրքի code · PDF էջ 415

  >>> S = '62'
  >>> I = 1
  >>> S + I
  TypeError: can only concatenate str (not "int") t

Գրքի code · PDF էջ 415

  >>> int(S) + I            # Force addition
  63

Մեկնաբանություն, տող 1․ Պարտադրել գումարում

Գրքի code · PDF էջ 415

  >>> S + str(I)            # Force concatenation
  '621'

Մեկնաբանություն, տող 1․ Պարտադրել կցում

Նմանատիպ built-in function-ներ կատարում են floating-point թվերի փոխակերպումները string-երից և string-երի, եթե expression-ներում պետք է խառնեք այդ երկուսը.

Գրքի code · PDF էջ 415

  >>> float('1.5') + 2.8
  4.3
  >>> '1.5' + str(2.8)
  '1.52.8'

Գլուխ 5-ում ներկայացված built-in eval function-ը կատարում է Python-ի expression-ի code պարունակող string-ը, ուստի կարող է նաև string-ը փոխակերպել ցանկացած տեսակի object-ի։ int և float function-ները փոխակերպում են միայն թվերի, սակայն այս սահմանափակումը նշանակում է, որ դրանք սովորաբար ավելի արագ են և ավելի անվտանգ, քանի որ չեն

Սկզբնաղբյուրի PDF էջ 416

ընդունում expression-ի կամայական code։ Ինչպես նաև համառոտ տեսանք Գլուխ 5-ում, string-երի ձևաչափումն առաջարկում է թվերը string-երի փոխակերպելու այլ եղանակներ. դրա մասին ավելին՝ առջևում։

Փոխակերպումների թեմայով՝ հնարավոր է նաև մեկ character-ը փոխակերպել դրա հիմքում ընկած ամբողջ թվային code-ին՝ այն փոխանցելով built-in ord function-ին։ Սա վերադարձնում է համապատասխան character-ը memory-ի մեջ ներկայացնելու համար օգտագործվող թվային «հերթական» value-ն՝ տեխնիկապես դրա Unicode code point-ը, ինչպես կիմանաք Գլուխ 37-ում, սակայն դա դեռ վճռորոշ չէ։ chr function-ը կատարում է հակառակ գործողությունը՝ ամբողջ թվային code-ը վերցնելով և այն համապատասխան character-ի փոխակերպելով.

Գրքի code · PDF էջ 416

  >>> ord('h')               # Character => ID (cod
  104
  >>> chr(104)               # ID => character (str
  'h'

Մեկնաբանություն, տող 1․ character => ID (code…

Մեկնաբանություն, տող 3․ ID => character (str… [կտրված է]

Գրքի code · PDF էջ 416

  >>> for c in 'hack':       # All code points in a
  ...     print(c, ord(c))
  ...
  h 104
  a 97

Մեկնաբանություն, տող 1․ Բոլոր code point-երը՝ մի …-ում

Սկզբնաղբյուրի PDF էջ 417

Գրքի code · PDF էջ 417

  c 99
  k 107

Ինչպես ցույց է տրված, կարող եք loop-ով ord-ը կիրառել string-ի բոլոր character-երի նկատմամբ, սակայն այս գործիքները կարելի է օգտագործել նաև string-երի վրա հիմնված պարզ մաթեմատիկա կատարելու համար։ Օրինակ՝ հաջորդ character-ին անցնելու համար փոխակերպեք և հաշվարկն արեք ամբողջ թվերով.

Գրքի code · PDF էջ 417

  >>> S = '5'
  >>> S = chr(ord(S) + 1)
  >>> S
  '6'
  >>> S = chr(ord(S) + 1)
  >>> S
  '7'

Առնվազն մեկ character-ից կազմված string-երի համար սա string-ից ամբողջ թվի փոխակերպելու համար built-in int function-ին այլընտրանք է տալիս, թեև իմաստ ունի միայն այն դեպքում, երբ character-երի հերթական արժեքները դասավորված են այնպես, ինչպես ակնկալում է ձեր code-ը.

Գրքի code · PDF էջ 417

  >>> int('5')
  5

Սկզբնաղբյուրի PDF էջ 418

Գրքի code · PDF էջ 418

  >>> ord('5') - ord('0')
  5

Հերթական value-ներն այստեղ ներկայացնելու մեկ այլ պատճառն այն է, որ դրանք օգնում են հասկանալ string-երի համեմատությունները. երբ համեմատում ենք երկու տեքստային string, Python-ն ինքնաբերաբար համեմատում է դրանք ձախից աջ, character առ character և բառարանագրական ձևով, այսինքն՝ character-երի code point-երի նույն value-ներով, որոնք վերադարձնում է ord-ը, մինչև առաջին անհամապատասխանությունը կամ string-երից որևէ մեկի ավարտը։ Օրինակ՝ հետևյալում t-ի code point-ն ավելի մեծ է, քան k-ինը, իսկ վերջում ավելի երկար string-ն է հաղթում.

Գրքի code · PDF էջ 418

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> 'hack' == 'hack', 'hact' > 'hack', 'hacker' >
  (True, True, True)

Նույնը վերաբերում է byte string-երին, որոնց կհանդիպեք Գլուխ 37-ում. դրանք համեմատվում են byte առ byte, մինչև արդյունքը հայտնի դառնա։ Հաջորդ գլխի ավելի հարուստ հավաքածուները, օրինակ՝ list-ները, նույն կերպ են վարվում. Python-ը ձեր փոխարեն համեմատում է դրանց բոլոր մասերը։

Սկզբնաղբյուրի PDF էջ 419

Հիշո՞ւմ եք immutable sequence եզրույթը։ Ինչպես տեսանք, sequence լինելը նշանակում է, որ string-երն աջակցում են կցման, կրկնման, indexing-ի և slicing-ի նման գործողություններին։ immutable մասը նշանակում է, որ string-ը չեք կարող փոխել տեղում, օրինակ՝ որևէ index-ին արժեք վերագրելով.

Գրքի code · PDF էջ 419

  >>> S = 'text'
  >>> S[0] = 'n'
  TypeError: 'str' object does not support item ass

Ուրեմն ինչպե՞ս Python-ում փոփոխել տեքստային տեղեկությունը։ string-ը փոխելու համար հիմնականում պետք է նոր string կառուցեք կցման ու slicing-ի նման գործիքներով և, ցանկության դեպքում, արդյունքը վերագրեք string-ի սկզբնական name-ին.

Գրքի code · PDF էջ 419

  >>> S = 'text'
  >>> S = S + 'ual!'           # To change a string
  >>> S
  'textual!'
  >>> S = S[:4] + ' processing' + S[-1]

Մեկնաբանություն, տող 2․ string-ը փոփոխելու համար

Սկզբնաղբյուրի PDF էջ 420

Գրքի code · PDF էջ 420

  >>> S
  'text processing!'

Առաջին օրինակը կցմամբ substring է ավելացնում S-ի վերջում։ Իրականում այն նոր string է ստեղծում և պահելու համար նորից assignment S-ին, սակայն սա կարող եք պատկերացնել որպես սկզբնական string-ի «փոփոխում»։ Երկրորդ օրինակը slicing-ի, indexing-ի և կցման միջոցով երեք character-ը փոխարինում է բազմաթիվ character-երով։ Ինչպես կտեսնեք հաջորդ բաժնում, նման ազդեցությունների կարելի է հասնել string-երի՝ replace-ի նման method-ներով.

Գրքի code · PDF էջ 420

  >>> S = 'text'
  >>> S = S.replace('ex', 'hough')
  >>> S
  'thought'

Ինչպես նոր string value տվող յուրաքանչյուր գործողություն, string method-ները ստեղծում են string-ի նոր object-ներ։ Եթե ցանկանում եք պահպանել այդ object-ները, կարող եք դրանք վերագրել variable-ների name-ների։ sequence-ների գործողություններով թե method-ներով՝ string-ի յուրաքանչյուր փոփոխության համար string-ի նոր object ստեղծելն այնքան անարդյունավետ չէ, որքան կարող է հնչել. հիշեք՝ ինչպես քննարկվեց նախորդ գլխում, Python-ն աշխատանքի ընթացքում ինքնաբերաբար garbage collection է հին չօգտագործվող string-ի object-ները՝ ազատելով դրանց զբաղեցրած տարածքը, այնպես որ նոր object-ները կրկին օգտագործում են

Սկզբնաղբյուրի PDF էջ 421

նախորդ value-ների զբաղեցրած տարածքը։ Python-ը սովորաբար ավելի արդյունավետ է, քան կարող եք ակնկալել։

Բայց string method-ները կարող են շատ ավելին անել, ինչպես կբացատրի հաջորդ բաժինը։

ՆՇՈՒՄ
Բացի bytearray-ից․ ինչպես նախնական ներկայացվեց Գլուխ 4-ում և կքննարկվի Գլուխ 37-ում, Python-ն ունի bytearray name-ով string type, որը mutable է և հետևաբար կարող է փոխվել տեղում։ bytearray object-ներն իրականում տեքստային string-եր չեն․ դրանք փոքր՝ 8-բիթանոց ամբողջ թվերի sequence-ներ են։ Սակայն աջակցում են սովորական string-երի նույն գործողությունների մեծ մասին և ցուցադրվելիս արտածվում են որպես ASCII character-եր։ Հետևաբար դրանք ևս մեկ տարբերակ են մեծ քանակի պարզ 8-բիթանոց տեքստի համար, որը պետք է հաճախ փոփոխվի։ Սակայն ավելի հարուստ Unicode տեքստը և առհասարակ str string-երը պահանջում են այստեղ ցուցադրված եղանակները։

Արդեն ներկայացված string բոլոր գործողություններից բացի՝ string-երը տրամադրում են method-ների հավաքածու, որն աջակցում է տեքստի մշակման ավելի բարդ նպատակներին։ Python-ում expression-ներն ու built-in function-ները կարող են աշխատել տարբեր type-երի հետ, բայց method-ներն ընդհանուր առմամբ հատուկ են object-ների type-երին․ օրինակ՝ string method-ներն աշխատում են միայն string-ի object-ների վրա։ Հետևողականության համար Python-ի տարբեր object-ներ օգտագործում են method-ների որոշ նույն name-ներ (օրինակ՝ շատերն ունեն

Սկզբնաղբյուրի PDF էջ 422

count և copy method-ներ, իսկ mutable object-ների մեծ մասը՝ pop), բայց դրանք, այնուամենայնիվ, ավելի շատ են կապված կոնկրետ type-ի հետ, քան մյուս գործիքները։

Ինչպես ներկայացվեց Գլուխ 4-ում, method-ները պարզապես function-ներ են, որոնք կապված են որոշակի object-ների հետ և գործում են դրանց վրա։ Տեխնիկապես դրանք object-ներին կցված attribute-ներ են, որոնք հղվում են կանչելի function-ների․ վերջիններս միշտ ունեն ենթադրվող գործողության առարկա։ Ավելի մանրամասն՝ function-ները code-ի package-ներ են, իսկ method-ների կանչերը միաժամանակ համադրում են երկու գործողություն՝ attribute-ի ստացում և կանչ․

attribute-ների ստացում
object.attribute ձևի expression-ը նշանակում է՝ «ստանալ object-ի attribute-ի value-ն»։
Կանչի expression-ներ
function(arguments) ձևի expression-ը նշանակում է՝ «գործարկել function-ի code-ը՝ դրան փոխանցելով զրո կամ ավելի ստորակետերով բաժանված argument-object-ներ, և վերադարձնել function-ի արդյունքի value-ն»։

Այս երկուսը համադրելը թույլ է տալիս կանչել object-ի method-ը։ method call-ի expression-ը՝

Սկզբնաղբյուրի PDF էջ 423

Գրքի code · PDF էջ 423

  object.method(arguments)

հաշվվում է ձախից աջ․ Python-ը նախ կստանա object-ի method-ը, ապա կկանչի այն՝ փոխանցելով և՛ object-ը, և՛ arguments-ը։ Կամ, պարզ բառերով, method call-ի expression-ը նշանակում է հետևյալը․

Գրքի code · PDF էջ 423

  Call method to process object with arguments.

Եթե method-ն արդյունք է հաշվում, այն նաև կվերադարձվի որպես method call-ի ամբողջ expression-ի արդյունք։ Որպես ավելի շոշափելի օրինակ՝

Գրքի code · PDF էջ 423

  >>> S = 'hack'
  >>> result = S.find('ac')     # Call the find met

Մեկնաբանություն, տող 2․ Կանչել find մե…

Այս համապատասխանությունը ճիշտ է թե՛ built-in type-երի, թե՛ օգտատիրոջ սահմանած class-երի method-ների համար, որոնք կուսումնասիրենք ավելի ուշ։ Ինչպես կտեսնեք գրքի այս մասում, object-ների մեծ մասն ունի կանչելի method-ներ, և բոլորին դիմում են method call-ի այս նույն syntax-ով։ object-ի method-ը կանչելու համար, ինչպես կտեսնեք հաջորդ բաժիններում, պետք է անցնեք արդեն գոյություն ունեցող object-ի միջոցով․ method-ները չեն կարող կատարվել (և գրեթե իմաստ չունեն) առանց գործողության առարկայի։

Սկզբնաղբյուրի PDF էջ 424

Աղյուսակ 7-3-ն ամփոփում է Python 3.12-ի built-in string object-ների method-ներն ու կանչերի ձևերը։ Դրանք ժամանակի ընթացքում փոխվում են, ուստի ամենաարդիական ցանկի համար անպայման ստուգեք Python-ի standard library-ի ձեռնարկը կամ ինտերակտիվորեն dir կամ help կանչ կատարեք ցանկացած string-ի կամ str type-ի name-ի վրա, ինչպես ցույց տրվեց Գլուխ 4-ում։

Այս աղյուսակում S-ը string-ի object է․ ոչ պարտադիր argument-ները վերցված են [] փակագծերի մեջ, ներդրված []-ը նշանակում է ոչ պարտադիր մաս՝ մեկ այլ ոչ պարտադիր մասից հետո, *X-ը և **X-ը նշանակում են ցանկացած քանակի X, իսկ թվարկված method-ներն իրականացնում են ավելի բարձր մակարդակի գործողություններ, ինչպիսիք են բաժանումն ու միացումը, տառերի մեծության փոխարկումները, բովանդակության ստուգումները և substring-երի որոնումն ու փոխարինումը։

Սկզբնաղբյուրի PDF էջ 425

Աղյուսակ 7-3. string method-ների կանչերը Python 3.12-ում

Բացել այս աղյուսակի ընթեռնելի ուղեցույցը →

Գրքի code · PDF էջ 425

 S.capitalize()           S.ljust(width [, fil
                          l])

Գրքի code · PDF էջ 425

 S.casefold()             S.lower()

Գրքի code · PDF էջ 425

 S.center(width [, fil   S.lstrip([chars])
 l])

Գրքի code · PDF էջ 425

 S.count(sub [, start    S.maketrans(x [, y [,
 [, end]])                z]])

Գրքի code · PDF էջ 425

 S.encode([encoding [,   S.partition(sep)
 errors]])

Գրքի code · PDF էջ 425

 S.endswith(suffix [,    S.removeprefix(prefix)
 start [, end]])

Գրքի code · PDF էջ 425

 S.expandtabs([tabsiz     S.removesuffix(suffix)
 e])

Գրքի code · PDF էջ 425

 S.find(sub [, start     S.replace(old, new [,
 [, end]])                count])

Գրքի code · PDF էջ 425

 S.format(fmtstr, *arg   S.rfind(sub [, start
 s, **kwargs)            [, end]])

Սկզբնաղբյուրի PDF էջ 426

Գրքի code · PDF էջ 426

 S.format_map(mapping)   S.rindex(sub [, start
                          [, end]])

Գրքի code · PDF էջ 426

 S.index(sub [, start    S.rjust(width [, fil
 [, end]])               l])

Գրքի code · PDF էջ 426

 S.isalnum()              S.rpartition(sep)

Գրքի code · PDF էջ 426

 S.isalpha()              S.rsplit([sep [, maxsp
                          lit]])

Գրքի code · PDF էջ 426

 S.isascii()              S.rstrip([chars])

Գրքի code · PDF էջ 426

 S.isdecimal()            S.split([sep [, maxspl
                          it]])

Գրքի code · PDF էջ 426

 S.isdigit()              S.splitlines([keepend
                          s])

Գրքի code · PDF էջ 426

 S.isidentifier()         S.startswith(prefix [,
                          start [, end]])

Գրքի code · PDF էջ 426

 S.islower()              S.strip([chars])

Գրքի code · PDF էջ 426

 S.isnumeric()            S.swapcase()

Գրքի code · PDF էջ 426

 S.isprintable()          S.title()

Սկզբնաղբյուրի PDF էջ 427

Գրքի code · PDF էջ 427

 S.isspace()              S.translate(map)

Գրքի code · PDF էջ 427

 S.istitle()              S.upper()

Գրքի code · PDF էջ 427

 S.isupper()              S.zfill(width)

Գրքի code · PDF էջ 427

 S.join(iterable)

Ինչպես տեսնում եք, string-երն ունեն բազմաթիվ method-ներ, և այստեղ տեղ չունենք բոլորը քննարկելու համար․ անհրաժեշտության դեպքում բաց թողնվածները կարելի է գտնել այլ աղբյուրներում։ Բայց սկսելու համար անցնենք մի քանի օրինակների, որոնք ցույց են տալիս ամենահաճախ օգտագործվող որոշ method-ներ գործողության մեջ և ընթացքում բացատրում Python-ում տեքստի մշակման հիմունքները։

Սկզբնաղբյուրի PDF էջ 428

Ինչպես տեսանք, string-երի մեծ մասը չի կարող ուղղակիորեն փոխվել տեղում, քանի որ դրանք immutable են։ Նախորդ բաժնում ուսումնասիրեցինք string-երը փոխելը sequence-ի գործողություններով, բայց այստեղ շարունակենք այդ պատմությունը method-ների համատեքստում։

Վերանայելու համար՝ առկա string-ից նոր տեքստային value ստանալու համար կարող եք կառուցել նոր string՝ sequence-ի այնպիսի գործողություններով, ինչպիսիք են slicing-ն ու միակցումը։ Օրինակ՝ string-ի մեջտեղի երկու character-ը փոխարինելու համար կարող եք օգտագործել այսպիսի code՝ գրեթե այնպես, ինչպես արեցինք նախորդ բաժնում․

Գրքի code · PDF էջ 428

  >>> S = 'textly!'
  >>> S[:4] + 'ful' + S[-1]             # Make a ne
  'textful!'

Մեկնաբանություն, տող 2․ Ստեղծել նոր…

Բայց եթե ձեր նպատակը պարզապես substring փոխարինելն է, փոխարենը կարող եք օգտագործել string-ի replace method-ը․

Գրքի code · PDF էջ 428

  >>> S = 'textly!'
  >>> S.replace('ly', 'ful')            # Replace a
  'textful!'

Մեկնաբանություն, տող 2․ Փոխարինել a… [կտրված է]

Սկզբնաղբյուրի PDF էջ 429

replace method-ն ավելի ընդհանուր է, քան այս code-ից կարող է թվալ։ Այն որպես argument ընդունում է սկզբնական substring-ը (ցանկացած երկարության) և այն փոխարինող նոր substring-ը (ցանկացած երկարության) ու կատարում համատարած որոնում և փոխարինում՝ հաշվի առնելով ոչ պարտադիր երրորդ argument-ը, որը սահմանափակում է կատարվող փոխարինումների քանակը․

Գրքի code · PDF էջ 429

  >>> '--@--@--@--'.replace('@', 'PY', 2)
  '--PY--PY--@--'

Այս դերում replace-ը կարող է օգտագործվել որպես պարզ ձևանմուշային փոխարինումներ իրականացնելու գործիք (օրինակ՝ ստանդարտ նամակներում)։ Եթե պետք է փոխարինեք մեկ ֆիքսված չափի string, որը կարող է հանդիպել ցանկացած դիրքում, կարող եք կրկին փոխարինում կատարել կամ substring-ը գտնել string-ի find method-ով, ապա կատարել slice․

Գրքի code · PDF էջ 429

  >>> S = 'xxxxPYxxxxPYxxxx'
  >>> where = S.find('PY')              # Search fo
  >>> where                             # Occurs at
  4
  >>> S = S[:where] + 'CODE' + S[(where+2):]
  >>> S
  'xxxxCODExxxxPYxxxx'

Մեկնաբանություն, տող 2․ Փնտրել…

Մեկնաբանություն, տող 3․ Հանդիպում է … դիրքում

Սկզբնաղբյուրի PDF էջ 430

find method-ը վերադարձնում է այն դիրքի շեղումը, որտեղ հայտնվում է substring-ը, կամ −1, եթե այն չի գտնվում (լռելյայն որոնում է սկզբից, իսկ դրա ազգական rfind-ը որոնում է հակառակ ուղղությամբ)։ Ինչպես տեսանք ավելի վաղ, սա substring-ի որոնման գործողություն է՝ ճիշտ ինչպես in expression-ը, բայց find-ը վերադարձնում է գտնված substring-ի դիրքը։ Այս համատեքստում replace-ը գործն ավելի հեշտ է անում և կարող է ավելին անել․ հետևյալում փոխարինվում են և՛ մի քանի հանդիպումներ, և՛ մի քանի թիրախներ․

Գրքի code · PDF էջ 430

  >>> S = 'xxxxPYxxxxPYxxxx'
  >>> S.replace('PY', 'CODE', 1)        # Replace o
  'xxxxCODExxxxPYxxxx'

Մեկնաբանություն, տող 2․ Փոխարինել մե…

Գրքի code · PDF էջ 430

  >>> S.replace('PY', 'CODE')           # Replace a
  'xxxxCODExxxxCODExxxx'

Մեկնաբանություն, տող 1․ Փոխարինել a… [կտրված է]

Գրքի code · PDF էջ 430

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> 'xxxxWHATxxxxHOWxxxx'.replace('WHAT', 'CODE'
  'xxxxCODExxxxPYTHONxxxx'

Հիշեցնենք, որ replace-ը յուրաքանչյուր անգամ վերադարձնում է նոր string-ի object (դրա համար այստեղ երկու կանչ կարելի է շղթայել)։ Քանի որ string-երն immutable են, method-ները, ինչպես sequence-ի գործողությունները, իրականում երբեք տեղում չեն փոխում այն string-ը, որի վրա գործում են, նույնիսկ եթե կոչվում են «replace»։ method call-ի ստեղծած նոր string-ի object-ը պահելու համար այն վերագրեք որևէ name-ի․

Սկզբնաղբյուրի PDF էջ 431

Գրքի code · PDF էջ 431

  >>> S = S.replace('PY', 'CODE')
  >>> S
  'xxxxCODExxxxCODExxxx'

Այն փաստը, որ միակցման գործողություններն ու replace method-ը յուրաքանչյուր runtime ստեղծում են string-ի նոր object-ներ, դրանց միջոցով string-եր փոխելու հնարավոր թերությունն է․ յուրաքանչյուր միջանկյալ արդյունք պետք է ստեղծի լիարժեք object՝ իր տեքստի նոր պատճենով։ Եթե շատ մեծ string-ի վրա բազմաթիվ փոփոխություններ պետք է կիրառեք, գուցե կարողանաք բարձրացնել ձեր script-ի արտադրողականությունը՝ string-ը փոխարկելով տեղում փոփոխություններին աջակցող object-ի․

Գրքի code · PDF էջ 431

  >>> S = 'text'
  >>> L = list(S)                       # Explode s
  >>> L
  ['t', 'e', 'x', 't']

Մեկնաբանություն, տող 2․ Բաժանել s… [կտրված է]

built-in list function-ը (իրականում՝ object-ի կառուցման կանչ) ցանկացած sequence-ի (կամ այլ iterable object-ի) տարրերից կառուցում է նոր list․ այս դեպքում string-ի character-երը «ցրում» է list-ի մեջ։ Երբ string-ն այս ձևով է, կարող եք դրանում կատարել բազմաթիվ փոփոխություններ՝ առանց յուրաքանչյուր փոփոխության համար նոր պատճեն ստեղծելու․

Սկզբնաղբյուրի PDF էջ 432

Գրքի code · PDF էջ 432

  >>> L[0] = 'h'                        # Works for
  >>> L[3] = '!'
  >>> L
  ['h', 'e', 'x', '!']

Մեկնաբանություն, տող 1․ Աշխատում է … համար

Փոփոխություններից հետո անհրաժեշտության դեպքում (օրինակ՝ file-ում գրելու համար) կարող եք նորից փոխարկել string-ի՝ string-ի join method-ով list-ը կրկին մեկ string-ի մեջ «հավաքելով»․

Գրքի code · PDF էջ 432

  >>> S = ''.join(L)                    # Implode b
  >>> S
  'hex!'

Մեկնաբանություն, տող 1․ Միավորել b… [կտրված է]

Առաջին հանդիպման ժամանակ join method-ը կարող է մի փոքր հակառակ թվալ։ Քանի որ այն string-երի (ոչ թե list-ների) method է, կանչվում է ցանկալի բաժանիչ string-ի միջոցով։ join-ը list-ի (կամ այլ iterable object-ի) string-երը միացնում է՝ list-ի տարրերի միջև դնելով բաժանիչը․ այս դեպքում այն օգտագործում է դատարկ string բաժանիչ՝ list-ից կրկին string-ի փոխարկելու համար։ Ավելի ընդհանուր դեպքում հարմար է ցանկացած string բաժանիչ և string-երի iterable object․

Գրքի code · PDF էջ 432

Աղբյուրում line-ի վերջը կտրված է։ Սա գործարկելիության երաշխիքով օրինակ չէ։ Տես ստուգված համարժեքները։

  >>> 'PY'.join(['which', 'language', 'is', 'best'
  'whichPYlanguagePYisPYbestPY?'

Սկզբնաղբյուրի PDF էջ 433

Թեև դա կախված է Python-ի implementation-ից, substring-երը միանգամից միացնելը կարող է ավելի արագ աշխատել, քան դրանք առանձին-առանձին միակցելը։ Ավելի վաղ նշված mutable bytearray string-ը նույնպես կարող է օգնել արդյունավետության հարցում․ քանի որ այն կարող է փոխվել տեղում, ASCII-ի նման պարզ, մեկ byte-ի չափով character-եր ունեցող տեքստերի համար առաջարկում է այս list / join համակցության այլընտրանքը։

string method-ների մեկ այլ տարածված դեր է տեքստի վերլուծության պարզ ձևը, այսինքն՝ կառուցվածքի վերլուծությունն ու substring-երի առանձնացումը։ Ֆիքսված դիրքերից substring-եր վերցնելու համար կարող ենք կիրառել slicing-ի եղանակներ․

Գրքի code · PDF էջ 433

  >>> line = 'aaa bbb ccc'

Գրքի code · PDF էջ 433

  >>> col1 = line[:3]
  >>> col2 = line[4:8]
  >>> col3 = line[-3:]

Գրքի code · PDF էջ 433

  >>> col1, col2, col3
  ('aaa', 'bbb ', 'ccc')

Այստեղ տվյալների սյունակները հայտնվում են ֆիքսված դիրքերում և հետևաբար կարող են slicing-ով առանձնացվել սկզբնական string-ից։ Այս եղանակը կարելի է համարել

Սկզբնաղբյուրի PDF էջ 434

վերլուծություն, քանի դեռ ձեր տվյալների բաղադրիչներն ունեն հայտնի դիրքեր։ Իսկ եթե տվյալներն իրարից առանձնացնում է ինչ-որ բաժանիչ, բաղադրիչները կարող եք վերցնել բաժանելու միջոցով։ Սա կաշխատի նույնիսկ այն դեպքում, երբ տվյալները string-ի ներսում կարող են հայտնվել կամայական դիրքերում․

Գրքի code · PDF էջ 434

  >>> line = 'aaa bbb     ccc'
  >>> cols = line.split()
  >>> cols
  ['aaa', 'bbb', 'ccc']

string-ի split method-ը string-ը մասնատում է substring-երի list-ի՝ բաժանիչ string-ի շուրջ։ Նախորդ օրինակում բաժանիչ չէինք փոխանցել, ուստի լռելյայն օգտագործվում են բացատային character-երը․ string-ը բաժանվում է մեկ կամ ավելի բացատների, tab-ների և newline-երի խմբերի տեղերում, և մենք հետ ենք ստանում արդյունք substring-երի list-ը։ Այլ կիրառություններում տվյալները կարող են առանձնացնել ավելի շոշափելի բաժանիչներ։ Ցուցադրելու համար հաջորդ օրինակը string-ը բաժանում է (և հետևաբար վերլուծում է) ստորակետերով՝ տվյալների բազաների որոշ դերերում տարածված բաժանիչով (ավելի վաղ քննարկված string-ի փոխարկման գործիքները կարող են այստեղ substring-երը թվերի փոխարկել)․

Գրքի code · PDF էջ 434

  >>> line = 'Python,3.12,scripting,33'
  >>> line.split(',')

Սկզբնաղբյուրի PDF էջ 435

Գրքի code · PDF էջ 435

  ['Python', '3.12', 'scripting', '33']

Բաժանիչները կարող են նաև մեկ character-ից երկար լինել․

Գրքի code · PDF էջ 435

  >>> line = 'youPYarePYaPYstringPYcoder'
  >>> line.split('PY')
  ['you', 'are', 'a', 'string', 'coder']

Թեև slicing-ի և բաժանման վերլուծական հնարավորությունները սահմանափակ են, երկուսն էլ արագ են աշխատում և կարող են կատարել տեքստի առանձնացման հիմնական գործերը։ Ստորակետերով բաժանված տեքստային տվյալները նաև CSV file-ի ձևաչափի մասն են․ այս ուղղությամբ ավելի առաջադեմ գործիքի համար տե՛ս նաև Python-ի standard library-ի csv module-ը։

string-ի մյուս method-ներն ավելի նեղ նպատակներ ունեն, օրինակ՝ text line-ի վերջից հեռացնել բացատային character-երը, փոխարկել տառերի մեծությունն ու փոքրությունը, ստուգել բովանդակությունը և ստուգել substring-ի առկայությունը վերջում կամ սկզբում․

Գրքի code · PDF էջ 435

  >>> line = "Python's strings are awesome!\n"

Գրքի code · PDF էջ 435

  >>> line.rstrip()                       # Drop wh
  "Python's strings are awesome!"

Մեկնաբանություն, տող 1․ Հեռացնել բացատա…

Սկզբնաղբյուրի PDF էջ 436

Գրքի code · PDF էջ 436

  >>> line.upper()                        # Case co
  "PYTHON'S STRINGS ARE AWESOME!\n"
  >>> line.isalpha()                      # Content
  False
  >>> line.endswith('awesome!\n')         # Suffix
  True
  >>> line.startswith('Python')
  True

Մեկնաբանություն, տող 1․ Տառաչափի փոխա…

Մեկնաբանություն, տող 3․ Բովանդակություն

Մեկնաբանություն, տող 5․ Վերջածանց

string method-ների նույն արդյունքներին հասնելու համար երբեմն կարելի է օգտագործել նաև այլընտրանքային եղանակներ․ օրինակ՝ in անդամության operator-ը կարելի է օգտագործել substring-ի առկայությունը ստուգելու համար, իսկ երկարության և slicing-ի գործողությունները՝ endswith-ը նմանակելու համար․

Գրքի code · PDF էջ 436

  >>> line.find('awesome') != -1          # Search
  True
  >>> 'awesome' in line
  True

Մեկնաբանություն, տող 1․ Որոնում

Գրքի code · PDF էջ 436

  >>> sub = 'awesome!\n'
  >>> line.endswith(sub)                  # End tes
  True
  >>> line[-len(sub):] == sub
  True

Մեկնաբանություն, տող 2․ Վերջավորության ստու…

Սկզբնաղբյուրի PDF էջ 437

Նկատի ունեցեք, որ string method-ներից ոչ մեկը նմուշներ չի ընդունում․ նմուշների վրա հիմնված տեքստի մշակման համար պետք է օգտագործեք Python-ի standard library-ի re module-ը՝ առաջադեմ գործիք, որը համառոտ կներկայացվի Գլուխ 37-ում, բայց հիմնականում այս գրքի շրջանակներից դուրս է։ Սակայն իրենց սահմանափակումների շնորհիվ string method-ները կարող են ավելի արագ աշխատել, քան re module-ի գործիքները։

Կրկին՝ քանի որ string-երի համար այդքան շատ method-ներ կան, այստեղ չենք դիտարկի դրանցից յուրաքանչյուրը։ Գրքի հետագա մասում կտեսնեք string-երի մի քանի լրացուցիչ օրինակներ, բայց մանրամասների համար կարող եք նաև դիմել Python-ի library-ի ձեռնարկին և այլ տեղեկատու աղբյուրների կամ պարզապես ինքնուրույն ինտերակտիվ փորձեր կատարել։ Ինչպես նշվեց Գլուխ 4-ում, help(S.method)-ը տեղեկություն է տալիս ցանկացած S string-ի object-ի method-ի մասին․ եթե S չունեք, օգտագործեք help(str.method)։

Այս ամենով հանդերձ, այս բաժնի քննարկման մեջ մեկ method նկատելիորեն բացակայում է․ format-ը կատարում է string-ի ձևաչափում, որը մեկ քայլում համադրում է բազմաթիվ գործողություններ։ Այն նաև Python-ի ավելի մեծ թեմայի մաս է, որին անցնում ենք հաջորդիվ։

interpreted և compiled․ ամբողջ ճանապարհը

Լեզուն և implementation-ը

Python-ը լեզվի անունն է․ դրանով նկարագրվում են program-ի գրության և վարքի կանոնները։ CPython-ն այդ լեզուն իրականացնող կոնկրետ համակարգ է։ Ուրիշ implementation-ը կարող է այլ կերպ կազմակերպել ներքին աշխատանքը՝ պահելով լեզվի հիմնական վարքը։ Ուստի «Python-ը interpreted է» expression-ը պետք է բացել իրական կատարման քայլերով, ոչ միայն համեմատել պիտակները։

name՝ a · reference · object՝ [1, 2] · type՝ list · name-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։name՝ areferenceobject՝ [1, 2]type՝ listname-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։

compilation-ը պարտադիր machine code չէ

compilation-ը ներկայացման փոխակերպում է։ C/C++-ի սովորական գործիքաշարում արդյունքը կարող է հասնել processor-ի machine code-ին։ CPython-ի սովորական ճանապարհի միջանկյալ արդյունքը bytecode է, որը կատարում է interpreter-ը։ Նախապես կամ runtime compilation-ը և ստատիկ կամ dynamic typing-ն առանձին հարցեր են։

C/C++ · source code · compilation և · assembly · linking · library-ների հետ · machine code-ի · կատարում · Սովորական ahead-of-time compiled գործիքաշարի պարզեցված պատկերը։C/C++source codecompilation ևassemblylinkinglibrary-ների հետmachine code-իկատարումՍովորական ahead-of-time compiled գործիքաշարի պարզեցված պատկերը։

CPython-ի կատարումը՝ մարդու լեզվով

Պատկերացրու, որ քո գրած program-ը նախ վերածվում է համակարգին հարմար հրահանգների, իսկ հետո այդ հրահանգները կատարվում են։ Քո .py տեքստը պարզապես CPU-ին հանձնվող machine instruction-ների նույն շարքը չէ։ Ամբողջ script-ի syntax error-ը կարող է հայտնաբերվել դեռ նրա հրահանգները կատարելուց առաջ։ interactive environment-ում, սակայն, նախորդ մուտքերն արդեն կարող էին կատարված լինել՝ մինչև հաջորդ սխալ մուտքը։

Python · source code · compilation · դեպի bytecode · interpreter-ի · կատարում · program-ի · արդյունք · Python-ը և CPython իրականացումը տարբեր հասկացություններ են։Pythonsource codecompilationդեպի bytecodeinterpreter-իկատարումprogram-իարդյունքPython-ը և CPython իրականացումը տարբեր հասկացություններ են։

Ինչ է պահվում __pycache__-ում

Ներմուծվող module-ի .pyc cache-ը կարող է խուսափել հաջորդ բեռնման ժամանակ աղբյուրից նորից bytecode ստանալուց։ Այն ինքնին չի դարձնում հաշվարկի algorithm-ն ավելի արագ, մեքենայական անկախ program չի ստեղծում և սկզբնական program-ի գաղտնագրման երաշխիք չէ։ Ուղղակի գործարկված գլխավոր file-ի և ներմուծվող module-ի վարքն այստեղ պետք է տարբերել։

Python · source code · compilation · դեպի bytecode · interpreter-ի · կատարում · program-ի · արդյունք · Python-ը և CPython իրականացումը տարբեր հասկացություններ են։Pythonsource codecompilationդեպի bytecodeinterpreter-իկատարումprogram-իարդյունքPython-ը և CPython իրականացումը տարբեր հասկացություններ են։

Արագությունը մի գործոն չունի

program-ի արագության վրա ազդում են algorithm-ը, տվյալների կառուցվածքը, իրականացումը, օգտագործվող library-ն և իրական ծանրաբեռնվածությունը։ Python program-ի որոշ աշխատանք կարող է կատարվել compiled library-ում։ Որոշ իրականացումներ օգտագործում են նաև JIT մոտեցումներ։ Սա չի նշանակում, որ Python-ի ամեն տեղադրում կամ յուրաքանչյուր տող նույն եղանակով է օպտիմացվում։

Մուտք · Գործողություն · Արդյունք · Քայլերով հասկանալը հեշտացնում է կիրառությունը։ՄուտքԳործողությունԱրդյունքՔայլերով հասկանալը հեշտացնում է կիրառությունը։

type hint-ը և կատարման կանոնը

age: int գրառումը կարող է օգտակար լինել փաստաթղթավորման և type checker-ների համար։ Բայց դրանից ինքնաշխատ չի հետևում, որ CPython-ն ամեն assignment-ի ժամանակ կհրաժարվի str արժեքից։ Միաժամանակ սխալ կլինի ասել, թե annotation-ները երբեք գոյություն չունեն runtime․ դրանք կարող են կարդացվել գործիքների և library-ների կողմից։

a · b · list [1, 2] · c → [1, 2] · Նույն արժեքը և նույն object-ը նույն հարցը չեն։ablist [1, 2]c → [1, 2]Նույն արժեքը և նույն object-ը նույն հարցը չեն։

Տեխնիկական հիմք՝ Python Glossary, Modules, GCC stages։

Ավելացված և ստուգված օրինակներ

Վաղ հանդիպող ձևավորման օրինակ

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 185, 186

tool, major, minor = 'Demo', 3, 12
a = 'Using %s version %s.%s' % (tool, major, minor)
b = 'Using {} version {}.{}'.format(tool, major, minor)
c = '{1:,.2f} / {0}'.format('code'[1:], 12345.67)
assert a == b == 'Using Demo version 3.12'
assert c == '12,345.67 / ode'
print(a)
print(c)
Ստուգման իրական արտածումը
Using Demo version 3.12
12,345.67 / ode

Փոխարինվող արժեքները լրիվ փոխանցված են։ Երկրորդ օրինակը նախ տողից ընտրում է մի հատված, ապա ձևավորում թիվը։ Սա նախորդ էջերում հանդիպող օրինակի ստուգված համարժեքն է, ոչ 438-րդ էջից սկսվող բաժնի ամբողջ դասը։

Ներդրված արդյունք comprehension-ով

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 204

rows = [[x, x // 2, x * 2] for x in range(-4, 5, 2)]
assert rows == [[-4, -2, -8], [-2, -1, -4], [0, 0, 0],
                [2, 1, 4], [4, 2, 8]]
print(rows)
Ստուգման իրական արտածումը
[[-4, -2, -8], [-2, -1, -4], [0, 0, 0], [2, 1, 4], [4, 2, 8]]

Արտաքին անցումը ընտրում է x-ը, իսկ ներսի expression-ը յուրաքանչյուր x-ի համար նոր list է ստեղծում։

a = [1, 2] · a.append(3) · նույն list-ը · [1, 2, 3] · Փոփոխությունը կատարվում է object-ի մեջ․ անունը կարող է մնալ նույնը։a = [1, 2]a.append(3)նույն list-ը[1, 2, 3]Փոփոխությունը կատարվում է object-ի մեջ․ անունը կարող է մնալ նույնը։

Զուգավորումից dictionary

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 209

keys = ['name', 'job', 'age']
values = ['Ani', 'researcher', 25]
record = dict(zip(keys, values))
assert record == {'name': 'Ani', 'job': 'researcher', 'age': 25}
print(record)
Ստուգման իրական արտածումը
{'name': 'Ani', 'job': 'researcher', 'age': 25}

zip-ը զուգավորում է համապատասխան տարրերը, իսկ dict-ը զույգերից ստանում է key–value կապեր։

name · "Ani" · age · 20 · key-ը կապվում է value-ի հետ․ key-ը պարտադիր թվային index չէ։name"Ani"age20key-ը կապվում է value-ի հետ․ key-ը պարտադիր թվային index չէ։

Ներդրված տվյալների ընտրություն

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 210

record = {'name': {'first': 'Ani', 'last': 'Petrosyan'},
          'job': ['developer', 'teacher'], 'age': 25}
assert record['name']['first'] == 'Ani'
assert record['job'][1] == 'teacher'
print(record['name']['first'], record['job'][1])
Ստուգման իրական արտածումը
Ani teacher

Առաջին indexing-ը ընտրում է արտաքին dictionary-ի value-ն, հաջորդը՝ արդեն ընտրված object-ի տարրը։

արտաքին a · պատճեն b · ընդհանուր ներքին list · a[0] · b[0] · shallow copy-ը կարող է պահպանել ներքին ընդհանուր reference-ները։արտաքին aպատճեն bընդհանուր ներքին lista[0]b[0]shallow copy-ը կարող է պահպանել ներքին ընդհանուր reference-ները։

Տեքստ, UTF-8 և file-ի byte-եր

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 229

text = '🐍hÄck👏'
f = open('unicode_demo.txt', 'w', encoding='utf-8')
assert f.write(text) == 6
f.close()
f = open('unicode_demo.txt', 'r', encoding='utf-8')
restored = f.read()
f.close()
f = open('unicode_demo.txt', 'rb')
raw = f.read()
f.close()
assert restored == text and len(raw) == 13
print(len(text), len(raw))
print(restored)
Ստուգման իրական արտածումը
6 13
🐍hÄck👏

Նույն տեղեկությունը տեքստային մակարդակում ունի 6 code point, իսկ UTF-8-ով պահպանված file-ում՝ 13 byte։ Փորձարկման file-ը ստեղծվում է միայն առանձնացված ժամանակավոր directory-ում։

Տեքստ՝ str · 6 code point · UTF-8 encoding · 13 byte · «🐍hÄck👏» օրինակում code point-երի և byte-երի քանակները տարբեր են։Տեքստ՝ str6 code pointUTF-8 encoding13 byte«🐍hÄck👏» օրինակում code point-երի և byte-երի քանակները տարբեր են։

Թվային գրառման տարբեր հիմքեր

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 285, 286, 287, 288

assert 0xF == 0b1111 == 15
assert (1 * 2**3 + 1 * 2**2 + 1 * 2**1 + 1) == 15
assert int('64') == int('100', 8) == int('40', 16) == 64
assert eval('0x40') == 64
print(oct(64), bin(64), hex(255))
print('{:o}, {:b}, {:x}, {:#X}'.format(64, 64, 255, 255))
Ստուգման իրական արտածումը
0o100 0b1000000 0xff
100, 1000000, ff, 0XFF

Հիմքը փոխում է գրառումը, ոչ թվի արժեքը։ eval-ի այստեղի մուտքը հաստատուն, հայտնի code է․ սովորական թվային տեքստը վերլուծելու համար int-ը խուսափում է կամայական code կատարելուց։

0b1111 · 15 · 0o17 · 0xF · Սրանք նույն ամբողջ թվի տարբեր գրառումներ են։0b1111150o170xFՍրանք նույն ամբողջ թվի տարբեր գրառումներ են։

Գրառման բաժանարարն ու float մոտարկումը

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 293

assert 1234.125 == 1_234.125
assert 0.1 + 0.2 != 0.3
print(format(0.1, '.20f'))
print(0.1 + 0.2)
Ստուգման իրական արտածումը
0.10000000000000000555
0.30000000000000004

Ընդգծումը թվային literal-ում ընթերցելիության համար է։ Իսկ երկուական float-ի մոտարկման խնդիրը առանձին հարց է։

Տասնորդական · 0.1 · Երկուական · մոտարկում · Տեսանելի · արդյունք · 0.100000… · Float-ի ներկայացումը և էկրանին ընտրված ձևավորումը տարբեր փուլեր են։Տասնորդական0.1ԵրկուականմոտարկումՏեսանելիարդյունք0.100000…Float-ի ներկայացումը և էկրանին ընտրված ձևավորումը տարբեր փուլեր են։

Կլորացման դիրքի ընտրություն

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 298

assert round(2.567) == 3
assert round(2.567, 2) == 2.57
assert round(2567, -3) == 3000
assert round(2.5) == 2 and round(3.5) == 4
print(round(2.567), round(2.567, 2), round(2567, -3))
print(1 / 3, round(1 / 3, 2), f'{1 / 3:.2f}')
Ստուգման իրական արտածումը
3 2.57 3000
0.3333333333333333 0.33 0.33

Դրական երկրորդ argument-ը ընտրում է ստորակետից հետո դիրքերը, բացասականը՝ ստորակետից առաջ։ Float-ի արժեքն ու նրա էկրանային ձևավորումը պետք է տարբերել։

Ընտրություն և խառնում

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 300

import random
rng = random.Random(7)
foods = ['Pizza', 'Tacos', 'Tikka', 'Soup']
chosen = rng.choice(foods)
assert chosen in foods
suits = ['hearts', 'clubs', 'diamonds', 'spades']
cards = [(rank, suit) for suit in suits for rank in range(1, 14)]
assert len(cards) == 52
rng.shuffle(cards)
assert len(set(cards)) == 52
print(chosen, len(cards))
Ստուգման իրական արտածումը
Tikka 52

Ընտրությունը վերցնում է մեկ տարր։ Խառնելը փոխում է հերթականությունը, բայց չպետք է կորցնի կամ կրկնի քարտերը։ Առանձին Random object-ը փորձի վիճակը չի խառնում մյուս օրինակներին։

Decimal՝ տեքստից և float-ից

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 303, 304, 305

from decimal import Decimal, getcontext
getcontext().prec = 28
exact = Decimal('0.1') + Decimal('0.1') + Decimal('0.1')
assert exact - Decimal('0.3') == 0
assert Decimal(0.1) != Decimal('0.1')
print(exact)
print(Decimal(0.1))
Ստուգման իրական արտածումը
0.3
0.1000000000000000055511151231257827021181583404541015625

Տեքստից կառուցված արժեքները չեն inheritance նախորդ float-ի մոտարկումը։ Decimal-ը, այնուամենայնիվ, ունի ճշտության համատեքստ․ անսահման ճշտության ընդհանուր երաշխիք չէ։

Տասնորդական · 0.1 · Երկուական · մոտարկում · Տեսանելի · արդյունք · 0.100000… · Float-ի ներկայացումը և էկրանին ընտրված ձևավորումը տարբեր փուլեր են։Տասնորդական0.1ԵրկուականմոտարկումՏեսանելիարդյունք0.100000…Float-ի ներկայացումը և էկրանին ընտրված ձևավորումը տարբեր փուլեր են։

Ռացիոնալ և տասնորդական հաշվարկի տարբեր ուղիներ

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 309, 311

from fractions import Fraction
from decimal import Decimal, getcontext
getcontext().prec = 28
assert Fraction(1, 10) * 3 == Fraction(3, 10)
assert Fraction(1, 3) + Fraction(6, 3) == Fraction(7, 3)
direct = Decimal(1) / Decimal(3)
from_float = Decimal(1 / 3)
assert direct != from_float
print(Fraction(1, 3) + Fraction(6, 3))
print(direct)
print(from_float)
Ստուգման իրական արտածումը
7/3
0.3333333333333333333333333333
0.333333333333333314829616256247390992939472198486328125

Առաջին դեպքում հարաբերությունները ճշգրիտ ռացիոնալ են։ Երկրորդ համեմատության մեջ Decimal(1 / 3)-ը ստանում է արդեն հաշվարկված float-ը, ոչ սկզբնական 1/3 ճշգրիտ հարաբերությունը։

0b1111 · 15 · 0o17 · 0xF · Սրանք նույն ամբողջ թվի տարբեր գրառումներ են։0b1111150o170xFՍրանք նույն ամբողջ թվի տարբեր գրառումներ են։

Կրկնությունների հեռացում և հերթականություն

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 322

items = ['bb', 'aa', 'cc', 'aa', 'bb']
unique = set(items)
assert unique == {'aa', 'bb', 'cc'}
print(sorted(unique))
Ստուգման իրական արտածումը
['aa', 'bb', 'cc']

set-ը հեռացնում է կրկնությունները։ Ցուցադրման համար sorted-ը հատուկ կիրառում ենք, որպեսզի տեսանելի հերթը կանխատեսելի լինի։

[1, 1, 2, 3, 2] · set(...) · {1, 2, 3} · set-ը պահում է տարբեր տարրերը․ ցուցադրման հերթը երաշխավորված չէ։[1, 1, 2, 3, 2]set(...){1, 2, 3}set-ը պահում է տարբեր տարրերը․ ցուցադրման հերթը երաշխավորված չէ։

string-երի հաջորդական համեմատություն

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած string-ի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 418

result = ('hack' == 'hack', 'hact' > 'hack', 'hacker' > 'hack')
assert result == (True, True, True)
assert ord('t') > ord('k')
print(result)
Ստուգման իրական արտածումը
(True, True, True)

Համեմատությունն առաջ է գնում մինչև առաջին տարբեր code point-ը։ Եթե մի string-ը մյուսի ճիշտ նախածանցն է, ավելի երկարն ավելի մեծ է համարվում։ Սա բնական լեզվի dictionary կարգի ընդհանուր երաշխիք չէ։

P · 0 · -6 · y · 1 · -5 · t · 2 · -4 · h · 3 · -3 · o · 4 · -2 · n · 5 · -1 · "Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։P0-6y1-5t2-4h3-3o4-2n5-1"Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։

Փոխարինումը նոր string է տալիս

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած string-ի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 430

line = 'xxWHATxxHOWxx'
changed = line.replace('WHAT', 'CODE')
assert changed == 'xxCODExxHOWxx'
assert line == 'xxWHATxxHOWxx'
print(line)
print(changed)
Ստուգման իրական արտածումը
xxWHATxxHOWxx
xxCODExxHOWxx

Սկզբնական string-ը մնում է անփոփոխ։ Նոր արդյունքը պահում ենք առանձին անունով։

"banana" · replace("a", "A", 1) · "bAnana" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"banana"replace("a", "A", 1)"bAnana"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

Բաղադրիչների միջև բաժանարար

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած string-ի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 432

parts = ['we', 'learn', 'code']
result = ' / '.join(parts)
assert result == 'we / learn / code'
print(result)
Ստուգման իրական արտածումը
we / learn / code

Բաժանարար string-ի join method-ն այն տեղադրում է բաղադրիչների միջև՝ առանց սկզբում կամ վերջում ավելորդ բաժանարարի։

["a", "b"] · "-".join(...) · "a-b" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։["a", "b"]"-".join(...)"a-b"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

compilation-ը և կատարումը՝ առանձին քայլերով

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 61, 63, 65, 71

source = 'result = 3 * (4 + 2)'
compiled = compile(source, '<learning-demo>', 'exec')
namespace = {}
assert 'result' not in namespace
exec(compiled, namespace)
assert namespace['result'] == 18
print(type(compiled).__name__, namespace['result'])
Ստուգման իրական արտածումը
code 18

compile-ը ստեղծում է code object։ Միայն դրանից result անունը դեռ չի հայտնվում մեր namespace-ում։ exec-ից հետո է code-ը կատարվում և արժեքը հասանելի դառնում։

Python · source code · compilation · դեպի bytecode · interpreter-ի · կատարում · program-ի · արդյունք · Python-ը և CPython իրականացումը տարբեր հասկացություններ են։Pythonsource codecompilationդեպի bytecodeinterpreter-իկատարումprogram-իարդյունքPython-ը և CPython իրականացումը տարբեր հասկացություններ են։

type hint-ն ինքնաշխատ արգելք չէ

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 361, 362, 363, 364

age: int = 'twenty'
assert isinstance(age, str)
assert __annotations__['age'] is int
print(type(age).__name__)
Ստուգման իրական արտածումը
str

Python-ի այս ստուգված միջավայրում հուշումն առկա է որպես annotation, բայց str assignment-ն ինքնաշխատ չի արգելում։ Արտաքին type checker-ները կարող են այլ գնահատական տալ։

Փոքր .py file-ի գործարկում

Ավելացված ինքնուրույն օրինակ․ սա գրքի կորած տողի վերականգնման պնդում չէ։ Աղբյուրի թեման՝ PDF էջեր 119

print('Բարև Python')
Ստուգման իրական արտածումը
Բարև Python

Այս code-ը պահպանվում է lesson_demo.py անունով։ terminal-ից գործարկման հրամանն է python3 lesson_demo.py։ Ստուգման ժամանակ օգտագործվել է նույն Python միջավայրի իրական գործարկիչը՝ առանձին ժամանակավոր directory-ում։

Աղյուսակների ընթեռնելի ուղեցույց

Ավելացված ուսումնական տեսքեր․ տեսանելի տողադարձված գրառումները միացված են, իսկ բնագրի հատվածները պահպանված են վերևում։ Կաղապարային գրառումները պարտադիր առանձին գործարկելի program-եր չեն։

Աղյուսակ 4-1․ Python-ի built-in հիմնական object-ները — ընթեռնելի մեկնաբանություն

Աղբյուրի PDF էջեր՝ 167, 168

ԳրառումԻմաստը՝ պարզ բառերով
1234, 3.1415, 0b111, 1_234, 3+4j, Decimal, FractionԹվեր։ Վերադասավորված են ամբողջ, floating-point, երկուական և կոմպլեքս թվերի օրինակներն ու Decimal և Fraction անունները։
'code', "app's", b'a\x01c', 'h\u00c4ck', 'hÄck🐍'Տողեր։ byte և Unicode գրառումներն էլ ընդգրկված են։ Օձի նշանը վերականգնված է նույն բջջի տեսանելի պատկերից։
[1, [2, 'three'], 4.5], list(range(10))list-ներ։ Առաջին օրինակում կա ներդրված list, երկրորդում՝ list constructor-ի կանչ։
{'job': 'dev', 'years': 40}, dict(hours=10)dictionary-ներ։ Ներկայացված են literal գրառումը և dict constructor-ի կանչը։
(1, 'app', 4, 'U'), tuple('hack'), namedtupletuple-ներ։ Ներկայացված են literal, tuple constructor-ի կանչ և namedtuple անունը։
open('docs.txt'), open(r'C:\data.bin', 'wb')file-եր։ text file-ի բացում և երկուական գրելու ռեժիմով բացում։
set('abc'), {'a', 'b', 'c'}set-ներ։ set constructor-ի կանչ և set-ի literal։
Boolean values, types, NoneԱյլ հիմնական object-ներ։
functions, modules, classes (մասեր IV, V և VI)Ծրագրային միավորների object-ներ։ Այս տողը աղբյուրում շարունակվում է 168-րդ էջում։
compiled code, stack tracebacks (մասեր IV և VII)Իրականացման object-ներ։

Աղյուսակ 5-1․ Թվային literal-ներ և constructor-ներ — ընթեռնելի մեկնաբանություն

Աղբյուրի PDF էջեր՝ 248

ԳրառումԻմաստը՝ պարզ բառերով
1234, −24, 0, 9_999_999_999_999Ամբողջ թվեր՝ անսահմանափակ չափով։ Վերջին թվի տեսանելի տողադարձված մասերը միացված են։ − նշանն աղբյուրի տպագրական նշանն է։
1.23, 1., 3.14e-10, 4E210, 4.0e+210floating-point թվեր։ 4E21 և հաջորդ տողի 0 տեսանելի մասերը միացված են 4E210 գրառման մեջ։
0o177, 0x9ff, 0b101010Ութական, տասնվեցական և binary literal-ներ։
3+4j, 3.0+4.0j, 3JԿոմպլեքս թվերի literal-ներ։
set('hack'), {1, 2, 3, 4}set-ներ՝ constructor-ներ և literal-ներ։
Decimal('1.0'), Fraction(1, 3)Տասնորդական և սովորական կոտորակների ընդլայնման type-եր։
bool(X), True, FalseBoolean type և հաստատուններ։

Աղյուսակ 5-2․ expression-ների operator-ները՝ աճող precedence-ով — ընթեռնելի մեկնաբանություն

Աղբյուրի PDF էջեր՝ 254, 255, 256

ԳրառումԻմաստը՝ պարզ բառերով
yield x, yield from xgenerator function-ի send՝ ուղարկման արձանագրություն։ yield from-ի հաջորդ տողի տեսանելի x-ը միացված է։
x := yassignment-ի expression։
lambda args: expressionԱնանուն function-ի ստեղծում։ expression բառի տեսանելի expre և ssion մասերը միացված են։
x if y else zԵռանդամ ընտրություն։ x-ը հաշվարկվում է միայն, եթե y-ը ճշմարիտ է։
x or yՏրամաբանական OR։ y-ը հաշվարկվում է միայն, եթե x-ը կեղծ է։
x and yՏրամաբանական AND։ y-ը հաշվարկվում է միայն, եթե x-ը ճշմարիտ է։
not xՏրամաբանական ժխտում։
x in y, x not in yՊատկանելության ստուգումներ՝ iterable object-ներում։
x is y, x is not yobject-ների identity-ի ստուգումներ։
x < y, x <= y, x > y, x >= yՄեծությունների համեմատություն, set-ների subset-ի և superset-ի ստուգում։
x == y, x != yԱրժեքների հավասարության և անհավասարության operator-ներ։
x | yԲիթային OR, set union, dictionary-ների միաձուլում։
x ^ yԲիթային XOR, set-ների սիմետրիկ տարբերություն։
x & yԲիթային AND, set intersection։
x << y, x >> yx-ի տեղաշարժը ձախ կամ աջ՝ y bit-ով։
x + yԳումարում, կցում։
x – yՀանում, set difference։ – նշանն այստեղ պահպանված է աղբյուրի տպագրությամբ։
x * yԲազմապատկում, կրկնում։
x % yՄնացորդ, ձևաչափում։
x / y, x // yԲաժանում՝ իրական և դեպի ներքև կլորացվող։
x @ yՄատրիցային բազմապատկում։ Աղբյուրի նշումով՝ Python-ի կողմից չօգտագործվող։
−xԹվային նշանի հակադարձում։ − նշանն այստեղ պահպանված է աղբյուրի տպագրությամբ։
+xՆույնության գործողություն։
˜xԲիթային NOT՝ շրջում։ ˜ նշանն այստեղ պահպանված է աղբյուրի տպագրությամբ։
x ** yԱստիճան բարձրացնելը։
await xՍպասման expression՝ ասինխրոն function-ներում։
x[i]indexing՝ հաջորդականության, արտապատկերման և այլ object-ների համար։
x[i:j:k]Հատում։
x(...)Կանչ՝ function, method, դաս կամ այլ callable object։
x.attrՀղում attribute-ին։
(...)tuple, expression կամ generator expression։
[...]list կամ list comprehension (comprehension)։
{...}dictionary, set կամ dictionary ու set comprehension-ներ (comprehensions)։

Աղյուսակ 7-1․ Տարածված string literal-ներ և գործողություններ — ընթեռնելի մեկնաբանություն

Աղբյուրի PDF էջեր՝ 376, 377, 378

ԳրառումԻմաստը՝ պարզ բառերով
S = ''Դատարկ string։
S = "app's"Կրկնակի չակերտներով string։ Այն գործում է նույն կերպ, ինչ մեկական չակերտներով գրառումը։
S = 'c\no\td\x00e'escape sequence-ներ պարունակող string։
S = """… multiline…"""Եռակի չակերտներով block տող։ multiline բառի երկու տեսանելի մասերը միացված են. բազմակետերը աղբյուրի տեղապահերն են։
S = r'\temp\data.txt'Չմշակված string՝ escape sequence-ները չմշակող։ data.txt անվան տեսանելի tx և t մասերը միացված են։
B = b'h\xc4ck'byte string. տե՛ս գլուխներ 4-ը և 37-ը։
S = 'py\U0001F40D'Unicode string. տե՛ս գլուխներ 4-ը և 37-ը։
S = u'py\U0001F40D'Python 2.X-ի հետ համատեղելիության գրառում. տե՛ս գլուխ 37-ը։
S1 + S2string-երի կցում։
S * 3string-ի կրկնում։
S[i]indexing։
S[i:j]Հատում։
len(S)Երկարության ստացում։
S1 > S2, S1 == S2Համեմատություններ՝ մեծություն և հավասարություն։
'a %s coder' % kindstring-ի ձևաչափման expression։
'a {0} coder'.format(kind)string-ի ձևաչափման method։ Հաջորդ string-ի տեսանելի (kind) argument-ը միացված է կանչին։
f'a {kind} coder'string-ի ձևաչափման literal՝ Python 3.6 և ավելի նոր տարբերակներում։
S.find('od')string method՝ որոնում։ Աղբյուրն այստեղ հղում է անում method-ների ամբողջ list-ին՝ իր ձևակերպմամբ «բոլոր 43»-ին։
S.rstrip()string method՝ վերջի բացատային character-երի հեռացում։
S.replace('od', 'ood')string method՝ փոխարինում։ Փոխարինող string-ի տեսանելի oo և d մասերը միացված են։
S.split(',')string method՝ բաժանում ըստ բաժանիչի։
S.isdigit()string method՝ բովանդակության ստուգում։
S.lower()string method՝ տառաչափի փոխարկում։
S.endswith('thon')string method՝ վերջավորության ստուգում։
S.join(strlist)string method՝ միավորում բաժանիչով։
S.encode('utf8')Unicode encoding։ Նկարագրության և կանչի էջադարձը վերադասավորված է։
B.decode('latin1')Unicode decoding. տե՛ս նաև աղյուսակ 7-3-ը։
'py' in S.lower()Պատկանելության ստուգում։
for x in S: print(x)Կրկնություն։ print և հաջորդ string-ի (x) տեսանելի մասերը միացված են։
[c * 2 for c in S]Կրկնություն՝ list comprehension-ով (comprehension)։
map(ord, S)Կրկնություն՝ map-ի կիրառմամբ։
re.match('Py(.*)on', line)Ձևանմուշի համապատասխանեցում՝ library-ի module-ով։ Հաջորդ տողի տեսանելի line) մասը միացված է կանչին։

Աղյուսակ 7-2․ Տողերի հետադարձ շեղագծով character-երը — ընթեռնելի մեկնաբանություն

Աղբյուրի PDF էջեր՝ 386, 387

ԳրառումԻմաստը՝ պարզ բառերով
\\Հետադարձ շեղագիծ. պահվում է մեկ \ character։
\'Մեկական չակերտ. պահվում է ' character-ը։
\"Կրկնակի չակերտ. պահվում է " character-ը։
\nՆոր string՝ նաև string-ի առաջանցում կոչվող character։
\rԿուրսորի վերադարձ string-ի սկիզբ. օրինակ՝ Windows-ի \r\n sequence-ի մեջ։
\tՀորիզոնական թաբուլյացիա։
\vՈւղղահայաց թաբուլյացիա։
\aԶանգի ազդանշան՝ որտեղ այն աջակցվում է։
\bՀետքայլ՝ backspace։
\fԷջի առաջանցում՝ formfeed։
\xhhՏասնվեցական code point կամ byte-ի արժեք. ճիշտ 2 տասնվեցական թվանշան։
\oooՈւթական code point կամ byte-ի արժեք. մինչև 3 թվանշան՝ 377 վերին սահմանով։
\0Զրոյական character՝ ութական երկուական 0. այն չի ավարտում string-ը։
\uhhhhUnicode character-ի code point՝ 16-բիթանոց արժեք, ճիշտ 4 տասնվեցական թվանշան։
\UhhhhhhhhUnicode character-ի code point՝ 32-բիթանոց արժեք, ճիշտ 8 տասնվեցական թվանշան։ Տողադարձված վերջին h-ը միացված է։
\N{name}Unicode տվյալների շտեմարանում name նույնացուցիչով character-ը։
\newlineԱնտեսվում է. հետադարձ շեղագծին հաջորդում է շարունակության իրական նոր տողը։ newline-ն այստեղ տեղապահ է, ոչ բառացի գրվող տեքստ։
\otherՊահվում է բառացի։ Աղբյուրի ձևակերպմամբ՝ 3.12-ում տալիս է զգուշացում, իսկ ապագայում՝ սխալ։

Աղյուսակ 7-3․ string method-ների կանչերը Python 3.12-ում — տեսանելի պայմանական ստորագրություններ և ավելացված բացատրություններ

Աղբյուրի PDF էջեր՝ 425, 426, 427

ԳրառումԻմաստը՝ պարզ բառերով
S.capitalize()Առաջին character-ին կիրառում է վերնագրային տառաչափ, իսկ մնացածներին՝ փոքրատառ։
S.ljust(width[, fill])string-ը հավասարեցնում է ձախ՝ մինչև width լայնությունը։ Աջից լրացնում է fill character-ով կամ լռելյայն բացատներով։
S.casefold()Կատարում է Unicode casefold փոխակերպում՝ տառաչափն անտեսող համեմատությունների համար։
S.lower()Տառաչափ ունեցող character-երը դարձնում է փոքրատառ։
S.center(width[, fill])string-ը կենտրոնացնում է width լայնության մեջ՝ եզրերը լրացնելով fill character-ով կամ բացատներով։
S.lstrip([chars])Սկզբից հեռացնում է chars-ում գտնվող character-երը, իսկ argument-ը բաց թողնելիս՝ բացատային character-երը։ chars-ը character-երի հավաքածու է, ոչ ամբողջական նախածանց։
S.count(sub[, start[, end]])Հաշվում է sub substring-ի չհամընկնող հանդիպումները՝ ամբողջ string-ում կամ նշված միջակայքում։
S.maketrans(x[, y[, z]])Ստեղծում է character-երի փոխակերպման աղյուսակ՝ translate method-ում օգտագործելու համար։
S.encode([encoding[, errors]])string-ը կոդավորում է byte-երի՝ նշված encoding-ով և սխալների մշակման եղանակով։
S.partition(sep)Առաջին sep բաժանիչով բաժանում է երեք մասի՝ դրանից առաջ եղած տեքստը, բաժանիչը և հետո եղած տեքստը։ Վերադարձնում է tuple։
S.endswith(suffix[, start[, end]])Ստուգում է string-ի կամ նշված միջակայքի վերջավորությունը։
S.removeprefix(prefix)Հեռացնում է ամբողջ prefix նախածանցը, եթե string-ը դրանով է սկսվում։
S.expandtabs([tabsize])Թաբերը փոխարինում է բացատներով՝ tabsize-ով որոշվող թաբուլյացիայի դիրքերին հասնելու համար։
S.removesuffix(suffix)Հեռացնում է ամբողջ suffix վերջածանցը, եթե string-ը դրանով է ավարտվում։
S.find(sub[, start[, end]])Գտնում է sub-ի առաջին դիրքը ամբողջ string-ում կամ միջակայքում։ Եթե չի գտնում, վերադարձնում է −1։
S.replace(old, new[, count])old substring-ը փոխարինում է new-ով։ count-ը կարող է սահմանափակել փոխարինումների քանակը։
S.format(fmtstr, *args, **kwargs)Ձևաչափում է string-ի փոխարինման դաշտերը փոխանցված արժեքներով։ Այստեղ պահպանված է հենց աղբյուրի պայմանական ստորագրությունը՝ ներառյալ fmtstr անունը։
S.rfind(sub[, start[, end]])Գտնում է sub-ի վերջին դիրքը ամբողջ string-ում կամ միջակայքում։ Եթե չի գտնում, վերադարձնում է −1։
S.format_map(mapping)string-ի ձևաչափման դաշտերի արժեքները վերցնում է mapping արտապատկերումից։
S.rindex(sub[, start[, end]])Գտնում է sub-ի վերջին դիրքը։ Չգտնելու դեպքում առաջացնում է exception։
S.index(sub[, start[, end]])Գտնում է sub-ի առաջին դիրքը։ Չգտնելու դեպքում առաջացնում է exception։
S.rjust(width[, fill])string-ը հավասարեցնում է աջ՝ մինչև width լայնությունը՝ ձախից լրացնելով fill character-ով կամ բացատներով։
S.isalnum()Ստուգում է՝ արդյոք string-ը ոչ դատարկ է, և բոլոր character-երը տառեր կամ թվային character-եր են։
S.rpartition(sep)Վերջին sep բաժանիչով բաժանում է երեք մասի՝ դրանից առաջ եղած տեքստը, բաժանիչը և հետո եղած տեքստը։ Վերադարձնում է tuple։
S.isalpha()Ստուգում է՝ արդյոք string-ը ոչ դատարկ է, և բոլոր character-երը տառեր են։
S.rsplit([sep[, maxsplit]])string-ը բաժանում է մասերի list-ի՝ բաժանումները սկսելով աջից։ sep-ը բաժանիչն է, իսկ maxsplit-ը՝ բաժանումների ոչ պարտադիր սահմանը։
S.isascii()Ճշմարիտ է դատարկ string-ի համար կամ երբ բոլոր character-երն ASCII միջակայքից են։
S.rstrip([chars])Վերջից հեռացնում է chars-ում գտնվող character-երը, իսկ argument-ը բաց թողնելիս՝ բացատային character-երը։ chars-ը character-երի հավաքածու է, ոչ ամբողջական վերջածանց։
S.isdecimal()Ստուգում է՝ արդյոք string-ը ոչ դատարկ է, և բոլոր character-երը Unicode տասնորդական թվանշաններ են։
S.split([sep[, maxsplit]])string-ը բաժանում է մասերի list-ի՝ sep բաժանիչով կամ լռելյայն բացատային character-երով։ maxsplit-ը սահմանափակում է բաժանումների քանակը։
S.isdigit()Ստուգում է՝ արդյոք string-ը ոչ դատարկ է, և բոլոր character-երը թվանշաններ են՝ ներառյալ որոշ ոչ տասնորդական թվանշաններ։
S.splitlines([keepends])string-ը բաժանում է առանձին line-երի list-ի։ keepends-ը կարող է պահպանել line-ի ավարտի character-երը։
S.isidentifier()Ստուգում է՝ արդյոք string-ը համապատասխանում է Python նույնացուցիչի syntax-ին։ keyword լինելը առանձին հարց է։
S.startswith(prefix[, start[, end]])Ստուգում է string-ի կամ նշված միջակայքի սկզբնամասը։
S.islower()Ճշմարիտ է, եթե կա տառաչափ ունեցող առնվազն մեկ character, և բոլոր այդպիսի character-երը փոքրատառ են։
S.strip([chars])Երկու ծայրերից հեռացնում է chars-ում գտնվող character-երը, իսկ argument-ը բաց թողնելիս՝ բացատային character-երը։
S.isnumeric()Ստուգում է՝ արդյոք string-ը ոչ դատարկ է, և բոլոր character-երն ունեն Unicode թվային արժեք։
S.swapcase()Փոքրատառերը դարձնում է մեծատառ, իսկ մեծատառերը՝ փոքրատառ։
S.isprintable()Ճշմարիտ է դատարկ string-ի համար կամ երբ բոլոր character-երը տպելի են։
S.title()Տալիս է բառամասերի վերնագրային տառաչափով տարբերակը՝ սկզբնական character-երը մեծատառ, շարունակությունը՝ փոքրատառ։
S.isspace()Ստուգում է՝ արդյոք string-ը ոչ դատարկ է, և բոլոր character-երը բացատային character-եր են։
S.translate(map)string-ի character-երը փոխակերպում է map աղյուսակով։ Փոխակերպումը կարող է character-եր փոխարինել կամ հեռացնել։
S.istitle()Ստուգում է՝ արդյոք տառաչափ ունեցող բառամասերը վերնագրային տառաչափով են։
S.upper()Տառաչափ ունեցող character-երը դարձնում է մեծատառ։
S.isupper()Ճշմարիտ է, եթե կա տառաչափ ունեցող առնվազն մեկ character, և բոլոր այդպիսի character-երը մեծատառ են։
S.zfill(width)Ձախից ավելացնում է զրոներ՝ մինչև width լայնությունը։ Սկզբնական + կամ - նշանը մնում է զրոներից առաջ։
S.join(iterable)Միացնում է iterable-ի string-երը՝ S-ն օգտագործելով որպես նրանց միջև դրվող բաժանիչ։

Պատկերավոր բացատրությունների ատլաս

Python-ի կատարման ճանապարհը

Python · source code · compilation · դեպի bytecode · interpreter-ի · կատարում · program-ի · արդյունք · Python-ը և CPython իրականացումը տարբեր հասկացություններ են։Pythonsource codecompilationդեպի bytecodeinterpreter-իկատարումprogram-իարդյունքPython-ը և CPython իրականացումը տարբեր հասկացություններ են։

ahead-of-time compiled սովորական շղթա

C/C++ · source code · compilation և · assembly · linking · library-ների հետ · machine code-ի · կատարում · Սովորական ahead-of-time compiled գործիքաշարի պարզեցված պատկերը։C/C++source codecompilation ևassemblylinkinglibrary-ների հետmachine code-իկատարումՍովորական ahead-of-time compiled գործիքաշարի պարզեցված պատկերը։

name, reference, object, type

name՝ a · reference · object՝ [1, 2] · type՝ list · name-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։name՝ areferenceobject՝ [1, 2]type՝ listname-ը կապակցված է object-ի հետ․ type-ը պատկանում է object-ին։

Երկու name՝ նույն object-ը

a · b · list [1, 2] · c → [1, 2] · Նույն արժեքը և նույն object-ը նույն հարցը չեն։ablist [1, 2]c → [1, 2]Նույն արժեքը և նույն object-ը նույն հարցը չեն։

Ներդրված object-ի ընդհանուր reference-ներ

արտաքին a · պատճեն b · ընդհանուր ներքին list · a[0] · b[0] · shallow copy-ը կարող է պահպանել ներքին ընդհանուր reference-ները։արտաքին aպատճեն bընդհանուր ներքին lista[0]b[0]shallow copy-ը կարող է պահպանել ներքին ընդհանուր reference-ները։

string-ի դրական և բացասական index-ները

P · 0 · -6 · y · 1 · -5 · t · 2 · -4 · h · 3 · -3 · o · 4 · -2 · n · 5 · -1 · "Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։P0-6y1-5t2-4h3-3o4-2n5-1"Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։

slice-ի վերջը չի ներառվում

P · 0 · -6 · y · 1 · -5 · t · 2 · -4 · h · 3 · -3 · o · 4 · -2 · n · 5 · -1 · "Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։P0-6y1-5t2-4h3-3o4-2n5-1"Python"[1:4] = "yth"․ 4-րդ սահմանը չի ներառվում։

list-ի փոփոխությունը

a = [1, 2] · a.append(3) · նույն list-ը · [1, 2, 3] · Փոփոխությունը կատարվում է object-ի մեջ․ անունը կարող է մնալ նույնը։a = [1, 2]a.append(3)նույն list-ը[1, 2, 3]Փոփոխությունը կատարվում է object-ի մեջ․ անունը կարող է մնալ նույնը։

key-ից դեպի value

name · "Ani" · age · 20 · key-ը կապվում է value-ի հետ․ key-ը պարտադիր թվային index չէ։name"Ani"age20key-ը կապվում է value-ի հետ․ key-ը պարտադիր թվային index չէ։

Տարբեր տարրերի set

[1, 1, 2, 3, 2] · set(...) · {1, 2, 3} · set-ը պահում է տարբեր տարրերը․ ցուցադրման հերթը երաշխավորված չէ։[1, 1, 2, 3, 2]set(...){1, 2, 3}set-ը պահում է տարբեր տարրերը․ ցուցադրման հերթը երաշխավորված չէ։

Նույն ամբողջի տարբեր գրառումներ

0b1111 · 15 · 0o17 · 0xF · Սրանք նույն ամբողջ թվի տարբեր գրառումներ են։0b1111150o170xFՍրանք նույն ամբողջ թվի տարբեր գրառումներ են։

Float-ը մոտարկում է

Տասնորդական · 0.1 · Երկուական · մոտարկում · Տեսանելի · արդյունք · 0.100000… · Float-ի ներկայացումը և էկրանին ընտրված ձևավորումը տարբեր փուլեր են։Տասնորդական0.1ԵրկուականմոտարկումՏեսանելիարդյունք0.100000…Float-ի ներկայացումը և էկրանին ընտրված ձևավորումը տարբեր փուլեր են։

Տեքստը և encoded byte-երը

Տեքստ՝ str · 6 code point · UTF-8 encoding · 13 byte · «🐍hÄck👏» օրինակում code point-երի և byte-երի քանակները տարբեր են։Տեքստ՝ str6 code pointUTF-8 encoding13 byte«🐍hÄck👏» օրինակում code point-երի և byte-երի քանակները տարբեր են։

file-ի տեքստային մակարդակը

file-ի byte-եր · decode UTF-8 · Python str · Տեքստային · մշակում · Տեքստային open-ը կարող է encoding-ն ու decoding-ը կատարել ձեր փոխարեն։file-ի byte-երdecode UTF-8Python strՏեքստայինմշակումՏեքստային open-ը կարող է encoding-ն ու decoding-ը կատարել ձեր փոխարեն։

string method՝ upper

"Hello" · upper() · "HELLO" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"Hello"upper()"HELLO"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ lower

"Hello" · lower() · "hello" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"Hello"lower()"hello"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ replace

"banana" · replace("a", "A", 1) · "bAnana" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"banana"replace("a", "A", 1)"bAnana"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ strip

" code " · strip() · "code" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։" code "strip()"code"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ split

"a,b,c" · split(",") · ["a", "b", "c"] · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"a,b,c"split(",")["a", "b", "c"]method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ join

["a", "b"] · "-".join(...) · "a-b" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։["a", "b"]"-".join(...)"a-b"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ find

"banana" · find("na") · 2 · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"banana"find("na")2method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ startswith

"Python" · startswith("Py") · True · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"Python"startswith("Py")Truemethod-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ endswith

"demo.py" · endswith(".py") · True · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"demo.py"endswith(".py")Truemethod-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ isalpha

"abc" · isalpha() · True · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"abc"isalpha()Truemethod-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ isdigit

"123" · isdigit() · True · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"123"isdigit()Truemethod-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

string method՝ encode

"Ä" · encode("utf-8") · b"\xc3\x84" · method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։"Ä"encode("utf-8")b"\xc3\x84"method-ի վերադարձվող արդյունքը պետք է տարբերել սկզբնական object-ից։

Հասկացությունների հիշեցումներ

Python language

programming language է։ Լեզուն պետք է տարբերել այն իրականացնող կոնկրետ program-ից՝ օրինակ CPython-ից։

Նույն Python code-ը կարող է գործարկվել տարբեր իրականացումներով։

program

instruction-ների և տվյալների կազմակերպված ամբողջություն, որով համակարգչին նկարագրում ենք պահանջվող վարքը։

Մուտք → հաշվարկ → արդյունք։

algorithm

Խնդիրը լուծելու հստակ քայլերի նկարագրություն։ Նույն algorithm-ը կարելի է իրականացնել տարբեր լեզուներով։

Նախ գտնել ամենամեծ թիվը, հետո վերադարձնել նրա index-ը։

source code

Մարդու գրած program-ի տեքստն է։ Այն ինքնին դեռ CPU-ի machine instruction-ների sequence չէ։

print(2 + 3)

compiler / compilation

program-ի ներկայացումը մեկ ձևից մյուսը փոխակերպող գործիք է։ Թիրախը կարող է լինել machine code, bytecode կամ այլ միջանկյալ ներկայացում։

CPython-ը նույնպես source code-ը կոմպիլացնում է bytecode-ի։

interpreter / interpretation

program-ի ներկայացումը կատարող համակարգ է։ «interpreted» չի նշանակում, որ սկզբնական տեքստը պարտադիր առանց նախնական մշակման ընթերցվում ու կատարվում է line by line։

CPython-ի դեպքում կատարումը սովորաբար հաջորդում է bytecode-ի ստացմանը։

CPython implementation

Python-ի հիմնական, սովորաբար C-ով կառուցված implementation-ն է։ Այն ներառում է վերլուծման, bytecode ստանալու և program-ի կատարման գործիքները։

Python-ը լեզուն է, CPython-ը՝ դրա implementation-ներից մեկը։

bytecode

Իրականացման ներքին instruction-ների ներկայացում է։ CPython-ի bytecode-ը սովորաբար կատարվում է նրա interpreter-ով և CPU-ի machine code-ը չէ։

bytecode-ի մանրամասները կարող են փոխվել Python-ի տարբերակների միջև։

machine code

Կոնկրետ processor-ի instruction-ների համակարգով ներկայացված program է։ Այն պետք է տարբերել Python-ի աղբյուրից և CPython-ի bytecode-ից։

C/C++ գործիքաշարի սովորական վերջնական արդյունքը կարող է պարունակել machine code։

bytecode cache / .pyc

Ներմուծվող module-ի compiled ներկայացումը կարող է պահվել __pycache__ directory-ի .pyc file-ում։ Սա բեռնման cache է, ոչ գաղտնագրում և ոչ կատարման ինքնաշխատ արագացում։

Ուղղակի գործարկված գլխավոր script-ի համար .pyc ստեղծվելը պարտադիր չէ։

JIT compilation

Կատարման ընթացքում հաճախ օգտագործվող code-ը հետագա արագ կատարման համար կոմպիլացնելու մոտեցում է։ Հնարավորություններն ու պայմանները կախված են կոնկրետ իրականացումից և հավաքումից։

JIT-ը չպետք է վերագրել Python-ի բոլոր տեղադրումներին։

runtime

Այն փուլն է, երբ արդեն գործարկված program-ը հաշվարկում է value-ներ, ընտրում ճյուղեր և կատարում գործողություններ։

TypeError-ը կարող է ի հայտ գալ հենց կատարման ընթացքում։

REPL / interactive prompt

Կարդալու, գնահատելու և արդյունքը ցուցադրելու կրկնվող միջավայր է։ >>>-ը նրա հրավերն է, ոչ թե սովորական .py file-ի code-ի մասը։

>>> 2 + 3
5

script / .py file

Պահպանված Python code-ով file է, որը կարող ենք գործարկել կամ որոշ դեպքերում ներմուծել որպես module։

python3 demo.py

IDE / development environment

code գրելու, գործարկելու և հաճախ նաև վրիպազերծելու գործիքների համակցություն է։ Միջավայրին տիրապետելը և խնդիր լուծելը տարբեր, փոխկապակցված հմտություններ են։

IDLE-ի editor-ի պատուհանը և Python Shell-ը նույն գործառույթը չունեն։

module

Վերօգտագործվող Python code-ի կազմակերպման միավոր է։ Ներմուծումը սովորաբար գտնում ու բեռնում է module-ը և հասանելի դարձնում նրա name-ները։

import math
math.sqrt(9)

package

module-ները հիերարխիկ name-ներով կազմակերպելու միջոց է։ package-ի կառուցվածքը պետք է տարբերել պարզապես ներբեռնվող software package-ից։

package.submodule

file path / search path

file path-ը նկարագրում է file-ի տեղը։ Համակարգի PATH-ն օգնում է հրաման գտնել, իսկ Python-ի sys.path-ը՝ ներմուծվող module գտնել։ Դրանք նույն ցանկը չեն։

terminal-ում python3 գտնելը և import անելիս module գտնելը տարբեր որոնումներ են։

main module / __main__

Ուղղակի գործարկվող module-ի __name__ name-ը սովորաբար __main__ է։ Այդ name-ով պայմանը թույլ է տալիս տարբերակել ուղղակի գործարկումն ու ներմուծումը։

if __name__ == '__main__':
    print('run')

syntax / SyntaxError

Սահմանում է՝ ինչ ձևով կարելի է կազմել լեզվի expression-ներն ու statement-ները։ Շարահյուսականորեն սխալ code-ը չի կարող սովորական ձևով կատարվել։

Չփակված փակագիծը կարող է առաջացնել SyntaxError։

exception

Կատարման ընթացքում հատուկ պայման կամ խափանում ներկայացնող մեխանիզմ է։ Հաղորդագրությունն ու հետագիծը օգնում են հասկանալ տեղի ունեցածը։

1 / 0 առաջացնում է ZeroDivisionError։

debugging

program-ի սպասված ու փաստացի վարքի տարբերությունը գտնելու և պատճառը ստուգելու գործընթաց է։

Կարդա սխալը, փոքրացրու օրինակը, ստուգիր ենթադրությունը։

object

Python-ի տվյալները ներկայացվում են object-ներով։ object-ն ունի type, value և identity, իսկ mutability-ն կախված է նրա type-ից։

123-ը, "abc"-ը և [1, 2]-ը տարբեր type-ի object-ներ են։

type

Որոշում է՝ object-ն ինչպիսի value է ներկայացնում և ինչ գործողություններ է աջակցում։ name-ը typed տարա չէ․ այն հղվում է որևէ object-ի։

type(3) → int; type("3") → str

variable / name

name է, որը կապակցված է object-ի հետ։ Նոր assignment-ը կարող է name-ը կապակցել այլ object-ի հետ՝ առանց հինը փոխելու։

a = 3
a = "three"

assignment

assignment-ի statement-ը հաշվարկում է աջ կողմը և արդյունքը վերագրում թիրախին․ name-ը կարող է վերակապակցվել, իսկ տարրի կամ attribute-ի assignment-ը կարող է փոխել գոյություն ունեցող object-ը։ = և == տարբեր գործողություններ են։

a = [1, 2]

reference / shared reference

Տարբեր name-ներ կարող են հղվել նույն object-ին։ Այդ object-ի փոփոխությունը երևում է բոլոր այդ name-ներով, իսկ մեկ name-ի վերակապակցումը մյուսները չի փոխում։

a = [1]
b = a
b.append(2)

dynamic typing

object-ների type-երը որոշվում և օգտագործվում են runtime։ name-ն իր ամբողջ կյանքի ընթացքում պարտադիր կապված չէ մեկ type-ի object-ների հետ։

a = 1; հետո a = "text" թույլատրելի է։

type hint / annotation

code-ին կցված type նկարագրություն է։ Python-ը սովորաբար ինքնաշխատ չի պարտադրում դրա պահպանումը, բայց ստուգիչներն ու library-ները կարող են այն օգտագործել։

age: int = 20

mutable object

object է, որի պարունակությունը կարելի է փոխել՝ պահպանելով նույն object-ը։ list-ներն ու dictionary-ները mutable են։

a = [1]; a.append(2)

immutable object

object է, որի value-ն տեղում չի փոխվում։ string-ին կամ ամբողջ թվին վերաբերող նոր արդյունքը կարող է լինել ուրիշ object։

s = "abc"; t = s.replace("a", "A")

identity / is

is-ը ստուգում է՝ արդյոք երկու expression-ը հենց նույն object-ին են հղվում։ ==-ը սովորաբար համեմատում է value-ները։

a = [1]; b = [1] → a == b ճշմարիտ, a is b՝ կեղծ։

shallow copy / deep copy

shallow copy-ը նոր արտաքին տարա է ստեղծում, բայց կարող է պահել նույն ներքին object-ների reference-ները։ deep copy-ը փորձում է պատճենել նաև ներսի կառուցվածքը։

b = a[:] չի երաշխավորում ներդրված list-ների անկախությունը։

reference counting / garbage collection

CPython-ը memory management-ի համար օգտագործում է reference counting և cycle-երի հավաքման մեխանիզմ։ Իրականացման այս մանրամասները լեզվի բոլոր համակարգերի ընդհանուր երաշխիք չեն։

name-ի del-ը պարտադիր չի նշանակում, որ նրա նախկին object-ն այլևս ոչ ոք չի օգտագործում։

expression

code-ի կառուցվածք է, որի գնահատումը value է տալիս։

2 + 3; len("abc")

statement

program-ի կատարման քայլ նկարագրող կառուցվածք է։ Ոչ ամեն statement է expression։

a = 3; import math

operator / precedence

operator-ը գործողություն է նշանակում։ precedence-ն ու խմբավորումը որոշում են՝ ինչպես է կառուցվում expression-ը։ Փակագծերը հստակեցնում են ցանկալի կարգը։

2 + 3 * 4 = 14; (2 + 3) * 4 = 20

integer / int

Python-ի ամբողջ թվերն ունեն կամայական ճշտություն՝ հասանելի memory-ի սահմաններում։ Մեծ թիվ ստանալը պարտադիր մեքենայական ամբողջի գերլցում չի առաջացնում։

2 ** 100

floating-point number / float

Սովորական CPython-ում սա սովորաբար երկուական կրկնակի ճշտությամբ թիվ է։ Տասնորդական շատ կոտորակներ ճշգրիտ չեն ներկայացվում։

0.1 + 0.2-ը պարտադիր ճշգրիտ 0.3 չէ։

complex number / complex

Ունեն իրական և կեղծ մասեր։ Python-ում կեղծ միավորը գրվում է j-ով։ Սովորական կարգային < և > համեմատությունները կոմպլեքսների համար սահմանված չեն։

(3 + 4j).real → 3.0

true division / floor division

/ կատարում է սովորական բաժանում։ //-ը բաժանման արդյունքը հատակով կլորացնում է դեպի բացասական անվերջություն։

-3 / 2 → -1.5; -3 // 2 → -2

modulo / %

Ամբողջ թվերի համար b≠0 դեպքում a = (a // b) * b + a % b։ Սա պետք է կապել դեպի բացասական անվերջություն կլորացվող //-ի հետ։

-3 % 2 → 1

exponentiation / **

Բարձրացնում է աստիճան։ Միանդամ մինուսն ու աստիճանը խառնելիս փակագծերը կարևոր են։

-2 ** 2 → -4; (-2) ** 2 → 4

numeric bases

0b, 0o և 0x նախածանցները փոխում են literal-ի գրառման հիմքը, ոչ ստացված int object-ի առանձին type-ը։

0b1111 == 0o17 == 0xF == 15

bitwise operations

& | ^ ~ << >> operator-ները աշխատում են ամբողջ թվերի բիթային ներկայացման հետ։ Դրանք պետք է տարբերել and, or, not տրամաբանական գործիքներից։

5 & 3 → 1; 1 << 3 → 8

Decimal

Տասնորդական թվաբանություն է՝ կարգավորվող համատեքստով ու ճշտությամբ։ Տեքստից կառուցելը խուսափում է նախորդ float մոտարկումը ներմուծելուց։ Բոլոր գործողությունները անսահման ճշտությամբ չեն։

Decimal('0.1') != Decimal(0.1)

Fraction

Ներկայացնում է ամբողջ համարիչի և հայտարարի հարաբերությունը։ Ամբողջ թվերից կամ համապատասխան տեքստից կառուցելիս կարող է ճշգրիտ պահել ռացիոնալ value-ն։

Fraction(1, 3) + Fraction(1, 3) → Fraction(2, 3)

rounding / round

Կլորացնում է նշված դիրքին։ Հավասար կեսի դեպքում սովորաբար ընտրվում է մոտակա զույգ արդյունքը, իսկ float-ի երկուական մոտարկումը կարող է ազդել տեսանելի արդյունքի վրա։

round(2.5) → 2; round(3.5) → 4

Boolean / bool

True և False value-ներն են։ Python-ում bool-ը int-ի ենթատիպ է, սակայն տրամաբանական իմաստը պետք է տարբերել պարզապես թվային գրառումից։

True == 1; False == 0

truth value / truth testing

Զրոն, None-ը և շատ դատարկ object-ներ կեղծ են համարվում։ and և or operator-ները կարող են վերադարձնել հենց operand-ներից մեկը, ոչ միայն bool։

'' or 'default' → 'default'

None

Առանձին object է, որը հաճախ նշանակում է value-ի բացակայություն կամ համապատասխան արդյունքի չլինելը։ Այն նույնը չէ, ինչ 0-ը կամ դատարկ string-ը։

value is None

sequence types

Դիրքերով կազմակերպված object-ներ են, որոնց համար հաճախ սահմանված են indexing, slicing և հերթական անցում։ string-ը, list-ն ու tuple-ն օրինակներ են։

s[0], s[1:3]

string / str

immutable sequence է՝ Unicode code point-երից։ Այն պետք է տարբերել bytes object-ից։

"Հայերեն"; "abc"

literal

code-ի մեջ անմիջապես գրված value-ի ներկայացումն է։ Նույն value-ն կարող է ունենալ տարբեր լիտերալային գրառումներ։

'abc', "abc", 0xF

index / indexing

sequence-ի կոնկրետ դիրքի ընտրություն է։ Առաջին տարրի index-ը 0 է, իսկ բացասականները հաշվում են վերջից։

s[0]; s[-1]

slice / slicing

s[start:stop:step] գրառմամբ ընտրվում է ենթահաջորդականություն։ Stop սահմանը սովորաբար ներառված չէ։ Բացասական step-ի դեպքում շարժման ուղղությունը փոխվում է։

"Python"[1:4] → "yth"

length / len

Վերադարձնում է տարրերի քանակը։ str-ի համար դա Unicode code point-երի թիվն է, որը պարտադիր չէ հավասար լինի տեսանելի գրանշանների կամ encoded byte-երի քանակին։

len("🐍hÄck👏") → 6

Unicode / code point

Նշաններին տրված թվային նույնացումների համակարգ է։ code point-ը, էկրանին երևացող գրանշանը և UTF-8 byte-երի քանակը տարբեր հասկացություններ են։

ord("A") → 65

encoding / decoding

encode-ը տեքստը փոխարկում է byte-երի, decode-ը՝ byte-երը տեքստի։ Երկու կողմում անհրաժեշտ է համապատասխան encoding։

"Ä".encode("utf-8") → b"\xc3\x84"

bytes / bytearray

bytes-ը 0–255 value-ներով immutable sequence է, իսկ bytearray-ը mutable է։ Դրանք str տեքստը չեն, մինչև համապատասխան կերպով վերծանվեն։

b"ABC"[0] → 65

escape sequence

Հակադարձ շեղագծով գրառում է, որը literal-ի մեջ կարող է հատուկ character նշանակել։ Գրառման երկարությունն ու ստացված string-ի երկարությունը կարող են տարբերվել։

'a\nb' պարունակում է newline character

raw string literal

r նախածանցը հիմնականում պահպանում է հակադարձ շեղագծերը։ Այն string-երի նոր type չի ստեղծում և չի վերացնում literal-ի բոլոր շարահյուսական սահմանափակումները։

r'C:\temp\data.txt'

concatenation / repetition

sequence-ների + գործողությունը կարող է միակցել, իսկ ամբողջ թվով *-ը՝ կրկնել։ Ներդրված mutable տարրերի կրկնումը կարող է կրկնել reference-ները, ոչ անկախ object-ները։

[[]] * 3 → երեք reference նույն ներքին list-ին։

membership / in

Տարայի մեջ համապատասխան անդամի առկայության ստուգում է։ string-ի համար կարող է substring փնտրել, իսկ dictionary-ի համար լռելյայն ստուգում է key-ները։

'bc' in 'abcd'; 'name' in record

method / attribute

obj.name-ը attribute է ընտրում։ Եթե ընտրվածը method է, obj.name(...) կանչը կատարում է համապատասխան գործողությունը։

s.upper; s.upper()

string replacement / replace

Ստեղծում է փոխարինումներով նոր string։ Սկզբնական str object-ը տեղում չի փոխում։

"aaa".replace("a", "A", 1) → "Aaa"

string splitting / split

string-ը բաժանում է բաղադրիչների և սովորաբար վերադարձնում list։ Առանց argument-ի split()-ի վարքը տարբերվում է split(" ")-ից։

" a  b ".split() → ["a", "b"]

string joining / join

Կանչվում է բաժանարար string-ի վրա և այդ բաժանարարով միացնում է string բաղադրիչները։

"-".join(["a", "b"]) → "a-b"

stripping / strip

Հեռացնում է սկզբի կամ վերջի համապատասխան character-երը։ Փոխանցված string-ը character-երի set է, ոչ պարտադիր մեկ ամբողջական նախածանց կամ վերջածանց։

"  text\n".strip() → "text"

substring search / find

find-ը վերադարձնում է առաջին դիրքը կամ -1, եթե չի գտնում։ index-ը չգտնելու դեպքում exception է առաջացնում։

"banana".find("na") → 2

list

mutable, դիրքերով կազմակերպված sequence է։ Կարող է պահել տարբեր type-երի object-ների reference-ներ և փոփոխել իր չափը։

[1, "two", [3]]

append / extend

append-ը մեկ object է ավելացնում, իսկ extend-ը՝ տրվող iterable object-ի տարրերը։ Տեղում փոփոխող այս method-ները սովորաբար չեն վերադարձնում նոր list-ը։

a.append([2, 3]) և a.extend([2, 3]) տարբեր են։

comprehension

iterable տվյալներից նոր տարրեր կազմելու կարճ գրառում է՝ հնարավոր պայմանի կիրառմամբ։

[x * x for x in range(5) if x % 2 == 0]

iterable

object է, որից կարելի է iterator ստանալ և հերթով անցնել տարրերով։ Այն պարտադիր չէ list լինի կամ բոլոր տարրերը memory-ի մեջ միանգամից պահի։

Տողը, list-ը և range-ը iterable object-ների օրինակներ են։

iterator

Պահպանում է հերթական անցման վիճակը և next() կանչին տալիս է հաջորդ տարրը, մինչև սպառվելը։

it = iter([1, 2]); next(it) → 1

generator

value-ներն ըստ պահանջի արտադրող iterator-ի տեսակ է։ value-ներն առաջացնում է քայլ առ քայլ, ոչ պարտադիր ամբողջ ցանկով։

(x * x for x in range(3))

range

Ներկայացնում է ամբողջ թվերի sequence՝ առանց ամբողջական list ստեղծելու անհրաժեշտության։ Վերջի սահմանը չի ներառվում։

list(range(2, 7, 2)) → [2, 4, 6]

dictionary / dict

key-ները կապում է value-ների հետ։ key-ները hashable են։ Ժամանակակից Python-ը պահպանում է key-ների ավելացման հերթականությունը, ինչը թվային դիրքերով list լինել չի նշանակում։

{"name": "Ani", "age": 20}

hashability / hashable

object-ի hash-ը պետք է իր կյանքի ընթացքում կայուն լինի և համապատասխանի հավասարության կանոնին։ dictionary-ի key կամ set-ի անդամ լինելու համար դա անհրաժեշտ է։

tuple-ը hashable է միայն եթե նրա բոլոր տարրերն էլ hashable են։

tuple

immutable sequence է։ Պարունակած mutable object-ները կարող են փոխվել՝ առանց հենց tuple-ի դիրքային reference-ները փոխելու։

(1,) մեկ տարրով tuple է, (1)-ը՝ պարզապես թիվ։

set / frozenset

Պահում է տարբեր hashable տարրեր և չի տալիս վստահելի դիրքային դասավորություն։ set-ը mutable է, frozenset-ը՝ immutable։

set([1, 1, 2]) → {1, 2}

file object

open-ը file-ի հետ աշխատող object է վերադարձնում։ Ռեժիմը որոշում է ընթերցում/գրում/հավելում և տեքստային կամ byte աշխատանքը։

open("demo.txt", "r", encoding="utf-8")

text file / binary file

text mode-ը encoding-ի միջոցով str է վերադարձնում կամ ընդունում։ binary mode-ում աշխատանքը կատարվում է bytes տվյալներով։

"r" և "rb" ռեժիմները նույն վերադարձվող type-ը չունեն։

file closing / close

Ավարտում է file object-ի հետ աշխատանքը և կարևոր է ռեսուրսների ու գրառման ավարտման համար։

f.write("hello"); f.close()

function

name-ով կամ այլ կերպ հասանելի կանչվող object է։ Կանչի ժամանակ argument-ներ է ընդունում և կարող է արդյունք վերադարձնել։

len("abc") → 3

argument / parameter

parameter-ը function-ի սահմանման անվանված տեղն է, իսկ argument-ը՝ կանչի ժամանակ փոխանցվող value-ն կամ նրա գրառումը։

def f(x): ... գրառման x-ը parameter է, f(3)-ի 3-ը՝ argument։

object-oriented programming / OOP

program-ի կազմակերպման մոտեցում է, որտեղ տվյալներն ու նրանց վարքը կապվում են object-ների և type-երի հետ։ Python-ի built-in object-ների օգտագործումը նախապատրաստում է class-երի թեմային։

Տողն ունի իր method-ները՝ upper, split և այլն։

class / instance

class-ը նոր object-ների վարքն ու կառուցվածքը սահմանելու գործիք է, իսկ instance-ն այդ class-ի կոնկրետ object-ն է։ Կուրսի այս մասում թեման ներկայացվում է նախնական մակարդակով։

class-ի լիարժեք քննարկումը գրքի ավելի ուշ մասերում է։

help / dir

dir-ը ցույց է տալիս object-ի հասանելի name-ները, իսկ help-ը՝ համապատասխան փաստաթղթավորումը։ Ցանկը տեսնելը դեռ չի բացատրում ամեն գործիքի ճիշտ կիրառությունը։

help(str.split); dir(str)

type conversion

Նոր type-ի համապատասխան ներկայացում ստանալն է։ Թվային string-ը և թիվը տարբեր object-ներ են, իսկ փոխարկումն ամեն value-ի համար չէ, որ հնարավոր է։

int("12") → 12; str(12) → "12"

ord / chr

ord-ը մեկ code point պարունակող string-ի թվային նույնացումն է տալիս, իսկ chr-ը՝ թույլատրելի թվից համապատասխան մեկ code point-ով string-ը։

hex(ord("🐍")) → "0x1f40d"

random selection / random

random module-ի հիմնական generator-ները կեղծ պատահական են։ Ուսումնական կրկնելի փորձերում կարելի է օգտագործել առանձին Random(seed) object։

rng = random.Random(7); rng.choice(items)

eval / exec

eval-ը expression է գնահատում, exec-ը՝ code-ի statement-ներ կատարում։ Դրանք code-ի կատարում են, ոչ պարզապես անծանոթ մուտքը անվնաս թվի վերածելու միջոց։

Պարզ թվային տեքստի համար ընտրիր համապատասխան int կամ float փոխարկումը։

string formatting preview

Գրքի նախնական գլուխներում ձևավորումը հանդիպում է որպես օրինակ։ Այս նյութի սահմանը PDF-ի 437-րդ էջն է․ 438-ից սկսվող առանձին String Formatting բաժինն այստեղ ներառված չէ։

Վաղ օրինակները պահպանված են, բայց հաջորդ բաժնի մանրամասն դասը չի ավելացվել։