Python ua:Функції

Вступне слово

Функції — шматки програми, які можна неодноразово використовувати. Вони дають тобі змогу надати ім’я для блоку інструкцій і тоді ти зможеш виконувати цей іменований блок коду будь-де і будь-коли в твоїй програмі. Для цього потрібно буде просто вказати ім’я функції. Це називається  викликом функції. Ми вже використали багато вбудованих функцій, таких як len і range.

Концепція функцій є напевно найбільш важливим будівельним блоком будь-якої не тривіальної програми (в будь-якій мові програмування), тож ми розглянемо різні аспекти функцій в цьому розділі.

Функції визначаються за допомогою ключового слова def. Для того щоб створити функцію потрібно розмістити ключове слово def перед ідентифікатором функції (її ім’ям), потім вказати пару дужок всередині яких можуть міститися імена змінних (аргументи функції), в кінці рядка дві крапки. Після двох крапок (в новому фізичному ряду) йде блок інструкцій, який є тілом функції. На прикладі ти побачиш, що це насправді дуже просто.

Приклад:

#!/usr/bin/python3
# Filename: function1.py

def sayHello():#sayHello — ім’я функції
#цей код належить функції.
#Він виконується кожен раз, коли функція викликається.
#Його ще називають тілом функції
     print('Hello world!')
     #кінець функції        
        
sayHello() # викликаємо функцію
sayHello() # викликаємо функцію знову

Виведе:

$ python function1.py Hello World! Hello World!

Як це працює:

Ми визначили функцію яка називається sayHello використовуючи синтаксис про який говорилося трохи вище. Ця функцій не приймає жодних параметрів тому в дужках не оголошено жодної змінної. Параметри для функцій це просто вхідні дані які вона якимось чином опрацьовує. Тому ми можемо надати їй ці дані і отримати назад відповідні результати.

Зауваж, що ми викликали одну й ту ж функцію двічі, що означає що нам не потрібно знову писати один і той самий код.

Параметри функції

Функції можуть приймати параметри. Параметри це значення які ти передаєш функції. Таким чином функції можуть робити щось, опрацювуючи ці значення. Ці параметри, це не що інше, як змінні значення яких визначаються коли ми викликаємо функцію.

Параметри вказуються всередині пари дужок при визначенні функції. Якщо параметрів декілька, то вони розділяються комами. При виклику функції аргументи передаються так само. Зважай на термінологію – імена змінних, які використовуються при визначенні функції називаються параметрами, тим часом як змінні які передаються під час виклику функції називаються аргументами.

Приклад:

        #!/usr/bin/python
        # Filename: func_param.py
        def printMax(a, b):
                if a > b:
                        print(a, 'is maximum')
                elif a == b:
                        print(a, 'is equal to', b)
                else:
                        print(b, 'is maximum')

        printMax(3, 4) #аргументи — літеральні константи

        x = 5
        y = 7

        printMax(x, y) #змінні як аргументи
               
        

Виведе:

                
        $ python func_param.py
        4 is maximum
        7 is maximum
               
 
        

Як це працює:

В цій програмі ми визначили функцію з іменем printMax яка приймає два параметри з іменами a і b. Ми визначаємо яке число більше використовуючи просту if…else конструкцію і потім виводимо більше число.

При першому виклику printMax в якості аргументів були використані числа (не змінні). Другого разу функція викликається із змінними в якості параметрів. Значення аргументу x буде присвоєно параметру a, а значення аргументу y стане значенням параметру b.

Локальні змінні

Коли ти оголошуєш змінні всередині визначення функції, то вони жодним чином не відносяться до інших змінних з такими ж іменами які знаходяться зовні функції. Іншими словами: імена змінних є локальними по відношенню до функції (вони існують тільки під час виконання функції всередині якої вони містяться). Це називається областю видимості змінних. Всі змінні мають область видимості яка відповідає області видимості блоку всередині якого вони оголошені, починаючи з того місця де було визначено ім’я змінної. Змінні оголошені поза межами функції чи класу є глобальними для даного модуля (програми). І доступні з будь-якого місця всередині цього модуля

