Գլուխ 2. Python հիմունքներ

Փոփոխականներ և տվյալների տեսակներ

Փոփոխականներ
Փոփոխականները նախատեսված են տվյալների պահպանման համար: Python-ում փոփոխականի անունը պետք է սկսվի այբբենական նիշով կամ ներքևով և կարող է պարունակել այբբենական թվային նիշ և ներքև: Եվ բացի այդ, փոփոխականի անվանումը չպետք է համընկնի Python լեզվի հիմնաբառերի անվան հետ։ Շատ հիմնաբառեր չկան, դրանք հեշտ է հիշել.

Օրինակ, եկեք ստեղծենք փոփոխական.

name = "Tom"

Այստեղ սահմանվում է փոփոխական name, որը պահում է «Tom» տողը:

Python-ն օգտագործում է փոփոխականների անվանման երկու տեսակ՝ camel case և underscore նշում :

Camel case-ը ենթադրում է, որ փոփոխականի անվան յուրաքանչյուր նոր ենթաբառ սկսվում է մեծատառով։ Օրինակ:

userName = "Tom"

Ընդգծման նշումը նշանակում է, որ փոփոխականի անվան ենթաբառերն առանձնացված են ընդգծված նշանով: Օրինակ:

user_name = "Tom"

Եվ մենք նաև պետք է հաշվի առնենք մեծատառերի զգայունությունը, այնպես որ փոփոխականները name կներկայացնեն Name տարբեր օբյեկտներ:

name = "Tom" Name = "Tom"

Սահմանելով փոփոխական՝ մենք կարող ենք այն օգտագործել ծրագրում։ Օրինակ, փորձեք տպել դրա բովանդակությունը վահանակում՝ օգտագործելով ներկառուցված տպման գործառույթը.

name = "Tom" print(name)

Օրինակ, PyCharm միջավայրում փոփոխականի սահմանում և օգտագործում.

Փոփոխականի տարբերակիչ առանձնահատկությունն այն է, որ մենք կարող ենք փոխել դրա արժեքը մինչ ծրագիրը աշխատում է.

name = "Tom" print(name) name = "Bob" print(name)

Տվյալների տեսակները

Փոփոխականը պահպանում է տվյալների տեսակներից մեկի տվյալները: Python-ում տվյալների շատ տարբեր տեսակներ կան: Այս դեպքում մենք կդիտարկենք միայն ամենահիմնական տեսակները՝ bool , int , float , complex և str .

Բուլյան արժեքներ

Bool տեսակը ներկայացնում է երկու բուլյան արժեք՝ True (true) կամ False (false): True արժեքը օգտագործվում է ցույց տալու համար, որ ինչ-որ բան ճիշտ է: Մինչդեռ False-ը , մյուս կողմից, ցույց է տալիս, որ ինչ-որ բան կեղծ է: Այս տեսակի փոփոխականների օրինակ.

isMarried = False print(isMarried) # False isAlive = True print(isAlive) # True

Ամբողջ թվեր

int տեսակը ներկայացնում է մի ամբողջ թիվ, օրինակ՝ 1, 4, 8, 50: Օրինակ

age = 21 print("Age:", age) count = 15 print("Count:", count)

Լռելյայնորեն ստանդարտ թվերը դիտվում են որպես տասնորդական թվեր: Բայց Python-ը նաև աջակցում է թվերին երկուական, օկտալ և տասնվեցական համակարգերում: Նշելու համար, որ թիվը ներկայացնում է երկուական, թվին դրվում է 0b նախածանց .

= 0b11 b = 0b1011 c = 0b100001 print(a) print(b) print(c)

Նշելու համար, որ թիվը ներկայացնում է օկտալային համակարգը, թվին դրվում է 0o նախածանց .

a = 0o7 b = 0o11 c = 0o17 print(a) print(b) print(c)

Նշելու համար, որ թիվը ներկայացնում է տասնվեցական, թվին դրվում է 0x նախածանց .

a = 0x0A b = 0xFF c = 0xA1 print(a) print(b) print(c)

Հարկ է նշել, որ ցանկացած համակարգում մենք չենք փոխանցում տպման ֆունկցիայի համարը վահանակի վրա ելքի համար, այն լռելյայն կարտադրվի տասնորդական համակարգում:

Կոտորակային թվեր

Լողացող տիպը ներկայացնում է լողացող կետի համար, օրինակ՝ 1.2 կամ 34.76: Կետն օգտագործվում է որպես ամբողջ թվերի և կոտորակային մասերի բաժանարար։

height = 1.68 pi = 3.14 weight = 68. print(height) # 1.68 print(pi) # 3.14 print(weight) # 68.0

Լողացող կետի թիվը կարող է սահմանվել էքսպոնենցիալ նշումով.

x = 3.9e3 print(x) # 3900.0 x = 3.9e-3 print(x) # 0.0039

