თავი 2 | ფუნქციები და პირობითი ოპერატორები

რა არის ფუნქცია?!

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

რას ნიშნავს ფუნქციის განსაზღვრა?!

ფუნქციის განსაზღვრა ნიშნავს ფუნქციის აბსტრაქტული ჩანაწერის გაკეთებას def სიტყვის გამოყენებით, მაგალითად:

def my_function():
  ...

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

რა არის პარამეტრი?!

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

def my_function(var):
  ...

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

რა არის ფუნქციის scope-ი?!

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

def my_function(var):
  instruction_1(... var ...)
  instruction_2(... instruction_1 ...)
    instruction_3(... ... ...)
      ... ... ... (... ... ...)

პირველი და მეორე ინსტრუქციები ოთხი გამოტოვებით(თაბ ღილაკზე ერთხელ დაჭერა = ოთხ სივრცეს) ანუ ერთი იდენტაციით მარჯვნივაა წანაცვლებული, მესამე ინსტრუქცია ორი იდენტაციით, ხოლო მეოთხე სამით; შეგვიძლია მაგალითად მოვიყვანოთ ასეთი კონსტრუქცია:

განსაზღვრა ჩემი_ფუნქცია(პარამეტრი): ინსტუქცია_1(... პარამეტრი …) ინსტუქცია_2(... … …) ინსტუქცია_3(... … …) ინსტუქცია_3_1(... … …) ინსტუქცია_3_2(... … …) ინსტუქცია_3_2_1(... … …) … … … … … … … (… … …)

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

def my_function(var):
  instruction_1(... var ...)
  instruction_2(... instruction_1 ...)
    instruction_3(var ... instruction_2)
      return instruction_3

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

რა ნიშნავს ფუნქციის გამოძახება და რა არის არგუმენტი?!

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

my_function(2)
my_function(input("Enter your integer: ")

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

რა არის ლოკალური და გლობალური ცვლადი?!

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

def my_function(var):			
  instruction_1(... var ...)
  instruction_2(... instruction_1 ...)
  num = instruction_3(var ... instruction_2)
    instruction_3_1(... instruction_3 ...)
      return instruction_3_1

ამ შემთხვევაში var და num ცვლადები არიან ლოკალური ცვლადები რაც ნიშნავს იმას, რომ "my_function()" ფუნქციის სხეულის-სქოუფის გარეთ მათ ვერ გამოვიყენებთ. გლობალური ცვლადი არის ცვლადი რომელიც გლობალურ სივრცეშია განსაზღვრული ანუ სივრცეში რომელიც არც ერთ სქოუფში არ ხვდება და შესაბამისად ისინი ყველგან ჩანან, მაგალითად:

user_input = input("Enter your integer: ")
def my_function():			
  instruction_1(... user_input ...)
  instruction_2(... instruction_1 ...)
  num = instruction_3(user_input ... instruction_2)
    instruction_3_1(... instruction_3 ...)
      return instruction_3_1
def your_function():			
  instruction_1(... user_input ...)
  instruction_2(... instruction_1 ...)
    return instruction_2(... instruction_1 ...)
my_function()
your_function()

ამ შემთხვევაში user_input არის გლობალურ სივრცეხი განსაზღვრული ცვლადი რომელიც განსაზღვრული ფუნქციების სქოუფებში ჩანს.

ჩაშენებული ფუნქცია და დასახელებული პარამეტრები?!

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

print()

დასახელებული ცვლადი არის ცვლადი რომელიც ფუნქციას გაწერილი აქვს რაიმე დეფაულტ მნიშვნელობაზე და ჩვენ ჩვენ საჭიროების მიხედვით შეგვილია ჩვენი სურვილისამებრ ჩავანაცვლოთ ან საერთოდ გავაუქმოთ დეფაულტად გაწერილი მნიშვნელობა, მაგალითად:

print("hello", "world")

აუთფუთი იქნება:

hello world

ხოლო მაგალითად:

print("hello", "world", sep="-", end="!!!\n")

აუთფუთი იქნება:

hello-world

ანუ print() ფუნქციის დასახელებული პარამეტრებია sep და end ხოლო მათთვის გაწერილი მნიშვნელობებია " " და "\n" შეასბამისად

როგორი ფუნქციები შეგვხვდება დავალებებში?!

1 - ფუნქცია რომელიც ღებულობს ინფუთს და აბრუნებს აუთფუთს

def sqr_funtion(var):
  return var * var
print(sqr_function(2))

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

2 - ფუნქცია რომელიც ღებულობს ინფუთს და არაფერს აბრუნებს

def sqr_funtion(var):
  print(var * var)
sqr_function(2)

3 - ფუნქცია რომელიც არ ღებულობს ინფუთს და აბრუნებს აუთფუთს

def sqr_funtion():
  var = int(input("Enter your integer: "))
  return var * var
print(sqr_function())

4 - ფუნქცია რომელიც არც ინფუთს ღებულობს და არც აუთფუთს აბრუნებს

def main():
  var = int(input("Enter your integer: "))
  print(sqr_function(var))
def sqr_funtion(var):
  return var * var
main()

რა არის პირობითი ოპერატორი?!

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

თუ ხვალ არ იწვიმებს და ძაღლიც მოწყენილი იქნება:
	მე და ძაღლი გავისეირნებთ
ან თუ იწვიმებს და ძაღლი მოწყენილი იქნება:
	ძაღლს სახლში ვეთამაშები
დანარჩენ შემთხვევებში:
	სავარჯიშოდ წავალ

პითონური ჩანაწერის კონსტრუქცია იქნებოდა:

if … … …:
	…
elif … … …:
	…
else:
	…

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

if condition1:
	instruction1
elif condition2:
	instruction2
elif condition3:
	instruction3
	instruction8
elif condition4:
	instruction4
elif condition5:
	instruction5
else:
	instruction6
	instruction7

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

აღნიშნული კონსტრუქცია კერძო შემთხვევებში შეიძლება ჩანაცვლებული იყოს or ოპერატორის გამოყენებით ამ კონსტრუქციით:

if condition1 or condition2 or condition3 or condition4:
	instruction1
else:
	instruction2

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

or ოპერატორის and ოპერატორით ჩანაცვლების შემთხვევაში იგივე კოსტრუქციის ლოგიკა შეიცვლება ისეთნაირად, რომ if ოპერატორის უკლებლივ ყველა პირობა უნდა შესრულდეს, რომ შესაბამისი ინსტრუქცია განხორციელდეს, მაგალითად:

if condition1 and condition2 and condition3 and not condition4:
	instruction1
else:
	instruction2

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

if condition1:
	if condition2:
		if condition3:
			if condition4:
				if condition5:
					instruction1
else:
	instruction2

თუ რამოდენიმე პირობა ერთმანეთისგან დამოუკიდებლად ერთდროულად შეიძლება დადგეს და ამიტომ მათი ცალ-ცალკე შემოწმებაა საჭირო შეგვიძია ასეთი კონსტრუქცია გამოვიყენოთ:

if condition1:
	instruction1
if condition2:
	instruction2
if condition3:
	instruction3
if condition4:
	instruction4
if condition5:
	instruction5
else:
	instruction6

აღსანიშნავია, რომ else ოპერატორის მეექვსე ინსტრუქცია მხოლოდ იმ შემთხვევაში აღსრულდება თუ არ აღსრულდება მეხუთე პირობა, დანარჩენ პირობებთან მას კავშირი არ აქვს.