python-ის ძირითადი თემები.md

საკითხების სია

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

ტერმინი	განმარტება
data type	მნიშვნელობის ტიპი, როგორიცაა string, int, boolean და ა.შ.
variable	ცვლადი; მოცანემი, რომლის მნიშვნელობაც შეიძლება შეიცვალოს პროგრამის მსვლელობისას
constant	მუდმივა; მონაცემი, რომლის მნიშვნელობაც მუდმივია, არ იცვლება პროგრამის მსვლელობისას
keyword	პროგრამირების ენაში რეზერვირებული სიტყვა, რომელსაც განსაზღვრული ფუნქცია აქვს. ზოგიერთი keyword-ია: if, while, def, break
condition	პირობა; მდგომარეობა, რომელიც შეიძლება იყოს ჭეშმარიტი (True) ან მცდარი (False)
loop	ციკლი
index	ინდექსი, რიგის ნომერი
indent	დაშორება, კოდის განშტოება
code block	კოდის ერთობლიობა, რომელიც ერთადაა თავმოყრილი
function	კოდის ბლოკი, რომელიც გამოძახებისას ერთ კონკრეტულ მოქმედებას ასრულებს
argument	მნიშვნელობა, რომელიც ფუნქციას გამოძახებისას ფრჩხილებს შორის გადაეცემა
parameter	სახელები, რომლებიც მოცემულია ფუნქციის შექმნისას ფრჩხილებს შორის

ზოგიერთი მონაცემთა ტიპი

string (ტექსტი)

a = 'Hello World'
b = ''
c = '8'

print(type(a), type(b), type(c))

# <class 'str'> <class 'str'> <class 'str'>

class იგივეა, რაც მონაცემის ტიპი.

ნებისმიერი მნიშვნელობა, რომელიც წერია ერთ ან ორმაგ ბრჭყალებში, Python-ში string ტიპისაა.

int, float (რიცხვები)

a = 10
b = 17.5

print(type(a), type(b))

# <class 'int'> <class 'float '>

მთელი რიცხვები Python-ში int ტიპისაა, ათწილადი კი float ტიპის.

boolean

a = not True
b = 10 > 5

print(a, b)

# False, True

boolean ტიპის მონაცემი იღებს ორ მნიშვნელობას - True ან False-ს.

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

List

a = [1, 2, 'abc', 17.5, ['one', 'two', 'three'], True]

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

Dictionary

car = {
    'brand': 'Ford',
    'model': 'Mustang',
    'year': 1964
}

Dictionary გასაღებს აკავშირებს მნიშვნელობასთან. გასაღების(key) სახელს მოსდევს ორი წერტილი და მნიშვნელობა(value). შესაძლებელია ნებისმიერი ტიპის და რაოდენობის key:value წყვილის დამატება. Dictionary-ის შესაქმნელად გამოყენება ფიგურული ფრჩხილები ({}).

Dictionary-ის მნიშვნელობებს მივწვდებით გასაღების გამოყენებით: car['brand']

ახალი მნიშვნელობის დასამატებლად გამოიყენება ჩანაწერი dictionary[key] = value, მაგ.: car['color'] = 'red'

სხვადასხვა ფუნქციები

ზოგადი: print, type, input, len, str, int

ზოგიერთი ფუნქცია მუშაობს მხოლოდ შესაბამის მონაცემის ტიპთან:

string: upper, lower, title, replace, startswith, endswith, removeprefix, removesuffix

list: append, remove

string და list: split, index, count

პროგრამის დინების კონტროლი

if/elif/else keyword-ები გამოიყენება პირობის (condition) დასატესტად.

if [condition 1]:
  ...
elif [condition 2]:
  ...
else:
  ...

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

კოდის დინებას ცვლის if/else, რომელიც რაიმე პირობის მიხედვით ირჩევს შემდეგ ნაბიჯს.

თუ condition1/2-დან რომელიმე აღმოჩნდა ჭეშმარიტი, შესრულდება შესაბამის ბლოკში ჩაწერილი კოდი. სხვა შემთხვევაში კი else ბლოკში ჩაწერილი კოდი გაეშვება.

ციკლები

For

for [element] in [elements]:
  ...

