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

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

ფუნქციები პითონში

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

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

>>>def dummy_function():
pass
>>>print(type(dummy_function))
< class 'function' >
>>>D=dummy_function()
>>>print(type(D))
< class 'NoneType' >
>>>print(D)
None
>>>def Gauss(x, mean, sigma):
from math import pi, exp, sqrt
return (1./sqrt(2.0*pi*sigma)*exp(-0.5*(x-mean)**2/sigma**2))

>>>G1=Gauss(0.0, 0.0, 1.0)
>>>print(' Gauss(0.0, 0.0, 1.0)= %6.3f '% G1)
Gauss(0, 0, 1.0)= 0.399

პირველ ხაზზე ჩაწერილი ფუნქცია dummy_function პითონის სინტაქსის თვალსაზრისით სწორად არის ჩაწერილი და ეკუთვნის პითონის ფუნქციის კლასის ობიექტებს. რადგან ეს ფუნქცია ერთი დებულებსგან (pass) შედგება, ეს დებულება შეგვეძლო იმავე, ფუნქციის განმარტების ხაზზე მოგვეთავსებინა. ამ ფუნქციაზე მიმართვა ნაჩვენებია შემდეგ ხაზზე. ეს ფუნქცია არაფერს არ გააკეთებს, რადგან მისი ერთადერთი დებულების დანიშნულება სწორედ არაფრის გაკეთებაა. შესაბამისად ეს ფუნქცია არ დააბრუნებს არანაირ ობიექტს, რაც ნიშნავს რონ D-ცვლადზე მინიჭებული ობიექტის ტიპი და მნიშვნელობა განუსაზღვრელი იქნება. ამავე მაგალითში განსაზღვრულია გაუსის ფუნქცია Gauss, რომელსაც სამი არგუმენტი (პარამეტრი) აქვს. ფუნქციის პირველი პარამეტრია მისი არგუნემტი, ხოლო ორი დანარჩენი პარამეტრია ფუნქციის ცენტრალური მნიშვნელობა და სტანდარტული გადახრა(დისპერსია). გაუსის ფუნქცია მნიშვნელოვან როლს ასრულებს მათემატიკურ სტატისტიკაში, რადგანაც აღწერს სტატისტიკის ერთ-ერთ ყველაზე გავრცელებულ ნორმალურ განაწილებას. გაუსის ფუნქციისათვის დასაბრუნებელი ობიექტის მინიჭება ხდება ოპერატორით return. მოყვანილ მაგალიში G1 ცვლადს ენიჭება გაუსის ფუნქციის მნიშნელობა, პარამეტრებისათვის (0.0, 0.0, 1.0)

შემდეგ მაგალითში, კვადრატული განტოლების ax² + bx + c = 0 ამოხნის პროგრამა, რომელზეც ამ კურსის წინა ნაწილებში გვქონდა საუბარი ჩაწერილია ფუნქციის სახით, რომლის არგუმენტებია განტოლების პარამეტრები a, b და c. ამ ფუნქციიდან ხდება პითონის მათეტიკური მოდული ფუნქცია sqrt -ს გამოძახება, ამიტომ აუცილებელია რომ ამ ფუნქციის ჩართვა მოხდეს ჩვენი ფუნქციის დებულებების ბლოკში. კვადრატული განტოლების ამოხსნის ფუნქცია აბრუნებს ტუპლოს ტიპის ობიექტს, რომლის ელემენტებია განტოლების ფესვები. როდესაც დაბრუნებული ტუპლის სიგრძე არის 0, განტოლებას არ აქვს ამონახსნი ნამდვილ რიცხვეთა სიმრავლეში, ხოლო როცა ტუპლის სიგრძე არის 1, განროლებას მხოლოდ ერთი ფესვი აქვს. მოყვანილ მაგალითში , ნაჩვენებია კვადრატული განტოლების ამოხსნა სამი აღნიშნული შემთხვევისთვის.

>>>def square_equation(a,b,c):
from math import sqrt
D= b*b - 4.0 * a *c
if D > 0: x= (-0.5*(b - sqrt(D))/a, -0.5*(b + sqrt(D))/a)
elif D==0: x =(-0.5*b/a, )
else: x=()
return x
>>>print(square_equation(1.0,-3.0, 2.0))
(2.0, 1.0)
>>>print(square_equation(1.0, 2.0, 1.0))
(-1.0,)
>>>print(square_equation(1.0, 1.5, 1.0))
()

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

>>>def square_equation(a,b,c):
''' კვადრატული განროლების ამოხსნა \n
განტოლების ამონახსნი იწერება ტუპლში, რომლის სიგრძეა \n
2 თუ განტოლებას ორი ნამდვილი რიცხვი აკმაყიფილებს (აქვს ორი ფესვი) \n
1 თუ განტოლებას ერთი ნამდვილი რიცხვი აკმაყიფილებს (აქვს ერთი ფესვი) \n
0 თუ განტოლებას არ აქვს ამონახსნი ნამდვილ რიცხვთა სიმრავლეში \n '''
from math import sqrt
D= b*b - 4.0 * a *c
if D > 0: x= (-0.5*(b - sqrt(D))/a, -0.5*(b + sqrt(D))/a)
elif D==0: x =(-0.5*b/a, )
else: x=()
return x
>>>print(square_equation(1.0,-3.0, 2.0))
(2.0, 1.0)
>>>print(square_equation(1.0, 2.0, 1.0))
(-1.0,)
>>>print(square_equation(1.0, 1.5, 1.0))
()
>>> help(square_equation)
Help on function square_equation in module __main__:

square_equation(a, b, c)
კვადრატული განროლების ამოხსნა

განტოლების ამონახსნი იწერება ტუპლში, რომლის სიგრძეა:

2 თუ განტოლებას ორი ნამდვილი რიცხვი აკმაყიფილებს (აქვს ორი ფესვი)

1 თუ განტოლებას ერთი ნამდვილი რიცხვი აკმაყიფილებს (აქვს ერთი ფესვი)

0 თუ განტოლებას არ აქვს ამონახსნი ნამდვილ რიცხვთა სიმრავლეში

ლოკალური და გლობალური ცვლადები

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

>>>def function1():
PI = 3.14
return PI
>>>def function2():
return (2.0*PI)
>>>print(' function1 = ', function1())
function1= 3.14
>>print(' function2 = ', function2())
Traceback (most recent call last):
File "", line 1, in
function2()
&nbp File "", line 2, in my_function2
return (2.0*PI)
NameError: name 'PI' is not defined

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

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

>>>def function1():
global PI
PI = 3.14
return PI
>>>def function2():
return (2.0*PI)
>>>print(' function1 = ', function1())
function1= 3.14
>>>print(' function1 = ', function1())
function2= 6.28

რადგან პითონი ინტერპრეტირებადი ენაა, function1-ის გამოძახება წინ უნდა უძღვოდეს function2 გამოძახებას, რადგანაც გლობალური ცვლადი სწორედ ამ ფუნქციაშია განსაზღვრული. წინააღმდეგ შემთხვევაში გამეორდება შეცდომა NameError.

მოყვანილ მაგალითებში გამოყენებული PI ცვლადის მნიშვნელობა 2 ნიშნის სიზუსტით არის განსაზღვრული, პითონის მატემატიკური math მოდულის განხილვისას კი ვნახეთ, რომ π ამ მოდულის ატრიბუტს წარმოადგენს და მასში 16 ნიშნის სიზუსტით არის მოცემული. როგორ შეგვიძლია ეს მნიშვნელობა გამოვიყენოთ ჩვენს მიერ განსაზღვრულ ფუნქციებში ? ამის მაგალითი, უკვე მოყვანილი იყო გაუსის ფუნციის განხილვისას, აქ დავამატებთ, რომ გლობალურ ცვლადს შეგვიძლია ეს მნიშვნელონა მივანიჭოთ, როგორც ეს ქვევით არის ნაჩვენები:

>>>def function1():
from math import pi
global PI
PI = pi
return PI
>>>def function1():
return (2.0*PI)
>>function1()
>>print('function2= ', function2())
function2= 6.283185307179586

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

>>>def function1():
PI=3.14
def function2():
def function3():
return (3.0*PI)
return (2.0*PI)
print(' function3=', function3())
print(' function2=', function2())
return PI
>>>print(function1())
function3= 9.42
function2= 6.28
3.14

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

>>>from math import pi, exp, sqrt,
>>>def Gauss(x, mean, sigma): return (1./sqrt(2.0*pi*sigma)*exp(-0.5*(x-mean)**2/sigma**2))
>>>def equation2(a,b,c):
D= b*b - 4.0 * a *c
if D >= 0: return (-0.5*(b - sqrt(D))/a, -0.5*(b + sqrt(D))/a)
else: return ()
>>>print(' Gauss(0.0, 0.0, 1.0) = ', Gauss(0.0, 0.0, 1.0))
Gauss(0.0, 0.0, 1.0) = 0.3989422804014327
>>>print(' Solution= ', eqution2(1.0, -3.0, 2.0))
Solution= (2.0, 1.0)

კიდევ რისი ცოდნა საჭირი გლობალური და ლოკალური ცვლადების შესახებ ?
გლობალური და ლოკალური სიდიდეების ცნება მნიშვნელოვანია კლასების განხილვისას ?

ფუნქციის პარამეტრები და მათი ტიპები

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

>>>G01=Gauss(0.,1.)
Traceback (most recent call last):
File "", line 1, in
G01=Gauss(0.,1.)
TypeError: Gauss() missing 1 required positional argument: 'sigma'

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

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

>>>def Gauss(x, mean=0.0, sigma=1.0):
from math import pi, exp, sqrt
return (1./sqrt(2.0*pi*sigma)*exp(-0.5*(x-mean)**2/sigma**2))
>>>print(' Gauss(0.0)= %6.3f '% Gauss(0.0) )
Gauss(0.0)= 0.399
>>>print(' G(0.0, sigma=1.0)= %6.3g'% Gauss(0.0, sigma=1.0))
G(0.0, sigma=1.0)= 0.399
>>>print(' G(0.0, mean=2.0)= %6.3g'% Gauss(0.0, mean=2.0))
G(0.0, mean=2.0)= 0.054
>>>print(' G(0.0, 0,1, 0.1 )= %6.3g'% Gauss(0.0, 0.1, 0.1))
G(0.0, 0,1, 0.1 )= 0.765
>>>print(' G(sigma=1.0, x=0.0 )= %6.3g'% Gauss(sigma=1.0, x=0.0))
G(sigma=1.0, x=0.0 )= 0.399
>>>print(' G(sigma=1.0, 0.0 )= %6.3g'% Gauss(sigma=1.0, mean=0.0))
Traceback (most recent call last):
File "C:/Users/Rezo/Desktop/IOM_2/IOM_Book/web/py3/example_3_a2.py", line 12, in
print(' G(sigma=1.0, 0.0 )= %6.3g'% Gauss(sigma=1.0, mean=0.0))
TypeError: Gauss() missing 1 required positional argument: 'x'

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

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

