გაკვეთილი 1

ცვლადების ჩაწერის წესი პირველი სინტაქსური წესია, რომელსაც გავეცანით. პითონის პროგრამა წარმოადგეს პროგრამული დებულებების (statement) ერთობლიობას. როგორც წესი, პითონის დებულება ერთ ხაზზე იწერება, და შედგება ცვლადებისგან(ობიექტებისაგან) და ოპერატორებისგან, რომლებიც პროგრამულ ოპერაციებს ანხორციელებენ. ყველაზე გავრცელებულ ოპერატორს წარმოადგენს მინიჭების ოპერატორი =, რომლის საშუალებით ცვლადს(ობიექტს) მნიშვნელობა ენიჭება, ან უფრო სწორედ კომპუტერული მეხსიერების ის ნაწილის უკავშირდება, რომელშიც ჩაწერილია ეს მნიშვნელობა. პითონის სინტაქსი განსაზღვრავს როგორც დებულებების ჩაწერის წესს ასევე ჩაწერის პოზიციას. შეგვიძლია ჩავთვალოთ, რომ პითონის პროგრამა, გარკვეულ პოზიციებზე ჩაწერილი დებულებების ერთობლიობას წარმოადგენს. ამის შესახებ უდრო დაწვრილებით გვექნება საუბარი როდესაც დებულებების გამოყოფილ ბლოკს განვიხილავთ. ქვემოთ მოყვანილია მინიჭების ოპერატორის გამოყენების მაგალითები, საიდანაც სჩანს რომ შესაძლებელია მინიჭების ოპერატორით რამოდენიმე ცვლადს(ობიექტს) მიენიჭოს მნიჭვნელობა. მაგალითის ბოლოს ცვლადი Year ორჯერ არის ჩაწერილი. პირველ შემთხვევაში ცვლადი ჩაწერილია პირველ პოზიციაზე პითონი "პრომპტის" >>> შემდეგ, ხოლო მეორე შემთხვევაში Year ჩაწერილია ორი პოზიციის შემდეგ, რაც პითონში სინტაქსურ შეცდომას იწვევს.

>>>NewYear=2015
>>>NewYear
2015
>>>Date,Month,Year=9,1,2015
>>>Date
>>> 9
>>>Month
1
>>>This_identificator_1=Month
>>>This_identificator_1
1
>>>Year
2015
>>> Year
SyntaxError: unexpected indent

მოყვანილ მაგალითში ცვლადები ეკუთვნიან რიცხვების ტიპის ობიექტებს, რომელთა მნიშვნელობა განვსაზღვრეთ მინიჭების ოპერატორით. რიცხვითი ტიპის ცვლადები პითონის ძირითადი ობიეტებია და მათ პირველ რიგში განვიხილავთ.

პიონის რიცხვითი ცვლადები

პითონის ობიექტი ან ცვლადი, როგორც უკვე ავღნიშნეთ კომპუტერული მესხიერების მონიშნული ნაწილია, რომელზეც მიმართვა ხორციელდება იდენტიფიკატორის (სახელის) საშუალებით. პითონის ბაზური ტიპის ობიექტებს მიეკუთვნებიან რიცხვითი ცვლადები. პითონში რიცხვითი ცვლადები რამდენიმე ტიპად(კლასად) იყოფა: მთელი, ათწილადი(მცოცავი წერტილით), კომპლექსური . ამ კურსში მხოლოდ მთელ და მცოცავი წერტილის ფორმატის მქონე რიცხვებს განვიხილავთ. კომპლექსური რიცხვების განხილვა კომპუტერული პროგრამირების საწყის კურსში როგორც წესი არ ხდება.

რიცხვების მათემატიკური ჩაწერა პოზიციური სისტემას ემყარება. ათობით სისტემაში რიცხვის ჩასაწერად საკმარისია 10 სიმბილო(ციფრი). ათობით სისტემაში n პოზიციაში 10ⁿ რიცხვის ჩაწერა შეიჩლება. რიცხვების კომპუტერული წარმოდგენა ორობით (ბინარულ) სისტემას ეფუძნება. ე.ი. ამ სისტემაში რიცხვები ჩაიწერება ორი სიმბოლოს(ციფრის) საშუალებით: 0 და 1). თუ კომპუტერულ მეხსიერებაში რიცხვზე გამოყოფილია n-პოზიცია(ბიტი), ამ გამოყოფილ ადგილზე შეიძლება ჩავწეროთ 2ⁿ დადებითი მთელი რიცხვი. უარყოფითი მთელი რიცხვების ჩასაწერად ერთი ორობითი პოზიცია(ბიტი) უნდა გამოიყოს ნიშნის აღნიშვნისთვის. პროგრამირების კომპილირებად ენებში (მაგალითად C++) მთელ რიცხვებისთვის გამოყოფილია ორობითი პოზიციების (ბიტების) ფიქსირებულ რაოდენობა. მაგალიად თუ მთელ რიცხვზე გამოყოფილია 64 ბიტი, მაქსიმალური მთელი რიცხვი, რომელიც შეიძლება მეხსირებაში მოთავსდეს იქნება 2⁶⁴-1. პითონი ინტერპრეტირებადი ენაა და მთელ რიცხვზე გამოყოფილი ბიტების რიცხვი მხოლოდ კომპუტერის მეხსიერების სიდიდით არის შეზღუდული. ეს ნიშნავს, რომ პითონში მთელი რიცხვების დიაპაზონი პრაქტიკულად შეუზღუდავია. თუმცა ბუნებრია, რომ ამოცანების უმრავლესობაში შეზღუდული დიაპაზონის რიცხვები გამოიყენება.

ნამდვილი (არამთელი) რიცხვების წარმოდგენისთვის კომპუტერში გამოიყენება რიცსვების წარმოდგენა, მცოცავი წერტილის ფორმატში. ამ ფორმატში რიცხვზე გამოყოფილი პოზიციები ორ ნაწილად იყოფა - ერთ ნაწილში იწერება წილადური ნაწილი, ხოლო მეორეში ამ რიცხვის ხარისხი. მაგალითად, თუ 64 ბიტიან კომპუტერებზე წილადურ ნაწილზე გამოყოფილია 53 პოზიცია, ეს ნიშნავს, რომ 1/2⁵³ სიზუსტით შეიძლება წარმოვადგინოთ, რად დაახლოებით 10^-16 შეესაბამება. პროგრამირების საწყის კურსში განხილული ამოცანებისთვის რიცხვების კომპუტერული წარმოდგენის სიზუსტეები სავსებით საკმარია, თუმცა სიზუსტის პრობლემას შეიძლება აქაც წავაწყდეთ. რიცხვების წარმოდეგნისთვი პროგრამირებაში ასევე გამოიყენება რვაობითი და თექვსმეტობითი წარმოდგენა, რომლებსაც ამ ეტაპზე არ განვიხილავთ.

