Python-ის საფუძვლები: ცვლადები, მონაცემთა ტიპები და არითმეტიკული ოპერაციები

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

ინტერაქტიული კოდი 🐍

ამ გვერდზე კოდის ბლოკების გაშვება პირდაპირ ბრაუზერში შეგიძლია — შეცვალე კოდი და დააჭირე ▶ გაშვებას. (პირველი გაშვება ~რამდენიმე წამი — Python იტვირთება.)

🖨️ print() ფუნქცია

print() არის Python-ის ფუნქცია, რომელიც ეკრანზე ბეჭდავს მნიშვნელობებს. ეს ყველაზე ხშირად გამოყენებადი ხელსაწყოა, როცა გვინდა ვნახოთ, რა ხდება კოდში.

• ტექსტი (სტრიქონი) იწერება ბრჭყალებში: "..." ან '...'.
• ერთ print()-ში რამდენიმე მნიშვნელობა შეიძლება, მძიმით გამოყოფილი — ისინი ჰარით დაიბეჭდება.

სცადე ⬇️ (შეცვალე ტექსტი და გაუშვი):

ცვლადები და მათი ტიპები

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

• ცვლადის სახელები უნდა იყოს აღწერითი, მარტივი და გასაგები. აი რამდენიმე წესი:
  • გამოიყენეთ მხოლოდ ასოები (a-z, A-Z), ციფრები (0-9) და ქვედა ხაზი _.
  • სახელი არ უნდა იწყებოდეს ციფრით.
  • არ გამოიყენოთ რეზერვირებული სიტყვები.
  • გამოიყენეთ snake_case სტილი (სიტყვები გამოყოფილია _-ით) Python-ში.

Python-ში ცვლადის გამოცხადება ხდება პირდაპირ მნიშვნელობის მინიჭებით:

VS CODE - ში ფაილის გახსნა:

🆚 Ctrl+O

ცვლადების გამოცხადება

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

განმარტება:

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

მონაცემთა ტიპები

მონაცემთა ძირითადი ტიპები

ცვლადებს შეიძლება ჰქონდეთ სხვადასხვა ტიპის მონაცემები. ძირითადი ტიპებია:
int: მთელი რიცხვები (მაგ.: 5, -10)
float: წილადი რიცხვები (მაგ.: 3.14, -0.5)
str: სტრიქონები (მაგ.: "გამარჯობა")
bool: ლოგიკური მნიშვნელობები (True, False)
list: სიები (მაგ.: [1, 2, 3])
tuple: კორტეჟები (მაგ.: (1, 2))
set: სიმრავლეები (მაგ.: {1, 2, 3})
dict: ლექსიკონები (მაგ.: {"name": "ანა", "age": 25})

განმარტება:

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

რეზერვირებული სიტყვები

Danger

აღწერა: პითონს აქვს სიტყვები, რომლებიც დაცულია ენისთვის და არ შეიძლება გამოვიყენოთ ცვლადების სახელებად.
მაგ.: if, else, for, while, True, False, None, and, or, not, def, class, return და სხვ.
მაგალითი:
არასწორი რეზერვირებული სიტყვის გამოყენება, ეს გამოიწვევს შეცდომას!

❌ if = 10

✅ condition = 10

print(condition)

განმარტება:

რეზერვირებული სიტყვების სრული სია: import keyword; print(keyword.kwlist).
ყოველთვის გამოიყენეთ აღწერითი სახელები, რომლებიც არ ემთხვევა ამ სიტყვებს.

არითმეტიკული ოპერაციები:

აღწერა: პითონი გვაძლევს საშუალებას, შევასრულოთ მათემატიკური ოპერაციები:
+ (მიმატება)
- (გამოკლება)
* (გამრავლება)
/ (გაყოფა)
// (მთელი გაყოფა)
% (ნაშთი)
** (ხარისხში აყვანა)

განმარტება:

/ ყოველთვის აბრუნებს float-ს, მაგ.: 10 / 2 = 5.0.
// აბრუნებს მთელ რიცხვს, მაგ.: 10 // 3 = 3.
% გვაძლევს გაყოფის ნაშთს.
** გამოიყენება რიცხვის ხარისხში ასაყვანად.

შემოკლებული არითმეტიკული ოპერაციები:

აღწერა: ეს არის ოპერაციები, რომლებიც ამარტივებს ცვლადის მნიშვნელობის განახლებას:
+= (მიმატება და მინიჭება)
-= (გამოკლება და მინიჭება)
= (გამრავლება და მინიჭება)
/= (გაყოფა და მინიჭება)
//= (მთელი გაყოფა და მინიჭება)
%= (ნაშთი და მინიჭება)
*= (ხარისხი და მინიჭება)