>>>def square_equation1(a=1.0, b=-2.0, c=1.0):
from math import sqrt
D= b*b - 4.0 * a *c
if D > 0: x= (-0.5*(b - sqrt(D))/a, -0.5*(b + sqrt(D))/a)
elif D==0: x =(-0.5*b/a, )
else: x=()
return x
>>>print(square_equation1())
(1.0)
>>>print(square_equation1(b=2.0)
(-1.0,)
>>>print(square_equation1(1.0, -3.0, 2.0))
(-1.0, 2.0) :

ფუნქციის განსაზღვრისას პარამეტრების რიცხვი შეიძლება დაფიქსირებული არ იყოს. ამის მაგალითად გამოდგება მათეამატიკური პოლინომი f(x) = ∑ a_i xⁱ, რომლის პარამეტრები შეიძლება ერთიდან n-მდე იცვლებოდეს. პითონში შესაძლებელია ფუნქციის განსაზღვრა პარამეტრების ცვლადი რიცხვით. ასეთი პარამეტრები შეიძლება იყოს როგორც პოზიციური ასევე საკვანძო.

>>>def poly1(x, *a):
from math import pow
p=0
if (len(a)==0):
p=x
else:
for i in range(len(a)):
p += a[i]*pow(x,i)
return p
>>>P0=poly1(1.0)
>>>print('P0=', P0)
P0= 0.0
>>>P1=poly(1.0, 5.0)
P1= 5.0
>>>print(P(2.0, 2.0, 3.0)= ', poly1(2.0, 2.0, 3.0))
P(2.0, 2.0, 3.0)= 8.0
>>>print(P(2.0, 2.0, 3.0,4.0) = ', poly1(2.0, 2.0, 3.0, 4.0))
P(2.0, 2.0, 3.0, 4.0) = 24.0

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

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

>>>def funpar1(a, b=1, **ka):
print('a={} b={}'.format(a,b), 'ka=', ka)
>>>def funpar2(a, b=2, *pa, **ka):
print('a={} b={}'.format(a,b), ' pa=', pa, 'ka=', ka)
>>>funpar1(100,200, x=1,y=2)
a=100 b=200 ka= {'y': 2, 'x': 1}
>>> print('a={} b={}'.format(a,b), ' pa=', pa, 'ka=', ka)
a=100 b=200 pa= (300, 500) ka= {'z': 30.0, 'y': 20.0, 'x': 10.0}

პითონის ფუნქციის funpar1 განსაზღვრულია სამი პარამეტრით, პირველი პარამეტრი პოზიციური პარამეტრია, მეორე პარამეტრი საკვანძო პარამეტრს წარმოადგეს, რომელსაც მიმიებული აქვს საწყისი მნიშვნელობა, ხოლო მესამე პარამეტრი , რომლის წინ ჩაწერილია ** ცლადი სიგრძის მქონე საკვანძო პარამეტია. მაგალითში მოყვანილი პითონის ფუნქციის funpar2 პარამეტრების სია ჩვენ მიერ განხილულ ყველა ტიპის პარამეტრს შიცავს. პირველი პარამეტრი(a)პოზიციურია, მეორე (b=1) საკვანძო, მესამე პარამეტრი(*pa) ცვლადი სიგრძის მქონე პოზივიური პარამეტრს წარმოადგენს, ხოლო მეოთხე (**ka) ცვლადი სიგრძის მქონე საკვანძო პარამეტრია. ფუნქცია ბეჭდავს გადაცემულ პარამეტრებს და არ აბრუნებს ობიექტს. როგორც ბოლო ხაზი მიუთითებს, ცვლადი სირძის პოზიციური პარამეტრები ფუმქციაში დიქციონარის სახით გადაეცემა. როგორც ამ კურსის წინა ნაწილებში ვნახეთ, დიქვიონარი არ არის ინდექსირებადი მიმდევრობა, ამიტომ ბედვაში არ არის გამეორებული ფუნქციის გამოძახების დროს გადაცემული საკვანძო პარამეტრების მიმდევრობა.

პითონის მოდულები random და statistics

პითონის სტანდარტული ბიბლიოთეკის მოდული math იყო პირველი მოდული, რომელსაც ამ კურსში გავეცანით. ამ ნაწილში განვიხილავთ, კიდევ ორ მათემატიკურ მოდულს, კერძოდ კი პითონის შემთხვევითი რიცხვების random მოდულს და პითონის სტატისტიკის მოდულს statistics.

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

ფსევდო-შემთხვევითი რიცხვების მიმდევრობა, დამოკიდებულია საწყის მნიშვნელობაზე. ასეთი მიმდევრობები გარკვეული პერიოდი აქვთ.ეს ნიშნავს, რომ ფსევდო-შემთხვევითი რიცხვების მიმდევრობა ასეთ პერიოდებში ერთი და იგივეა. ფსევდო-შემთხვევითი რიცხვების გენერაციის თანამედროვე კომპუტერულ ალგორითმებში პერიოდის სიგრძე იმდენად დიდია, რომ შეგვიძლია ჩავთვალოთ რომ ფსევდო-შემთხვევითი რიცხვების მიმდევრობა არ მეორდება. მაგალითად პითონში ფსევდო-შემთხვევითი რიცხვის გენერაცის ხდება ალგორითმით, რომლის პერიოდია 2¹⁹⁹³⁷-1. შემდგომში კომპუტერულ ფსევდო-შემთხვევით რიცხვებს მოვიხსენიებთ, როგორც შემთხვევით რიცხვებს. პითონის შემთვევითი რიცხვების გენერაციის მოდეული ramdom დეტალურად არის აღწერილი პითონის სტანდარტული ბიბლიოთეკის ვებ-გვერდზე.

პითონის სტანდარტული ბიბლიოთეკის შემთხვევითი რიცხვების მოდულის ძირითადი მეთოდი (ფუქცია) არის random. ამ მეთოდირ ხდება რომელიც შემთხვევითი რიცხვების გენერაცია აბრუნებს [0,1) - ინტერვალში ( 0 &le random() < 1). ამ მეთოდის გამოწენების პერველი მაგალით მოყვანილია ქვვით:

>>>import random as r
>>>xr=[]
>>>N=1000
>>>for i in range(N):
xr.append(r.random())
>>> mean=sum(xr)/N
>>>print(' 3 random numbers: {0:7.5g}, {1:7.5g}. {2:7.5f}'.format(xr[0], xr[1], xr[2])
>>>print(' Length of ramdom sequense={0:6d}, mean = {3:7.5g} '.format(len(xr), mean))
3 random numbers: 0.55546, 0.31401. 0.43707
Length of random sequense= 1000, mean = 0.50009

ამ მაგალიღში ხდება 1000 შემთხვევითი რიცხვის გენერაცია და მათი დამატება ცარიელ ლისტში. მაგალითის ბოლოს მოყვანილია (დაბეჭდილია) შემთხვევითი რიცხვების ლისტის xr პირველი სამი ელემენტი და და ამ მიმდევრობის საშუალო მნიშვნელობა.

შემთხვევითი რიცხვები, რომელთა გენერაცია ფუნქცია random-ით ხდება, თანაბრად არიან განაწილებულები, [0,1) ინტერვალში. მატემატიკურ სტატისტიკაში თანაბარი განაწილების დასახასიათებლად საკმარისია განაწილების ინტერვალის a ≤ x ≤ b ცოდნა. ასეთი განაწილების საშუალო მნიშვნელობაა (a+b)/2, ხოლო საშუალო კვადრატული გადახრა . პითონის -მოდულის მეთოდები(ფუნქციები) საშუალება შემთხვევითი რიცხვების სხვა განაწილებების გენერაციის საშუალებას იძლება. ქვევით მოყვანილია, მეთოდები, რომლებიც შემთხვევითი რიცხვების ზოგიერთი განაწილების გენერაციის საშუალებას იძლევა:

**mode**-პარამეტრის დასაშვები მნიშვნელობები
uniform(a,b)	თანაბრად განაწილებული შემთხვევითი რიცხვის გენერაცია
normalvariate(m, s)	ნორმალურად განაწილებული შემთხვევითი რიცხვის გენერაცია. განაწილების საშუალი მნიშვნელობაა <><>, ხოლო დისპერსის <><>
gauss(m,s)	ანალოგიურია წინა ხაზშო მოყვანილი მეთოდის.
(a,b)	ფაილი გახსნილია ჩაწერისთვის, ამ იქმნება თავიდან. თუ ფაილი არსებონს ახალი ჩანაწერები ემატება ძველს
expovariate(xl)	ორობითი (binaru) ფაილი
expovariate(xl) (a,b)	ტექსტური ფაილი
(expovariate(xl) a,b)	დისკური ფაილის იხსნება განახლებისთვის (კითხვა და ჩაწერა)

<>ნიშნავს, რომ აღნიშნულ ინტერვალში რომელიც პირველ მაგალითში იყო მოყვანილი, ბილოს მაგალითში მოცემილი შ რომელიც მიმდევრობის (ლიგენერაცია ვუსშემთხვევიი რიცხვების მოდული საშულაბას იძლება გენერირებული იყოს შემდეგი განაწილებები: ნორმალური ანუ გაუსის განაწილება (),

uniform(a,b)

expovariate(xl)

gammavariate

normalvariate(mu, sigma)

triangular

lognormvariate

randint(a,b)

randrange(a,b)

sample(xl,n)

seed(a=None, version=2)

choice

როგორც ზევით ავღნიშნეთ, კომპუტერული შემთხვევითი რიცხვების გენერაცია გარკველი ალგორითმით ხდება. გენერირებული მიმდევრობა დამოკიდებულია თუ საწყის მნიშვნელობაზე, რომლის განსაზღვრა ხდება მეთოდით seed, რომელსაც ორი საკვანძო პარამეტრი აქვს, (a=None, version=2). თუ მეთოდის გამოძახება არ ხდება, ან ხდება პარამეტრების გარეშე, (ე.ი. საწყისი მნიშვნელობით) მაშინ ეს პარამეტრი შემთხვევით მნიშვნელობას იღებს (მაგალითად გამოძახების დროს), ხოლო პარამეტრი განსაზღცრულია, მაშინ გენერირებული მიმევრობა ერთი და იგივე საწყისი მნიშვნელობის შემთხვევაი ერთნაირი იქნება. ამის მაგალითი ქვევით არის მოყვანილი:

>>>import random as r
>>>r.seed(0)
>>>xr1=[]
>>>xg1=[]
>>>N1=1000
>>>for i in range(N1):
xr1.append(r.random())
xg1.append(r.gauss(0.0, 1.0))
>>>r.seed(0)
>>>xr2=[]
>>>xg2=[]
>>>N2=1000
>>>for i in range(N2):
xr2.append(r.random())
xg2.append(r.gauss(0.0, 1.0))
>>> print(' random numbers 1 : {0:7.5g}, {1:7.5g}. {2:7.5f}'.format(xr1[0], xr1[1], xr1[2]) )
random numbers 1 : 0.84442, 0.25892. 0.51127
>>> print(' random numbers 2 : {0:7.5g}, {1:7.5g}. {2:7.5f}'.format(xr2[0], xr2[1], xr2[2]) )
random numbers 2 : 0.84442, 0.25892. 0.51127
>>> print(' Normal random numbers 1 : {0:7.5g}, {1:7.5g}. {2:7.5f}'.format(xg1[0], xg1[1], xg1[2]) )
Normal random numbers 1 : 0.052192, -1.0434. -1.44712
>>> print(' Normal random numbers 2 : {0:7.5g}, {1:7.5g}. {2:7.5f}'.format(xg2[0], xg2[1], xg2[2]) )
Normal random numbers 2 : 0.052192, -1.0434. -1.44712

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

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

>>>import random as r
>>>import statistics as s
>>>xr1=[]
>>>xg1=[]
>>>xe1=[]
>>>N1=10000
>>>for i in range(N1):
xr1.append(r.random())
xg1.append(r.gauss(0.0, 1.0))
xg1.append(r.gauss(0.0, 1.0))
>>>r.seed(0)
>>>xr2=[]

კიდევ რა შემთხვევით რიცხვებზე ?

ინფორმაციის ჩაწერა და წაკითხვა ფაილში

ჩვენ უკვე გავეცანით პროგრამაში ინფორმაციის შეყვანას ჩართული ფუნქცია input-ის საშუალებით და და პროგრამიდან ინფორმაციის გამოყვანას print-ის საშუალებით. პირველი ფუნქცია საშუალებას იძლევა ინფორმაცია კომპუტერის კლავიატურიდან შევიყვანოთ, ხოლო მეორე ფუნქციას კი ინფორმაცია კომპუტერის ეკრანზე გამოაქვს. პითონის ინტერპრეტატორის პროგრამიდან გამოსვლის შემდეგ ამ ფუნქციებით შეყვანილი თუ განოყვანილი ინფორმაცია იკარგება. ეს ორი ფუნქცია არ ამოწურავს იმ საშუალებებს რომლებიც პითონში არსებობს ინფორმაციის გაცვლითვის. პითონის პროგრამიდან შესაძლებელია როგორც წინასწარ მომზადებული მონაცემების წაკითხვა, ასევე მონაცემების ჩაწერა ფაილის სახით. ფაილი წარმოადგენს გარკვეული ფორმატით ჩაწერილ მონაცემთა ერთობლიობას, რომელიც განთავსებულია კომპუტერის დისკზე ან ინფორმაციის შენახვის (მეხსიერების) სხვა საშუალებაზე. ფაილს აქვს სახელი, რომელიც როგორც წესი ორი ნაწილისგან შედგება, რომლებიც ერთმანეთისგან წერტილით არის გამოყოფილი. სახელის პირველი ნაწილი უნიკალურია, ხოლო მეორე ნაწილი, რომელსაც ხშირად ფაილის გაფართოებას უწოდებენ განსაზღვრავს ფაილის ტიპს, რომელიც ფაილში ინფორმაციის შენახვის წესზე (ფორმატზე) მიუთითებ. მაგალითად ფაილი, რომელიც მოცემულია გაფართოებით txt, როგორც წესი შეიცავს ტექსტურ ინფორმაციას, თუნცა ასეთ ფაილში ტექსტში შეიძლება რიცხვები იყოს ჩაწერილი. ფაილის შეიძლება ორობითი კოდით იყოს ჩაწერილი. ასეთ ფაილების წაკითხვას სპეციალური პროგრამები სჭირება. ყველასათვის ნაცნობია ფორმატება, რომლებსაც ხშირად ვხვდებოთ და რომლების თანამედრობე ყოფის ატრიბუტებუ გახდნენ. ასეთი ფაილის მაგალითებია ტექსტის რედაქტორის (Microsoft Word) მიერ მომზადებული ფაილები, რომლებსა აქვთ გაფართოება doc და გრაფიკული ფაილები, რომელთა გაფართეობა როგორც წესი ფალის ფორმატზე მიუთითს, როგორც მაგალითად PDF (portable Document format), GIF (Graphics Interchange Format) JPEG (Joint Photographic Experts Group) PNG (The Portable Network Graphics).

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

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


>>>open("my_file1.txt") 

Traceback (most recent call last):
  File "", line 1, in 
    open("my_file1.txt")
FileNotFoundError: [Errno 2] No such file or directory: 'my_file1.txt'

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

**mode**-პარამეტრის დასაშვები მნიშვნელობები
"r"	ფაილი გახსნილია მხოლოდ კითხვითვის
"w"	ფაილი გახსნილია ჩაწერისთვის, ჩაწერა ხდება დასაწყისიდან, ე.ი. თუ ფაილში ჩაწერამდე არსებული ინფორმაცია დაიკარგება
"x"	იქმნება ახლი ფაილი, რომელიც გახსნილია
"a"	ფაილი გახსნილია ჩაწერისთვის, ამ იქმნება თავიდან. თუ ფაილი არსებონს ახალი ჩანაწერები ემატება ძველს
"b"	ორობითი (binaru) ფაილი
"t"	ტექსტური ფაილი
"+"	დისკური ფაილის იხსნება განახლებისთვის (კითხვა და ჩაწერა)

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

>>> MyFile1 = open("my_file.txt","r")
>>> MyFile1.read()
'cp1252'

დასაშვებია ასევე გარკვეული რაოდენობის ბაოტების წაკითხვა მეთოდში read მაგალითად 6-ბაიტის წაკითხვა ფაილიდან: read(6)
წაკითხვის პოზიცია: მეთოდი seek საშუალებას იძლება განისაზღვროს ჩანეწერის პოზიცია ფაილის შიგნით:
seek(0) - ფაილი დასაწყისი
seek(5) - პოზიცია მე-5 ბაიტზე (სიმბოლოების კოდირება მოკლეს არის გადმოცემული Unicode კოდირების ნაწილში)
მეთოდი tell() რომელიც იძლევა საშუალებას დადგინდეს პოზიცია გახსნილ ფაილში

>>>import sys
>>>sys.stdin.encoding
'cp1252'
>>sys.stdout.encoding
'cp1252'

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

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

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

>>>file1=open("Text1.txt")
>>>Text = file1.read()
>>>words=Text.split()
>>>words.sort()
>>>print(words)

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

Unicode სიმბოლოების მქონე ტექსტური ფაილის კითხვა

ტექსტური ფაილების დამუშავების შესაძლებლობები პითონის საშუალებით. პითონი ფართოდ გამოიყენება Natural Language Processing (NLP) თვის. ბუნებრივია, რომ პითონით ქართული ტექსტების ანალიზიც შეიძლება, ამისათვის პირველ რიგში საჭიროა Unicode სიმბოლოებისგან შედგენილი ტექსტური ფაილის გახსნა და წაკითხვა. პითონ-3-ში ამისათვის ფუნქცია open-ში, საჭიროა პარამეტრის მითითება encoding="utf8". ტექსტური ფაილიდან პირველ როგში უნდა გამოიყოს ტესტური ერთეული (სიტყვა). ამ ბმულში მოქვანილია პითონის მოდული , რომლის საშუალებით შესაძლებელია ქართული ანბანის სიმბოლოებისგან შედგენილი სიტყვის გამოყოფა:

შესაძლებელია გადავცეთ ფუნქციის სახელი როგორც პარამეტრი ? მაგალითად sys.argv შესაძლებლობებით ?
შესაძლებელია ტექსტური ფაილის წაკითხვა ინტერნეტიდან ? მაგალითად lib.ge -დან ?
მაგალითად შეიძლება წავიკითხოთ ილიას ჭაცჭაცაძის პროზა ? კაცია ადამიანი ? ( კაცია ადამიანი ? )
როგორი ანალიზი უნდა ჩაუტარდეს ტექსტს?

>>>file1=open("Text1.txt", encoding="utf8")

ფაილში ჩაწერა

როგორ ხდება ფაილში ჩაწერა ? პირველ რიგში საჭიროა ახალი ფაილის ან უკვე არსებული ფაილის გახსნა. არსებული ფაილის გახსნის შემთხვევაში საჭიროა განისაზღვროს, მოხდება ჩაწერა დასაწყისიდან (ამ შემთხვევაში ფაილის გახსნამდე რსებული ინფორმაცია დაიკარგება), თუ მოხდება ახალი ინფორმაციის დამატება ფაილის ბოლოს. ეს განისაზღვრება ფუმცია პარამეტრით mode, რომლის მნიშვნელობა განსაზღცრავს შესაძლებელია თუ არა ფაილში ჩაწერა და საიდან დაიწყება ჩაწერა, თუ ის დაშვებულია. ფაილში ჩაწერა დაშვებულია, როდესაც ამ პარამეტრის მნიშვნელობაა 'w', ამ შემთხვევაში თუ მითითებული სახელის ფაილი არ არსებობს, ასეთი ფაილი შეიქმნება, ხოლო თუ ფაილი არსებობს, მასში ჩაწერა დასაწყისიდან მოხდება, ე.ი. ფაილში ჩაწერამდე არსებილი ინფორმაცია დაიკარგება. არსებულ ფაილში ჩანაწერების დამატება შესაძლებელია, როდესაც პარამეტრის მნიშვნელობაა 'a', სხვამხრივ ეს პარამეტრი 'w' პარამეტრის ანალოგიურია, რაც ნიშნავს რომ ამ პარამეტრის ხმარებისას ან ახალი ფაილი გაიხხნება (თუკი ასეთი ფაილი არ არსებობს) ან მოხდება არსებული ფაილში ინფორმაციის დამატება. ამშემთხვევაში ფაილში არსებული ინფორმავია ხელუხლებელი რჩება. ახალი ფაილის გახსნა და მასში ჩაწერა შესაძლებელია ასევე, როდესაც პარამეტრის მნიშვნელობაა 'x'. ამ შემთხვევაში ფაილი რომელიც იხნება ჩასაწერად, ან უნდა არსებობდეს, წინააღმდეგ შემთხვევაში მისი გახნა ამ პარამეტრით შეცდომას გამოიწვევს. ამ პარამეტრის ხმარება გამორიცხავს არსებული ფაილის შემთხვევით გადაწერას. პარამეტრი mode ასევე მიუთითებს ტექსტურია თუ არა ჩანაწერი. ფაილის კითხვის ან მასსი ჩაწერის დროს იგულისხმება, რომ ჩანაწერები ტექსტურია. ტექსტური ჩანაწერი განისაზღვრება სიმბოლოთი 't', ხოლო ორობითი ჩანაწერი სომბილოთი 'b'. ზემოთ მოყვანილ შემთხვევებში პარამეტრი მითითებული არ იყო, რაც ნიშნავს რომ პროგრამა საწყის მნიშვნელობას გამოიყენებს. თუკი ჩანაწერია ორობითია, მაშინ მისი მითითება აუცილებელია. mode პარამეტრის შესაძლო მნიშვნელობები შეიძლება იყოს 'rb', 'wb', 'xb', 'ab'.

>>>FileName='example1.txt'
>>> f1=open(FileName, mode='w')
>>> f1.write(' Example')
8
>>> f1.close()
>>>f1=open(FileName,mode='x')
Traceback (most recent call last):
File "", line 1, in
f1=open(FileName, 'x')
FileExistsError: [Errno 17] File exists: 'example1.txt'
>>>f1=open(FileName,mode='x')

ტექსტური ინფორმაციის ფაილში ჩაწერა, შესაძლებელია ფაილის ტიპის ობიექტის მეთოდებით write ან writelines. პირველი მეთოდით ფაილში ჩაწერს სტრინგს(ტექსტს), რომელიც ამ მეთოდის პარამეტრია. ტექსტის სასურველი სახით გამიყვანისათბის საჭიროა სპეციალური სიმბოლობის ხმარება. მაგალითად სიმბოლო '\n' ხაზის ბოლოს აღნიშნავს და ინფორმაციის წაკითხვას აადვილებს.
მეთოდი writelines ანალოგორად მუშაობს. რა განსხვავებაა მათ შორის ? <> აქ საჭიროა კარგი მაგალითი, რომელიც ფაილში ჩაწერის კარგი ილუსტრაცია იქნება.
შესაძლებელია მომზადდეს ტექსტური ობიექტი, რომელიც შემდეგ ერთიანად ჩაიწერება ფაილში.
მაგალითი:

>>>file1=open("Example2.txt", mode='a',encoding="utf8")
>>>txt = . . .
>>>file1.write(txt)
>>>file1.close()

რა მეთოდით ხდება ორობითი (ბინარული) ფაილის ჩაწერა. ასეთ ფაილში ამ მუშაობს write და writelines მეთოდები. ამ მეთოდების გამოიყენება, როდესაც ფაილი ისეა გახხნილი, როგორც ბინარული გამოიწვევს შეცდომას.

სტანდარტული ფაილი რომელიც შეიძლება წაიკითხო

სისტემური ფაილები ?

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

ფაილში ჩაწერის მაგალითი.

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

შესაძლებელია ინტერნეტში განლაგებული ფაილის წაკითხვა? ამისათვის პითობში არსებობს მოდული urllib

>>>mport urllib.request
>>>response = urllib.request.urlopen('http://python.org/')
>>> html = response.read()
>>> print(html)

სამეცნიერო მაგალითი ? <> კვარკნეტის წაკითხვა ?

რა ვისწავლეთ ან ნაწილში

ფუნციის შექმნა პითონის პროგრამაში.

გლობალური და ლოკალური ცვლდები

ფუნქციის პარამეტერები და მათი ტიპები

ინფორმაციის წაკითხვა და ჩაწერა ფაილებში.

მოდულები პითონში. პითონის სტანდარტული ბიბლიოთეკა

პითონის სტანდარტული ბიბლიოთეკის მოდულები:

პითონის მოდულის შექნა და მასთან მუშაობა

D r a f t !