Введение в функции. Модули

Введение

Функция — это группа инструкций, которая существует внутри программы с целью выполнения определенной задачи
Когда задача большая, её необходимо разбить на несколько приемлимых порций. Для этого используют функции.
Пример: нам нужно рассчитать заработную плату. Для написания программы нам нужно разбить задачу на подзадачи:

1. Получение почасовой ставки оплаты труда сотрудника
2. Получение числа отработанных часов
3. Расчёт заработной платы сотрудника до удержаний
4. Расчёт оплаты сверхурочных часов
5. Расчёт налоговых и прочих удержаний
6. Расчёт чистой заработной платы
7. Печать ведомости на получение заработной платы

Мы видим список инструкций, выполняя которые по очереди мы добьемся цели
Мы можем выделить функцию для решения каждой подзадачи. В нашей программе могли бы быть такие функции:

- функция получения почасовой ставки оплаты труда сотрудника
- функция получения количества часов
- функция расчета заработной платы сотрудника до удержаний
- функция расчета оплаты сверхурочных часов
- функция расчета налоговых и прочих удержаний
- функция расчета чистой заработной платы
- функция печати ведомости на получение заработной платы

Это называется модульным подходом и модуляризацией программы
Какие преимущества такого подхода?
- Более простой код. Каждую функцию читать легче, чем одну длинную последовательность
- Повторное использование кода — уменьшение дублирования в программе
- Более простое тестирование
- Более быстрая разработка: написанные однажды функции могут быть применены в нескольких программах
- Упрощение командной работы

Возврат значения

функции без возврата значения просто выполняют инструкции и ничего не возвращают
функции с возвратом значения что-то возвращают в ту инструкцию, которая её вызвала Примеры:
функция input() возвращает значение — строку
функции int() и float() тоже возвращают значение
функция print() ничего не возвращает, а только выполняет инструкцию печати

Функции без возврата значения

Именование:
- имя функции должно отражать то, что она делает
- не должно быть пробелов, ключевых слов Python
- первый символ — буква или нижнее подчеркивание
- как правило в именах функции используются глаголы ("get, take, calculate, print и т.д")
Синтаксис написания функций следующий

def имя_функции(): # это заголовок функции
    инструкция # это блок инструкций
    инструкция
    ...

Это называется определением функции. Говорят, что функция определена.

def message():
    print("Я - Артур,")
    print('король британцев')

Теперь вызовем функцию:

message()

Интерпретатор идет сверху вниз:

Видит определение функции,
Далее видит вызов функции,
Возвращается к определению,
Выполняет блок инструкций
И затем снова возвращается к месту вызова.

Добавим ещё одну функцию в наш пример

# определяем главную функцию
def main():
    print("У меня для вас известие.")
    message()
    print("До свидания!")

# затем определяем функцию message
def message():
    print("Я - Артур,")
    print('король британцев')

# вызываем главную функцию
main()

Интерактив:

Из каких двух частей состоит определение функции?
Что значит "вызвать функцию"?
Зачем нужны отступы в блоке инструкций?

Разбор:

Напишем программу, которая выводит на экран инструкции по разборке
сушилки для белья фирмы Nika.
Чтобы разобрать сушилку, нужно:
1. Отключить сушилку и отодвинуть от стены
2. Удалить шесть винтов с задней стороны сушилки
3. Удалить заднюю панель сушилки
4. Вынуть верхний блок сушилки
Программа должна показывать шаг за шагом по очереди по нажатию клавиши
Enter. Также необходимо предусмотреть приветственное сообщение.

Подготовим "каркас нашей программы". Затем реализуем каждую функцию.

def main():
    '''
    Последовательно вызывает функции и печатает одну за другой.
    После каждой инструкции нужно нажать Enter, чтобы перейти к следующей.
    '''
    pass # инструкция-пустышка - можно использовать при проектировании
# сначала можно продумать функции, а потом написать блоки инструкций в них

def startup_message():
    '''
    Печатает приветственное сообщение
    '''
    pass 

def step1():
    pass
def step2():
    pass
def step3():
    pass
def step4():
    pass

Напишите программу. "Точкой входа" должна быть функция main().

Области видимости: локальная и глобальная;

Когда переменной внутри функции присваивается значение, создаётся локальная переменная. Инструкции за пределами функции не имеют к ней доступа. Говорят, что переменная доступна в локальной области видимости
Когда переменная создается снаружи функции, она является глобальной и доступна в глобальной области видимости

name = "Tatyana" # глобальная переменная
def print_name():
    print(name)
    
def print_another_name():
    name = "Sergey" # локальная переменная
    print(name)
    
print_name()
print_another_name()

def print_name_again():
    name = "Ilona"
    print(name)

print_name_again()
print(name)

Практика: напишите любую программу с применением глобальной и локальной переменных.

Передача аргументов в функцию

Аргумент — любая порция данных, передаваемая в функцию, когда она вызывается
Параметр — переменная, которая получает аргумент, переданный в функцию

def show_double(number): # number - параметр функции
    result = number * 2
    print(result)

Закончим программу и разберём каждый её шаг:

def main(): # определение функции main
    value = 5 # создание переменной value
    show_double(value) # вызов функции show_double с аргументом 5
    
def show_double(number): # определение функции show_double с параметром number
    result = number * 2 # создание переменной result
    print(result) # печать переменной result