განმარტება:

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

არითმეტიკული ოპერაციების პრიორიტეტები

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

აღწერა: პითონი ასრულებს ოპერაციებს გარკვეული თანმიმდევრობით:
() – ფრჩხილები
** – ხარისხი
*, /, //, % – გამრავლება, გაყოფა, მთელი გაყოფა, ნაშთი
+, - – მიმატება, გამოკლება

Warning

თუ პრიორიტეტები თანაბარია, ოპერაციები სრულდება მარცხნიდან მარჯვნივ.

განმარტება:

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

ამოცანები

პირველი გაკვეთილისთვის

ერთ გაკვეთილზე ყველა ამოცანის გაკეთება საჭირო არ არის. დამწყებისთვის საკმარისია ამოცანები 1–8 (ცვლადები, არითმეტიკა, პრიორიტეტები). დანარჩენი — დამატებით სავარჯიშოდ, ხოლო input()/math-ის ამოცანები იხილე ბოლოს, 🔥 გამოწვევის სექციაში.

ამოცანა 1: ფართობის გამოთვლა

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

💡 ამოხსნა

length = 5.5
width = 3
area = length * width
print("მართკუთხედის ფართობი:", area)  # გამოიტანს: მართკუთხედის ფართობი: 16.5

ამოცანა 2: ნაშთის გამოთვლა

დავალება: შექმენით პროგრამა, რომელიც ითვლის, თუ რამდენჯერ ჯდება რიცხვი a რიცხვში b (მთელი გაყოფა) და რა ნაშთი რჩება.
გამოიყენეთ // და %.

💡 ამოხსნა

a = 17
b = 5
quotient = a // b
remainder = a % b
print("გაყოფის შედეგი:", quotient)   # გამოიტანს: 3
print("ნაშთი:", remainder)            # გამოიტანს: 2

ამოცანა 3: შემოკლებული ოპერაციები

დავალება: შექმენით ცვლადი total, რომელიც თავდაპირველად უდრის 10-ს.
გაზარდეთ ის 5-ით, გაამრავლეთ 2-ზე და შემდეგ გაყავით 3-ზე შემოკლებული ოპერაციების გამოყენებით.

💡 ამოხსნა

total = 10
total += 5   # total = 15
total *= 2   # total = 30
total /= 3   # total = 10.0
print("საბოლოო მნიშვნელობა:", total)  # გამოიტანს: საბოლოო მნიშვნელობა: 10.0

ამოცანა 4: პრიორიტეტების გამოყენება

დავალება: გამოთვალეთ გამოსახულება 5 + 2 * 3 ** 2 ორჯერ: ერთხელ ფრჩხილების გარეშე და მეორედ ფრჩხილებით (5 + 2) * 3 ** 2. გამოიტანეთ ორივე შედეგი.

💡 ამოხსნა

result1 = 5 + 2 * 3 ** 2  # 3 ** 2 = 9, 2 * 9 = 18, 5 + 18 = 23
result2 = (5 + 2) * 3 ** 2  # 5 + 2 = 7, 3 ** 2 = 9, 7 * 9 = 63
print("ფრჩხილების გარეშე:", result1)  # გამოიტანს: 23
print("ფრჩხილებით:", result2)       # გამოიტანს: 63

ამოცანა 5: ცვლადის ტიპის შემოწმება

დავალება: შექმენით რამდენიმე ცვლადი (მაგ.: num, text, flag) სხვადასხვა ტიპის მონაცემებით (int, str, bool).
გამოიყენეთ type() ფუნქცია მათი ტიპების გამოსატანად.

💡 ამოხსნა

num = 42
text = "პითონი"
flag = True
print("num-ის ტიპი:", type(num))   # გამოიტანს: <class 'int'>
print("text-ის ტიპი:", type(text)) # გამოიტანს: <class 'str'>
print("flag-ის ტიპი:", type(flag)) # გამოიტანს: <class 'bool'>

ამოცანა 6: ცვლადების გამოცხადება და ტიპის შემოწმება

შექმენით ოთხი ცვლადი: name (სტრიქონი), age (მთელი რიცხვი), height (წილადი რიცხვი), is_student (ბულეანი).
გამოიტანეთ თითოეული ცვლადის მნიშვნელობა და მისი ტიპი type() ფუნქციის გამოყენებით.

💡 ამოხსნა

name = "მარიამი"
age = 22
height = 1.65
is_student = True
print("სახელი:", name, "ტიპი:", type(name))      # გამოიტანს: სახელი: მარიამი ტიპი: <class 'str'>
print("ასაკი:", age, "ტიპი:", type(age))         # გამოიტანს: ასაკი: 22 ტიპი: <class 'int'>
print("სიმაღლე:", height, "ტიპი:", type(height)) # გამოიტანს: სიმაღლე: 1.65 ტიპი: <class 'float'>
print("სტუდენტია:", is_student, "ტიპი:", type(is_student)) # გამოიტანს: სტუდენტია: True ტიპი: <class 'bool'>

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