Приклад:

        #!/usr/bin/python
        # Filename: func_local.py

        x = 50
        def func(x):
                print('x is', x)
                x = 2
                print('Changed local x to', x)
        func(x)
        print('x is still', x)

Виведе:

        $ python func_local.py
        x is 50
        Changed local x to 2
        x is still 50

Як це працює:

Першого разу, коли ми використали значення змінної x, Python взяв значення параметра оголошеного в функції.

Далі ми присвоїли число 2 змінній x. Ім’я x є локальним для нашої функції. Тому, коли ми змінюємо значення x всередині функції, x визначений в головному блоці залишаєтсья незмінним.

Останній виклик функції print вивів значення x з головного блоку і таким чином ми переконалися, що значення змінної не змінилося.

Використання оператора global

Якщо ти хочеш змінити значення змінної яка визначена на найвищому рівні програми (тобто не всередині функції чи класу), тоді тобі треба сказати Python, що ім’я це не локальне, а глобальне. Це досягається за рахунок оператору global. Неможливо привласнити значення змінній яка визначена ззовні функції із самої функції, не використавши оператор global.

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

Зауваження: неможливо використовувати оператор global і одночасно привласнювати значення змінній, тобто не дозволено писати global x=3 але можна global x; x = 3;.

Приклад:

        #!/usr/bin/python
        # Filename: func_global.py
        x = 50
        def func():
                global x
                print('x is', x)
                x = 2
                print('Changed global x to', x)
        func()
        print('Value of x is', x)
                
        

Виведе:

                
        $ python func_global.py
        x is 50
        Changed global x 
to 2
        Value of x is 2
                
        

Як це працює:

Оператор global використаний для того щоб оголосити, що x це глобальна змінна. Таким чином використовуються змінна x саме з глобальної області видимості, а не однойменна змінна, яка належить функції.

Можна використати декілька імен змінних з одним операторм global. Наприклад, global x, y, z.

Викорисатання оператора nonlocal

Ми побачили як отримати доступ до змінних всередині локальних і глобальних областей видимості. Але існує ще один тип області видимості яка називається "не локальною" областю видимості. Не локальна область досягається тоді коли ти визначаєш функцію всередині іншої функції. Оператор nonlocal оголошує (робить доступними) ті змінні, які знаходяться в області видимості "батьківської" функції.

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

Давай розглянемо наступний приклад:

#!/usr/bin/python
# Filename: func_nonlocal.py
        def func_outer():
                x = 2
                print('x is', x)
        def func_inner():
                nonlocal x
                x = 5
func_inner()
print('Changed local x to', x)
func_outer()
        

Виведе:

                
$ python func_nonlocal.py
x is 2
Changed local x to 5
                
        

Як це працює:

Про змінну x визначену в першому рядку функції func_outer можна сказати, що вона не глобальна, і в той же час не локальна, по відношенню до функції func_inner, але завдяки оператору nonlocal ми все ж таки отримали до неї доступ.

Типові значення аргументів

Для деяких функцій ти можеш захотіти зробити деякі з параметрів необов’язковими і використовувати для них типові значення, у тому випадку якщо користувач не надав значення для подібних параметрів. Для визначення типового значення аргументу потрібно після імені параметра написати оператор присвоєння (=) і вказати значення, яке буде використано за відсутності відповідного значення від коритсувача.

Май на увазі, що типове значення аргументу має бути константою. Якщо бути точнішим, типове значення повинно бути незмінним (пояснення чому так в наступних розділах). Поки просто запам’ятай це.

Приклад:

#!/usr/bin/python
# Filename: func_default.py

def say(message, times = 1):
        print(message * times)
say('Hello')
say('World', 5)
        

Вивід:

                
$ python func_default.py
Hello
WorldWorldWorldWorldWorld
                
        

