თავი 4 (4,10 - 4,11)

4.10 ნაყოფიერი ფუნქციები და გაბათილებული ფუნქციები

ზოგიერთი ფუნქცია რომელსაც ვიყენებთ, როგორიცაა მათ. ფუნქცია აწარმოებს შედეგებს. ასეთ ფუნქციებს ვეძახით ნაყოფიერ ფუნქციას (fruitful functions). სხვა ფუნქციები, მაგალითად print_twice,  რაღაცას აკეთებს, მაგრამ არ აბრუნებს მნიშვნელობას. ამათ ეძახიან გაბათილებულ ფუნქციებს (void functions.)

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

x = math.cos(radians)

golden = (math.sqrt(5) + 1) / 2

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

>>> math.sqrt(5)

2.2360679774997898

მაგრამ სკრიპტში, ნაყოფიერ ფუნქციას თუ გამოიძახებ და ფუნქციის  შედეგს (return value, result)ცვლადში თუ არ შეინახავ, მნიშვნელობა გაქრება ნისლში!

math.sqrt(5)

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

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

>>> result = print_twice('Bing')

Bing

Bing

>>> print result

None

მნიშვნელობა None არაა იგივე რაც სტრინგი "None", ამას აქვს სპეციალური მნიშვნელობა რომელსაც აქვს თავისი ტიპი:

>>> print type(None)

<type 'NoneType'>

ფუნქციაში შედეგი  რომ დააბრუნო , ფუნქციაში ვიყენებთ return ბრძანებას. მაგალითად, შეგვიძლია გავაკეთოთ მარტივი ფუნქცია სახელად addtwo , რომელიც ორ ციფრს ერთმანეთს მიუმატებს და დააბრუნებს შედეგს:

def addtwo(a, b):

      added = a + b

      return added

x = addtwo(3, 5)

print x

ეს სკრიპტი როცა განხორციელდება, print  ბრძანება ამობეჭდავს 8 - ს, იმიტომ რომ addtwo  ფუნქცია გამოძახებული იყო  არგუმენტებით 3 და 5.  ფუნქციის შიგნით პარამეტრები a და b  შესაბამისად იყო 3 და 5 . ფუნქციამ გამოთვალა ჯამი ორი ციფრის და მოათავსა ლოკალურ ფუნქციის ცვლადში სახელად added და გამოიყენა ბრძანება return რომ დათვლილი მნიშვნელობა გაეგზავნა უკან გამოძახების კოდში (back to the calling code) როგორც ფუნქციის შედეგი რომელიც მიენიჭა ცვლადს x და ამოიბეჭდა.

4.11 რატომ ფუნქციები?

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

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

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

·         დიდი პროგრამის ფუნქციებად დაყოფა  გაძლევთ საშუალებას რომ გამართოთ ნაწილები სათითაოდ და შემდეგ შეკრათ ერთ მთლიანად.

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

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