11(b)-Lesson №23

С функциями вы уже знакомы, потому что применяли встроенные функции языка Python (input, int, randint).

Например, при вводе данных мы использовали функцию input — она возвращает символьную строку, введённую с клавиатуры:

s = input()

Чтобы преобразовать эту строку в число, мы вызывали ещё одну функцию — int, которая получала на вход результат работы функции input и возвращала целое число, полученное из введённой строки:

n = int (input())

Теперь вы научитесь писать свои собственные функции.

Функция, как и процедура, — это вспомогательный алгоритм, который может принимать аргументы. Но, в отличие от процедуры, функция всегда возвращает значение-результат. Результатом может быть число, символ, символьная строка или любой другой объект.

Начнём с простой функции lastDigit, которая определяет последнюю цифру переданного ей целого числа. Схема её работы показана на рис. 8.11.

Эта функция объявляется так:

def lastDigit(n):
    d = n % 10 
    return d

Название функции должно говорить о том, что делает эта функция. Мы выбрали для неё имя lastDigit, образованное от английских слов last — последний и digit — цифра.

Объявление начинается служебным словом def (от англ. define — определить). В скобках после имени новой функции указан один параметр с именем п. В отличие от многих других языков программирования (например, Паскаля или С) в Python не нужно указывать тип параметров. Тело функции записывается с отступом, так же как и тело условного оператора или цикла.

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

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

n = 4321
print("Число", n, "оканчивается на", lastDigit(n)) 

или при вычислениях:

sum = О
while n > 0:
    sum += lastDigit(n) 
    n = n // 10

В этом фрагменте программы определяется сумма цифр числа, записанного в переменную n.

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

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

def maxDigit(n):
    М = -1
    while n > 0:
        d = n % 10 
        if d > M: M = d 
        n = n // 10 
    return M

а функция sumDigits — сумму цифр числа:

def sumDigits(n): 
    sum = 0 
    while n!= 0: 
        sum += n % 10 
        n = n // 10 
    return sum

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

print(sumDigits(12345))

Вот несколько более сложных примеров:

х = 2*sumDigits(n+5) 
z = sumDigits(k) + sumDigits(m) 
if sumDigits(n) % 2 == 0: 
    print("Сумма цифр чётная") 
    print("Она равна", sumDigits(n))

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

def maxDigitX2(х):
    s = maxDigit(х*х) # вызов функции из функции 
    return s

Функция, которая находит среднее по величине из трёх различных чисел (т. е. число, заключённое между двумя остальными), может быть определена так:

def middle(a, b, c): 
    mi = min(a, b, c) 
    ma = max(a, b, c)
    return a+b+c-mi-ma

Она использует встроенные функции min и max. Идея решения состоит в том, что если из суммы трёх чисел вычесть минимальное и максимальное, то получится как раз третье число.

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

def divmod(x, у): 
    d = x // у 
    m = x % у 
    return d, m

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

a, b = divmod(7, 3) 
print(а, b)          # 2 1

Если указать только одну переменную, мы получим кортеж — набор элементов, который заключается в круглые скобки:

q = divmod(7, 3) 
print(q)             # (2, 1)

Часто применяют функции, которые возвращают логическое значение (True или False). Иначе говоря, такая логическая функция отвечает на вопрос «да или нет?» и возвращает 1 бит информации.

Построим функцию, которая определяет чётность числа. Напомним, что число чётное, если остаток от его деления на 2 равен нулю (в этом случае функция должна вернуть логическое значение True — истина), и нечётное, если этот остаток — не ноль (тут функция должна вернуть значение False — ложь):

def even(n): 
    if n % 2 == 0: 
        return True 
    else:
        return False

Можно записать то же самое несколько проще:

def even(n):
    return (n % 2 == 0)

Здесь (n%2 == 0) — это условие, которое может быть истинно или ложно. Это логическое значение и вернёт функция.

Вызвать функцию even из основной программы можно так:

n = int(input()) 
if even(n):
    print ("Число", n, "чётное.") 
else:
    print("Число", n, "нечётное.")

Вернёмся к задаче, которую мы уже рассматривали: вывести на экран все простые числа в диапазоне от 2 до 1000. Алгоритм определения простоты числа оформим в виде функции. При этом его можно легко вызвать из любой точки программы.

Запишем основную программу на псевдокоде:

for i in range (2,1001) : 
    if i - простое : 
        print(i)

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

if isPrime (i): 
    print(i)

Остаётся написать саму функцию isPrime. Будем использовать уже известный алгоритм: если число п в интервале от 2 до √n не имеет ни одного делителя, то оно простое:

def isPrime (n): 
    k = 2
    while k*k <= n and n % k != 0: 
        k += 1 
    return (k*k > n)

Эта функция возвращает логическое значение, которое определяется как

k*k > n

Если это условие истинно, то функция возвращает True, иначе — False.

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

n = int (input())
while isPrime(n):
    print(n, " - простое число") 
    n = int (input())

Выполнить домашнюю работу