Функції у

Про концепцію Функції

function - це блок організованого коду, який використовують повторно для виконання конкретного завдання. Functions забезпечують кращу модульність застосунку й високий рівень повторного використання коду. Python, як і інші мови програмування, має вбудовані функції (print, map тощо), які доступні одразу. Ми також можемо визначати власні функції. Такі функції називають user-defined functions. Функції можуть робити щось таке просте, як виведення повідомлення в консоль, а можуть бути й досить складними.

Щоб виконати код усередині функції, потрібно викликати функцію: для цього пишемо назву функції, а потім дужки [()]. Дані, відомі як arguments, можна передати функції, розмістивши їх усередині дужок. Визначення функції може містити нуль або більше parameters. Параметри визначають, які аргументи приймає функція. Параметр визначає, якого типу має бути переданий аргумент. Аргумент - це фактичне значення, яке передають під час виклику функції. Функції можуть виконувати різні завдання залежно від аргументів, переданих параметрам.

Функція також може повернути значення за допомогою ключового слова return. Значення, яке повертає функція, називають return value. Повернене значення повертається тому, хто викликав функцію.

Створення

У Python функції створюють за допомогою ключового слова def. Після визначення функції йдуть назва функції та дужки [()]. Усередині дужок вказують параметри, розділені комами. Після закривної дужки двокрапка (:) відокремлює сигнатуру функції від тіла функції.

Тіло функції - це блок коду, який виконується під час виклику функції. Тіло функції має відступ. Відступ важливий, бо Python покладається на нього, щоб визначити, де закінчується блок коду. Значення можна повернути з функції за допомогою ключового слова return, і ним потім може скористатися той, хто викликав функцію.

def function_name(parameter1, parameter2, ...):
    # function body
    return parameter1 + parameter2

Ми також можемо визначити функцію без параметрів і без поверненого значення.

def function_name():
    # function body
    pass

Зауважмо, що функції все ж потрібне тіло, навіть якщо воно нічого не робить, інакше спроба запустити програму спричинить помилку відступу:

>>> def my_bodyless_func():
...      

File ~/temp.py:1
    
    ^
IndentationError: expected an indented block

Виклик функції

Щоб викликати функцію, пишемо назву функції, а потім дужки [()]. Параметри, які передають функції, розміщують усередині дужок, розділяючи комами.

Розгляньмо таку функцію:

def greet():
    print("Hello")

Наведену вище функцію можна викликати за допомогою такого синтаксису:

>>> greet()
Hello

Параметри та їхні аргументи

Аргументи - це значення, які передають функції під час її виклику. Вони можуть бути будь-якого типу даних, зокрема іншими функціями чи класами.

Визначмо функцію add, яка додає два числа:

def add(first, second):
    print(first + second)

Параметри first і second визначають, які аргументи прийматиме функція add. (Зауважмо, що слова parameter та argument часто вживають як взаємозамінні, хоч і неточно.) Коли функцію викликають, аргументи передають їй. Потрібно передати аргументи для обох параметрів, інакше буде викликано TypeError.

>>> add(2, 3)
5

# Function can be called multiple times, with different parameters
>>> add(4, 3)
7
>>> add(5, 6)
11

