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

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

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

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

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

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

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

🆚 Ctrl+O

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

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

მაგალითი:# ცვლადის გამოცხადება 
name = "გიორგი"  # სტრიქონი
age = 20         # მთელი რიცხვი (int)
height = 1.75    # წილადი რიცხვი (float)
print(name, age, height)  # გამოიტანს: გიორგი 20 1.75

განმარტება:

ცვლადის სახელი უნდა იყოს აღწერითი, მაგ.: 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})

მაგალითი:x = 10 # int 
y = 2.5         # float 
text = "სალამი" # str 
is_valid = True # bool 
print(type(x), type(y), type(text), type(is_valid))  
# გამოიტანს: <class 'int'> <class 'float'> <class 'str'> <class 'bool'>

განმარტება:

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).
ყოველთვის გამოიყენეთ აღწერითი სახელები, რომლებიც არ ემთხვევა ამ სიტყვებს.

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

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

#მაგალითი:
a = 10
b = 3

print("მიმატება:", a + b)      # გამოიტანს: 13
print("გამოკლება:", a - b)     # გამოიტანს: 7
print("გამრავლება:", a * b)    # გამოიტანს: 30
print("გაყოფა:", a / b)        # გამოიტანს: 3.3333333333333335
print("მთელი გაყოფა:", a // b) # გამოიტანს: 3
print("ნაშთი:", a % b)          # გამოიტანს: 1
print("ხარისხი:", a ** b)       # გამოიტანს: 1000

განმარტება:

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

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

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

მაგალითი:x = 5
x += 3   # იგივეა, რაც x = x + 3
print(x) # გამოიტანს: 8

x *= 2   # იგივეა, რაც x = x * 2
print(x) # გამოიტანს: 16

x //= 3  # იგივეა, რაც x = x // 3
print(x) # გამოიტანს: 5

განმარტება:

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

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

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

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

Warning

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

მაგალითი:
result1 = 2 + 3 * 4     
# 3 * 4 = 12, შემდეგ 2 + 12 = 14 
print(result1)         
# გამოიტანს: 14

result2 = (2 + 3) * 4 
# 2 + 3 = 5, შემდეგ 5 * 4 = 20
print(result2)         
# გამოიტანს: 20

result3 = 2 ** 3 * 2  
# 2 ** 3 = 8, შემდეგ 8 * 2 = 16
print(result3)         
# გამოიტანს: 16

განმარტება:

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

ამოცანები

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

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

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

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

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

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

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

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

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

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

დავალება: გამოთვალეთ გამოსახულება 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

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

დავალება: შექმენით რამდენიმე ცვლადი (მაგ.: 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'>

რჩევები:

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

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

შექმენით ოთხი ცვლადი: 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

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

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

მაგალითი:
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-ს.

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

შექმენით ცვლადი 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-ს, თუ გაყოფის შედეგი წილადია.

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

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

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

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

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

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

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

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

ამოცანა: სტუდენტის 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-ს, მაშინაც კი, თუ შედეგი მთელი რიცხვია.

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

შექმენით პროგრამა, რომელიც ითვლის რიცხვის 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-იც.

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

შექმენით ცვლადი 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) /= ოპერაციის შემდეგ.

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

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

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

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

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

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

გამოთვალეთ, რა ნაშთი რჩება, როცა რიცხვი 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 ტიპისაა.

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

გარდაქმენით ტემპერატურა ფარენჰაიტიდან ცელსიუსში ფორმულის გამოყენებით: 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-ს.

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

გარდაქმენით ტემპერატურა ცელსიუსიდან ფარენჰაიტში ფორმულის გამოყენებით: 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 ტიპისაა გაყოფის გამო.

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

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

მაგალითი:

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

განმარტება:

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

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

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

მაგალითი:

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

განმარტება:

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

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

გარდაქმენით მანძილი მეტრებიდან ფუტებში.
გამოიყენეთ ცვლადი 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 ტიპისაა.

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

შექმენით ცვლადი 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-ს.

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

გამოთვალეთ მართკუთხედის ფართობი (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 ტიპისაა, რადგან გამოყენებულია მხოლოდ მთელი რიცხვები.

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

გამოთვალეთ კვადრატის ფართობი (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 ტიპისაა.

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

გამოთვალეთ პარალელეპიპედის მოცულობა (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 ტიპისაა.

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

გამოთვალეთ კუბის მოცულობა (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 ტიპისაა.

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

დავალება: შექმენით ორი ცვლადი 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 ტიპისაა, რადგან გამოყენებულია მთელი რიცხვები.

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

გამოთვალეთ მართკუთხედის ფართობი (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 ტიპისაა.

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

გამოთვალეთ პარალელეპიპედის მოცულობა (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 იქნება.

დასასრული

---

---

---

რთულია:

არ ვაკეთებთ

ამოცანა : პითაგორას თეორემა

შექმენით პროგრამა, რომელიც ითვლის სამკუთხედის ჰიპოტენუზის სიგრძეს პითაგორას თეორემის გამოყენებით (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.

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

შექმენით პროგრამა, რომელიც ამოწმებს, არის თუ არა რიცხვი n 3-ის ჯერადი, % ოპერატორის გამოყენებით. თუ ნაშთი 0-ია, გამოიტანეთ „3-ის ჯერადია“. მაგალითი:n = 9 if n % 3 == 0: print(n, "არის 3-ის ჯერადი") # გამოიტანს: 9 არის 3-ის ჯერადი else: print(n, "არ არის 3-ის ჯერადი")

მითითება:

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

ამოცანა : პითაგორას თეორემა (გაფართოებული)

შექმენით პროგრამა, რომელიც ითვლის სამკუთხედის ჰიპოტენუზას 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} ფორმატირება გამოაქვს რიცხვი ორი ათობითი ნიშნით.
დარწმუნდით, რომ შეყვანილი მნიშვნელობები დადებითია.

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

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

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

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

შექმენით პროგრამა, რომელიც ითვლის ორ წერტილს შორის მანძილს კოორდინატთა სიბრტყეზე (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() და ფრჩხილები სწორი პრიორიტეტისთვის.