თითოეული ელემენტისთვის elements მიმდევრობაში, შესრულდება for ბლოკში ჩაწერილი კოდი.

element არის ჩვენი შერჩეული ნებისმიერი სახელი, რომელიც მიუთითებს elements მიმდევრობის (მაგალითად სიის ან dictionary-ის) მიმდინარე (current) ელემენტზე ციკლის მსვლელობისას.

elements მიმდევრობა შეიძლება იყოს:

• რიცხვების დიაპაზონი (range(0, 10))
• string მნიშვნელობა ('apple')
• სია ([1, 2, 3])
• Dictionary ({'age': 24})
• სხვა

სინტაქსი ოდნავ იცვლება dictionary-სთან მუშაობისას. შეგვიძლია მივწვდეთ dictionary-ის გასაღებებს, მნიშვნელობებს ან გასაღები:მნიშვნელობის წყვილებს.

• გასაღებები - keys()

for key in dictionary.keys():
    print(key)

• მნიშვნელობები - values()

for value in dictionary.values():
    print(value)

• გასაღები:მნიშვნელობის წყვილები - items()

for key, value in dictionary.items():
    print(key, value)

While

while [condition]:
  ...

while ბლოკში ჩაწერილი კოდი შესრულდება იქამდე, სანამ condition (პირობა) ჭეშმარიტია (True)

i = 0
numbers = []

while i < 10:
    numbers.append(i)
    i += 1

ამ შემთხვევაში პირობა არის i < 10.

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

ამ შემთხვევაში ამ როლს ასრულებს i += 1: ციკლის ყოველ ჯერზე i ცვლადის მნიშვნელობას ემატება 1. როცა i ცვლადის მნიშვნელობა მიაღწევს 10-ს, პირობა i < 10 აღარ იქნება True, შესაბამისად, ციკლი შეწყდება.

---

for i in range(10):
    if i == 5:
        continue
    elif i == 8:
        break
        
    print(i)
    
# 0 1 2 3 4 6 7

ორივენაირი ციკლის შემთხვევაში break და continue keyword-ები ციკლის მსვლელობას ცვლის.

ფუნქციების შექმნა და გამოძახება

ფუნქციის შექმნისას იწერება def(define) keyword, შემდეგ ჩვენი შერჩეული ფუნქციის სახელი და ფრჩხილებს შორის ნებაყოფლობითი პარამეტრები. ფრჩხილebs მოყვება : და indent.

def [name] ([parameters]):
    ...

ქვემოთ მოცემულ ფუნქციას პარამეტრები არ აქვს.

def greet():
    print('Hello!')

ფუნქციის გამოსაყენებლად აუცილებელია მისი გამოძახება სახელის და ფრჩხილების კომბინაციით -greet()

def add(a, b):
    return a + b

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

return keyword-ის გამოყენების შემთხვევაში, ფუნქციის შედეგი (ჩანაწერი, რომელიც მოსდევს return keyword-ს, ამ შემთხვევაში a + b) "გვიბრუნდება", ე. ი. შეიძლება შევინახოთ ცვლადში ან გადავცეთ სხვა ფუნქციებს, მოვეპყრათ, როგორც მნიშვნელობას (როგორიცაა string hello ან int 651):

result = add(1, 2)

print(result)
print(add(5, 6))

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

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

TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

ელემენტების წვდომა ინდექსით

Python-ში, და სხვა პროგრამირების ენებში, ინდექსის ათვლა იწყება 0-დან.

ელემენტის წასაკითხად გამოიყენება ასეთი სინტაქსი: field[index], სადაც field მუდმივის ან ცვლადის სახელია. მას მოყვება კვარდატულ ფრჩხილებში ჩაწერილი ინდექსი

lang = 'python'

letters = ['i', 'j', 'k']

print(lang[4], letters[0])

# o i

ელემენტი	p	y	t	h	o	n
ინდექსი	0	1	2	3	4	5

ოპერატორები

• ლოგიკური: and, or, not
• მათემატიკური: +, -, %, /, //, *, **
• გატოლების: =, +=, -=, *=, /=, %=
• შედარების: ==, !=, <, >, <=, >=

---

დასაწყისში დაბრუნება