Як це працює:

Функція з іменем say виводить на екран якийсь рядок стільки разів скільки ми захочемо. Якщо не передавати другий аргумент, тоді, типово, рядок буде виведено лише один раз.

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

Важливо

Тільки ті параметри, які знаходяться в кінці списку параметрів можуть мати типові значення. Не можна мати параметр з типовим значенням ПЕРЕД параметром без такого. Це через те, що значення присвоюються відповідним параметрам згідно позиції параметрів у списку. Наприклад, def func(a, b=5) правильно, але def func(a=5, b) неправильно.

Іменовані аргументи

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

Такий підхід має дві переваги — перша — використання функцій стає легшим, оскільки не треба перейматися порядком слідування аргументів. Друга причина — можна надавати значення тільки тим параметрам яким ми хочемо, за умови що інші параметри мають типові значення.

Приклад:

#!/usr/bin/python
# Filename: func_key.py

def func(a, b=5, c=10):
        print('a is', a, 'and b is', b, 'and c is', c)

func(3, 7)
func(25, c=24)
func(c=50, a=100)
        

Виведе:

                
$python func_key.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50
                
        

Як це працює:

Функція з іменем func має один параметр без типового значення аргументу, за яким ідуть два параметра з типовими значеннями аргументів.

При першому виклику (func(3, 7)) параметр a отримує значення 3, параметр b значення 7, і параметр c типове значення 10.

При другому виклику тіє ж функції (func(25, c=24)) змінна a отримує значення 25, через позицію аргумента. Потім параметр c набуває значення 24 (було використано іменовані аргументи). Змінна b теж набуває свого типового значення, яке було визначено при оголошенні функції.

Втретє (func(c=50, a=100)) ми використали лише іменовані аргументи. Зауваж, що аргумент c було передано функції перед аргументом a, і це при тому, що в визначенні функції параметр a знаходиться перед параметром c.

Довільна кількість аргументів (список аргументів довільної довжини)

Інколи в тебе виникне потреба визначити функцію яка може приймати будь-яку к-ть параметрів. Цього можна досягти використовуючи зірочки.

#!/usr/bin/python
# Filename: total.py

def total(initial=5, *numbers, **keywords):
        count = initial
        for number in numbers:
                count += number
        for key in keywords:
                count += keywords[key]
        return count
print(total(10, 1, 2, 3, vegetables=50, fruits=100))
        

Виведе:

                
$ python total.py
166
        
        

Як це працює:

Коли ми оголошуємо параметр якому передує символ зірочки, такий як наприклад, *param, тоді всі позиційні аргументи починаючи з цієї позиції і до кінця будуть зібрані як список з іменем 'param'.

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

Ми розглянемо списки і словники згодом.

Використання тільки іменованих параметрів

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

#!/usr/bin/python
# Filename: keyword_only.py

def total(initial=5, *numbers, vegetables):
        count = initial
        for number in numbers:
                count += number
        count += vegetables
        return count

print(total(10, 1, 2, 3, vegetables=50))
print(total(10, 1, 2, 3))
# Виникне 
помилка тому що не було вказано
#типового значення для аргументу 'vegetables'
        

Виведе:

$ python keyword_only.py
66
Traceback (most recent call last):
File "test.py", line 12, in 
print(total(10, 1, 2, 3))
TypeError: total() needs keyword-only argument vegetables

        

Як це працює:

Оголошення параметрів після параметра із символом * призводить до того що ці параметри будуть доступні тільки як іменовані аргументи. Якщо для цих аргументів не вказано типове значення, тоді виклик такої функції призведе до виникнення помилки, якщо не вказано значення для іменованого аргументу.

Якщо тобі потрібні тільки ключові аргументи але немає потреби в параметрі з зірочкою, тоді можна просто вказати лише символ * без імені параметра: def total(initial=5, *, vegetables).

Оператор return

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

Приклад:

#!/usr/bin/python
# Filename: func_return.py

def maximum(x, y):
        if x > y:
                return x
        else:
                return y

print(maximum(2, 3))
        

Виведе:

$ python func_return.py
3

        

Як це працює:

Функція maximux повертає максимальне число серед аргументів, які їй передали. Вона використовує просту конструкцію if…else для знаходження більшого значення і потім повертає його.

Зауваж, що оператор return без значення еквівалентний конструкції return None. None — спеціальний тип в Python, який означає ніщо. Даний тип використовується, наприклад, для позначення того, що змінна не має значення, якщо їй присвоєно None.

Кожна функція неявно містить в собі інструкцію return None, якщо ти, звісно, не написав власний оператор return. Це можна побачити якщо виконати код print(someFunction()), де someFunction не використовує оператор return:

def someFunction():
        pass
        

Оператор pass використовується в Python для позначення порожнього блоку операторів.

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

Рядки документації (DocStrings)

Python містить привабливу можливість яка називається рядки документації, яку зазвичай скорочують до docstrings. Це важливий інструмент, який ти мусиш використовувати, оскільки це допомогає краще документувати програму і робить її легшою для розуміння. Неймовірно, але ми можемо отримати рядок документації скажімо з функції, коли програма виконується!

Приклад:

#!/usr/bin/python
# Filename: func_doc.py

def printMax(x, y):
        '''Виведе максимальне число з двох вказаних.

        Аргументи повинні мати тип даних int.'''
        x = int(x) # конвертувати в тип int, якщо це взагалі можливо
        y = int(y)

        if x > y:
                print(x, 'максимальне')
        else:
                print(y, 'максимальне')

printMax(3, 5)
print(printMax.__doc__)#виклик атрибуту функції
        

Виведе:

$ python func_doc.py
5 максимальне
Виведе максимальне число з двох вказаних.
                Аргументи повинні мати тип даних int.

        

Як це працює:

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

Існує домовленість щодо написання рядків документації. Їх прийнято розміщувати в декількох фізичних рядках. Перший рядок починається з великої літери і закінчується крапкою. Другий рядок є порожнім. Детальний опис програми починається з третього рядка. Я вам наполегливо раджу слідувати цій домовленості для всіх ваших рядків документації у всіх нетривіальних функціях.

Ми можемо отримати доступ до рядків документації функції printMax використовуючи атрибут __doc__ (зауваж два символи нижнього підкреслювання) ціїє функції. Просто запам’ятай що Python все опрацьовує, як об’єкт, в тому числі і функції. Про об’єкти ми вивчимо більше у розділі про класи.

Якщо ти вже користувався Python`івською функцією help(), тоді ти вже бачив рядки документації в дії. Все що вона робить так це просто викликає атрибут __doc__ вказаної функції і акуратно виводить його на екран. Ти можеш випробувати її на функції printMax – просто включи виклик help(printMax) в текст програми. Пам’ятай, що потрібно натиснути клавішу q для виходу з довідки.

Автоматизовані інструменти можуть отримувати документацію з твоєї програми в такий спосіб. Саме тому я дуже рекомендую використовувати рядки документацї для будь-яких нетривіальних функцій. Команда pydoc яка постачається разом з вашим дистрибутивом Python працює з рядками документації схожим чином до функції help().

Підсумок

Ми побачили так багато аспектів використання функцій, але зауваж, що це не все. Проте, ми розглянули більшість з того, що ти будеш використовувати в Python щодня.

Далі ми розглянемо як використовувати і створювати модулі.

Коментарі

Добавити новий

Залишити коментар
Ім`я:
e-mail:	не повідомлятиповідомляти
Тема:
	Введіть цей настирливий код

Русская редакция: www.freedom-ru.net & www.joobb.ru

3.26 Copyright (C) 2008 Compojoom.com / Copyright (C) 2007 Alain Georgette / Copyright (C) 2006 Frantisek Hliva. All rights reserved."