Մաթեմատիկան՝ python ծրագրավորման լեզվում

Հետազոտական աշխատանքի բովանդակություն

• Ներածություն
• Ինչ է python-ը
• Ի՞նչ է Python math մոդուլը
• Թվաբանական ֆունկցիաներ
• Հաշվիր թվի ֆակտորյալը
• Հաշվիր ամենամեծ ընդհանուր բաժանարարը
• Կոտորակի մոդուլ Python-ում
• Կոտորակների վրա մաթեմատիկական գործողություններ կատարելը
• Կոտորակների վրա հիմնված հաշվարկներ՝ օգտագործելով մաթեմատիկական մոդուլի տարբեր գործառույթներ
• Եզրակացություն
• Գրականության ցանկ

Ներածություն

Այս հոդվածում կխոսեմ python ծրագրավորման լեզվում մաթեմատիկայի առկայության, մաթեմատիկական մոդուլների և կիրառումների մասին։

• Ինչ է Python math մոդուլը
• Ինչպես օգտագործել math մոդուլը խնդիրներ լուծելու համար
• Որոնք են math մոդուլի հաստատունները, ներառյալ pi, tau-ն և Էյլերի թիվը
• Որո՞նք են built-in functions և math functions տարբերությունները
• Որո՞նք են տարբերությունները math, cmath, և NumPy-ի միջև

Կներկայացնեմ․

• Python Syntax
• Comments
• Multi Line Comments
• Python Variables
• Python-ում փոփոխականներ ստեղծելու մի քանի կանոններ․
• Global and Local Python Variables
• Python Data Types
• Python Numbers
• Python Strings
• Python Booleans
• Python List
• Python Tuples
• Python Sets
• Python Dictionary
• Python For Loops
• Python while Loop

Ինչ է python-ը

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

Python-ը հաճախ համեմատվում է այլ մեկնաբանվող լեզուների հետ, ինչպիսիք են Java, JavaScript, Perl, Tcl կամ Smalltalk: Համեմատությունները C++-ի, Common Lisp-ի և Scheme-ի հետ նույնպես կարող ենք կատարել:

Python Syntax

Python-ի շարահյուսությունը կարող է իրականացվել՝ ուղղակիորեն hրամանի տողում գրելով, կամ սերվերի վրա ստեղծելով python ֆայլ, օգտագործելով .py ֆայլի ընդլայնումը և գործարկելով այն հրամանի տողում։

Python Indentation

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

Comments

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

Multi Line Comments

Քանի որ Python-ը անտեսելու է տողերի տառերը, որոնք վերագրված չեն փոփոխականին, կարող եք ձեր կոդի մեջ ավելացնել բազմագիծ տող (եռակի չակերտներ) և տեղադրել ձեր մեկնաբանությունը դրա ներսում։

Python Variables

Python Variable-ը բեռնարկղեր է, որոնք պահում են արժեքներ: Կարիք չկա փոփոխականների ներմուծման կամ օգտագործման ժամանակ հայտարարել դրանց տեսակը: Փոփոխականը ստեղծվում է այն պահին, երբ մենք առաջին անգամ նրան արժեք ենք հատկացնում: Python փոփոխականը անուն է, որը տրվում է հիշողության վայրին: Դա ծրագրի պահեստավորման հիմնական միավորն է: Python-ը թույլ է տալիս «=» օպերատորների հետ միաժամանակ մի քանի փոփոխականների մեկ արժեք վերագրել:  Python-ը թույլ է տալիս մեկ տողում ավելացնել տարբեր արժեքներ “,” օպերատորներով: Եթե ​​օգտագործում ենք նույն անունը, ապա փոփոխականը սկսում է վերաբերել նոր արժեքին և տեսակին:

• Փոփոխականում պահվող արժեքը կարող է փոխվել ծրագրի կատարման ընթացքում:
• Python Variables-ը միայն անվանում է, որը տրված է հիշողության վայրին, բոլոր գործողությունները, որոնք կատարվում են այդ հիշողության գտնվելու վայրի փոփոխական ազդեցությունների վրա:

Python-ում փոփոխականներ ստեղծելու մի քանի կանոններ․

• Փոփոխական անունը պետք է սկսվի տառով կամ ընդգծված նիշով:
• Փոփոխական անունը չի կարող սկսվել թվով:
• Փոփոխական անունը կարող է պարունակել միայն ալֆա-թվային նիշեր և ընդգծումներ (Az, 0-9 և _ ):
• Փոփոխականների անունները մեծատառերի նկատմամբ զգայուն են (անունը, անունը և NAMEը երեք տարբեր փոփոխականներ են):
• Վերապահված բառերը (հիմնաբառերը) չեն կարող օգտագործվել փոփոխականը անվանելու համար:

Global and Local Python Variables

Local variables նրանք են, որոնք սահմանվում և հայտարարվում են ֆունկցիայի ներսում: Մենք չենք կարող այս փոփոխականն անվանել ֆունկցիայից դուրս։

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

Համաշխարհային հիմնաբառի կանոններ.

• Եթե ​​փոփոխականին տրված է արժեք ֆունկցիայի մարմնի ցանկացած կետում, ապա այն ենթադրվում է որպես տեղային, եթե հստակորեն հայտարարված չէ որպես գլոբալ:
• Փոփոխականները, որոնք հիշատակվում են միայն ֆունկցիայի ներսում, անուղղակիորեն գլոբալ են:
• Մենք օգտագործում ենք գլոբալ հիմնաբառ՝ ֆունկցիայի ներսում գլոբալ փոփոխական օգտագործելու համար:
• Ֆունկցիայից դուրս գլոբալ հիմնաբառ օգտագործելու կարիք չկա:

Փոփոխական տեսակ Python-ում

Տվյալների տեսակները տվյալների տարրերի դասակարգումն են կամ դասակարգումը: Այն ներկայացնում է արժեքի այն տեսակը, որը պատմում է, թե ինչ գործողություններ կարող են կատարվել որոշակի տվյալների վրա: Քանի որ Python ծրագրավորման մեջ ամեն ինչ օբյեկտ է, տվյալների տեսակները իրականում դասեր են, իսկ փոփոխականները՝ այս դասերի օրինակը (օբյեկտը):

Python Data Types

Փոփոխականները կարող են պահել տարբեր տեսակի տվյալներ, իսկ տարբեր տեսակներ կարող են տարբեր բաներ անել: Կարող ենք ստանալ ցանկացած օբյեկտի տվյալների տեսակը՝ օգտագործելով  type() ֆունկցիան։ Python-ն ունի լռելյայնորեն ներկառուցված տվյալների հետևյալ տեսակները․

Python Numbers

Python-ում կան երեք թվային տեսակներ.

• int — ամբողջ թիվ է՝ դրական կամ բացասական, առանց տասնորդականների, անսահմանափակ երկարությամբ։
• float — «լողացող կետի համարը» դրական կամ բացասական թիվ է, որը պարունակում է մեկ կամ մի քանի տասնորդական թվեր: Կարող է լինել նաև գիտական ​​թվեր, որոնք ունեն «e»՝ 10-ի հզորությունը ցույց տալու համար:
• complex — բարդ թվերը գրվում են «j»-ով որպես երևակայական մաս.

Python Strings

Python-ում տողերը բայթերի զանգվածներ են, որոնք ներկայացնում են Յունիկոդի նիշերը: Python-ը չունի նիշերի տվյալների տեսակ, մեկ նիշը պարզապես տող է 1 երկարությամբ: Քառակուսի փակագծերը կարող են օգտագործվել տողի տարրեր մուտք գործելու համար: Python-ում տողերը կարող են ստեղծվել միայնակ չակերտների կամ կրկնակի չակերտների կամ եռակի չակերտների միջոցով:  String- ի առանձին նիշերին կարելի է մուտք գործել՝ օգտագործելով Indexing մեթոդը: Ինդեքսավորումը թույլ է տալիս հասցեների բացասական հղումներին մուտք գործել տողի հետևի նիշերը, օրինակ՝ -1-ը վերաբերում է վերջին նիշին, -2-ը՝ երկրորդ վերջին նիշին և այլն: Մինչև տիրույթից դուրս ինդեքս մուտք գործելը կառաջացնի IndexError : Միայն ամբողջ թվերը կարող են փոխանցվել որպես ինդեքս, float կամ այլ տեսակներ, որոնք կառաջացնեն TypeError : Տողից նիշերի մուտք գործելու միջոցով մենք կարող ենք նաև հակադարձել դրանք, գրելով [::-1]: Python-ում թույլատրված չէ տողից նիշերի թարմացում կամ ջնջում: Սա սխալ կառաջացնի, քանի որ նյութի նշանակումը կամ տողից տարրի ջնջումը չի աջակցվում: Չնայած ամբողջ String-ի ջնջումը հնարավոր է ներկառուցված del հիմնաբառի օգտագործմամբ: Դա պայմանավորված է նրանով, որ տողերը անփոփոխ են, հետևաբար տողի տարրերը չեն կարող փոխվել, երբ այն նշանակվել է: Միայն նոր տողերը կարող են վերագրվել նույն անունով: Ամբողջ տողի ջնջումը հնարավոր է del բանալի բառի օգտագործմամբ: Ավելին, եթե մենք փորձենք տպել տողը, դա կառաջացնի սխալ, քանի որ տողը ջնջված է և անհասանելի է տպելու համար: Python-ում տողերը կարող են ֆորմատավորվել format() մեթոդի միջոցով, որը շատ բազմակողմանի և հզոր գործիք է տողերի ձևաչափման համար: Format մեթոդը String-ում պարունակում է գանգուր փակագծեր {} որպես տեղապահեր, որոնք կարող են արգումենտներ պահել ըստ դիրքի կամ բանալի բառի՝ հերթականությունը նշելու համար:

Python Booleans

