Вступ
Як ми і домовлялися попереднього уроку, цього разу ми з вами розберемося з функціями у Пітоні.
Що таке функція? Функція – це невелика автономна програма (кусок коду), що виконує певне завдання і яку ви можете використовувати в різних місцях вашої основної більшої програми. Після того як ви створили вашу функцію ви можете використовувати її у будь-який час, у будь-якому місці і скільки завгодно разів.
Таким чином функції економлять ваш час і зусилля допомагаючи уникати повторювання вашого коду кожен раз коли вам потрібно запрограмувати одне і те ж завдання.
Використання Функцій
Python має багато вже готових (вбудованих) функцій, які ми з вами можемо використовувати одразу ж після інсталяції цієї мови, просто ‘викликавши‘ її. Виклик функції у себе включає передачу даних функції і потім отримання певного значення від неї. На дуже простому прикладі це виглядає отак:
|
1 |
function_name(parameters) |
- function_name‘ тут є назвою функції, яку ми викликаємо
- а ‘parameters‘ – це значення, які ми передаємо функції, щоб дати їй знати що робити і як саме це робити. Наприклад, якщо функція множить будь-яке дане число на 5, тоді у даному випадку ‘parameters’ буде казати функції, яке число вона повинна множити на 5. Якщо ми передамо 70 в параметрах, тоді функція поверне 70 x 5 = 350.
Якщо не все зрозуміло поки – не хвилюйтесь. В наступних секціях цього уроку ми пройдемося детальніше по виклику функції, її аргументах та результату функції.
Параметри і Результати Функцій – Зв’язок з Функцією
Насправді для комп’ютера не важлива сама назва функції, а більше те, що функція отримує в якості її аргументів, і що вона повертає як результат свого виконання (виклику). І на практиці, коли комп’ютер виконує функцію, він не бачить назву функції, але її результат який ця функція повертає. Так само як із змінними – комп’ютер не бачить назв змінних, але бачить значення цих змінних.
Назвемо ту функцію, що множить передане їй число на 5 – multiply. При виклику цієї функції передаємо їй число, яке хочемо щоб вона нам помножила на 5 в дужках. Наприклад:
|
1 |
a = multiply(70) |
Насправді для комп’ютера це виглядатиме як:
|
1 |
a = 350 |
Ми викликали функцію під назвою multiply передавши їй число 70 в дужках, і вона повернула нам 350 (результат 70 помножити на 5).
А тепер спробуємо приклад із справжньою функцією, тому можете запускати Пітон інтерпретатор і також спробувати наступні рядочки, та перевірити чи результат ваш співпаде з нижченаведеним.
Ми викличемо функцію raw_input. Дана функція запитує користувача ввести будь-які дані (символ, або цілу стрічку), вона отримує введені користувачем дані і повертає їх у вашу програму у вигляді стрічки тексту. Пробуємо наступний код:
|
1 |
a = raw_input("What is your name?") |
|
2 |
print a |
Після запуску першого рядка дана програма зупиниться і запросить вас ввести що-небудь рядочком “What is your name?“. Тоді ви вводите, наприклад “John“, натискаєте ввід (Enter) і після цього програма продовжує свою роботу. Змінна ‘a‘ отримує стрічку “John” значенням і у наступному рядку ми цю стрічку роздруковуємо.
Пітон інтерпретатор бачитиме нашу програму приблизно у наступному вигляді:
|
1 |
a = "John" |
|
2 |
print "John" |
Пам’ятаємо, що змінна – це лише збережені в пам’яті комп’ютера значення. Для комп’ютера змінна ‘a‘ не виглядає як ‘a‘, просто як значення що в ній зберігається. Функції у цьому сенсі є подібні до змінних – для головної програми (у якій ці функції використовуються), вони виглядають просто як значення, які ці функції повертають.
Програма Калькулятор
Давайте тепер спробуємо написати ще одну програму, яка працюватиме для нас як калькулятор. Цього разу вона вже буде дійсно корисною і трохи цікавішою, ніж ті які розглядали перед цим. Ми зробимо так, що програма буде спочатку питати, яку операцію ми хочемо здійснити – додавання, множення двох чисел, ділення чи віднімання одного числа від іншого.
З цим ми спочатку будемо мати невеличку проблемку – функція ‘raw_input’ (та яку ми щойно використовували у прикладі наведеному вище) повертає дані від користувача у вигляді стрічки, а нам потрібно буде мати число. На щастя, хтось в Пітоні вже давним давно написав функцію, подібну по до ‘raw_input‘, але яка транслює введені дані користувацькі у числовий формат. Це означає, що всередині нашої програми калькулятора ми зможемо мати числові дані введені користувачем, а саме дані типу ‘integer‘ – це ціле число в Пітоні.
Тепер давайте з вами змоделюємо наш калькулятор. Ми хочемо мати щось на зразок меню, до якого будемо повертатися кожного разу після того, як закінчимо додавати, віднімати чи іншу операцію. Тобто нам потрібно буде запрограмувати постійний цикл, що буде працювати до моменту допоки користувач не накаже програмі закінчити дію.
На даному етапі ми розглядаємо лише чотири математичних операції: додавання, віднімання, множення і ділення. Давайте спочатку напишемо так званий псевдо-код програми. Тобто, змоделюємо алгоритм українською мовою. А вже коли матимемо його, тоді перекладемо на мову Python 
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
ПОЧАТОК ПРОГРАМИ
друкуємо початкове привітання допоки користувач не зупинив програму, робимо: роздруковуємо користувачу щось на зразок меню доступних операцій друкуємо Варіант 1 - додавання друкуємо Варіант 2 - віднімання друкуємо Варіант 3 - множення друкуємо Варіант 4 - ділення друкуємо Варіант 5 - вийти з калькулятора
запитуємо який Варіант користувач бажає виконати якщо Варіант 1: просимо ввести перше число просимо ввести друге число додаємо їх друкуємо результат на екран якщо Варіант 2: просимо ввести перше число просимо ввести друге число віднімаємо від першого числа друге друкуємо результат на екран якщо Варіант 3: просимо ввести перше число просимо ввести друге число множимо два числа друкуємо результат на екран якщо Варіант 4: просимо ввести перше число просимо ввести друге число ділимо перше число на друге і знову виводимо результат на екран якщо Варіант 5: виходимо із циклу
Друкуємо на екран прощальне повідомлення
ЗАКІНЧЕННЯ ПРОГРАМИ |
Як бачите, більшість програми міститься всередині циклу. Тобто програма закінчиться лише тоді коли користувач обере Варіант 5 – який наказує програмі зупинити своє виконання. Якщо ж користувач вибирає будь-який з попередніх чотирьох варіантів – тоді ми просимо його ввести послідовно два числа, над якими і виконуємо обрану перед цим операцію. На кінець – виводимо результат на екран. От і вся логіка!
А тепер спробуємо протранслювати наш псевдо-калькулятор на реальний калькулятор, з псевдо-мови на мову Пітон 
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
# -*- coding: utf-8 -*- # програма Калькулятор print "Вітаємо!"
# ця змінна скаже циклу коли потрібно зупинитися loop = 1
# цю змінну ми використаємо для запам'ятовування Варіанту дії обраної користувачем choice = 0
# використовуємо цикл 'while' який працюватиме доти доки зміння loop є 1 while loop == 1: # роздрукуємо нашому користувачеві всеможливі дії print "Набір доступних дій:" print "1) Додавання" print "2) Віднімання" print "3) Множення" print "4) Ділення" print "5) Закрити Калькулятор"
# отже, запитаємо яку ж дію хоче здійснити наш користувач # і запам'ятаємо його вибір у змінній choice # зверніть увагу, ми використовуємо функцію "input", а не "raw_input" # функція "input" перетворить введені дані від користувача у число choice = input("Оберіть вашу дію: ") if choice == 1: # додавання # просимо користувача ввести два числа по черзі num1 = input("Додати це число: ") num2 = input("до цього: ")
# роздруковуємо результат додавання отриманих двох чисел # зверніть увагу, що як гарно ми форматуємо вивід, щоб користувач у зручному # вигляді побачив, що ж саме сталося, напр. "3 + 4 = 7" print num1, " + ", num2, " = ", num1 + num2 elif choice == 2: # віднімання # набір дій приблизно такий як і у попередній гілці "if" за винятком # однієї речі - тепер ми передані нам два числа віднімаємо один від одного num1 = input("Віднімаємо число: ") num2 = input("від: ") print num2, " - ", num1, " = ", num2 - num1 elif choice == 3: # множення # аналогічно з дією множення num1 = input("Множимо число: ") num2 = input("на: ") print num1, " * ", num2, " = ", num1 * num2 elif choice == 4: # ділення # остання операція, операція ділення num1 = input("Ділимо число: ") num2 = input("на: ") print num1, " / ", num2, " = ", num1 / num2 elif choice == 5: # користувач побажав вийти з калькулятора # щоб закінчити цикл програми достатньо встановити значення змінної # loop у будь-яке значення відмінне від 1 loop = 0
# і на кінець прощаємося з нашим користувачем print "Дякуємо за користування калькулятором! Приходьте ще!" |
Ух! Велика получилась програмуліна. Якщо ви цього ще не зробили, тоді спробуйте тепер її скопіювати у свій власний файлик в редакторі чи в Python IDE, зберегти його як ‘calculator.py‘ і запустити. Спробуйте побавитись з різними опціями і варіантами, що ми щойно напрограмували, вводячи як цілі числа (тип integer в Пітоні) так і дроби (тип float в Пітоні). Також спробуйте вводити неправильні дані, як от текст, і гляньте, що станеться, як поведеться програма, які помилки віддасть вам у відповідь. Пізніше ми з вами навчимося відловлювати різного роду помилки у нашому коді, і правильно обробляти їх, навіть якщо користувач ввів неправильний формат даних.
Зверніть увагу на те, що більшість програми знаходиться всередині циклу. І виходимо ми з нього лише коли користувач обере Варіант 5. Також на початку кожного циклу ми знову виводимо довідкову інформацію про набір доступних дій.
Визначення Власних Функцій
Ок, це дуже добре, що ми вже навчились користуватися готовими існуючими функціями, що вже є написані для нашого користування. Але, що коли нам самим потрібно написати власну функцію, щоб наприклад заощадити трохи часу, уникнути дублікації коду, а також щоб мати можливість використати її у наших інших програмах?
Тут і приходить нам на допомогу пітонівський оператор ‘def’. Оператором ми називаємо певну інструкцію, яка вказує Пітону що саме зробити. Наприклад, оператор ‘+’ вказує на те, що треба виконати операцію додавання, оператор ‘while’ заставляє Пітон інтерпретатор розпочати виконання циклу.
Оcь як працює оператор ‘def’:
|
1 2 3 4 5 6 7 8 9 10 |
def function_name(parameter_1, parameter_2): {цей код є тілом функції} {ще трохи коду} {і ще .... } return {значення, яке ми повертаємо з функції головній програмі}
{а вже цей код не є частиною функції} {тому що він не починається з відступів} # пам'ятаємо, що потрібно ставити двокрапку ":" наприкінці # рядочка, який починається з ключового слова "def" |
function_name – це ім’я нашої функції. У наступному рядочку після ‘def’ ми пишемо код, який називається “тілом функції” – це те, що наша функція власне робить. Тіло функції завжди починається з додаткових відступів. Про параметри (агрументи) функції paremeter_1 i parameter_2 ми поки не будемо хвилюватися, а розберемо їх трішки пізніше.
Функція – це як мініатюрна програма, яка може також приймати певні параметри (аргументи, вхідні дані), вона запускається з вхідними даними, і наприкінці свого виконання зазвичай повертає певне значення. Тому що функція є, ніби, окремою програмою, вона не зазвичай не бачить змінних, які є визначені у нашій головній програмі, і навпаки – наша основна програма не бачить змінних, які є визначені всередині нашої функції. Наприклад, нижченаведена функція, яка виводить слово “hello” на екран, а потім ще й повертає число ’1234′ головній програмі:
|
1 2 3 4 5 6 7 8 9 10 |
"# -*- coding: utf-8 -*-" # у рядку нижче ми визначаємо функцію hello def hello(): # виводимо на екран слово "hello" print "hello" # повертаємо число 1234 return 1234
# тепер викличемо нашу, щойно визначену, функцію print hello() |
Що ми зробили в останньому рядочку програми наведеної вище? Введіть дану програму у вашому редакторі, і запустіть. Результат буде наступним:
|
1 2 |
hello 1234 |
Отже, що відбулося?
- коли рядочок ‘def hello()’ був запущений Пітон інтерпретатором, функція ‘hello’ була створена у цей момент
- у рядочку ж ‘print hello()’ ми зробили ВИКЛИК функції ‘hello’, тобто код, що знаходиться всередині визначеної функції, запустився
- відповідно функція виконала свій рядочок “print ‘hello’”, та потім повернула число ’1234′ назад у головну програму
- і на кінець – головна програма вивела на екран те значення, що повернула наша функція “print hello()” і таким чином ми отримали у другому рядочку число ’1234′ як результат виконання нашої цілої програми
Зауважте, головна програма навіть не здогадувалася, що слово ‘hello’ було виведене на екран. Все про що вона знала – це те, що функція повернула їй значення ’1234′, яке вона успішно вивела на екран
Параметри Функцій
Ще одну річ, яку ми розберемо з вами у цьому не маленькому уроці – це те, як саме передавати параметри (аргументи) функції. Давайте з вами пригадаємо попередній вигляд того, як ми визначили нашу функцію ‘function_name’:
|
1 2 3 4 5 |
def function_name(parameter_1, parameter_2): {цей код є тілом функції} {ще трохи коду} {і ще .... } return {значення, яке ми повертаємо з функції головній програмі} |
У даному визначенні на місці parameter_1 та parameter_2 (всередині дужок) ми зазвичайн ставимо імена змінних, в яких ми передаємо певні параметри нашій функції. Ми можемо передавати скільки завгодно параметрів, головне пам’ятати ставити кому між ними. Коли ми викликаємо функцію, перше значення, яке ми передаємо нашій функції буде передане під назвою parameter_1. Відповідно друге значення у нашому випадку передане функції буде доступне (всередині функції) як – parameter_2.
Тобто наступний запис:
|
1 |
function_name('test', 2345) |
викличе нашу функцію function_name і передасть їй два аргументи (параметри): стрічку ‘test’ та число 2345. Стрічка ‘test’ буде доступна всередині функції під якою назвою? Саме так – parameter_1 Відповідно число 2345 можна буде отримати через змінну під назвою parameter_2.
У мові Пітон є також можливість визначати функції з параметрами, які по замовчуванню міститимуть уже певне значення. А також приймати аргументи навмання, за їхньою позицією, або іменах (ключах) змінних. Але поки ці складніші випадки зачіпати не будемо.
Кінцева Програма
Давайте тепер з вами пригадаємо наш калькулятор! І спробуємо переписати його використовуючи наші знання про функції. З однією основною метою – зробити тіло головного циклу нашого калькулятора – простішим для розуміння і з меншою кількістю коду.
Щоб довго не пояснювати, спочатку наведу вам те, що у мене вийшло з функціями, тобто кінцеву програму. А потім трошки розберемо:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
# -*- coding: utf-8 -*- # програма Калькулятор
# ця функція виводитиме меню нашого калькулятор, а також # запитує і передає вибір користуача про дію у головну програму def menu(): print " " print "Вітаємо!" # роздрукуємо нашому користувачеві всеможливі дії print "Набір доступних дій:" print "1) Додавання" print "2) Віднімання" print "3) Множення" print "4) Ділення" print "5) Закрити Калькулятор" print " " # тут ми просимо користувача ввести/обрати дію, і віддаємо його вибір назад # у головну програму return input("Оберіть вашу дію: ")
# нижче визначаємо функції дій з числами, у них ми не повертаємо ніяких значень, а лише # виводимо на екран результат їхніх дій
# додаємо два числа def add(num1, num2): # функція приймає два параметра, два числа # і виводить результат їхнього додавання у зручному для користувача форматі # пам'ятаємо print може приймате більш ніж один аргумент, через кому print num1, "+", num2, "=", num1 + num2
# віднімання def sub(num1, num2): print num2, "-", num1, "=", num2 - num1
# множення def mul(num1, num2): print num1, "*", num2, "=", num1 * num2
# ділення def div(num1, num2): print num1, "/", num2, "=", num1 / num2
# після того як визначили усі необхідні функції, починаємо основну програму
# ця змінна скаже циклу коли потрібно зупинитися loop = 1
# цю змінну ми використаємо для запам'ятовування Варіанту дії обраної користувачем choice = 0
# використовуємо цикл 'while' який працюватиме доти доки зміння loop є 1 while loop == 1:
# отже, запитаємо яку ж дію хоче здійснити наш користувач # і запам'ятаємо його вибір у змінній choice choice = menu() if choice == 1: # додавання # тут ми у скороченому вигляді отримуємо значення чисел, а також обраховуємо їх # та роздруковуємо на екран - усе в одну стрічку, завдяки використанню наших # визначених напередодні функцій.
# отже викликаємо функцію add передаючи їй два числа введені користувачем add(input("Додати це число: "), input("до цього: ")) elif choice == 2: # віднімання # те ж саме з відніманням sub(input("Віднімаємо число: "), input("від: ")) elif choice == 3: # множення # множенням mul(input("Множимо число: "), input("на: ")) elif choice == 4: # ділення # та діленням div(input("Ділимо число: "), input("на: ")) elif choice == 5: # користувач побажав вийти з калькулятора # щоб закінчити цикл програми достатньо встановити значення змінної # loop у будь-яке значення відмінне від 1 loop = 0
# і на кінець прощаємося з нашим користувачем print "Дякуємо за користування калькулятором! Приходьте ще!" |
Зауважте – сама програма загалом стала трохи більшою, ніж була перед цим. Проте ми значно спростили тіло нашого основного циклу використовуючи у ньому наші функції. Тобто загалом, програма наша стала легшою для розуміння.
Ми визначили усі наші функції із самого початку програми. Тобто це ми визначили кусочки функціоналу, який не запускається в момент коли Пітон інтерпретатор зчитує і пробує зрозуміти наш модуль, а лише коли запущена програма доходить до рядочків, де напряму явно здійснюється виклик наших функцій. Напр.:
|
1 |
div(input("Ділимо це число: "), input("на це: ")) |
В даній програмі ви викликаємо наші функції знову і знову, допоки користувач не вийде з калькулятора. Таким чином можемо перевикористовувати логіку закладену у нашу функцію скільки завгодно разів.
І на останок, щодо нашої оновленої програми калькулятора. Тепер, кожного разу коли вам потрібно буде оновити логіку калькулятора, тобто оновити основний цикл нашої програми, вам буде достатньо переглянути близько 24 рядочків коду, замість 50-ти, які були у нашому циклі перед використанням функцій. Тобто функції допомогли нам зробити наш код таким, що буде легше підтримувати і оновлювати у майбутньому.
На закінчення…
Ура!!! Який доооооовжелезний урок у нас з вами вийшлов! Але, в будь-якому випадку, ви молодці, що дійшли до цього моменту!
Цей урок забрав у мене не одну годину часу, і я старався донести інформацію якомога простіше. Тому маю велику надію, що матеріал корисний і доступний.
Функції – це одна з найважливіших концепцій у більшості мов програмування. Тому зрозуміти даний матеріал є надзвичайно важливим для нас з вами, щоб успішно рухатися далі!
Дописуйте у коментарі, якщо виникають питання, або знайшли помилки у прикладах. І будемо по-трохи рухатися далі до наступного уроку. Наш наступний крок – розібратися із трішки складнішими типами даних у мові Пітон – таких як кортежі, списки та словники!
Чекаю на ваші коментарі: