პროგრამირება პითონზე

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

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

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

პითონის ლისტი და ლისტის მეთოდები

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

>>>my_list1 = [1,2,3,4,5,6,7,8,9,10]
>>>type(my_list1)
>>> < class 'list' >
>>>my_list2=[]
>>>new_list=[1, my_list1, 'Element 3', my_list2]
>>>new_list
>>> [1, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'Element 3', []]
>>>len(my_list1)
>>> 10
>>>len(my_list2)
>>> 0

ამ მაგალითში პირველ ხაზზე იქმნება ახალი ლისტი (ანუ ლისტის კლასის ობიექტი), რომლის სახელია my_list1. ამ ლისტის ელემენტები მთელი დადებით რიცხვებია 1 დან 10-მდე. როგორც ჩანაწერი მიუთითებს, ლისტის ელემენტები მოთავსებულია კვადრატულ ფრჩხილებში და ერთმანეთისგან გამოყოფილია მძიმით. პითონის პროგრამაში შესაძლებელია ცარიელის ლისტის შექმნაც, my_list2 ცარიელი ლისტია, ე.ი. ლისტი, რომელშიც ელემენტების რაოდენობა 0-ის ტოლია. ცვლადი new_list წარმოადგენს სხვადასხვა ტიპის ობიექტებისგან შემდგარი ლისტის მაგალითს. ისევე როგორც ტექსტური ცვლადების(სტრინგების) შემთხვევაში, ლისტის ელემენტების რაოდენობის განსაზღვრა შეიძლება პითონის ჩართული ფუნქციით len.

ლისტის წარმოადგენს ელემენტების მოწესრიგებულ მიმდევრობას, რაც ნიშნვს რომ მასში არსებული ელემენტებს გააჩნიათ რიგითი ნომერი ანუ ინდექსი. ლისტის ინდექსი სტრინგის ინდექსის ანალოგიურია და ამიტომ მასზე მიმართვაც ისევე ხდება როგორც სტრინგის შემთხვევაში. მიმართვის მაგალითები ქვემოთ არის მოყვანილი:

>>>print(my_list1[0])
1
>>>item_0=my_list1[0]
>>>print(my_list1[9])
10
>>>print(my_list1[-1])
10
>>>print(my_list1[-10])
1

პითონის ლისტი დინამიური, ე.ი. ცვალებადი ობიექტია, რომლის ელემენტები და სიგრძე პროგრამაში შეილება შეიცვალოს. ეს ნიშნავს, რომ ლისტში შესაძლებელია როგორც ელემენტების დამატება, ასევე ელემენტების წაშლა. ეს ცვლილებები ხორციელდება ლისტის ფუნქციებით (მეთოდებით). ელემენტის დამატება ლისტის ბოლოში ხდება მეთოდით append(new_element), რომელიც ახალ ობიექტს (new_element), ლისტის ბოლოში (ბოლო ელემენტის შემდეგ) მოათავსებს. ამ მეთოდით შესაძლებელია ცარიელი ლისტის შევსება. ახალი ელემენტის დამატება ლისტში შეიძლება ასევე ნებისმიერი ადგილზე. ასეთი დამატება ხორციელდება მეთოდით insert(i, new_element), სადაც პარამეტრი i მიუთითებს ინდექსს, რომელიც ახალ ელემენტის ექნება დამატების შემდეგ. შესაბამისად, როდესაც i=0 დამატებული ელემენტი ლისტის პირველი ელემენტი ხდება, ხოლო როცა ინდექსი i ლისტის სიგრძის ტოლია, მაშინ ახალი ელემენტი ლისტში ბოლო ადგილს იკავებს, ე.ი. ამ შემთხვევაში ეს მეთოდი append-ის ანალოგიურია. ლისტის მეთოდები, რომელთა გამოყენებით შესაძლებელია ლისტის დამატება ქვევით არის მოყვანილი