Բուլյանները ներկայացնում են երկու արժեքներից մեկը՝ Trueկամ False: Կարելի է գնահատել ցանկացած արտահայտություն Python-ում և ստանալ երկու պատասխաններից մեկը, True կամ False։ Ֆունկցիան bool()թույլ է տալիս գնահատել ցանկացած արժեք և տալ True կամ False։

• Գրեթե ցանկացած արժեք գնահատվում է, Trueեթե այն ունի որոշակի բովանդակություն:
• Ցանկացած տող է True, բացառությամբ դատարկ տողերի:
• Ցանկացած թիվ է True, բացի 0.
• Ցանկացած ցուցակ, բազմակի, հավաքածու և բառարան են True, բացառությամբ դատարկների:
• Շատ արժեքներ չկան, որոնք գնահատվում են False, բացառությամբ դատարկ արժեքների, ինչպիսիք են (), [], {}, ""համարը 0 և արժեքը None: 
• Արժեքը False գնահատվում է False:
• Եվս մեկ արժեք կամ օբյեկտ գնահատվում է False, եթե ունեք օբյեկտ, որը կազմված է դասից, որն ունի __len__ֆունկցիա, որը վերադարձնում է 0 կամ False.

Python Lists

Python ցուցակները նման են դինամիկ չափերի զանգվածներին, որոնք հայտարարված են այլ լեզուներով (վեկտոր C++-ում և ArrayList Java-ում): Պարզ լեզվով ասած՝ ցուցակը իրերի հավաքածու է, որը կցվում է [ ]-ով և բաժանվում ստորակետերով։  Ցանկը հաջորդականության տվյալների տեսակ է, որն օգտագործվում է տվյալների հավաքածուն պահելու համար: Tuples-ը և String- ը հաջորդականության տվյալների այլ տեսակներ են: Ցուցակները ամենապարզ բեռնարկղերն են, որոնք Python լեզվի անբաժանելի մասն են: Ցանկերը չպետք է միշտ միատարր լինեն, ինչը այն դարձնում է Python- ի ամենահզոր գործիքը : Մեկ ցուցակը կարող է պարունակել Տվյալների Տիպեր, ինչպիսիք են ամբողջ թվերը, տողերը, ինչպես նաև օբյեկտներ: Ցուցակները փոփոխական են, և, հետևաբար, դրանք կարող են փոփոխվել նույնիսկ դրանց ստեղծումից հետո: Python-ում ցուցակները կարող են ստեղծվել՝ պարզապես հաջորդականությունը տեղադրելով քառակուսի փակագծերում []: Ցանկի կետերին մուտք գործելու համար դիմեք ինդեքսի համարին: Ցանկում որևէ տարր մուտք գործելու համար օգտագործեք ինդեքսային օպերատորը: Ցուցանիշը պետք է լինի ամբողջ թիվ: Ներդրված ցուցակները հասանելի են՝ օգտագործելով nested indexing:  Python-ում բացասական հաջորդականության ինդեքսները ներկայացնում են դիրքերը զանգվածի վերջից: Փոխանակ հաշվարկելու օֆսեթը, ինչպես List[len(List)-3]-ում, բավական է պարզապես գրել List[-3]: Բացասական ինդեքսավորումը նշանակում է սկսած վերջից, -1-ը վերաբերում է վերջին կետին, -2-ը վերաբերում է երկրորդ վերջին կետին և այլն: Python len() -ն օգտագործվում է ցուցակի երկարությունը ստանալու համար։ Տարրերը կարելի է ավելացնել Ցուցակում՝ օգտագործելով ներկառուցված append() ֆունկցիան: Միաժամանակ միայն մեկ տարր կարող է ավելացվել ցանկին՝ օգտագործելով append() մեթոդը, append() մեթոդով մի քանի տարրերի ավելացման համար օգտագործվում են հանգույցներ։ Tuples-ը կարող է նաև ավելացվել ցանկին հավելվածի մեթոդի կիրառմամբ, քանի որ tuples-ն անփոփոխ է: Ի տարբերություն Sets-ի, Ցուցակները կարող են նաև ավելացվել առկա ցանկին՝ append() մեթոդի կիրառմամբ: append() մեթոդն աշխատում է միայն ցանկի վերջում տարրեր ավելացնելու համար, ցանկալի դիրքում տարրեր ավելացնելու համար օգտագործվում է insert() մեթոդը: Ի տարբերություն append()-ի, որն ընդունում է միայն մեկ արգումենտ, insert() մեթոդը պահանջում է երկու արգումենտ (դիրք, արժեք):  Բացի append() և insert() մեթոդներից, կա ևս մեկ մեթոդ տարրերի ավելացման համար՝ extend() , այս մեթոդը օգտագործվում է ցանկի վերջում միաժամանակ մի քանի տարրեր ավելացնելու համար: Ցանկը կարող է հետ շրջվել՝ օգտագործելով Python-ում reverse() մեթոդը : Տարրերը կարելի է հեռացնել Ցուցակից՝ օգտագործելով ներկառուցված remove() ֆունկցիան, սակայն Սխալ է առաջանում, եթե տարրը չկա ցանկում: Remove() մեթոդը միանգամից հեռացնում է միայն մեկ տարր, մի շարք էլեմենտներ հեռացնելու համար օգտագործվում է կրկնիչը: remove() մեթոդը հեռացնում է նշված տարրը: pop() ֆունկցիան կարող է օգտագործվել նաև ցանկից որևէ տարր հեռացնելու և վերադարձնելու համար, բայց լռելյայնորեն այն հեռացնում է ցուցակի միայն վերջին տարրը, ցանկի որոշակի դիրքից տարրը հեռացնելու համար տարրի ինդեքսը փոխանցվում է: որպես արգումենտ pop() մեթոդի համար:

