- ზოგიერთი მონაცემთა ტიპი
- სხვადასხვა ფუნქციები
- პროგრამის დინების კონტროლი
- ციკლები
- ფუნქციების შექმნა და გამოძახება
- ელემენტების წვდომა ინდექსით
- ოპერატორები
ტერმინი | განმარტება |
---|---|
data type | მნიშვნელობის ტიპი, როგორიცაა string, int, boolean და ა.შ. |
variable | ცვლადი; მოცანემი, რომლის მნიშვნელობაც შეიძლება შეიცვალოს პროგრამის მსვლელობისას |
constant | მუდმივა; მონაცემი, რომლის მნიშვნელობაც მუდმივია, არ იცვლება პროგრამის მსვლელობისას |
keyword | პროგრამირების ენაში რეზერვირებული სიტყვა, რომელსაც განსაზღვრული ფუნქცია აქვს. ზოგიერთი keyword-ია: if, while, def, break |
condition | პირობა; მდგომარეობა, რომელიც შეიძლება იყოს ჭეშმარიტი (True) ან მცდარი (False) |
loop | ციკლი |
index | ინდექსი, რიგის ნომერი |
indent | დაშორება, კოდის განშტოება |
code block | კოდის ერთობლიობა, რომელიც ერთადაა თავმოყრილი |
function | კოდის ბლოკი, რომელიც გამოძახებისას ერთ კონკრეტულ მოქმედებას ასრულებს |
argument | მნიშვნელობა, რომელიც ფუნქციას გამოძახებისას ფრჩხილებს შორის გადაეცემა |
parameter | სახელები, რომლებიც მოცემულია ფუნქციის შექმნისას ფრჩხილებს შორის |
a = 'Hello World'
b = ''
c = '8'
print(type(a), type(b), type(c))
# <class 'str'> <class 'str'> <class 'str'>
class იგივეა, რაც მონაცემის ტიპი.
ნებისმიერი მნიშვნელობა, რომელიც წერია ერთ ან ორმაგ ბრჭყალებში, Python-ში string ტიპისაა.
a = 10
b = 17.5
print(type(a), type(b))
# <class 'int'> <class 'float '>
მთელი რიცხვები Python-ში int
ტიპისაა, ათწილადი კი float
ტიპის.
a = not True
b = 10 > 5
print(a, b)
# False, True
boolean ტიპის მონაცემი იღებს ორ მნიშვნელობას - True
ან False
-ს.
ასეთი ტიპის მონაცემს შეგვიძლია პირობებიც (და სხვა ნებისმიერი ჩანაწერი, რაც საბოლოოდ True
ან False
-ად გარდაიქმნება) გავუტოლოთ.
a = [1, 2, 'abc', 17.5, ['one', 'two', 'three'], True]
სიაში შესაძლებელია ნებისმიერი ტიპის ელემენტების თავმოყრა. სიის შესაქმნელად გამოიყენება კვადრატული ფრჩხილები ([]
)
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 [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 [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
- მათემატიკური:
+
,-
,%
,/
,//
,*
,**
- გატოლების:
=
,+=
,-=
,*=
,/=
,%=
- შედარების:
==
,!=
,<
,>
,<=
,>=