# Passing an incorrect number of parameters will raise a `TypeError`
>>> add(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'second'

>>> add(2, 3, 4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes 2 positional arguments but 3 were given

Повернене значення

Повернене значення - це значення, яке повертають тому, хто викликав функцію. return value може бути будь-якого типу даних, зокрема іншою функцією чи класом. Його може використати той, хто викликав функцію, для подальших операцій. Якщо функція явно не визначає return value, інтерпретатор Python поверне значення None.

Визначмо функцію add:

def add(first, second):
    return first + second

Ми можемо зберегти повернене значення у змінній і потім вивести його:

>>> result = add(2, 3)
>>> print(result)
5
# Type of result is `int`
>>> type(result)
<class 'int'>

# We can also perform operations on the return value
>>> result * 2
10

# A function without an explicit return value will return `None`
>>> def log(message):
    print(message)

# Hello is printed because of print(message), but return value is `None`
>>> return_value = log("Hello")
Hello
>>> return_value
None

Використання return негайно завершує виконання функції й повертає значення тому, хто її викликав.

>>> def show(first, second):
    print(first)
    return first
    print(second)

# second never gets printed, because the function exits after the return statement
>>> show(1, 2)
1

Модульність

Складні програми можна розбити на менші частини. Різні функції можна використовувати для виконання різних конкретних завдань.

Припустімо, програма має виконати такі завдання:

• Обчислити площу круга
• Обчислити площу прямокутника
• Обчислити площу трикутника

Ми можемо розбити програму на менші частини.

def circle_area(radius):
    return 3.14 * radius * radius

def rectangle_area(length, breadth):
    return length * breadth

def triangle_area(base, height):
    return 0.5 * base * height

Тепер ми можемо викликати функції в потрібному порядку.

>>> circle_area(2)
12.56
>>> triangle_area(2, 3)
3.0
>>> rectangle_area(2, 3)
6
>>> rectangle_area(1, 2) + circle_area(2) + triangle_area(1, 2)
15.56

Область видимості змінних

Якщо змінну (або імʼя) визначено всередині функції, вона буде доступною лише всередині області видимості функції (або локального простору імен), навіть якщо за межами області видимості функції є змінна з тією самою назвою.

Змінні, визначені поза функцією на рівні модуля, належать до глобального простору імен. Змінні, визначені поза функцією, але всередині зовнішньої функції чи класу, належать до нелокального простору імен.

Python використовує правило LEGB (Local, Enclosing, Global, Built-in), щоб визначити назви змінних під час роботи програми:

1. Пошук у локальному (або функціональному) просторі імен.
2. Пошук у зовнішньому (або нелокальному) просторі імен, якщо назву не знайдено в локальному.
3. Пошук у глобальному просторі імен (рівень модуля), якщо назву не знайдено в нелокальному/зовнішньому.
4. Пошук у вбудованому (загальнопрограмному або загальному для Python) просторі імен, якщо назву не знайдено в глобальному.

Якщо назву так і не вдалося визначити, Python викличе NameError exception.

# Global namespace.
general_favorite = "apples"


def alices_favorite():
   # Local namespace.  
   favorite = "cherries"
   
   # This works because Python will eventually find general_favorite in the global namespace.
   # Python will find 'print' in the built-in namespace.
   print(f'Alice has always liked {favorite}, but most people like {general_favorite}.')

   
def our_favorite_fruits():
    # Enclosing or nonlocal namespace.
    yours = "peaches"
    
    def my_favorite():
        # Local namespace.
        mine = "pears"
        
        # This works because Python will eventually find 'yours' in the enclosing/nonlocal namespace.
        print(f'My favorite is {mine}, but you like {yours} instead.')
        
        # This works because Python will eventually find 'general_favorite' in the global namespace.
        print(f'Everyone seems to like {general_favorite}')
    
    # This function is in the local namespace of the 'our_favorite_fruits' function.  
    my_favorite()

    
# This will raise NameError: name 'favorite' is not defined, because the variable favorite is local to alices_favorite.
print(favorite)

Якщо ми хочемо зробити назву змінної доступною поза локальною областю видимості функції (або змінити змінну, визначену поза областю видимості функції), потрібно використати одне з ключових слів global або nonlocal.

Використання ключового слова global вказує Python почати пошук у глобальному просторі імен. Присвоєння цій змінній тоді змінюватимуть глобальну змінну, а не створюватимуть локальну версію. Коли global використовують для оголошення змінної, цю змінну додають до глобального простору імен. Тож global варто використовувати обережно, бо додавання чи зміна глобальної змінної може вплинути на весь інший код, який використовує її значення.

Ключове слово nonlocal вказує Python шукати або створювати змінну в нелокальному чи зовнішньому просторі імен. Його використовують, коли функція вкладена в іншу функцію чи клас і потребує доступу до змінних і області видимості зовнішньої функції.

Функції як обʼєкти першого класу

У Python функції можна присвоювати змінним і передавати як аргументи іншим функціям. Їх можна використовувати як повернені значення. Функції також можна розміщувати в послідовності (list, tuple тощо) або як значення в dict. Функції можна використовувати будь-де, де можна використати будь-який інший обʼєкт. Це тому, що функції є обʼєктами першого класу. Як такі, вони мають спеціальні атрибути й навіть можуть визначати отримання та встановлення власних атрибутів.

# print is a function

# A function can be assigned to a variable.
>>> function_as_variable = print
>>> function_as_variable("Hello")
Hello
>>> type(fake_print)
<class 'builtin_function_or_method'>

# Functions can be passed as an argument to another function.
>>> def check_print(func):
    func("Hello")
>>> check_print(print)
Hello

# Function can be used as an item in a sequence.
>>> my_list = [print, "Hello"]
>>> my_list[0]("Hello")
Hello

# Functions can be used as a value in a dictionary.
>>> my_dict = {"key": print}
>>> my_dict["key"]("Hello")
Hello

# Functions can be returned from a function.
>>> def return_func():
    return print
>>> return_func()("Hello")
Hello

Функції також можна вкладати в інші функції.

def outer():
    num = 10
    
    # This is a nested, or "inner" function.
    def inner():
        print(num)
    
    # Outer function calling inner function
    inner()

Внутрішня функція може отримати доступ до змінної num, визначеної в зовнішній функції.

>>> outer()
10

Спеціальні атрибути

Функції в Python мають спеціальні атрибути. Ось деякі з них:

• __name__: назва функції
• __doc__: рядок документації функції
• __module__: модуль, у якому визначено функцію
• __globals__: словник глобальних змінних у функції
• __code__: обʼєкт коду, що містить інструкції функції

>>> def add(first, second):
      return first + second

# Function name
>>> print.__name__
'print'
>>> len.__name__
'len'
>>> add.__name__
'add'

# Function documentation
>>> abs.__doc__
'Return the absolute value of the argument.'

# Module
>>> len.__module__
'builtins'
>>> add.__module__
'__main__'

Повний перелік атрибутів функцій можна знайти в Python DataModel.