Մենք կարող ենք ենթատողեր և ենթացանկեր ստանալ՝ օգտագործելով slice: Python List-ում կան ամբողջ ցուցակը բոլոր տարրերով տպելու բազմաթիվ եղանակներ, սակայն ցուցակից տարրերի որոշակի շրջանակ տպելու համար մենք օգտագործում ենք Slice գործողությունը: Slice գործողությունը կատարվում է Ցուցակների վրա՝ երկու կետի օգտագործմամբ (:): 

Python Tuples

Tuple- ը Python-ի օբյեկտների հավաքածու է, որը շատ նման է ցուցակի: Թուպլում պահվող արժեքների հաջորդականությունը կարող է լինել ցանկացած տեսակի, և դրանք ինդեքսավորվում են ամբողջ թվերով։ 

Թուպլիկի արժեքները շարահյուսորեն բաժանվում են «ստորակետներով»: Թեև դա անհրաժեշտ չէ, բայց ավելի տարածված է բազմակի սահմանումը փակելով փակագծերում տրված արժեքների հաջորդականությունը: Սա օգնում է ավելի հեշտությամբ հասկանալ Python tuples-ը:

Python-ում tuples-ները ստեղծվում են՝ տեղադրելով «ստորակետով» առանձնացված արժեքների հաջորդականություն՝ տվյալների հաջորդականությունը խմբավորելու համար փակագծերի կիրառմամբ կամ առանց դրա: Python tuple-ի ստեղծումն առանց փակագծերի օգտագործման հայտնի է որպես Tuple Packing:  Tuples-ը կարող է պարունակել ցանկացած թվով տարրեր և ցանկացած տվյալների տեսակ (օրինակ՝ տողեր, ամբողջ թվեր, ցուցակ և այլն): Tuples կարող են ստեղծվել նաև մեկ տարրով, բայց դա մի փոքր բարդ է: Փակագծերում մեկ տարր ունենալը բավարար չէ, այն կրկնակի դարձնելու համար պետք է լինի հետին «ստորակետ»:  Թուպլիկները անփոփոխ են, և սովորաբար դրանք պարունակում են տարասեռ տարրերի հաջորդականություն, որոնք հասանելի են բացման կամ ինդեքսավորման միջոցով ( կամ նույնիսկ ատրիբուտով՝ անվանակոչված զույգերի դեպքում): Ցուցակները փոփոխական են, և դրանց տարրերը սովորաբար միատարր են և հասանելի են՝ ցուցակի վրա կրկնելով: Բազմաթիվ փոփոխականների բացման ժամանակ ձախ կողմում գտնվող փոփոխականների թիվը պետք է հավասար լինի տրված a-ի մի շարք արժեքներին:  Tuple-ի միացումը երկու կամ ավելի զույգերի միացման գործընթացն է: Միացումն իրականացվում է «+» օպերատորի օգտագործմամբ: Թուպլիկների միացումը կատարվում է միշտ սկզբնական կուտի վերջից: Այլ թվաբանական գործողություններ չեն կիրառվում Tuples-ի վրա: Միայն նույն տվյալների տեսակները կարող են համակցվել կապակցման հետ, սխալ է առաջանում, եթե ցուցակը և բազմապատիկը համակցված են: 

Tuple-ի կտրատումը կատարվում է Tuple-ից որոշակի տիրույթ կամ ենթատարրերի հատված բերելու համար: Կտրատումը կարող է կատարվել նաև ցուցակների և զանգվածների վրա: Ցանկում ինդեքսավորումը հանգեցնում է մեկ տարրի բեռնման, մինչդեռ կտրատումը թույլ է տալիս վերցնել մի շարք տարրեր: Բացասական աճի արժեքները կարող են օգտագործվել նաև Tuples-ի հաջորդականությունը փոխելու համար:  Tuples-ը անփոփոխ է, ուստի թույլ չի տալիս ջնջել դրա մի մասը: Ամբողջ tuple-ը ջնջվում է del() մեթոդի կիրառմամբ:  Ջնջելուց հետո Tuple-ի տպումը հանգեցնում է սխալի: 

Python Sets