>>>my_list2.append(200)
>>>my_list2.append(400)
>>>print(len(my_list2)
>>>2
>>>print(my_list2)
>>>[200, 400]
>>>my_list2.insert(0, 100)
>>>my_list2.insert(2, 300)
>>>my_list2.insert(4, 500)
>>>print(my_list2)
>>>[100, 200, 300, 400, 500]

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

>>>my_list3=[]
>>>my_list3.extend([10, 20, 30])
>>>print(len(my_list3)
[10, 20, 30]
>>>my_list3.extend((40,50))
>>>my_list3.extend([60])
print(my_list3)
[10, 20, 30, 40, 50, 60]
>>>my_list3.extend(70)
Traceback (most recent call last):
File "", line 1, in
my_list3.extend(70)
TypeError: 'int' object is not iterable

ლისტში ასევე შესაძლებელია ელემენტების შეცვლა (ჩანაცვლება) და მიმდევრობიდან წაშლა. ლისტის ელემენტის ჩანაცვლება ხდება ამ ელენტისათვის ახალი მნიშვნელობის მინიჭებით. ლისტიდან x-ელემენტის წაშლა ხდენა მეტოდით remove(x). თუ ლისტში რამდენიმე ასეთ ელემენტია, წაიშლება მხოლოდ პირველი ელემენტი. იმის დადგენა, თუ რამდენი x-ელემენტია ლისტში, შეიძლება მეთოდით count(x). უნდა ავღნიშნოთ, რომ თუ ლისტში არ არის ელემენტი-x, მაშინ remove(x) მეთოდის ხმარება შეცდომას გამოიწვევს. შეცდომის თავიდან აცილება შეიძლება, თუ მეთოდის გამოყენებამდე შევამოწმებთ, არის თუ არა ეს ელემენტიც ლისტში. ეს შესაძლებელია ოპერატორით in, რომელიც ამოწმებს არის თუ რა ელემენტი x მიმდევრობაში. თუ ეს ელემენტი არის მიმდევრობაში, ამ შემოწმების შედეგი იქნება ბულის ცვლადი True, წინააღმდეგ შემთხვევაში კი False. ქვემოთ მოყვანილია ამ მეთოდის გმოყენების მაგალიტები:

>>>my_list3.remove(10)
>>>my_list3.remove(70)
Traceback (most recent call last):
File "", line 1, in
my_list4.remove(70)
ValueError: list.remove(x): x not in list
>>> x=70
>>> x in my_list3
False
>>>x=60
>>>if (x in my_list3): my_list3.remove(xelement)
>>>print(my_list3)
[ 20, 30, 40, 50 ]

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

>>>my_list3.clear()
>>>print(my_list3)
[]
>>>del my_list3
>>>print(my_list3)
Traceback (most recent call last):
File "", line 1, in
print(my_list3)
NameError: name 'my_list3' is not defined

ლისტიდან შესაძლებელია ასევე ელემენტის ამოღება მეთოდით pop(). ეს მეთოდი აბრუნებს ლისტის ბოლო ელემენტს, თვითონ ელემენტი კი ლისტიდან წაიშლება. ეს ნიშნავს, რომ ამ მეთოდის გამოყენების შემდეგ ლისტის სიგრძე ერთით შემცირდება.

>>>my_list4=['a', 'b', 'c', 'd']
>>>item=my_list4.pop()
>>>print(item)
d
>>>print(my_list4)
['a', 'b', 'c']

ლისტში არსებობენ მეთოდები, რომლებიც საშუალებას იძლევიან, რომ ლისტის ელემენტები დალაგდეს ზრადადი ან კლებადი მიმდევრობის სახით. მეთოდის sort() გამოყენება ლისტის ელემენტებს ზრდადობის მიხედვით დაალაგებს xl[i+1]>xl[i], ხოლო მეთოდი reverse() კი ლისტის კლებადობის მიხედვით xl[i]> xl[i+1]. ლისტის ელემენტების აღნიშული მეთოდებით დალაგება შესაძლებელია იმ შემთვევაში, თუ ლისტის ელემენტები ერთი ტიპის ობიექტები (მაგალითად რიცხვები ან სტრინგები) არიან. სხვა შემთხვევებში ამ მეთოდების ხმარება გამოიწვევს შეცდომას.

>>>my_list5=["aa", "ac", "ba", "d", "aaa", "bcc"]
>>>my_list5.sort()
>>>print(my_list5)
['aa', 'aaa', 'ac', 'ba', 'bcc', 'd']
>>>my_list5.reverse()
>>>print(my_list5)
['d', 'bcc', 'ba', 'ac', 'aaa', 'aa']
>>>my_list6=[12,8,6,2,1,7,9,5,4,10,3,11]
>>>my_list6.sort()
>>>print(my_list6)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>>my_list6.reverse()
>>>print(my_list6)
[12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>>my_list6.insert(2,"a")
>>>print(my_list6)
[12, 11, 'a', 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
my_list6.sort()
Traceback (most recent call last):
File "", line 1, in
my_list6.sort()
TypeError: unorderable types: str() < int()

ლისტის ტიპის ობიექტისთვის, ისევე როგორც სტრინგისთვის, შესაძლებელია მის "სლაისთან" ანუ მის გარკვეულ ნაწილთან (ამოჭრილ ნაწილთან) მუშაობა. ლისტის სლაისი ასევე ლისტის ობიექტია, რომელიც მხოლოდ იმ ელემენტებს შეიცავს რომელიც მოქცეულია მითითებულ ინდექსებს შორის ( i1: i2). ელემენტენის რაოდენობა სლაისში არის i2-i1. სლაისის პირველი ელემენტი იქნება i1, ხოლო ბოლო ელემენტი i2-1 სლაისის გამოყენების მაგალითები მოყვანილია ქვემოთ:

>>>my_list7=['a', 'b', 'c', 'd', 1, 2, 3, 4, 5 ]
>>>type(my_list7[0:4])
< class 'list' >
>>>print(my_list7[0:4])
['a', 'b', 'c', 'd']
>>>print(my_list7[-9:-4])
['a', 'b', 'c', 'd', 1]

ლისტების ობიექტებზე, ისევე როგორც სტრინგებზე განსაზღვრულია ასევე გაერთიანების (concatenation) და ლისტის ელემენტების 'გამრავლების' ოპერაციები.

>>>my_list8=["a", "b", "c", "d"]
>>>my_list9=["e", "f", "g", "h"]
>>>my_list10=my_list8 + my_list9
>>>print(my_list10)
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>>my_list11=8*["a"]
>>>print(my_list11)
['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']

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

>>>data_txt=' 1 2 3.14 1.2e+5 -10.1 '
>>>x=data_txt.split()
>>>print(x)
['1', '2', '3.14', '1.2e+5', '-10.1']
>>>x1=eval(x[0])
>>>print(x1)
1
>>>print(eval(x[3])
120000.0

ლისტის მეთოდები
მეთოდი	სინტაქსი	მეთოდის აღწერა
append	list.append(x)	ახალი ელემენტის დამატება ლისტის ბოლოს. ოპერაციის შემდეგ, ლისტის ელემენტებს რაოდენობა (სიგრძე) ერთით იზრდება.
clear	list.clear()	ლისტის (მისი ელემენტების) წაშლა. ოპერაციის შემდეგ რჩება ცარილი ლისტი, სიგრძით 0.
count	list.count(x)	გამოთვლა, თუ რამდენჯერ გვხვდება ელემენტი x მოცენულ ლისტში. თუ ასეთი ელემენტი ლისტში არ არის, მაშინ აბრუნებს მნიშვნელობას 0.
extend	list.extend(xl)	ლისტის ბოლო ელმენტს ემატება xl მიმდევრობის ელემენტები
index	list.index(x)	ლისტის x-ელემენტის ინდექსი. თუ ლისტში რამდენიმე ასეთი ელემენტია, მეთოდი დააბრუნებს პირველი ელემენტის ინდექს, ხოლო თუ ასეთი ელემენტი ლისტში არ არის, მეთოდი დასრულდება შეცდომით.
insert	list.insert(i,x)	ელემენტის ჩასმა ლისტის გარკვეულ პოზიციაზე ინდექსით i, ე.ი. ჩასმა ხდება ელემენტის შემდეგ, რომლის ინდექსია i-1.
pop	list.pop(x)	x-ელემენტის ამოღება ლისტიდან. ამ მეთოდის შემდეგ ლისტის სიგრძე ერთით მცირდება
remove	list.remove(x)	ლისტიდან x-ელემენტის წაშლა. თუ ლისტში რამდენიმე ასეთი ელემენტია. წაიშლება მხოლოდ პირველი.
reverse	list.reverse()	ლისტის ელემენტების დალაგება კლებადობის მიდეხვით
sort	list.sort	ლისტის ელემენტების დალაგება ზრდადობის მიდეხვით

ლისტებთან სამუშაოდ არსებობენ ასევე პითონის ჩართული ფუნქციები, მაგალითად min(xl) , max(xl) sum(xl) . აქ იგულიხსმება, რომ xl - ლისტის ელემენტები რიცხვები არიან. სხვა შემთხვევაში ამ ფუნქციების გამოძახება შეცდომით დასრულდება. ჩართული ფუნქვია min(xl) აბრუნებს xl-მომდევრობის უმცირესს ელემენტს, ხოლო ფუნქცია max(xl) მაქსიმალურ რიცხვს. ფუნქცია sum(xl) მნიშვნელობა კი რიცხვითი მიმდევრობის ჯამის ტოლია. მაგალითი

>>>xl=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>>print(min(xl))
1
>>>print(max(xl))
20
>>>print(sum(x1))
210

ტუპლი

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

>>>tuple1=1,2,3,4,5
>>>tuple2=(1,2,3,4,5)
>>>tuple1
(1,2,3,4,5)
>>>xt1=(1)
>>>type(xt1)
< class 'int' >
>>> xt2=(1,)
>>>type(xt2)
< class 'tuple' >

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

>>>tuple3=(1,2,3,4,5,6,7,8,9)
>>>tuple3[1]
2
>>> tuple1[1:3]
(2,3)
>>> tuple1.count(3)
1
>>>tuple1.index(3)
2

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

>>>vec3D=(10.5, 2.04, 0.41)
>>>x,y,z=vec3D
>>>type(x)
< class 'float' >
>>> print(x)
10.5

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

>>>ta=(1,2)
>>>tb=(3,4)
>>>tc = ta + tb
>>>print(tc)
(1, 2, 3, 4)
>>>tc=tc+(5,6)+(7,8)
>>>print(tc)
(1, 2, 3, 4, 5, 6, 7, 8)
>>>td=5*(1,2)
(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)

პოთონში შესაძლებელია ტუპლის ტიპის ობიექტის ლისტის ტიპის ობიექტად გადაყვანა, ისევე . ასევე როგორც ლისტის ტუპლში გადაყვანა. ასეთი გადაყვანა ხორციელდება პითონის ჩართული ფუნქციებით list(xl) და tuple(xl). პირველი ფუნქცია xl- მიმდევრობის ტიპის ობიექტს გარდაქმნის ლისტის ტიპის ობიექტად, ხოლო მეორე შემთხვევაში ტუპლის ტიპის ობიექტად.

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

სეტი

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

>>>set1={1,1,1,2,2,2}
>>>type(set1)
< class 'set' >
>>>len(set1)
2
>>>print(set1)
{1,2}
>>>len({})
2

როგორც ავღნიშნეთ პითონის სეტს მათემატიკური სიმრავლის ანალოგიური თვისებები აქვს, რაც ნიშნავს, რომ სეტებზე ისეთივე ოპერაციების ჩატარებ შეიძლება, როგორც სიმრავლეებზე. ახალი ელემენტის დამატება სეტში ხირციელდება მეთოდით add, თუ ამ მეთოდის პარამეტრია ელემენტი, რომელიც სეტში უკვე არსებობს, მაშინ მისი დამატება არ მოხდება. მეთოდები clear, pop, remove ლისტის შესაბამისი მეთოდების ანალოგიურია - remove სეტის იმ ელემენტს წაშლის, რომელიც მითითებულია მეთოდის პატამეტრად. თუ ასეთი ელემენტი სეტში არ არის, ეს გამოიწვევს შეცდომას. მეთოდი clear წაშლის სეტის(სიმრავლის) ყველა ელემენტს და მისი გამოყენების შემდეგ გვრჩება ცარიელი სეტი. მეთოდი pop, რომელსაც არ აქვს პარამეტრები, სეტიდან ელემენტს ამოიღებს. ცარიელ სეტზე ამ მეთოდის გამოყენება გამოიწვევს შეცდომას. სეტში ელემენტის წაშლა შესაძლებელია აგრეთვე მეთოდით discard, რომელიც remove-მეთოდის ანალოგიური, მაგრამ არ იძლევა შეცდომას, თუ მეთოდის პარამეტრათ მითითებული ელემენტი სეტში არ არის.

>>>set1.add(3)
>>>print(set1)
{1,2,3}
>>> set1[0]
Traceback (most recent call last):
File "", line 1, in
set1[0]
TypeError: 'set' object does not support indexing
>>>set1.remove(2)
>>>print(set1)
{1,3}
>>>set1.pop()
1
>>>print(set1)
{3}

ორი სეტის(სიმრავლის) გაერთიანება ხორციელდება მეთოდით union. გაერთიანებულ სეტში არის ორივე სიმრავლის (სეტის) ელემენტები. სეტების(სიმრავლეების) გადაკვეთა წარმოადგენს სეტს(სიმრავლეს), რ ომელიც მხოლოდ იმ ელემენტებს შეიცავს, რომლებიც ორივე სიმრავლეში არიან. მოცემული სეტის(სიმრავლის) განახლება, ანუ ახალი ელემენტების დამატება შესაძლებელია მეთოდით update, რომლის პარამეტრი წარმოადგენს სეტს, საიდანაც ხდება ელემენეტის დამატება. სეტების გადაკვეთა ხორციელდება მეთოდი intersection, intersection_update.
სეტებზე ასევე განსაზღვრულია სხვა ოპერაციები, difference, difference_update, symmetric_difference და symmetric_difference_update რომელებსაც ამ კურსში ან განვიხილავთ.

>>>s1={"Sun", "Mercury", "Venus", "Earth", "Mars","Jupiter","Saturn", "Uranus", "Neptune"}
>>>s2={"Earth", "Moon"}
>>>s2=s1.union(s2)
>>>print(s2)
>>>

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

>>> {1,2}.issubset({1,2,3,4,5})
True
>>> {1,2,3,4,5}.issubset({1,2,3,4,5})
true
>>> {1,2,3,4,5,6}.issubset({1,2,3,4,5})
False
>>> {1,2,3,4,5,6}.issuperset({1,2,3,4,5})
True
>>> {1,2,3,4,5,6}.isdisjoint({1,2,3,4,5})
False
>>> {1,2,3,4,5,6}.isdisjoint({7,8,9,10})
True

მაგალითები. სეტების მეთოდები - ორი სეტის შედარება:

მაგალითები 2 : როგორ შეიძლება სეტებზე გამოყენება ?

დიქციონარი (dictionary)

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

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

>>my_dict1={'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7, 'h':8, 'i':9, 'j':10 }
>>>my_dict1['a']
>>>1
>>>my_dict1["x"]
Traceback (most recent call last):
File "", line 1, in
my_dict1['x']
KeyError: 'x'
'b' in my_dict1
True
'b' not in my_dict1
False
'x' not in my_dict1
True
print(my_dict1)
{'e': 5, 'c': 3, 'g': 7, 'h': 8, 'i': 9, 'd': 4, 'a': 1, 'b': 2, 'f': 6, 'j': 10}

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

>>>my_dict2={}
>>>len(my_dict2)
0
>>>my_dict2['a']=10
>>>my_dict2['b']=20
>>>my_dict2['c']=30
>>>len(my_dict2)
3
>>>print(my_dict2)
{'b': 20, 'c': 30, 'a': 10}
>>>del my_dict2['b']
>>>print(my_dict2)
{'c': 30, 'a': 10}
>>>my_dict2.clear()
>>>print(my_dict2)
>>> {}

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

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

>>>a1=my_dict1.get('a', 'No such key')
>>>print(a1)
1
>>>a2=my_dict1.get('b', "No such key")
>>>print(a2)
2
>>>a3=my_dict1.pop('a')
>>>print(a3)
1
>>>a3=my_dict1.pop('a',"No such key" )
>>>print(a3)
No such key
>>>item=my_dict1.popitem()
>>>print(item)
('j':10)

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

dict1={'A':65, 'B':66, 'C':67, 'D':68 }
dict2={'a':97, 'b':98, 'c':99, 'd':100 }
dict1.update({'E':69})
dict1.update({'F':72})
print(dict1['F'])
72
dict1.update({'F':70})
print(dict1['F'])
70
dict1.update(dict2)
print(dict1['A'], dict1['a'])
65 97

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

>>>list_dict1=list(dict1.items())
>>>print(list_dict1)
[('E', 69), ('b', 98), ('D', 68), ('d', 100), ('B', 66), ('c', 99), ('A', 65), ('F', 70), ('a', 97), ('C', 67)]
>>>key_list=list(dict1.keys())
>>>print(key_list)
['E', 'b', 'D', 'd', 'B', 'c', 'A', 'F', 'a', 'C']
>>>v_list=list(dict1.values())
>>>print(v_list)
[98, 100, 65, 70, 97, 99, 66, 67, 69, 68]

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

>>>list1=['H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O' , 'F', 'Ne' ]
>>>list2=[1.008, 4.0026, 6.94, 9.012, 10.81, 12.011, 14.007, 15.999, 18.998, 20.1797 ]
>>>d=zip(list1,list2)
>>>C_dict=dict(d)
>>>print(C_dict)
{'Ne': 20.1797, 'F': 18.998, 'O': 15.999, 'C': 12.011, 'H': 1.008, 'Li': 6.94, 'B': 10.81, 'Be': 9.012, 'N': 14.007, 'He': 4.0026}

ციკლები: for და while

for x in xlist: print(x)

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

clist=[(1.0, 2.0, 1.5), (2.5, 4.2, 7.9), (3.8, 1.6, 8.3)]
for cc in clist:
x,y,x=cc
print(x, y, y)
1.5 2.0 2.0
7.9 4.2 4.2
8.3 1.6 1.6

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

index=0 while index < len(xlist): print(xlist[index]) index += 1

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

while - ციკლების ხმარება მოსახერხებელია პროგრამაში მონაცემების შეყვანისას. შეყვანა შეიძლენა შეწყდეს გარკვეული პირობის შესრულების შემთხვევაში, მაგალითად გარკვეული სიმბოლოს შეყვანისას ან იმ შემთვევაში, როდესაც შეყვანილია მონაცემების განსაზღვრული რაოდენობა:

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

>>>x=" "
>>>while len(x)>0:
x = input(" Your input:" )
print(" Input string is: ", x)



 >>>list1=[]

 >>>Max_length=10

 >>>while  len(list1)           x = input(" Your input:" )  

           list1.appen(eval(x))

ფუნქცია range

>>> list(range(1,11, 2))
[1,3,5,7,9]
>>> tuple(range(1,11, 2))
(1,3,5,7,9)
>>> set(range(1,11, 2))
{1,3,5,7,9}

>>>list(range(11))
[0,1,2,3,4,5,6,7,8,9,10]
>>>tuple(range(11))
(0,1,2,3,4,5,6,7,8,9,10)
>>>set(range(11))
{0,1,2,3,4,5,6,7,8,9,10}

>>>min(range(100))
0
>>>max(range(100))
99
>>>sum(range(100))
4950:

ოპერატორები break, continue, pass

x=" "
while len(x)>0:
x= input(" Your input: ")

True
>>> list(tuple1)== list1
True
>>>

>>>x=" "
>>>while len(x)>0:
x = input(" Your input:" )
continue
print(" Input string is: ", x)

>>>xlist = [10,11, 2, 12, 13, 14, 15, 1, 7, 16, 17, 3, 19]
>>> ix = 0
>>>for x in xlist:
if (x<10): continue
s1 += x
ix += 1
>>>print(" List Length=", len(xlist) )
>>>print(" Number of element %4d, sum = %6.2f" % (is, s1))
>>>

>>>xlist = [10,11, 2, 12, 13, 14, 15, 1, 7, 16, 17, 3, 19]
>>> ix = 0
>>>for x in xlist:
if (x>9):
s1 += x
ix += 1
>>>print(" List Length=", len(xlist) )
>>>print(" Number of element %4d, sum = %6.2f" % (is, s1))
>>>

პროგრამირება პითონზე. ნაწილი II

მიმდევრობები პითონში