main() # вызов функции main

Передавать можно несколько аргументов:

def main():
    print('Сумма чисел 12 и 45 равняется')
    show_sum(12, 45)
    
def show_sum(num1, num2):
    result = num1 + num2
    print(result)
    
main()

Напишите функцию, которая принимает имя и фамилию, и печатает на экран фамилию и имя (именно в этом порядке)

Именованные аргументы

При передаче аргумента в функцию, можно прямо указать имя параметра и его значения. Такой аргумент называется именованным

def main():
    paral_volume(width=6, length=5, height=7)
    
def paral_volume(length, width, height):
    v = length * width * height
    print(f'Объём параллелепипеда с длиной {length}, шириной {width} и высотой {height} составит {v}')

main()

Можно смешивать именованные и позиционные аргументы
Важно соблюдать порядок — сначала позиционные, потом именованные аргументы

paral_volume(5, height=7, width=6)

Функции с возвратом значения

Функции могут не просто выполнять действие, но и возвращать результат
Для этого используется ключевое слово return. Значение, указанное после return, отправляется к месту вызова функции

def sum(num1, num2):
    result = num1 + num2
    return result
    
def hello(name, surname):
    return f'Hello, {name} {surname}'!

Напишем программу, которая спрашивает пользователя доходы за месяц и расходы за месяц. В результате она должна сообщить баланс по итогам месяца

Разбор

def main():
    plus_money = int(input('Введите доходы за месяц: '))
    minus_money = int(input('Введите расходы за месяц: '))
    balance = diff(plus_money, minus_money)    
    print(balance)
    
def diff(n1, n2):
    result = n1 - n2
    return result

main()

Возвращение булевых значений

def is_even(number):
    if number % 2 == 0:
        return True
    else:
        return False

def main():
    number = int(input('Введите число: '))
    if is_even(number): # вызов функции в качестве условия - т.к. она вернет булево значение
        print('Число четное')
    else:
        print('Число нечетное')

Интерактив:

def do_something(number):
    return number * 2

Как называется функция?
Что функция делает?
Что покажет приведенная ниже инструкция с учетом определения функции?

print(do_something(10))

Модули

Модуль — это файл, который содержит программный код Python. Большие программы легче отлаживать и поддерживать, когда они разделены на модули
Разделение, как правило, проводится по смыслу и логике — в одном модуле мы объединяем функции, выполняющие задачи в одной области
В стандартной библиотеке Python есть большое количество модулей, которые можно подключить при помощи инструкции import. Рассмотрим примеры использования одного из популярных модулей: random

import random
# from random import randint - способ импорта конкретной функции из модуля
# тогда эту функцию можно будет вызывать без названия модуля
# вот так: randint(0, 10)
random.randint(0, 10) # функция возвращает целое число в диапазоне от 0 до 10 включительно
random.randrange(start, stop, step) # возвращает случайно выбранное число из последовательности
lst = list(range(10)) # список целых чисел от 0 до 9
random.choice(lst) # вернет случайный элемент последовательности
random.shuffle(lst) # перемешает случайным образом элементы изменяемой последовательности

Практика: познакомьтесь с возможностями модуля math. Решите задачу поиска длины гипотенузы, зная длины катетов прямоугольного треугольника при помощи модуля math.
- Документация: https://docs.python.org/3/library/math.html

Импорт самописных модулей

Когда мы импортируем один модуль в другой, то выполняются инструкции этого модуля: определяются функции и переменные
Если в модуле вызывается какая-то функция, то при импорте этого модуля, она тоже будет вызвана
Чтобы избежать этого, используется следующая конструкция:

# определена какая-то функция main
def main():
    pass
    
# нам нужно, чтобы она вызывалась только если мы запускаем этот модуль
# а если этот модуль импортируется -- тогда на вызывалась
# используем такую конструкцию:    
if __name__ == '__main__':
    main()

Почему так происходит?

При обработке модуля интерпретатор создаёт переменную __name__
Если модуль импортируется, она равна имени модуля.
Если модуль запускается, она равна __main__
Таким образом, условие if __name__ == '__main__': выполнится только в случае, если модуль запускается непосредственно

Практика:

Создайте два модуля. В каждом модуле определите по одной функции и вызовите их. Запустите каждый модуль — убедитесь, что будет вызвана только функция этого модуля
Теперь импортируйте один модуль в другой. Запустите каждый модуль — понаблюдайте за результатом. Попробуйте добавить обратный импорт. Удалите вызов функции в одном модуле, потом в другом. Запускайте модули на каждом этапе.
Добавьте конструкцию "if __name__ = '__main__':" в каждый модуль по очереди, проделайте шаги из пункта 2
Обсудите результаты с преподавателем

Итог:

Всегда используйте конструкцию if __name__ == '__main__': в запускаемом (главном) модуле вашей программы

Интерактив:

Какое ключевое слово игнорируется интерпретатором и может использоваться в качестве местозаполнителя для кода, который будет написан позже?
Как определить функцию? Как её вызвать?
Глобальная или локальная переменная создаётся внутри функции?
Какая инструкция должна быть в функции для возврата значения?
Что такое булева функция?
Зачем разбивать большую программу на модули?

PreviousПрактика NextФункции. Продолжение

Last updated 10 months ago