Python-ում Set- ը տվյալների տեսակների անկանոն հավաքածու է, որը կրկնվող է, փոփոխական և չունի կրկնօրինակ տարրեր: Կոմպլեկտի տարրերի կարգը որոշված ​​չէ, թեև այն կարող է բաղկացած լինել տարբեր տարրերից: Կոմպլեկտի օգտագործման հիմնական առավելությունը, ի տարբերություն ցուցակի, այն է, որ այն ունի բարձր օպտիմիզացված մեթոդ՝ ստուգելու, թե արդյոք որոշակի տարր պարունակվում է հավաքածուում: Կոմպլեկտները կարող են ստեղծվել՝ օգտագործելով ներկառուցված set() ֆունկցիան կրկնվող օբյեկտի կամ հաջորդականության հետ՝ տեղադրելով հաջորդականությունը գանգուր փակագծերի մեջ՝ բաժանված «ստորակետով»: Հավաքածուն չի կարող ունենալ փոփոխվող տարրեր, ինչպիսիք են ցուցակը կամ բառարանը, քանի որ այն փոփոխական է։  Հավաքածուն պարունակում է միայն եզակի տարրեր, սակայն հավաքածուի ստեղծման պահին կարող են փոխանցվել նաև մի քանի կրկնօրինակ արժեքներ: Հավաքածուի տարրերի դասավորությունը անորոշ է և անփոփոխ: Պարտադիր չէ, որ հավաքածուի տարրերի տեսակը նույնը լինի, տվյալների տիպի տարբեր արժեքներ կարող են փոխանցվել նաև հավաքածուին: Տարրերը կարող են ավելացվել Set-ին՝ օգտագործելով ներկառուցված add() ֆունկցիան: Միաժամանակ միայն մեկ տարր կարող է ավելացվել բազմությանը` օգտագործելով add() մեթոդը, loops օգտագործվում են միաժամանակ մի քանի տարրեր ավելացնելու համար add() մեթոդի կիրառմամբ։  Ցուցակները չեն կարող ավելացվել բազմությանը որպես տարրեր, քանի որ Ցուցակները հաշման ենթակա չեն, մինչդեռ Tuples-ը կարող է ավելացվել, քանի որ tuple-ները անփոփոխ են և հետևաբար՝ Hashable: Երկու կամ ավելի տարրերի ավելացման համար օգտագործվում է Update() մեթոդը: Update() մեթոդն ընդունում է ցուցակները, տողերը, tuples, ինչպես նաև այլ հավաքածուներ որպես իր արգումենտներ։ Այս բոլոր դեպքերում խուսափում են կրկնօրինակ տարրերից: Կոմպլեկտների տարրերը հնարավոր չէ մուտք գործել՝ հղում անելով ինդեքսին, քանի որ հավաքածուները դասավորված չեն, տարրերը չունեն ինդեքս: Բայց դուք կարող եք շրջել հավաքածուի տարրերի միջոցով՝ օգտագործելով for հանգույցը, կամ հարցնել, թե արդյոք նշված արժեք կա հավաքածուում՝ օգտագործելով in բանալի բառը: Տարրերը կարող են հեռացվել Set-ից՝ օգտագործելով ներկառուցված remove() ֆունկցիան, սակայն KeyError առաջանում է, եթե տարրը գոյություն չունի հավաքածուում: Առանց KeyError-ի հավաքածուից տարրեր հեռացնելու համար օգտագործեք discard(), եթե տարրը չկա հավաքածուում, այն մնում է անփոփոխ: Pop() ֆունկցիան կարող է օգտագործվել նաև հավաքածուից որևէ տարր հեռացնելու և վերադարձնելու համար, սակայն այն հեռացնում է միայն հավաքածուի վերջին տարրը: Եթե հավաքածուն դասավորված չէ, ապա ոչ մի կերպ հնարավոր չէ որոշել, թե որ տարրը կհայտնվի pop() ֆունկցիայի միջոցով:  Բոլոր տարրերը հավաքածուից հեռացնելու համար օգտագործվում է clear() ֆունկցիան:  Python-ում անփոփոխ օբյեկտներ են, որոնք աջակցում են միայն մեթոդներին և օպերատորներին, որոնք արդյունք են տալիս՝ չազդելով սառեցված հավաքածուի կամ բազմությունների վրա, որոնց վրա կիրառվում են: Թեև հավաքածուի տարրերը կարող են փոփոխվել ցանկացած պահի, սառեցված հավաքածուի տարրերը ստեղծումից հետո մնում են նույնը: Եթե ​​ոչ մի պարամետր չի փոխանցվել, այն վերադարձնում է դատարկ սառեցված հավաքածու:  

Python Dictionary

Բառարանը Python- ում բանալիների արժեքների հավաքածու է, որն օգտագործվում է տվյալների արժեքները պահելու համար, ինչպես քարտեզը, որը, ի տարբերություն տվյալների այլ տեսակների, որոնք պարունակում են միայն մեկ արժեք որպես տարր: Բառարան կարող է ստեղծվել՝ տեղադրելով տարրերի հաջորդականություն գանգուր {}փակագծերում՝ բաժանված «ստորակետով»: Բառարանը պարունակում է արժեքների զույգեր, որոնցից մեկը բանալին է, իսկ մյուս համապատասխան զույգ տարրը նրա Key:value- ն է : Բառարանում արժեքները կարող են լինել ցանկացած տեսակի տվյալների և կարող են կրկնօրինակվել, մինչդեռ բանալիները չեն կարող կրկնվել և պետք է լինեն անփոփոխ :  Բառարանի ստեղները մեծատառերի զգայուն են, նույն անվանումը, բայց Key-ի տարբեր դեպքերը կվերաբերվեն հստակ: 

Տարրերի ավելացումը կարող է իրականացվել մի քանի ձևով. Միանգամից մեկ արժեք կարող է ավելացվել Բառարանին` բանալիի հետ միասին արժեք սահմանելով, օրինակ` Dict[Key] = «Արժեք»: Բառարանում գոյություն ունեցող արժեքի թարմացումը կարելի է անել՝ օգտագործելով ներկառուցված update() մեթոդը։ Ներդրված հիմնական արժեքները կարող են նաև ավելացվել գոյություն ունեցող Բառարանին:  Ավելացնելիս, եթե բանալի-արժեքն արդեն գոյություն ունի, արժեքը թարմացվում է, հակառակ դեպքում բառարանին ավելացվում է արժեքով նոր բանալի: Բառարանի տարրերը մուտք գործելու համար նշեք նրա հիմնական անվանումը: Բանալին կարող է օգտագործվել քառակուսի փակագծերի ներսում: Կա նաև մի մեթոդ, որը կոչվում է get() , որը կօգնի նաև բառարանից տարր մուտք գործելիս: Այս մեթոդն ընդունում է բանալին որպես արգումենտ և վերադարձնում արժեքը: Ներկառուցված բառարանում որևէ բանալիի արժեքին հասանելի դարձնելու համար օգտագործեք ինդեքսավորման [] շարահյուսությունը:

Python For Loops

Python For loop-ն օգտագործվում է հաջորդական անցման համար, այսինքն՝ այն օգտագործվում է կրկնվող տողերի վրա կրկնելու համար, ինչպիսիք են String, Tuple, List, Set կամ Dictionary:

Python while Loop

Python while Loop- ը օգտագործվում է հայտարարությունների բլոկը բազմիցս գործարկելու համար, մինչև տվյալ պայմանը բավարարվի: Իսկ երբ պայմանը դառնում է false, ծրագրում ցիկլից անմիջապես հետո տողը կատարվում է։

Հայտարարությունները ներկայացնում են բոլոր հայտարարությունները, որոնք ներքաշված են նույն թվով նիշերի բացատներով այն բանից հետո, երբ ծրագրավորման կառուցվածքը համարվում է կոդի մեկ բլոկի մաս: Python-ը օգտագործում է նահանջը որպես հայտարարությունների խմբավորման մեթոդ: Երբ կատարվում է while հանգույց, expr-ը սկզբում գնահատվում է բուլյան համատեքստում, և եթե դա ճիշտ է, ապա հանգույցի մարմինը կատարվում է: Այնուհետև expr-ը նորից ստուգվում է, եթե այն դեռ ճիշտ է, ապա մարմինը նորից գործարկվում է, և դա շարունակվում է այնքան ժամանակ, մինչև արտահայտությունը դառնա կեղծ:

Ի՞նչ է Python math մոդուլը

Python math մոդուլը նախատեսված է մաթեմատիկական գործողություններ իրականացնելու համար։ Python-ում math մոդուը հնարավորություն է տալիս հավելվածում իրականացնել մաթեմատիկական հաշվարկներ։ Մոդուլն օգտագործելու համար պետք է այն ներմուծել․

>>> import math

Constants of the math Module

Python math մոդուլը իր մեջ պարունակում է մի շարք հայտնի մաթեմատիկական հաստատուններ, որոնք մեզ օգնում են խնդիրներ լուծելիս։

• Pi

Pi (π)-ն, մաթեմատիկական հաստատուն, որը ցույց է տալիս շրջանագծի երկարության հարաբերությունը տրամագծին։  Pi (π) -ն աշխարհում ամենաճանաչված մաթեմատիկական հաստատունն է։ Այն ունի տոնակատարության ամսաթիվը, որը կոչվում է Pi Day։ Pi (π) -ի արժեքը python-ում օգտագործվում է հետևյալ կերպ․

>>> math.pi
3.141592653589793

• Tau (τ)

Tau (τ)-ն, մաթեմատիկական հաստատուն է, որը ցույց է տալիս շրջանագծի երկարության հարաբերությունը շառավղին։ Այս թիվը նույնպես ունի ծննդյան օր, որը համարվում է հունիսի 28-ը։ Շատերը մաթեմատիկական խնդիրներում Tau (τ)-ի փոխարեն օգտագործում են  2π, բայց (τ)-ի օգտագործումը կարող է օգնել պարզեցնել հավասարումները։ Tau (τ)-ի արժեքը python-ում օգտագործվում է հետևյալ կերպ․

>>> math.tau
6.283185307179586

• Euler’s number

Euler’s number  ( e ) — Էյլերի թիվ։ ( e ) թիվը բնական լոգարիթմի հիմքը, մաթեմատիկական հաստատուն, իռացիոնալ և տրանսցենդենտ թիվ։ Հաճախ ( e )-ն անվանում են Էյլերի թիվ կամ Նեպերի թիվ։ Էյլերի թիվը կարևոր հաստատուն է, քանի որ այն ունի բազմաթիվ գործնական կիրառումներ, ինչպիսիք են ժամանակի ընթացքում բնակչության աճի հաշվարկը կամ ռադիոակտիվ քայքայման տեմպերի որոշումը: ( e ) -ի արժեքը python-ում օգտագործվում է հետևյալ կերպ․

>>> math.e
2.718281828459045

• Infinity

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

>>> f"Positive Infinity = {math.inf}"
'Positive Infinity = inf'
>>> f"Negative Infinity = {-math.inf}"
'Negative Infinity = -inf'

• Not a number (NaN)

Not a number (NaN) — ոչ մի թիվ։ Թիվը կամ NaN-ը իրականում մաթեմատիկական հասկացություն չէ: Այն առաջացել է համակարգչային գիտության ոլորտում՝ որպես հղում այն ​​արժեքներին, որոնք թվային չեն: NaN արժեքը կարող է պայմանավորված լինել անվավեր մուտքերով, կամ կարող է ցույց տալ, որ փոփոխականը , որը պետք է թվային լինի, վնասվել է տեքստային նիշերի կամ նշանների կողմից: Python-ում կարող ենք օգտագործել․

>>> math.nan
nan

Թվաբանական ֆունկցիաներ

Թվերի տեսությունը, կամ ավելի հին անվանմբ թվաբանությունը մաքուր մաթեմատիկական ճյուղ է, որը հիմնականում նվիրված է ամբողջ թվերի ուսումնասիրությանը։ Python math մոդուլը տրամադրում է ֆունկցիաներ, որոնք օգտակար են թվերի տեսությունում: Այս գործառույթները թույլ են տալիս հաշվարկել մի շարք կարևոր արժեքներ, ներառյալ հետևյալը.

• Թվի ֆակտորյալները 

Factorials Python — factorial()։ Այն իրենից ներկայացնում է 1-ից մինչև տրված որևէ n բնական թիվը եղած բոլոր բնական թվերի արտադրյալը։ Օրինակ՝ 5-ի ֆակտորիալը կգրվի այսպես․

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

1. for loops
2. Recursive functions
3. math.factorial()

1. for loops-ի օգնությամբ ֆակտորիալը կարող ենք գտնել հետևյալ եղանակով․

def fact_loop(num):
    if num < 0:
        return 0
    if num == 0:
        return 1

    factorial = 1
    for i in range(1, num + 1):
        factorial = factorial * i
    return factorial

2. Recursive functions: Ռեկուրսիվ ֆունկցիան օգտագործելով ֆակտորիալը կարող ենք գտնել հետևյալ եղանակով․

def fact_recursion(num):
    if num < 0:
        return 0
    if num == 0:
        return 1

    return num * fact_recursion(num - 1)

3. math.factorial() օգտագործելով, թվի ֆակտորիալը կարող ենք գտնել հետևյալ եղանակով։ Այստեղ մի կարևոր պայման, որ factorial()ընդունում է միայն դրական ամբողջ թվեր: Եթե ​​փորձեք մուտքագրել բացասական արժեք կամ տասնորդական թվեր, ապա կստանաք ValueError։

>>> math.factorial(7)
5040

Հաշվիր ամենամեծ ընդհանուր բաժանարարը

Երկու դրական թվերի ամենամեծ ընդհանուր բաժանարարը (GCD) ամենամեծ դրական ամբողջ թիվն է, որը երկու թվերն էլ բաժանում է առանց մնացորդի։

Օրինակ, 15-ի և 25-ի GCD-ն 5 է: Դուք կարող եք և՛ 15-ը, և՛ 25-ը բաժանել 5-ի առանց մնացորդի: Չկա ավելի մեծ թիվ, որն անում է նույնը: Եթե ​​վերցնում եք 15-ը և 30-ը, ապա GCD-ն 15 է, քանի որ և՛ 15-ը, և՛ 30-ը կարելի է բաժանել 15-ի առանց մնացորդի:

GCD-ն հաշվարկելու համար պետք չէ իրականացնել ձեր սեփական գործառույթները: Python mathմոդուլը տրամադրում է ֆունկցիա, որը կոչվում math.gcd()է, որը թույլ է տալիս հաշվարկել երկու թվերի GCD-ն: Դուք կարող եք դրական կամ բացասական թվեր տալ որպես մուտքագրում, և այն վերադարձնում է համապատասխան GCD արժեքը: Այնուամենայնիվ, դուք չեք կարող մուտքագրել տասնորդական թիվ:

import math
print(math.gcd(60, 48))

Եթե այս խնդիրը փորձենք լուծել ռեկուրսիայով

def greatest_divisor(a, b):
    if(b == 0):
        return a
    else:
        return hcf(b, a % b)
  
a = 60
b = 48
  
print(greatest_divisor(60, 48))

Կոտորակի մոդուլ Python-ում

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

1.class fractions.Fraction(numerator=0, denominator=1) :  Սա պահանջում է, որ համարիչը և հայտարարը թվերի օրինակներ լինեն: Վերադարձվում է ռացիոնալ և (համարիչ/հայտարար) կոտորակի օրինակ: Զրո բաժանման սխալ է առաջանում, եթե հայտարարը = 0:  Կոդային տարբերակով՝

from fractions import Fraction

print (Fraction(11, 35))
# returns Fraction(11, 35)

print (Fraction(10, 18))
# returns Fraction(5, 9)

print (Fraction())
# returns Fraction(0, 1)

2. class fractions.Fraction(float): Սա պահանջում է float օրինակ և վերադարձվում է նույն արժեքով կոտորակի օրինակ: 

from fractions import Fraction

print (Fraction(1.13))
# returns Fraction(1272266894732165, 1125899906842624)

3. class fractions.Fraction(decimal) :  Սա պահանջում է տասնորդական օրինակ և վերադարձվում է նույն արժեքով կոտորակի օրինակ: 

from fractions import Fraction

print (Fraction('1.13'))
# returns Fraction(113, 100)

4. class fractions.Fraction(string) : Սա պահանջում է տողի կամ յունիկոդի օրինակ և վերադարձվում է նույն արժեքով կոտորակի օրինակ: 

from fractions import Fraction

print (Fraction('8/25'))
# returns Fraction(8, 25)

print (Fraction('1.13'))
# returns Fraction(113, 100)

print (Fraction('3/7'))
# returns Fraction(3, 7)

print (Fraction('1.414213 \t\n'))
# returns Fraction(1414213, 1000000)

5. limit_denominator(max_denominator=1000000):

• Այս մեթոդը օգտակար է տվյալ լողացող կետով թվի ռացիոնալ մոտարկումներ գտնելու համար:
• Այս մոդուլը գտնում և վերադարձնում է ինքն իրեն ամենամոտ Կոտորակը, որն ունի հայտարար առավելագույնը max_denominator:
• Այս մոդուլը կարող է օգտագործվել նաև տվյալ կոտորակի համարիչը ամենացածր անդամով վերադարձնելու համար՝ օգտագործելով համարիչ հատկությունը, իսկ հայտարարը՝ օգտագործելով հայտարարի հատկությունը։

Կոտորակների վրա մաթեմատիկական գործողություններ կատարելը

from fractions import Fraction

print (Fraction(113, 100) + Fraction(25, 18))
# returns Fraction(2267, 900)

print (Fraction(18, 5) / Fraction(18, 10))
# returns Fraction(2, 1)

print (Fraction(18, 5) * Fraction(16, 19))
# returns Fraction(288, 95)

print (Fraction(18, 5) * Fraction(15, 36))
# returns Fraction(3, 2)

print (Fraction(12, 5) ** Fraction(12, 10))
# returns 2.8592589556010197

Կոտորակների վրա հիմնված հաշվարկներ՝ օգտագործելով մաթեմատիկական մոդուլի տարբեր գործառույթներ

import math
from fractions import Fraction

print (math.sqrt(Fraction(25, 4)))
# returns 2.5

print (math.sqrt(Fraction(28,3)))
# returns 3.0550504633038935

print (math.floor(Fraction(3558, 1213)))
# returns 2

print (Fraction(math.sin(math.pi/3)))
# returns Fraction(3900231685776981, 4503599627370496)

print (Fraction(math.sin(math.pi/3)).limit_denominator(10))
# returns Fraction(6, 7)

Եզրակացություն

Այս հոդվածում կատարեցի ուսումնասիրություն մաթեմատիկայի և python ծրագրավորման լեզվի միջև։ Ուսումնասիրեցի python ծրագրավորման մեջ մաթեմատիկական մոդուլը։ Մոդուլը ներառում է մի քանի հայտնի մաթեմատիկական հաստատուններ և կարևոր արժեքներ.

• Պի
• Տաու
• Էյլերի համարը
• Անսահմանություն
• Թիվ չէ (NaN)

Կատարեցի մի քանի խնդիրների լուծումներ․

• Հաշվիր թվի ֆակտորյալը
• Հաշվիր ամենամեծ ընդհանուր բաժանարարը
• Կոտորակի մոդուլ Python-ում
• Կոտորակների վրա մաթեմատիկական գործողություններ կատարելը
• Կոտորակների վրա հիմնված հաշվարկներ՝ օգտագործելով մաթեմատիկական մոդուլի տարբեր գործառույթներ

Գրականության ցանկ

1. The Python math Module: Everything You Need to Know
2. www.geeksforgeeks.org
3. https://www.w3schools.com
4. Python Documentation

Աշխատանքը word տարբերակով՝ տե՛ս այստեղ