>>> ix=1
>>> type(ix)
< class 'int' >
>>> ix_negative = -12
>>> fx=1.5
>>> type(fx)
< class 'float' >
>>> x1_3 = 1/3
>>> x1_3
0.3333333333333333
>>>x0=3*01 - 0.3
>>>x0
5.551115123125783e-17
>>> 1x1=1/3
SyntaxError: invalid syntax

ზემოთ მოყვანილ მაგალითში, ცვლადი ix მიეკუთვნება მთელი რიცხვის ტიპის ობიექტს. ობიექტის ტიპის დასადგენად პითონში არსებობს ფუნქცია type(x), რომელიც ბეჭდავს მისი არგუმენტის (x) ტიპს (კლასს). პითონში, ცვლადის(ობიექტის) ტიპის განსაზღვრა წინასწარ არ არის საჭირო, როგორც მაგალითად C++ - ში. ობიექტის ტიპი პითონში განისაზღვრება ავტომატურად, იმის მიხედვით თუ რა მნიშვნელობა ენიჭება ამ ობიექტს. პითონში მთელი რიცხვი ჩაიწერება მხოლოდ ციფრებისა და ნიშნის (+ ან -)საშუალებით. თუ რიცხვს ნიშანი არ ახლავს, იგულისხმება რომ ეს რიცხვი დადებითია.

ცვლადი fx ასევე რიცხვს წარმოადგენს, მაგრამ ის სხვა ტიპის რიცხვია, რადგან მის ჩაწერში მონაწილეობს წერტილი. მოცემული რიცხვი ათწილადს წარმოადგენს და წერტილი შეიძლება ნებისმიერ პოზიციაზე იყოს მოთავსებული. ასეთი რიცხვები პითონში (ისევე როგორც პროგრამირების სხვა ენებში) ეკუთვნიან მცოცავი წერტილის ტიპის რიცხვებს (floating point). x1_3 ცვლადი, რომელსაც პერიოდული ათწილადის 0.3(3) მნიშვბელობა მიენიჭა, განსაზღვრულია 17 ნიშნის სიზუსტით. შემდეგ ხაზზე განსაზღვრულ x0-ის მნიშვნელობა (0) რიცხვების წარმოდეგენის სასრული სიზუსტის გამო არ არის ნული, თუმცა ძალიან მცირე რიცხვია. როგორც ამას შემდგომ ვნახავთ, გარკვეულ შემთხვევებში ასეთი სიზუსტეც კი შეიძლება პრობლემა გახდეს.

ტექსტური ცვლადები (სტრინგები)

პითონის პროგრამების კიდევ ერთ ბაზურ ტიპს წარმოადგენს ტექსტური ცვლადი. ასეთ ცვლადს უწოდებენ ასევე სტრინგის (string). ტექსტური ცვლადების (სტრინგების) საშუალებით პითონის პროგრამებში ხორციელდება ინფორმაციის გაცვლა (შეყვანა და გამოყვანა). სტრინგები იძლევიან ტექსტებთან მუშაობის და კომპუტერული პროგრამის შედეგების გასაგებად გადმოცემის საშუალებას. პითონის ტექსტური ცვლადი(სტრინგი) არის სიმბოლოების მიმდევრობა, რომლებიც მოთავსებულია ბრჭყალებში. სტრინგის ჩასაწერად შესაძლებელია ასევე ორმაგი ბრჭალების გამოყენება. თუ სტრინგი ერთი ტიპის ბრჭყალებით (ერთმაგი ან ორმაგი) იხსნება, აუცილებელია, რომ იმავე ტიპის ბრჭყალებით დაიხუროს. წინააღმდეგ შემთხვევაში პითონი სინტაქსურ შეცდომას აღმოაჩენს. სტრინგის სწორი ჩაწერის მაგალითი მოყვანილია ქვემოთ. ამ მაგალითში ასევე ნაჩვენებია, რომ სტრინგის არასწორი ჩაწერა გამოიწვევს სინტაქსურ შეცდომას, EOL(End Of Line) - აღნიშვნა მიანიშნებს სტრიქონის (ხაზის) ბოლოს. sx2 სტრინგი არ დაიხურა ხაზის ბოლომდე, რაც გახდა სინტაქსური შეცდომის მიზეზი.

>>>sx='This_is_a_string'
>>>type(sx)
< class 'str' >
>>>sx1="This is the Python string"
>>>sx2="This is wrong'
SyntaxError: EOL while scanning string literal
>>>

მოყვანილ მაგალითში ცვლადები (ობიექტები) sx დს sx1 სტრინგის ტიპის ობიექტებს მიეკუთვნება. ამ ტიპის(კლასის) ობიექტებს გარკვეული თვისებები ახასიათებთ, მაგალითად მათ გააჩნიათ სიგრძე, რომელიც მიმდევრობაში არსებული სიმბოლოების რიცხვის ტოლია. პითონში არსებობს ფუნქვია len(x), რომლის საშუალებით შესაძლებელია x-სტრინგის სიგრძის განსაზღვრა. ქვემოთ მოყვანილია len(x) ფუნქციის გამოყენების მაგალითები. ყურადღება მიაქციეთ, რომ შეიძლება არსებობდეს ნულოვანი სიგრძის სტრინგი.

>>>l=len(sx)
>>>l
16
>>> len("")
0
>>>len(" ")
1
>>>len(ix)
Traceback (most recent call last):
File "", line 1, in
len(ix)
TypeError: object of type 'int' has no len()