• True
• False

ამოცანა 7: მარტივი არითმეტიკული ოპერაციები

შექმენით ორი ცვლადი
გამოიყენეთ ყველა არითმეტიკული ოპერატორი (+, -, , /, //, %, *) და გამოიტანეთ შედეგები.

💡 ამოხსნა

a = 15
b = 4
print("მიმატება:", a + b)      # გამოიტანს: 19
print("გამოკლება:", a - b)     # გამოიტანს: 11
print("გამრავლება:", a * b)    # გამოიტანს: 60
print("გაყოფა:", a / b)        # გამოიტანს: 3.75
print("მთელი გაყოფა:", a // b) # გამოიტანს: 3
print("ნაშთი:", a % b)          # გამოიტანს: 3
print("ხარისხი:", a ** b)       # გამოიტანს: 50625

a = 10 
b = 3
print("Addition:", a + b) # 13 
print("Subtraction:", a - b) # 7 
print("Multiplication:", a * b) # 30 
print("Division:", a / b) # 3.3333333333333335 
print("Floor division:", a // b) # 3 
print("Modulus:", a % b) # 1 
print("Exponentiation:", a ** b) # 1000

მითითება:

ყურადღება მიაქციეთ, რომ / აბრუნებს float-ს, ხოლო // აბრუნებს int-ს.

ამოცანა 8: შემოკლებული ოპერაციების გამოყენება

შექმენით ცვლადი score = 100. განაახლეთ მისი მნიშვნელობა შემდეგი ოპერაციებით: გაზარდეთ 20-ით, გაამრავლეთ 2-ზე, გაყავით 5-ზე, შეამცირეთ 10-ით.
გამოიყენეთ შემოკლებული ოპერატორები (+=, *=, /=, -=).

💡 ამოხსნა

score = 100
score += 20   # score = 120
score *= 2    # score = 240
score /= 5    # score = 48.0
score -= 10   # score = 38.0
print("საბოლოო ქულა:", score)  # გამოიტანს: საბოლოო ქულა: 38.0

მითითება: შეამოწმეთ, რომ /= აბრუნებს float-ს, თუ გაყოფის შედეგი წილადია.

ამოცანა 9: ოპერაციების პრიორიტეტები

გამოთვალეთ შემდეგი გამოსახულებები:

💡 ამოხსნა

10 + 5 * 2  
(10 + 5) * 2  
2 ** 3 * 4 + 1  
2 ** (3 * 4) + 1 



result1 = 10 + 5 * 2          # 5 * 2 = 10, 10 + 10 = 20
result2 = (10 + 5) * 2        # 10 + 5 = 15, 15 * 2 = 30
result3 = 2 ** 3 * 4 + 1      # 2 ** 3 = 8, 8 * 4 = 32, 32 + 1 = 33
result4 = 2 ** (3 * 4) + 1    # 3 * 4 = 12, 2 ** 12 = 4096, 4096 + 1 = 4097
print("შედეგი 1:", result1)   # გამოიტანს: 20
print("შედეგი 2:", result2)   # გამოიტანს: 30
print("შედეგი 3:", result3)   # გამოიტანს: 33
print("შედეგი 4:", result4)   # გამოიტანს: 4097

მითითება: გაითვალისწინეთ, რომ ** აქვს უმაღლესი პრიორიტეტი, შემდეგ *, /, //, %, ბოლოს +, -. ფრჩხილებით შეგიძლიათ შეცვალოთ თანმიმდევრობა.

ამოცანა 10: საშუალო არითმეტიკული

შექმენით პროგრამა, რომელიც ითვლის სამი რიცხვის (num1, num2, num3) საშუალო არითმეტიკულს.
გამოიყენეთ ცვლადები და გამოიტანეთ შედეგი.

💡 ამოხსნა

num1 = 10
num2 = 20
num3 = 30
average = (num1 + num2 + num3) / 3
print("საშუალო:", average)  # გამოიტანს: საშუალო: 20.0

მითითება: გაყოფა (/) ყოველთვის აბრუნებს float-ს.

ამოცანა 11: სტუდენტის GPA-ს გამოთვლა

დავალება: გამოთვალეთ სტუდენტის GPA (Grade Point Average - საშუალო ქულა) სამი საგნის ქულის მიხედვით.
გამოიყენეთ ცვლადები grade1, grade2, grade3 შემდეგი მნიშვნელობებით: grade1 = 85, grade2 = 90, grade3 = 78.
GPA გამოითვლება ფორმულით: gpa = (grade1 + grade2 + grade3) / 3.
გამოაჩინეთ GPA-ს მნიშვნელობა.

💡 ამოხსნა

grade1 = 85
grade2 = 90
grade3 = 78
gpa = (grade1 + grade2 + grade3) / 3  # (85 + 90 + 78) / 3 = 253 / 3 = 84.333...
print("სტუდენტის GPA:", gpa)  # გამოიტანს: სტუდენტის GPA: 84.33333333333333

განმარტება:

ცვლადები grade1, grade2, grade3 არის int ტიპის, რადგან ქულები მთელი რიცხვებია.
ფრჩხილები (grade1 + grade2 + grade3) უზრუნველყოფს, რომ მიმატება შესრულდეს გაყოფამდე.
გაყოფა (/) აბრუნებს float ტიპს, ამიტომ შედეგი წილადი რიცხვია.
GPA-ს გამოთვლისას სამი ქულის ჯამი იყოფა საგნების რაოდენობაზე (3).

რჩევები

გამოიყენეთ აღწერითი ცვლადების სახელები, მაგ.: grade1, gpa, რათა კოდი იყოს გასაგები.
გამოიყენეთ print() შედეგის შესამოწმებლად.
თუ გსურთ, სცადეთ სხვა ქულები (მაგ.: 92, 76, 88) და გამოთვალეთ ახალი GPA.
გაითვალისწინეთ, რომ გაყოფა (/) ყოველთვის აბრუნებს float-ს, მაშინაც კი, თუ შედეგი მთელი რიცხვია.

ამოცანა 12: ხარისხში აყვანა

შექმენით პროგრამა, რომელიც ითვლის რიცხვის base power-ე ხარისხს ** ოპერატორის გამოყენებით.
სცადეთ base = 2 და power = 3, შემდეგ base = 5 და power = 4.

💡 ამოხსნა

base = 2
power = 3
result = base ** power
print(base, "ხარისხში", power, ":", result)  # გამოიტანს: 2 ხარისხში 3 : 8

base = 5
power = 4
result = base ** power
print(base, "ხარისხში", power, ":", result)  # გამოიტანს: 5 ხარისხში 4 : 625

მითითება: ** ოპერატორი გამოიყენება ხარისხში ასაყვანად. სცადეთ უარყოფითი power-იც.

ამოცანა 13: ცვლადის განახლება

შექმენით ცვლადი counter = 0. განაახლეთ ის 5-ჯერ შემდეგი ოპერაციებით: += 2, *= 3, -= 4, /= 2, += 10.
გამოიტანეთ ყოველი ნაბიჯის შემდეგ.

💡 ამოხსნა

counter = 0
counter += 2
print("ნაბიჯი 1:", counter)  # გამოიტანს: 2
counter *= 3
print("ნაბიჯი 2:", counter)  # გამოიტანს: 6
counter -= 4
print("ნაბიჯი 3:", counter)  # გამოიტანს: 2
counter /= 2
print("ნაბიჯი 4:", counter)  # გამოიტანს: 1.0
counter += 10
print("ნაბიჯი 5:", counter)  # გამოიტანს: 11.0

მითითება: თვალი ადევნეთ, როგორ იცვლება ცვლადის ტიპი (int → float) /= ოპერაციის შემდეგ.

ამოცანა 14: რეზერვირებული სიტყვების თავიდან აცილება

სცადეთ შექმნათ ცვლადი სახელით for ან while და გამოიტანეთ შეცდომა.
შემდეგ შეცვალეთ სახელი აღწერითი სახელით (მაგ.: loop_count) და გამოიყენეთ ის რიცხვის გასაორმაგებლად.

💡 ამოხსნა

# არასწორი:
# for = 5  # გამოიწვევს SyntaxError

# სწორი:
loop_count = 5
loop_count *= 2
print("გაორმაგებული:", loop_count)  # გამოიტანს: გაორმაგებული: 10

მითითება: გამოიყენეთ import keyword; print(keyword.kwlist) რეზერვირებული სიტყვების სანახავად.

ამოცანა 15: ნაშთის გამოთვლა

გამოთვალეთ, რა ნაშთი რჩება, როცა რიცხვი n = 25 იყოფა m = 7-ზე.
გამოიყენეთ % ოპერატორი.
ასევე გამოთვალეთ მთელი გაყოფის შედეგი (//).

💡 ამოხსნა

n = 25
m = 7
remainder = n % m  # 25 ÷ 7 = 3 (მთელი) და ნაშთი 4
quotient = n // m  # 25 ÷ 7 = 3 (მთელი ნაწილი)
print("ნაშთი:", remainder)  # გამოიტანს: ნაშთი: 4
print("მთელი გაყოფა:", quotient)  # გამოიტანს: მთელი გაყოფა: 3

განმარტება:

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

ამოცანა 16: ფარენჰაიტიდან ცელსიუსში გარდაქმნა

გარდაქმენით ტემპერატურა ფარენჰაიტიდან ცელსიუსში ფორმულის გამოყენებით: C = (F - 32) * 5 / 9.
გამოიყენეთ ცვლადი fahrenheit = 68. გამოაჩინეთ ცელსიუსის მნიშვნელობა.

💡 ამოხსნა

fahrenheit = 68
celsius = (fahrenheit - 32) * 5 / 9  # (68 - 32) * 5 / 9 = 36 * 5 / 9 = 20
print("ცელსიუსი:", celsius)  # გამოიტანს: ცელსიუსი: 20.0

განმარტება:

ფრჩხილები (fahrenheit - 32) უზრუნველყოფს, რომ გამოკლება შესრულდეს გამრავლებამდე.
გაყოფა (/) აბრუნებს float-ს.

ამოცანა 17: ცელსიუსიდან ფარენჰაიტში გარდაქმნა

გარდაქმენით ტემპერატურა ცელსიუსიდან ფარენჰაიტში ფორმულის გამოყენებით: F = C * 9 / 5 + 32.
გამოიყენეთ ცვლადი celsius = 25.
გამოაჩინეთ ფარენჰაიტის მნიშვნელობა.

💡 ამოხსნა

celsius = 25
fahrenheit = celsius * 9 / 5 + 32  # 25 * 9 / 5 + 32 = 45 + 32 = 77
print("ფარენჰაიტი:", fahrenheit)  # გამოიტანს: ფარენჰაიტი: 77.0

განმარტება:

გამრავლება და გაყოფა (*, /) შესრულდება მანამ, სანამ მიმატება (+) მოხდება.
შედეგი float ტიპისაა გაყოფის გამო.

ამოცანა 18: მეტრებიდან კილომეტრებში გარდაქმნა

გარდაქმენით მანძილი მეტრებიდან კილომეტრებში.
გამოიყენეთ ცვლადი meters = 2500. ფორმულა: kilometers = meters / 1000.
გამოაჩინეთ შედეგი.

💡 ამოხსნა

meters = 2500
kilometers = meters / 1000  # 2500 / 1000 = 2.5
print("კილომეტრები:", kilometers)  # გამოიტანს: კილომეტრები: 2.5

განმარტება:

გაყოფა (/) აბრუნებს float-ს.
1 კილომეტრი = 1000 მეტრი.

ამოცანა 19: კილომეტრებიდან მეტრებში გარდაქმნა

გარდაქმენით მანძილი კილომეტრებიდან მეტრებში.
გამოიყენეთ ცვლადი kilometers = 3.
ფორმულა: meters = kilometers * 1000.
გამოაჩინეთ შედეგი.

💡 ამოხსნა

kilometers = 3
meters = kilometers * 1000  # 3 * 1000 = 3000
print("მეტრები:", meters)  # გამოიტანს: მეტრები: 3000.0

განმარტება:

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

ამოცანა 20: მარტივი გარდაქმნა (მეტრები ფუტებში)

გარდაქმენით მანძილი მეტრებიდან ფუტებში.
გამოიყენეთ ცვლადი meters = 10.
ფორმულა: feet = meters * 3.28084.
გამოაჩინეთ შედეგი.

💡 ამოხსნა

meters = 10
feet = meters * 3.28084  # 10 * 3.28084 = 32.8084
print("ფუტები:", feet)  # გამოიტანს: ფუტები: 32.8084

განმარტება:

1 მეტრი ≈ 3.28084 ფუტი.
შედეგი float ტიპისაა.

ამოცანა 21: შემოკლებული ოპერაციები გარდაქმნისთვის

შექმენით ცვლადი distance = 500 (მეტრებში).
გარდაქმენით ის კილომეტრებში (/= 1000), შემდეგ გაზარდეთ 2-ჯერ (*= 2), და ბოლოს შეამცირეთ 1-ით (-= 1).
გამოაჩინეთ ყოველი ნაბიჯის შედეგი.

💡 ამოხსნა

distance = 500
print("საწყისი მანძილი (მეტრებში):", distance)  # 500
distance /= 1000  # 500 / 1000 = 0.5
print("კილომეტრებში:", distance)  # 0.5
distance *= 2     # 0.5 * 2 = 1.0
print("გაორმაგებული:", distance)  # 1.0
distance -= 1     # 1.0 - 1 = 0.0
print("საბოლოო მნიშვნელობა:", distance)  # 0.0

განმარტება:

შემოკლებული ოპერატორები ამარტივებს გამოთვლებს.
/= აბრუნებს float-ს.

ამოცანა 22: მართკუთხედის ფართობი და პერიმეტრი

გამოთვალეთ მართკუთხედის ფართობი (area = length * width) და პერიმეტრი (perimeter = 2 * (length + width)) ცვლადების გამოყენებით.
გამოიყენეთ length = 6 და width = 4.
გამოაჩინეთ ორივე შედეგი.

💡 ამოხსნა

length = 6
width = 4
area = length * width  # 6 * 4 = 24
perimeter = 2 * (length + width)  # 2 * (6 + 4) = 2 * 10 = 20
print("მართკუთხედის ფართობი:", area)  # გამოიტანს: მართკუთხედის ფართობი: 24
print("მართკუთხედის პერიმეტრი:", perimeter)  # გამოიტანს: მართკუთხედის პერიმეტრი: 20

განმარტება:

length და width არის int ტიპის ცვლადები.
ფრჩხილები (length + width) უზრუნველყოფს, რომ მიმატება შესრულდეს გამრავლებამდე.
შედეგები int ტიპისაა, რადგან გამოყენებულია მხოლოდ მთელი რიცხვები.

ამოცანა 23: ოთხკუთხედის (კვადრატის) ფართობი და პერიმეტრი

გამოთვალეთ კვადრატის ფართობი (area = side * side) და პერიმეტრი (perimeter = 4 * side) ცვლადის გამოყენებით.
გამოიყენეთ side = 5.
გამოაჩინეთ ორივე შედეგი.

💡 ამოხსნა

side = 5
area = side * side  # 5 * 5 = 25
perimeter = 4 * side  # 4 * 5 = 20
print("კვადრატის ფართობი:", area)  # გამოიტანს: კვადრატის ფართობი: 25
print("კვადრატის პერიმეტრი:", perimeter)  # გამოიტანს: კვადრატის პერიმეტრი: 20

განმარტება:

side არის int ტიპის ცვლადი.
ფართობისთვის გამოიყენება გამრავლება, ხოლო პერიმეტრისთვის – გამრავლება 4-ზე.
შედეგები int ტიპისაა.

ამოცანა 24: პარალელეპიპედის მოცულობა

გამოთვალეთ პარალელეპიპედის მოცულობა (volume = length * width * height) ცვლადების გამოყენებით.
გამოიყენეთ length = 3, width = 4, height = 5.
გამოაჩინეთ შედეგი.

💡 ამოხსნა

length = 3
width = 4
height = 5
volume = length * width * height  # 3 * 4 * 5 = 60
print("პარალელეპიპედის მოცულობა:", volume)  # გამოიტანს: პარალელეპიპედის მოცულობა: 60

განმარტება:

ყველა ცვლადი (length, width, height) არის int ტიპის.
გამრავლება სრულდება მარცხნიდან მარჯვნივ, ამიტომ ფრჩხილები არაა საჭირო.
შედეგი int ტიპისაა.

ამოცანა 25: კუბის მოცულობა და ფართობი

გამოთვალეთ კუბის მოცულობა (volume = side * side * side) და ზედაპირის ფართობი (surface_area = 6 * side * side) ცვლადის გამოყენებით.
გამოიყენეთ side = 2.
გამოაჩინეთ ორივე შედეგი.

💡 ამოხსნა

side = 2
volume = side * side * side  # 2 * 2 * 2 = 8
surface_area = 6 * side * side  # 6 * 2 * 2 = 24
print("კუბის მოცულობა:", volume)  # გამოიტანს: კუბის მოცულობა: 8
print("კუბის ზედაპირის ფართობი:", surface_area)  # გამოიტანს: კუბის ზედაპირის ფართობი: 24

განმარტება:

side არის int ტიპის ცვლადი.
მოცულობისთვის გამოიყენება სამჯერადი გამრავლება, ხოლო ზედაპირის ფართობისთვის – 6 გვერდის ფართობი.
შედეგები int ტიპისაა.

ამოცანა 26: მართკუთხედის ფართობის განახლება

დავალება: შექმენით ორი ცვლადი length = 10 და width = 5.
გამოთვალეთ მართკუთხედის ფართობი (area = length * width).
შემდეგ გაზარდეთ length 2-ით და width 3-ით შემოკლებული ოპერატორებით (+=) და ხელახლა გამოთვალეთ ფართობი.
გამოაჩინეთ ორივე ფართობი.

💡 ამოხსნა

length = 10
width = 5
area = length * width  # 10 * 5 = 50
print("საწყისი ფართობი:", area)  # გამოიტანს: საწყისი ფართობი: 50

length += 2  # 10 + 2 = 12
width += 3   # 5 + 3 = 8
new_area = length * width  # 12 * 8 = 96
print("განახლებული ფართობი:", new_area)  # გამოიტანს: განახლებული ფართობი: 96

განმარტება:

+= ამარტივებს ცვლადის განახლებას.
ორივე ფართობი int ტიპისაა, რადგან გამოყენებულია მთელი რიცხვები.

ამოცანა 27: პერიმეტრისა და ფართობის შედარება

გამოთვალეთ მართკუთხედის ფართობი (area = length * width) და პერიმეტრი (perimeter = 2 * (length + width)) ცვლადებით length = 7 და width = 3.
შემდეგ გამოიყენეთ შემოკლებული ოპერატორი, რომ გააორმაგოთ length (*= 2) და ხელახლა გამოთვალეთ ფართობი და პერიმეტრი.
გამოაჩინეთ ყველა შედეგი.

💡 ამოხსნა

length = 7
width = 3
area = length * width  # 7 * 3 = 21
perimeter = 2 * (length + width)  # 2 * (7 + 3) = 20
print("საწყისი ფართობი:", area)  # გამოიტანს: საწყისი ფართობი: 21
print("საწყისი პერიმეტრი:", perimeter)  # გამოიტანს: საწყისი პერიმეტრი: 20

length *= 2  # 7 * 2 = 14
new_area = length * width  # 14 * 3 = 42
new_perimeter = 2 * (length + width)  # 2 * (14 + 3) = 34
print("განახლებული ფართობი:", new_area)  # გამოიტანს: განახლებული ფართობი: 42
print("განახლებული პერიმეტრი:", new_perimeter)  # გამოიტანს: განახლებული პერიმეტრი: 34

განმარტება:

*= 2 ორმაგდება length-ის მნიშვნელობა.
ფრჩხილები (length + width) უზრუნველყოფს სწორ პრიორიტეტს.
შედეგები int ტიპისაა.

ამოცანა 28: პარალელეპიპედის მოცულობის განახლება

გამოთვალეთ პარალელეპიპედის მოცულობა (volume = length * width * height) ცვლადებით length = 2, width = 3, height = 4.
შემდეგ გაასამმაგეთ height შემოკლებული ოპერატორით (*= 3) და ხელახლა გამოთვალეთ მოცულობა.
გამოაჩინეთ ორივე მოცულობა.

💡 ამოხსნა

length = 2
width = 3
height = 4
volume = length * width * height  # 2 * 3 * 4 = 24
print("საწყისი მოცულობა:", volume)  # გამოიტანს: საწყისი მოცულობა: 24

height *= 3  # 4 * 3 = 12
new_volume = length * width * height  # 2 * 3 * 12 = 72
print("განახლებული მოცულობა:", new_volume)  # გამოიტანს: განახლებული მოცულობა: 72

განმარტება:

*= 3 ზრდის height-ს სამჯერ.
მოცულობა რჩება int ტიპის, რადგან ყველა ცვლადი მთელი რიცხვია.

რჩევები

ყოველთვის გამოიყენეთ print() შუალედური შედეგების შესამოწმებლად.
გამოიყენეთ აღწერითი ცვლადების სახელები (მაგ.: length, width, area), რათა კოდი იყოს გასაგები.
თუ შეცდომა გაქვთ, ყურადღებით წაიკითხეთ შეცდომის შეტყობინება.
გამოიყენეთ ფრჩხილები რთული გამოსახულებების გასარკვევად.
ყურადღება მიაქციეთ ოპერაციების პრიორიტეტს; გამოიყენეთ ფრჩხილები, თუ არ ხართ დარწმუნებული თანმიმდევრობაში.
სცადეთ სხვადასხვა მნიშვნელობები, რათა ნახოთ, როგორ იცვლება შედეგი.
თუ გამოიყენება მხოლოდ მთელი რიცხვები, შედეგი იქნება int. თუ გაყოფა (/) გამოიყენება, შედეგი float იქნება.

---

🔥 გამოწვევა — დამატებითი ამოცანები (არასავალდებულო)

უფრო რთული — პირველი გაკვეთილის ფარგლებს სცდება

ეს ამოცანები იყენებს input()-ს, math მოდულს და ფორმატირებას (:.2f). სცადე მაშინ, როცა ზემოთ მოცემულ ძირითად ამოცანებს უკვე თავს გაართმევ.

გამოწვევა 1: პითაგორას თეორემა

შექმენით პროგრამა, რომელიც ითვლის სამკუთხედის ჰიპოტენუზის სიგრძეს პითაგორას თეორემის გამოყენებით (c = √(a² + b²)). გამოიყენეთ ორი ცვლადი a და b (კათეტები) და math.sqrt() ფუნქცია ფესვის გამოსათვლელად. გამოიტანეთ შედეგი.

💡 ამოხსნა

import math

a = 3
b = 4
c = math.sqrt(a ** 2 + b ** 2)  # 3² + 4² = 9 + 16 = 25, √25 = 5
print("ჰიპოტენუზა:", c)  # გამოიტანს: ჰიპოტენუზა: 5.0

მითითება:

math.sqrt()-ის გამოსაყენებლად საჭიროა import math.
დარწმუნდით, რომ a და b დადებითი რიცხვებია.
შედეგი იქნება float.

გამოწვევა 2: ნარჩენის გამოთვლა

შექმენით პროგრამა, რომელიც ამოწმებს, არის თუ არა რიცხვი n 3-ის ჯერადი, % ოპერატორის გამოყენებით. თუ ნაშთი 0-ია, გამოიტანეთ „3-ის ჯერადია“.

💡 ამოხსნა

n = 9
if n % 3 == 0:
    print(n, "არის 3-ის ჯერადი")  # გამოიტანს: 9 არის 3-ის ჯერადი
else:
    print(n, "არ არის 3-ის ჯერადი")

მითითება:

გამოიყენეთ % ნაშთის გამოსათვლელად.
სცადეთ სხვადასხვა n-ის მნიშვნელობები.

გამოწვევა 3: პითაგორას თეორემა (გაფართოებული)

შექმენით პროგრამა, რომელიც ითვლის სამკუთხედის ჰიპოტენუზას a და b კათეტებიდან. სთხოვეთ მომხმარებელს, შეიყვანოს a და b (input() ფუნქციით), გადააქციეთ ისინი float-ად, გამოთვალეთ ჰიპოტენუზა და გამოიტანეთ შედეგი ორი ათობითი ნიშნის სიზუსტით (:.2f).

💡 ამოხსნა

import math

a = float(input("შეიყვანეთ პირველი კათეტი: "))  # მაგ.: 6
b = float(input("შეიყვანეთ მეორე კათეტი: "))   # მაგ.: 8
c = math.sqrt(a ** 2 + b ** 2)
print(f"ჰიპოტენუზა: {c:.2f}")  # გამოიტანს: ჰიპოტენუზა: 10.00

მითითება:

input() აბრუნებს სტრიქონს, ამიტომ გამოიყენეთ float() გარდაქმნისთვის.
{c:.2f} ფორმატირება გამოაქვს რიცხვი ორი ათობითი ნიშნით.
დარწმუნდით, რომ შეყვანილი მნიშვნელობები დადებითია.

გამოწვევა 4: ფარენჰაიტიდან ცელსიუსში გარდაქმნა

შექმენით პროგრამა, რომელიც გარდაქმნის ტემპერატურას ფარენჰაიტიდან ცელსიუსში (C = (F - 32) * 5 / 9). სთხოვეთ მომხმარებელს, შეიყვანოს ფარენჰაიტის მნიშვნელობა, გამოთვალეთ ცელსიუსი და გამოიტანეთ შედეგი.

💡 ამოხსნა

fahrenheit = float(input("შეიყვანეთ ტემპერატურა ფარენჰაიტში: "))  # მაგ.: 98.6
celsius = (fahrenheit - 32) * 5 / 9
print(f"ტემპერატურა ცელსიუსში: {celsius:.2f}")  # გამოიტანს: ტემპერატურა ცელსიუსში: 37.00

მითითება:

გამოიყენეთ ფრჩხილები (fahrenheit - 32) პრიორიტეტის გასაკონტროლებლად.

გამოწვევა 5: მანძილის გამოთვლა

შექმენით პროგრამა, რომელიც ითვლის ორ წერტილს შორის მანძილს კოორდინატთა სიბრტყეზე (distance = √((x2 - x1)² + (y2 - y1)²)). სთხოვეთ მომხმარებელს, შეიყვანოს x1, y1, x2, y2 და გამოაჩინეთ მანძილი :.2f ფორმატით.

💡 ამოხსნა

import math

x1 = float(input("შეიყვანეთ x1: "))  # მაგ.: 0
y1 = float(input("შეიყვანეთ y1: "))  # მაგ.: 0
x2 = float(input("შეიყვანეთ x2: "))  # მაგ.: 3
y2 = float(input("შეიყვანეთ y2: "))  # მაგ.: 4
distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(f"მანძილი: {distance:.2f}")  # გამოიტანს: მანძილი: 5.00

მითითება:

ეს ამოცანა იყენებს პითაგორას თეორემას. გამოიყენეთ math.sqrt() და ფრჩხილები სწორი პრიორიტეტისთვის.