Լողացող թիվը կարող է ունենալ միայն 18 նշանակալի նիշ: Այսպիսով, այս դեպքում օգտագործվում է ընդամենը երկու նշան՝ 3.9։ Իսկ եթե թիվը չափազանց մեծ է կամ շատ փոքր, ապա մենք կարող ենք թիվը գրել նմանատիպ նշումով՝ օգտագործելով ցուցիչը։ Ցուցանիշից հետո թիվը ցույց է տալիս 10-ի հզորությունը, որով պետք է բազմապատկել բազային թիվը՝ 3,9։

Կոմպլեքս թվեր

Կոմպլեքս տեսակը ներկայացնում է կոմպլեքս թվեր ձևաչափով - երևակայական մասից հետո նշվում է j վերջածանցը

complexNumber = 1+2j print(complexNumber) # (1+2j)

String

str տեսակը ներկայացնում է տողեր։ Տողը ներկայացնում է նիշերի հաջորդականություն, որոնք փակցված են մեկ կամ կրկնակի չակերտներով, ինչպիսիք են «բարև» և «բարև»: Python 3.x-ում տողերը ներկայացնում են Unicode նիշերի մի շարք

message = "Hello World!" print(message) # Hello World! name = 'Tom' print(name) # Tom

Ավելին, եթե տողը շատ նիշեր ունի, այն կարելի է բաժանել մասերի և այդ մասերը տեղադրել կոդի տարբեր տողերի վրա։ Այս դեպքում ամբողջ տողը փակվում է փակագծերում, իսկ դրա առանձին մասերը՝ չակերտների մեջ.

text = ("Laudate omnes gentes laudate " "Magnificat in secula ") print(text)

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

''' Это комментарий ''' text = '''Laudate omnes gentes laudate Magnificat in secula Et anima mea laudate Magnificat in secula ''' print(text)

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

Փախուստի հաջորդականությունները տողում

Տողը կարող է պարունակել մի շարք հատուկ նիշեր՝ կառավարման հաջորդականություններ: Դրանցից մի քանիսը.

\\ : թույլ է տալիս շեղ ավելացնել տողի ներսում

\' : թույլ է տալիս ավելացնել մեկ մեջբերում տողի ներսում

\" : թույլ է տալիս ավելացնել կրկնակի մեջբերում տողի ներսում

\n ՝ ընդմիջում դեպի նոր տող

\t . ավելացնում է ներդիր (4 նահանջ)

Եկեք օգտագործենք մի քանի հաջորդականություն.

text = "Message:\n\"Hello World\"" print(text)

Թեև նման հաջորդականությունները կարող են մեզ օգնել որոշ հարցերում, օրինակ՝ տողում մեջբերում դնելը, ներդիր պատրաստելը կամ այն մեկ այլ տողի վրա փաթաթելը։ Բայց նրանք կարող են նաև խոչընդոտել: Օրինակ:

path = "C:\python\name.txt" print(path)

Այստեղ ուղու փոփոխականը պարունակում է ֆայլի որոշ ճանապարհ: Այնուամենայնիվ, տողի ներսում կան «\n» նիշեր, որոնք կմեկնաբանվեն որպես փախուստի հաջորդականություն: Այսպիսով, մենք կստանանք հետևյալ վահանակի ելքը.

Այս իրավիճակից խուսափելու համար r նիշը դրվում է տողից առաջ

path = r"C:\python\name.txt" print(path)

Արժեքների տեղադրում տողի մեջ

Python-ը թույլ է տալիս ներդնել այլ փոփոխականների արժեքները տողի մեջ: Դա անելու համար տողի ներսում փոփոխականները տեղադրվում են գանգուր փակագծերում {}, իսկ f նշանը դրվում է ամբողջ տողի առաջ.

userName = "Tom" userAge = 37 user = f"name: {userName} age: {userAge}" print(user) # name: Tom age: 37

Այս դեպքում {userName}userName փոփոխականի արժեքը կտեղադրվի տեղում: Նմանապես, փոխարենը կտեղադրվի userAge փոփոխականի արժեքը {userAge}:

Դինամիկ մուտքագրում

Python-ը դինամիկ մուտքագրված լեզու է: Սա նշանակում է, որ փոփոխականը խստորեն կապված չէ կոնկրետ տեսակի հետ:

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

Միևնույն ժամանակ, մինչ ծրագիրը գործարկվում է, մենք կարող ենք փոխել փոփոխականի տեսակը՝ նրան այլ տեսակի արժեք վերագրելով.

userId = "abc" print(userId) userId = 234 print(userId)

Օգտագործելով ներկառուցված type() ֆունկցիան ՝ կարող եք դինամիկ կերպով պարզել փոփոխականի ընթացիկ տեսակը.

userId = 'abc'
print(type(userId)) # <class 'str'>

userId = 234
print(type(userId)) # <class 'int'>