პითონში შესაძლებელია სტრინგის სიმბოლოების ამოღება (მათზე მიმართვა) რიგითი ნომრის (ინდექსის) მიხედვით. სტრინგის ელემენტებზე მიმართვა ხდება კვადრატულ ფრჩხილებში მოთავსებული ინდექსის საშუალებით. სტრინგის პირველი სიმბოლოს ინდექსი (ნომერი) არის 0, შესაბამისად ბოლო ელემენტის იქნება l-1, სადაც l=len(x) სტრინგის სიგრძეა. აქედან გამოდინარე, სტრინგის დადებითი ინდექსების(i) ინტერვალია 0 ≤ i ≤ l-1. სტრინგის ინდექსი შესაძლებელია უარყოფითი მთელი რიცხვი იყოს. როდესაც ინდექსი უარყოფითია, მისი ათვლა სტრინგის ბოლო სიმბოლოდან ხდება, ე.ი. ინდექსი -1 მიუთითებს სტრინგის ბოლო სიმბოლოს. უარყოფითი ინდექსის შემთხვევაში ინდექსების დასაშვები ინტერვალია: -l ≤ i ≤ -1. ამ ორი ინტერვალის გაერთიანება გვაძლევს სტრინგის ინდექსის დასაშვებ მნიშვნელობათა ინტერვალს: -l ≤ i ≤ l-1. სტრინგიდან შესაძლებელია ასევე ნაწილის (სლაისის) გამოყოფა. სლაისი გამოიყოფა კვადრატულ ფრჩხილებში მოთავსებული ორი ინდექსის (i1, i2) საშუალებით, რომელთა შორის განლაგებულია ორწერტილი (sx[i1:i2]). სლაისი ასევე სტრინგის ტიპის ობიექტის წარმოადგენს და შეიცავს (i2-i1) სიმბოლოს. სლაისის პირველ სიმბოლოს აქვს ინდექსი i1, ხოლო ბოლოს i2-1. ქვემოთ მოყვანილია სტრინგზე მიმართვის მაგალითები. ბოლო დებულებაში სტრინგის ინდექსი დასაშვები ინტერვალის გარეთ მდებარეობს, რაც იწვევს ინდექსის შეცდომას (IndexError).

>>>sx[0]
'T'
>>>sx[15]
'g'
>>> sx[-1]
'g'
>>> sx[-16]
'T'
>>> sx[0:4]
'This'
>>> sx[-16:-12]
'This'
>>>type(sx[0:4])
>>>
>>>sx[16]
Traceback (most recent call last):
File "", line 1, in
sx[16]
IndexError: string index out of range

ჩვენ არ დაგვიკონკრეტებია, თუ რას წარმოადგენს სიმბოლო, რომელიც ასევე ერთეულოვანი სიგრძის სტრინგად შეგვიძლია ჩავთვალოთ. მაგალითად, სიმბოლოებს წარმოადგენს კომპუტერის კლავიატურაზე განლაგებული ლათინური ანბანის ასოები, ციფრები, სასვენი ნიშნები და სპეციალური სიმბოლოები, როგორც §, $, %, &, | . პითონში ზოგიერთი კომპუტერული სიმბოლო ჩაიწერება დახრილი ხაზის(\) საშუალებით. მაგალითად აღნიშვნა '\n', ერთ სიმბოლოს წარმოადგენს და მიუთითებს სტრიქონის(ხაზის) ბოლოს. ასევე ჩაიწერება ზოგიერთი სხვა სიმბოლო, როგორც ეს ქვემოთ მოყვანილი მაგალითად სჩანს. მსგავსი ჩაიწერა ტექსტური ცვლადის(სტრინგის) შიგნით ბრჭყალების ხმარების საშუალებას იძლევა.

>>>str1, str2, str3 = '\n', '\\', '\''
>>>len(str1)
1
>>>len(str2)
1
>>>len(str3)
1
>>>str3='This is a string \'string\''
>>>str3
>>>"This is a string 'string' "
>>>

ამოიწურება, თუ არა სიმბოლოების რიცხვი კლავიატურიდან შეყვანილი მნიშნელობებით? ადვილი მისახვედრია, რომ პასუხი ამ კითხვაზე უარყოფითია, რადგანაც ლათინური კლავიატურიდან შესაძლებელია სხვა ანბანური სისტემის(მაგალითად ქართული) სიმბოლოების შეყვანა. კომპუტერული სიმბოლოები გარკვეულ სისტემას (კოდს) ეკუთვნიან. კომპუტერულ კოდირებაში თვითოეულ სიმბოლოს შეესაბამება მთელი რიცხვი. (კომპუტერული კოდირების შესახებ მოკლე ინფორმაცია ამ კურსის დამატებით ნაწილშია მოყვანილი). პითონში არსებობენ ფუნქციები ord(s) და chr(ix) რომლების კომპუტერული კოდირებასთან არიან დაკავშირებული. პირველი ფუნქცია, რომლის არგუმენტია სიმბოლო s (ერთეულოვანი სიგრძის სტრინგი), აბრუნებს ამ სიმბოლოს შესაბამის მთელ რიცხვს ანუ სიმბოლოს კოდს. მეორე ფუნქცია, რომლის არგუმენტია მთელი რიცხვი (ix), აბრუნებს ამ რიცხვის(კოდის) შესაბამის სიმბოლოს. თუ რა ინტერვალში იცვლება კომპუტერული სიმბოლოების შესაბამისი მთელი რიცხცები დამოკიდებულია იმაზე, თუ რა კოდირების სისტემა (კოდი) გამოიყენება კომპუტერში. თანამედროვე კომპუტერებში, როგორც წესი გამოყენებულია საერთაშორისო Unicode კოდირება, რომელიც მსოფლიოს სხვადასხვა ანბანური სისტემის, მათ შორის ქართულის ანბანის კოდებს და შესაბამის სიმბილოებს შეიცავს. ქართული სიმბოლოებისთვის (ასომთავრული და მხედრული) Unicode-ში გამოყოფილია 96 რიცხვი(კოდი)

ord(s) და chr(ix) ფუნქციების გამოყენების მაგალითები ქვემოთ არის მოყვანილი. ამ მაგალითებიდან სჩანს, რომ ლათინური ანბანის სიმბოლოებს A და a შეესაბამება მთელი რიცხვები 65 და 97. ქართული ასომთავრული ანბანის პირველ ასოს (სიმბოლოს 'Ⴀ') პითონის კოდია 4256, ხოლო მხედრული ანბანის 'ა'-ს შეესაბამება ნომერი 4304. ეს ნომრები Unicode კოდირებას იმეორებს. ეს მაგალითი მიუთითებს, რომ პითონის ტექსტურ ცვლადებში შესაძლებელია ქართული სიმბოლოების ხმარება. უნდა ავღნიშნიღ, რომ ტექსტის რედაქტორი პროგრმებიდან ყველა არ იყენებს Unicode - კოდირებას. წინამდებარე ტექსტი აკრეფილის EditPad Lite 7 პროგრამით, რომელშიც გათვალისწინებულია Unicode -ის ხმარება.

