Компьютерный центр г. Светлогорска

В контексте программирования функция (function) — это блок программы (или подпрограмма), к которому можно обращаться из любого другого места программы. Чтобы создать функцию, нужно определить ее имя, принимаемые аргументы и последовательность инструкций, которые она должна выполнять. Впоследствии вы можете «вызвать» функцию по ее имени.

Зачем нужны функции?

1. Создание новой функции позволяет присвоить имя группе инструкций, что упрощает чтение и отладку программы.
2. Функции уменьшают объем кода программы за счет исключения повторяющегося кода. А если вы захотите что-то изменить, нужно будет сделать это только в одном месте.
3. Разделение кода большой программы на функции упрощает отладку, так как можно тестировать каждую из функций индивидуально.
4. Хорошо продуманные функции зачастую полезны во многих программах. Как только вы напишете и отладите одну, вы сможете использовать ее снова и снова.

Вызов функции

Мы уже видели примеры вызова функции:

>>> len('функция')
7

Имя функции — len. Выражение в скобках называется аргументом функции. Если необходимо передать несколько аргументов — они указываются через запятую. Результат выполнения функции len() — вывод длины строки.

Обычно говорят, что функция «принимает» аргументы и «возвращает» значение или результат.

До сих пор мы использовали только функции, которые изначально присутствуют в языке Python, но можно создавать и новые функции. Для определения новой функции необходимо указать ее имя и последовательность инструкций, которые выполняются при ее вызове.

def print_lyrics():
    print(f"Я дровосек, и со мной все в порядке.")
    print(f"Я работал весь день, и теперь я в достатке.")

Слово def — ключевое; оно указывает, что это определение функции. Имя функции — print_lyrics. Правила для имен функций те же, что и для имен переменных. Вы не можете использовать зарезервированные (ключевые) слова в качестве имен функций, и вам следует избегать использования переменных и функций с одинаковыми именами.

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

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

Синтаксис для вызова новой функции такой же, как и для встроенных функций:

>>> print_lyrics()
Я дровосек, и со мной все в порядке.
Я работал весь день, и теперь я в достатке.

Как только вы определили функцию, вы можете использовать ее внутри другой функции. Например, чтобы повторить предыдущий припев, мы могли бы написать функцию с именем repeat_lyrics ():

def repeat_lyrics():
    print_lyrics()
    print_lyrics()

А затем вызовем repeat_lyrics():

>>> repeat_lyrics()
Я дровосек, и со мной все в порядке.
Я работал весь день, и теперь я в достатке.
Я дровосек, и со мной все в порядке.
Я работал весь день, и теперь я в достатке.

Параметры и аргументы

Некоторые из функций, которые мы видели, требуют передачи аргументов. Например, когда вы вызываете функцию math.ceil(), вы передаете число в качестве аргумента. Некоторые функции принимают более одного аргумента: функция divmod принимает два: делимое и делитель.

Внутри функции аргументы присваиваются переменным, называемым параметрами. Ниже представлено определение функции, которая принимает аргумент:

def print_twice(bruce):
    print(f"{bruce}")
    print(f"{bruce}")

Эта функция назначает аргумент параметру bruce. Когда функция вызывается, она выводит на экран значение параметра (каким бы оно ни было) дважды.

Эта функция работает с любым значением, которое может быть выведено на экран:

>>> print_twice('Спам')
Спам
Спам
>>> print_twice(2023)
2023
2023
>>> print_twice(math.pi)
3.14159265359
3.14159265359

Вы также можете использовать переменную в качестве аргумента:

>>> michael = 'Эрик, полпчелы.'
>>> print_twice(michael)
Эрик, полпчелы.
Эрик, полпчелы.

Имя переменной, которую мы передаем в качестве аргумента (michael), не имеет ничего общего с именем параметра (bruce). Неважно, какое имя переменной было у значения в вызывающей функции; сейчас в функции print_twice() мы будем обращаться к нему по имени bruce.

Переменные и параметры внутри функций — локальны

Когда вы создаете переменную внутри функции, она является локальной, что означает, что она существует только внутри функции. Например:

def print_cat(part1, part2):
    cat = part1 + part2
    print(f"{cat}")

Эта функция принимает два аргумента, объединяет их и выводит результат. Ниже представлен пример, где она используется:

>>> line1 = 'Тили-тили'
>>> line2 = 'трали-вали.'
>>> print_cat(line1, line2)
Тили-тили трали-вали

Когда выполнение функции print_cat() завершается, переменная cat уничтожается. Если мы попытаемся вывести ее, то получим исключение:

>>> print(cat)
NameError: name 'cat' is not defined

Параметры также локальны. Например, за пределами функции print_cat() нет ничего, что относится к part1 и part2.

Результативные функции и void-функции

Некоторые из функций, которые мы использовали, например математические, возвращают результат. Такие функции называются результативными функциями. Другие функции, вроде print(), выполняют действие, но не возвращают значение. Они называются void-функциями (или иногда — функциями, не возвращающими результат).

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

>>> x = math.cos(radians)
>>> golden = (math.sqrt(5) + 1) / 2

Для возвращения данных после выполнения работы самой функции используется оператор return:

def get_message():
    return "Hello, world!"

Затем результат функции можно присвоить переменной или использовать как обычное значение:

message = get_message()
print(f"{message}")

Hello, world!

Void-функции могут выводить что-то на экран или иметь какой-то другой эффект, но они не возвращают никакого значения.

>>> print(f"Бинго")
Бинго

Обязательные и необязательные параметры

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

def print_word(word, n=5):
    for i in range(n):
        print(f"{word}")

Первый параметр обязателен; второй — нет. По умолчанию переменной \(n\) присвоено значение \(5\).

Если вы передадите только один аргумент:

>>> print_word('Hello')

переменной n будет присвоено значение по умолчанию. Если вы передадите два аргумента:

>>> print_word('Hello', 1)

то переменная \(n\) получает значение второго аргумента. Другими словами, необязательный аргумент изменяет значение по умолчанию.

Если функция имеет как обязательные, так и необязательные параметры, все обязательные параметры должны быть указаны первыми, а необязательные — вторыми.

Напишите функцию get_avg(a, b, c), которая находит среднее число среди трёх различных чисел.

def get_avg(a, b, c):
    if a < b < c or c < b < a:
        return b
    if b < a < c or c < a < b:
        return a
    return c

a, b, c = map(int, input().split())
ans = get_avg(a, b, c)
print(f"{ans}")

2 1 4
2

Напишите функцию get_count(a, x), которая считает, сколько раз число \(x\) встречается в списке \(a\).

def get_count(a, x):
    cnt = 0
    for el in a:
        if el == x:
            cnt += 1
    return cnt

a = list(map(int, input().split()))
x = int(input())
ans = get_count(a, x)
print(f"{ans}")

1 2 3 2 1 4 1
1
3

Напишите функцию is_equal(a, b, n), которая проверяет, одинаковые ли матрицы \(a\) и \(b\) размерами \(n \times n\) или нет.

def is_equal(a, b, n):
    for i in range(n):
        for j in range(n):
            if a[i][j] != b[i][j]:
                return False
    return True

n = int(input())
a = [list(map(int, input().split())) for i in range(n)]
b = [list(map(int, input().split())) for i in range(n)]
if is_equal(a, b, n):
    print(f"YES")
else:
    print(f"NO")

2
1 2
3 4
1 2
3 5
NO

Практические задания

Python имеет ряд встроенных функций, которые всегда доступны:

С полным списком встроенных функций можно ознакомиться в официальной документации.

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

Прежде чем мы сможем использовать функции в модуле, мы должны импортировать его с помощью инструкции импорта:

>>> import math

Подключить определенные атрибуты модуля можно с помощью инструкции from:

>>> from math import gcd

С полным списком функций в математическом модуле можно ознакомиться в официальной документации.

В Python для работы со числами есть встроенные методы:

Строки предоставляют методы для множества полезных операций. Метод похож на функцию — он принимает аргументы и возвращает значение, но его синтаксис отличается. Например, метод upper() принимает строку и возвращает новую строку со всеми прописными буквами.

Вместо синтаксиса функции upper(word) используется синтаксис метода word.upper():

word = 'банан'
new_word = word.upper()
print(f"{new_word}")

БАНАН

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

С полным списком строковых методов можно ознакомиться в официальной документации.

В Python для работы со списками есть встроенные методы:

Найдите значение факториала числа \(n\).

from math import factorial

n = int(input())
ans = factorial(n)
print(f"{ans}")

5
120

Определите, равняется ли строка \(s\) строке «YES», где каждая буква может быть как заглавной, так и строчной.

s = input().lower()
if s == "yes":
    print(f"YES")
else:
    print(f"NO")

yEs
YES

Добавьте число \(x\) в конец списка \(a\).

x = int(input())
a = list(map(int, input().split()))
a.append(x)
print(*a)

3
1 2
1 2 3

Практические задания