>>>ord("A")
65
>>>ord("a")
97
>>>chr(65)
'A'
>>>chr(98)
'b'
>>>chr(ord("X"))
'X'
>>>chr(4256)
'Ⴀ'
>>>chr(4304)
'ა'

პითონში, ისევე როგორც ობიექტებზე ორიენტირებული პროგრამირების სხვა ენებში, ერთი ტიპის(კლასის) ობიექტებთან დაკავშირებულია მეთოდები(ფუნქციები), რომლებიც ამ ტიპის ობიექტებთან მუშაობისთვის არის განკუთვნილი. პითონის ობიექტიდან მეთოდის გამოძახება ხდება ობიექტისთვის წერტილის მიწერით, რასაც მოსდევს მეთოდის სახელი შესაბამისი არგუმენტებით. სტრინგებთან დაკავშირებული მეთოდები, რომელთა საშუალებით შესაძლებელია სტრინგში არსებული სიმბოლოს (x) რაოდეობის დადგენა (count(x)), x-სიმბოლოს ინდექსის პოვნა (index(x)). თუ სტრინგში ერთი სიმბოლო რამდენჯერნე მეორდება, ეს მეთოდი პირველი სიმბოლოს ინდექსს დააბრუნებს. სტრინგის მეთოდების გამოყენება ნაჩვენებია შემდეგ მაგალითში. აქვე ავღიშნავთ, რომ სტრინგის სხვა მეთოდებს კურსის შემდგომ ნაწილებში შევხვდებით.

>>>sx.count('i')
3
>>>sx.index('i')
1
>>>sx.index(sx1[20:26])
10
>>> sx.find("T")
0
>>>
'T'
>>>sx[16]

სტრინგენზე განსაზღვრული ორი ოპერაცია, რომლებიც შეკრების(+) და გამრავლების(*) მატემატიკური ოპერატორებით ხორციელდება. ოპერაციით + პითონში ხდება სტრინგების გაერთიანება (კონკატენაცია, concatenation). ხოლო * იწვევს სიმბოლების გამეორებას სტრინგში. ქვემოთ მოყვანილია ამ ოპერაციების მაგალითები:

>>>T='Tbilisi '
>>>S='State '
>>>T='University '
>>>TSU=T+S+U
>>>TSU
Tbilisi State University '
>>> a1=10*"a"
>>>a10
'aaaaaaaa'

როგორც აღნიშნული იყო, პითონის პროგრამებში სტრინგების საშუალებით ხორციელდება ინფორმაციის შეყვანა და გამოყვანა. პითონი შეიცავს ფუნქციას str(x), რომლის საშუალებით შესაძლებელია x-რიცხვითი ცვლადის (მთელი და ათწილადი) სტრინგის ტიპის ობიექტეში გადაყვანა. ასევე შესაძლებელია sx-სტრინგის მთელ რიცხვში (int(sx)) ამ მცოცავი ფორმატის რიცხვში (float(sx)) გადაყვანა. ბოლო ორი ფუნქციის შემთხვევაში sx-სტრინგი არ უნდა შეიცავდეს სიმბოლოებს, რომლებიც რიცხვითი ცვლადების ჩაწერაში არ გამოიყენება. მათი გამოყენება ქვემოთ მოყვანილ მაგალითშია ნაჩვენები.

>>>y="2015"
>>>int(y)
2015
>>>float(y)
2015.0
>>>xn=1918
>>>str(xn)
'1918'

ამ ნაწილის ბოლოს დავამატებთ, რომ პითონში არსებობს კიდევ ერთი ტიპის სტრინგი, ეგრეთ წედებული doc-სტრინგი. ასეთი სტრინგი იწყება და მთავდება სამი ბრჭყალით (''') ან (""") და შეიძლება რამდენიმე ხაზზე გაგრძელდეს. მის გამოყენებაზე პითონის პროგრამებში შემდეგში ვისაუბრებთ.

პითონის ჩართული (built-in) ფუნქციები

პითონის ფუნქცია, წარმოადგენს პროგრამის ნაწილს, რომელსაც გარკვეული დანიშნულება აქვს და რომლის გამოყენება მასზე მიმართვით ხდება. ფუნქციას, როგორც წესი გააჩნია არგუმენტები (პარამეტრები), რომლებიც მას მიმართვის დროს გადაეცემა. როგორც წესი, ფუნქციის შესრულების შედეგი ენიჭება ფუნციის იდენტიფიკატორს. თუმცა პითონის ფუნქციების დაპროგრამებას შემდეგ ნაწილებში გავეცნობით, პითონის ზოგიერთი ფუნქცია უკვე გამოვიყენეთ რიცსვითი და სტრინგის ტიპის ცვლადების განხილვის დროს. ეს ფუნქციები პითონის ჩართულ (buitl-in) ფუნქციებს წარმოადეგენენ. მაგალითად ცვლადის(ობიექტის) ტიპის დასადგენად ვისარგებლეთ ფუნქციით type(x), ხოლო ტექსტური ცვლადის (სტრინგის) სიგრძე დავადგინეთ ფუნქციით len(x). სტრინგების განხილვისას ვისარგებლედ ასევე ფუმქციებით chr(ix), float(x) , int(x), ord(cx) და str(x). პითონში არსებული ჩართული ფუნქციების სრული ჩამონათვალი და აღწერა მოცემულია პითონის პროგრამირების ფონდის გვერდზე.

პითონის ჩართული ფუნქციები პითონზე პროგრამირების აუცილებელი კომპონენტებს შეადგენენს. მაგალითად ინფორმაციის გამოყვანა პროგრამიდან (ბეჭდვა) პითონ-3 ში ხორციელდება ჩართული print-ფუნქციით, რომელიც ბუნებრივია, რომ თითქმი ყველა პროგრამაში გვხვდება. ჩართული ფუნქციების საშულებით შესაძლებელია ინფორმაციის მიღება პითონის ფუნქციებზე და პროგრამულ მოდულებზე. მაგალითად ფუნქცია help(f), ინფორმაციას იძლევა ფუნქციის შესახებ, რომელიც მას არგუმენეტად აქვს მითითებული. ბევრი პროგრამისტი თვლის, რომ პითონის შესწავლას შესაძლებელია ენაში არსებული საშუალებებით და დამატებით მასალას არ საჭიროებს. ქვემოთ მოყვანილია help(f) ფუნქციის გამოყენების მაგალითები.

>>>help(len)
Help on built-in function len in module builtins:

len(...)
len(object)

Return the number of items of a sequence or collection.
>>>help(chr)
Help on built-in function chr in module builtins:

chr(...)
chr(i) -> Unicode character

Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
>>>help(ord)
Help on built-in function ord in module builtins:

ord(...)
ord(c) -> integer

Return the integer ordinal of a one-character string.

როგორც ავღნიშნეთ, პითონის ჩართულ ფუნციებს ამ კურსში კიდევ ხშირად შევხვდებით.

მათემატიკური ფუნქციები

როგორ შეიძლება პითონის პროგრამაში ელემენტარული მათემატიკური ფუნქციების ხმარება? არიან ისეთი ფუნქციები, როგორც მაგალითად ტრიგონომეტრიულ ფუნქციები, პითონის ჩართული ფუნციები? პასუხი ამ კითხვაზე უარყოფითია, ელემენტარული მატემატიკური ფუნქციები არ წარმოადგენენ პითონის ჩართულ ფუნქციებს, როგორც ეს ქვემოთ მოყვანილი მაგალითიდან სჩანს სადაც ფუნქცია sin-მიმართვა შეცდომას იწვევს.

>>>sin(0.5)
Traceback (most recent call last):
File "", line 1, in
sin(0.5)
NameError: name 'sin' is not defined

ელემენტარული მათემატიკური ფუნქციები პითონის სტანდარტული ბიბლიოთეკის მათემატიკური მოდულის math ნაწილს შეადგენენ. პითონის მოდულებს და პითონის სტანდარტული ბიბლიოთეკას ამ კურსის შემდგომ ნაწილებში უფრო დეტალურად განვიხილივავთ, აქ მხოლოდ მატემატიკური მოდულის ფუნქციების გამოყენებაზე შევჩერდებით. პითონის მოდულში არსებული ფუნქციების და ობიექტების პროგრამაში გამოყენებისთვის საჭიროა ამ მოდულის ან მისი ნაწილების პროგრამაში ჩართვა. ეს შესაძლებლია რამდენიმე მეთოდით. მოდულის პროგრამაში ჩართვა ხდება ოპერატორით import, რომელსაც მოსდევს იმ მოდულის სახელი, რომლის ჩართვაც ხდება. (პითონის მოდული წარმოადგენს პითონის ინსტრუქციებით ჩაწერილ ტექსტურ ფაილს გაფართოებით py.)

ქვემოთ მოყვანილია პითონის მოდულის გამოძაძების მაგალითი. ამ მაგალითში ხდება მთელი მოდულის (ფუნქციების და ცვლადების) პროგრამაში ჩართვა.მათი გამოყენებისთვის პროგრამაში საჭიროა მოდულის სახელის მითითება.

>>>import math
>>>math.pi
3.141592653589793
>>> math.e
2.718281828459045
>>>math.sin(math.pi/6)
0.49999999999999994
>>>math.sin(math.pi/2)
1.0

შემდეგი მაგალითი წინა მაგალითისგან მხოლოდ იმით გამსხვავდება, რომ მოდული math გამოძახებულია სახელით m.

>>>import math as m
>>>m.pi
3.141592653589793
>>> m.e
2.718281828459045
>>>m.sin(m.pi/6)
0.49999999999999994
>>>m.sin(m.pi/2)
1.0

შემდეგ მაგალითში, წინა მაგალითებისგან განსხვავებით ხდება math მოდულის მხოლოდ გარკვეული ნაწილების გამოძახება და პროგრამაში ჩართვა. ასეთ შემთხვევაში ფუნქციაზე მიმართვისას საჭირო აღარ არის მოდულის სახელის ჩაწერა.

>>>from math import e, pi, sin
>>>pi
3.141592653589793
>>> e
2.718281828459045
>>sin(pi/6)
0.49999999999999994
>>>sin(pi/2)
1.0

ეს მაგალითი წინა მაგალითის ანალოგიურია, იმ განსხვავებით, რომ ამჯერად math მოდულის ყველა ფუნცია და ცვლადი ჩართულია პროგრამაში.

>>>from math import *

როგორც მოყვანილი მაგალითებიდან სჩანს, ფუნქციის გამოძახება მათემატიკური მოდულიდან სხვადასხვა მეთოდებით შეიძლება. უნდა ავღნიშნოთ,რომ ბოლო მეთოდი, განსაკუთრებით დიდ პროგრამებში, რეკომენდირებული არა არის. მოდულის ასეთი მიერთებისას შესაძლებელია, რომ მოდულის ფუნქციების და ცვლადების სახელები და პროგრამის იდენტიფიკატორები ერთმანეთს დაემთხვეს, რამაც შესაძებელია გაუთვალისწინებელ შედეგამდე მიგვიყვანოს.

პითონში არსებობს ჩართული ფუნქცია dir, რომელი გვაძლევს პითონის მოდულის ელემენტების სიას. ქვევით მოყვანილ მაგალითში ან ფუნქციის საშუალებით დაბეჭდილია მათემატიკური მოდულის math ელემენტების იდენტიფიკატორები.

>>>import math
>>>dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign',
'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf',
'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'pi', 'pow', 'degrees', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

მათემატიკურ მოდულში გაერთიანებულია 2 მათემატიკური მუდმივა (π და e), ელემენტარული მათემატიკური ფუნქციები, სპეციალური ფუნქციები და ასევე დახმარე ფუნქცები, მაგალითად კუთხური გრადუსების რადიანეში (radians(x)) და რადიანების კუთხურ გრადუსებში (degrees(x)) გადაყვანის ფუნქციები. მათემატიკის მოდულის ელემენტებზე მოკლე ინფორმაციის მიღება შეიძლება პითონის ჩართული ფუნქციით help.

>>> import math
>>>help(math.tan)
Help on built-in function tan in module math:

tan(...)
tan(x)

Return the tangent of x (measured in radians). <>>>help(math.factorial)
Help on built-in function factorial in module math:

factorial(...)
factorial(x) -> Integral

Find x!. Raise a ValueError if x is negative or non-integral.

პითონის ცხრილის მოთავს მცოცავი რომლის

მათემატიკური მოდულის ზოგიერთი ფუნქცია მოყვანილია პითონის მათემატიკური ფუნქციების ხმარების მაგალითები.

>>>from math import exp, factorial, pi, pow, sqrt
>>>mean, n = 1.5, 2
>>>Pn = pow(mean,n)*exp(-mean)/factorial(n)
>>>Pn
0.25102143016698353
>>>sigma=1.0
>>>G0=1./sqrt(2.0*pi*sigma)
>>>G0
0.3989422804014327

ინფორმაციის შეყვანა და გამოყვანა. ფორმატირება

პროგრამირების ენებში გათვალისწინებულია პროგრამაში ინფორმაციის შეყვანის რამდენიმე მეთოდი. ყველაზე მარტივი მეთოდს, ცლადისათვის მნიშვნელობის მინიჭებას, უკვე გავეცანით. ინფორმაციის შეყვანა შესაძლებელია მოხდეს ფაილიდან, რომელიც ლოკალური კომპუტერის დისკზეა განლაგებული ან ინტერნეტში ჩართული სერვერის ფაილურ სისტემაშია მოთავსებული . ფაილიდან ინფორმაციის კითხვას შემდგომში გავეცნობით, ამ ნაწილში კი განვიხილავთ ინფორმაციის შეყვანის ერთ-ერთ ყველაზე გავრცელებული მეთოდს, კერძოდ პროგრამაში ინფორმაციის შეყვანას კომპუტერის კლავიატურიდან.

პითონში (უფრო ზუსტად პითონ-3 ში) ინფორმაციის კლავიატურიდან შეყვანა ხდება ჩართული ფუნციის input საშუალებით. ამ ფუნქციის გამოყენების მაგალითი ქვემოთ არის მოყვანილი:

>>>x=input("Input number :")
Input number: 2
>>> x
'2.0'

მოყვანილ მაგალითში, ჩართული ფუნქციის input-ის პირველი არგუმეტია ტექსტური ცვლადი, რომელიც კომპუტერის ეკრანზე დაიბეჭდება. ეს ტექსტი არ წარმოადგენს აუვილებელ პარამეტრს, მაგრამ მისი ხმარებით სასურველია, რადგან ხშირად შეყვანილ ინფორნაციის განმარტებას იძლევა. ამ ტექსტის შემდეგ იმავე ხაზზე, კლავიატურიდან აიკრიფება საჭირი სტრინგი, ანუ კლავიატურის სიმბოლოების ერთობლიობა. სტრინგის შეყვანა მთავრდება კლავიშა Enter -ის დაჭერით. მოცემულ მაგალითში, შეყვანილი სტრინგი მიენიჭება x-ს. ეს ცვლადი სტრინგის ტიპის ობიქტია. თუ x მხოლოდ სათანადო სიმბოლოებისგან შედეგება შესაძლებელია მისი გადაქცევა მთელი ან მცოცავი წერტილის ტიპის რიცხვად. ეს შესაძლებელია როგორც პითონის ჩართული ფუნქციებით int ან float, რომლებიც უკვე იყო განხილული, ასევე ფუნქციით eval. ამ ფუნქციის არგუმენტი სტრინგის ტიპის ცვლადია და იმის მიხედვით თუ როგორია x-სტრინგი ფუნქცია დააბრუნებს მთელ ან მცოცავი წერტილის ფორმატის რიცხვს. აქაც ვგულისხმობთ, რომ x- სტრინგის სიმბოლობს შორის მხოლოს ის სიმბოლოები არიან, რომლების რიცხვითი ცვლადების ჩაწერისას გამოიყენება.

>>>eval(x)
2.0
>>>x=eval(input("enter integer:")) >>>x
2

პროგრამის მუშაობის პროცესში აუცილებელი შედეგების პროგრამიდან გამოყვანა (დაბეჭდვა). ისევე როგორც შეყვანის შემთხვევაში, ინფორმაციის გამოყვანაც რამდენიმე მეთოდით შეიძლება. აქამდე განხილულ მაგალითებში პითონის ინტერპრეტატორს ინფორმაცია გამოყავდა კომპუტერის ეკრანზე. პროგრამის ტექსში (პითონის სკრიპტში) ასე არ ხდება, ხაზზე ცვლადის დაწერით მისი მნიშვნელობა ეკრანზე არ იბეჭდება. პითონში, უფრო სწორად მის მე-3 ვერსიაში, ინფორმაციის გამოყვანა ეკრანზე (ბეჭდვა) ხორციელდება ჩართული ფუნქიით print. ქვევით მოყვანილია ამ ფუნქციის გამოყენების მაგალითი <\p>

>>>print(1/3)
0.3333333333333333
>>>a, b, c = 2/3, 5/7, 7/11
>>> print(a,b,c)
0.6666666666666666 0.7142857142857143 0.6363636363636364

მოყვანილ მაგალითში ხდება პერიოდული ათწილადის 0.3(3) დაბეჭდვა. შემდეგ ხაზზე კი განსაზღვრულია სამი რიცხვი (a, b, c) რომელთაგან თვითოეული პერიოდული ათწილადს წარმოადგენს. ასეთი რიცხვები კომპურტერში წარმოდგენელია სასრული სიზუსტით, რაც 16 ნიშნით გამოისახება. ბუნებრივია, რომ ასეთი სიზუსტე ხშირად საჭირო არ არის, მით უმეტეს რომ ასეთი სახით ჩაწერილი რიცხვები წაკითხვა ადვილი არ არის. რა თქმა უნდა სასურველია, რომ პროგრამიდან დაბეჭდილი ინფორმაცია ადვილად წასაკითხი და გასაგები იყოს. პროგრამირების ენებში ინფორმაციის სასურველი სახით დაბეჭდვა ხორციელდება ფორმატირების საშუალებით. ქვემოთ მოყვანილია ფორმატირების საშულებების გამოყენების მაგალითები print-ის ფუნქციაში. პირველ მაგალითში, იგივე სამი რიცხვი იბეჭდება მძიმის შემდეგ 2 ნიშნის სიზუსტით.

>>> print(" %5.2f %5.2f %5.2f "% (a,b,c))
0.67 0.71 0.64
>>>print("a b and c values: a=%5.2f , b=%5.f , c=2%5.2f "% (a,b,c))
a b and c values: a= 0.67 , b= 0.71 1 , c= 0.64

ფორმატირების ნიშნები.

რიცხვის ბეჭდვის ფორმატი დამოკიდებულია მის ტიპზე. განხილულ შემთხვევაში საქმე გვაქვს მცოცავი წერტილის ტიპის რიცხცებთან (ათწილადებთან), რომელთა დასაბეჭდად გამოყენებულია 5.2f - ფორმატი. რაც ნიშნავს, რომ ამ ტიპის რიცხვის დასაბეჭდად გამოყოფილია 5 პოზოცია, რომელთაგან ორი დაეთმობა წერტილის შემდეგ განლაგებულ ნიშნებს, ხოლო დარჩენილი სამ პოზიცია დაეთმობა წერტილის და მთელი ნაწილის ჩაწერას. თუკი რიცხვი უარყოფითია, ერთ პოზიციას დაიკავეს შესაბამისი ნიშანი(-). <\p>

ფორმატის ხმარებასთან დაკავშირებულია შეზღუდვები. ეს ნაწილი ჯერ არ არის მზად !

>>> a,b,c = 1234.33333, -121.1, 12.6666666
>>> print(" %5.2f %5.2f %5.2f "% (a,b,c))
1234.33 -121.10 12.67

სხვა ფორმატით ბეჭდვის მაგალითები.

ბეჭდვის ფუნქციაში, შესაძლებელია ასევე განსაზღვრულია თუ რა სიმბოლო (სომბოლოები) უნდა დაიბეჭდოს ცვლადების შორის, რომ ბეჭდვის შედეგი ადვილად წასაკითხი და გასაგები იყოს. ფუნქცია print-ში ეს ცორციელდება დამატებით არგუმენტით, რომლის კოდური სახელია(გასაღები keyword) sep. წინა მაგალითში, სადაც ამ არგუმენტის მნიშვნელობა მითითებული არ იყო და ფუნქცია print-იყენებდა ამ პარამეტრის პირბელად (default) მნიშვნელობას sep=" ".

>>> a,b,c = 1234.33333, -121.1, 12.6666666
>>> print(" %5.2f %5.2f %5.2f "% (a,b,c), sep=" - " )
1234.33 - 121.10 - 12.67

ბეჭდვის სხვა შესაძლო მაგალითია დასაბეჭდი ცვლადებიდან ტექსტური ცვლადის მომზადება და შემდეგ მისი დაბეჭდვა. სტინგის ტიპის ცვლადების აქვთ მეთოდი format, რომელიც ტექსტის(სტრინგის) ფორმატირების საშუალებას იძლევა. ამ მეთოთოდ შესაძლებელი სტრინგის გამოყოფილ პოზიციებზე ახალი ინფორმაციის (სტრინგების) ჩაწერა. მაგალითი, როგორ ხდება სტრინგში მნიშვნელობების ჩასმა

>>>a,b,c = 0.5111, 1.5200001, 2.499999999
>>>text="a b and c values: a={0:5.2f}, b={1:5.2f}, c={2:5.2f} "
>>>text.format(a,b,c)
a b and c values: a= 0.51, b= 1.52, c= 2.50

პითონი	მნიშვნელობა
cos(x)	კოსინუსი
sin(x)	სინუსი
atan(x)	ტანგენსი
acos(x)	არკ-კოსინუსი
asin(x)	არკ-სინუსი
atan(x)	არკ-ტანგენსი
exp(x)	ექსპონენციალური ფუნქცია
pow(a,x)	ხარისხოვანი ფუნქცია
sqrt(x)	კვადრატული ფესვი
log(x)	ნატურალური ლოგარითმი
log10(x)	ათობითი ლოგარითმი
factorial(n)	ფაქტორიალი

ფორმატის სპეციფიკაციები (ცხრილი არ არის მზად !)
	მნიშვნელობა
%d	მთელი რიცხვის ბეჭდვის ფორმატი
--	მთელი რიცხვის რვაობითი წარმოდეგენა
--	მთელი რიცხვის თექვსმეტობითი წარმოდგენა
%m.nf	მცოცავი წერტილის ფორმატის რიცხვის წარმოდგენა
--	მცოცავი წერტილის ფორმატის რიცხვის ექსპონენციალური სახით წარმოდგენა
%s	სტრინგის (ტექსტური ცვლადის) ბეჭდვა
--

ბულის ცვლადები, პირობითი გადასვლები და ინდენტაცია (indentation)

პროგრამირების დროს ხშირ შემთხვევებში, ამოცანის გადაწყვეტის ალგორიმთი დამოკიდებულია გარკვეული პირობის შესრულებაზე. მარტივ მაგალითად გამოდგება კვადრატული განტოლების a x² + bx + c = 0 ამოხსნის (ფესვების პოვნის) პრობლება. ამ განტოლების ამოხსნის ალგორითმი დამოკიდებული განტოლების დისკრიმინანტის მნიშვნელობაზე: D=b²- 4ac თუ დისკრიმინანტი ნულზე დიდი რიცხცია (D>0), მაშინ კვადრატულ განტოლებას ორი ნამდვილი ფესვი აქვს, თუ დისკრიმინანტი ნულის ტოლია (D=0) განტოლებას ერთი ნამდვილი რიცხვი აკმაყოფილებს, ხოლო იმ შემთხვევაში, როდესაც დეტერმინანტი უარყოფითია (D<0), კვადრატულ განტოლებას არ აქვს ამოხნა ნამდვილ რიცხვთა სიმრავლეში. ამრიგად, კვადრატული განტოლების ამოხნის ალგორითმში, აუცილებელ პირობას წარმოადგენს დისკრიმინანტის მნიშვნელობის გამოთვლა.

პითონში განსაზღვრულია შედარების ოპერაციები, რომელთაც ორი დასაშვები მნიშვნელობა შეიძლება პქონდეს, ან სხვაგვარად თუ ვიტყვით შედარება შეიძლება იყოს სწორი ან არ იყოს სწორი (ე.ი. მცდარი). თუ შედარების ოპერაციის შედეგს ცვლადით ავღნიშნავთ, ასეთ ცლადს ორი მნიშვნელობა ექნება. პითონში, ისევე როგორც პროგრამირების სხვა ენებში, ასეთ ცვლადებს ბულის ცვლადები (ბულის ტიპის ობიექტები) ეწოდება. ასეთ ობიექტებს ასევე მოიხსენიებენ როგორც ლოგიკურ ცვლადებს (ლოგიკურ ობიექტებს). ასეთ ცვლადებს შეუძლიათ ჰქონდეთ მნიშვნელობა True (ჭეშმარიტი, სწორი) და False (მცდარი, არასწორი). შედარების მათემატიკური ოპერაციები და პითონის შესაბამისი ანალოგები მოყვანილია ცხრილში.

შედარების ოპერაციები
მათ.	პითონი	განმარტება
a > b	a > b	მეტია
a ≥ b	a >= b	მეტი ან ტოლია
a < b	a < b	ნაკლებია
a ≤ b	a <= b	ნაკლები ან ტოლია
a ≡ b	a == b	იგივურია
a ≠ b	a != b	არ არის იგივური

ქვემოთ მოყვანილია შედარების ოპერაციების მაგალითები პითონის პროგრამებში შედარების ოპერაციის შედეგი წარმოადგენს ბულის (bool) კლასის(ტიპის) ობიექტს. ყურადღება მიაქციეთ, რომ პითონში ორი ობიექტის შედარება ხდება იგივურობის ოპერატორით (==). რომელიც განსხავავებულია მინიჭების (=) ოპერატორისგან. მინიჭების ოპერატორი ცვლის მის მარცხნივ განლაგებული ცვლადის მნიშვნელობას, ხოლო იგივური შედარება მის მარცხნივ და მარჯვნივ განლაგებული ცვლადების მნიშვნელობებს არ ცვლის.

>>a,b,c=1.0, -5.0, 6
>>>a>b
True
>>>L1=a>b
>>>type(L1)
< class 'bool' >
>>>b <=-5
True
>>>a >= c
False
>>>b == c
False
>>>b != c
True
>>>a>b
True

შედარების ოპერაციები
a and b	True	როდესაც a=True და b=True, ყველა სხვა შემთვევაში False
a or b	False	როდესაც a=False ან b=False, ყველა სხვა შემთვევაში True
not a	True	როდესაც a=False

კომპუტერულ პროგრამებში ბულის ცვლადები ძირითადათ პირობითი გადასვლებისათვის გამოიყენება. პირობითი გადასვლის ოპერატორები ბულის ცვლადების მნიშვნელობის შესაბამისად ახორციელებენ გადასვლას პროგრამის გამოყოფილ ნაწილზე, რომელიც მხოლოდ პირობის შესრულების შემთხვევაში სრულდება. პითონში, ბევრი სხვა პროგრამირების ენის მსგავსად, პირობითი გადასვლები ხორციელდება ოპერატორებით if , elif და else. ამ ოპერატორებს მოსდევთ პროგრამული დებულებების გამოყოფილი ნაწილი.

პროგრამის გარკვეული ნაწილის (პროგრამული ბლოკის) გამოყოფა პროგრამირების ენებში სხვადასხვა საშუალებებით ხდება. მაგალითად C++ პროგრამებში პროგრამული ბლოკი მოთავსებულია ფიგურულ ფრჩხილებში { ..... }. პითონში გამოყოფა ხორციელდება მეთოდით, რომელიც დაკავშირებულია გამოყოფილი ნაწილის ოპერატორების (დებულებების) წანაცვლებულ ჩაწერასთან (ინგლისურად indentation). ასეთი ტიპის გამოყოფას ინდენტაცის უწოდებენ. პითონში, როგორც ავღნიშნეთ, დებულებების ჩაწერის პოზიცია მკაცრად არის განსაზღვრული, და პირველი პოზიციიდან იწყება. პითონის დებულებების გამოყოფა იწყება მას შემდეგ, როდესაც პითონის დებულებას ორწერტილი (:) ახლავს ბოლოში. ორწერტილი პითონში მიანიშნებს პროგრამული ბლოკის დასაწყის და იხმარება მხოლოდ გარკვეული ოპერატორების შემდეგ. ორწერტილს( : ) მოსდევს პროგრამული ბლოკი, რომლის დებულებების ჩაწერის პოზიცია რამდენინე პოზიციით არის წანაცვლებული(წანაცვლება ხდება მაჯვნივ). ერთ ბლოკში გაერთიანებულ დებულებებს აუცილებელია, რომ ერთი და იგივე წანაცლება (ინდენტაცია) ჰქონდეს. ბლოკიდან გამოსვლას მიანიშნებს ის დებულება, რომელიც იმავე პოზიციაზე იწყება, როგორც დებულება, რომელსაც პროგრამული ბლოკის გამოყოფის აღმნიშვნელი ორწერტილი ახლდა (:). რამდენ პოზიციაზე უნდა მოხდეს ინდენტაცია ? პითონში ეს განსაზღვრული არ არის, მაგრამ მიღებული შეთანხმებით ინდენტაცია 4 პოზიციას შეადგენს, ე.ი. გამოყოფილო ბლოკის დებულება მე-5 პოზიციიდან უნდა დაიწყოს. იმ შემთხვევაში, როდესაც გამოყოფილი ბლოკი ერთ დებულებისგან შედგება, შესაძლებელია ამ დებულების ორწერტილის (:) შემდეგ, იმავე ხაზზე განლაგება. პირობითი გადასვლების და ინდენტაციის მაგალითები ქვევით არის მოყვანილი.

>>> age=22
>>>if age<15:
print(" School ")
elif (age>=15)and(age<18):
print(" High school")
elif(age>=18):
print(" College ")
else:
print(" ")
True
< class 'bool' >

პირობის შემოწმება პითონში იწყება ოპერატორით if , რომელსაც მოსდევს პროგრამის გამოყოფილი ნაწილი(პროგრამის ბლოკი), რომელიც სრულდება იმ შემთხვევაში, თუ if ოპერატორში მოცემული პირობის მნიშვნელობა არის True . თუ ეს პირობა არ სრულდება, შესაძლებელია დამატებითი პირობის შემოწმება ოპერატორით elif ან ახალ ბლოკზე გადასვლა ოპერატორით else . პითონში პირობითი გადასვლა ყოველთვის if ოპერატორით იწეება, რომელსაც შეიძლება მოსდევდეს ერთი ან რამდენიმე elif და ერთი else ოპერატორი.

ყურადღება მიაქვიეთ გამოყოფილი ბლოკის დებულებებს. პოთონის ინტერპეტატორი გამოყოფილ ბლოკს ერთ დებულებად აღიქვამს(?). მხოლოდ ბლოკიდან გამოსვლის შემდეგ ჩნდება პითონის >>> ნიშანი. კურსის შემდგომ ნაწილებში ინტერაქტიული პროგრამირებიდან პითონის სკრიპტების ჩაწერაზე გადავალთ. როდესაც პროგრამა პითონის დებულებების დიდი რაოდენობას და გამოყოფილ ბლოკებს შეიცავს შეიცავს პითონის სკრიპტების გამოყენება გაცილებით მოსახერხებელია. კვადრატული განტოლების ამოხსნის პროგრამა მოცემულია სკრიპტში

პროგრამირება პითონზე: შესავალი

საწყისები: ცვლადები და მათი ტიპები