Для чего нужны функции

Пользовательские функции в Си

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

Помните, мы говорили о парадигмах программирования, а точнее о структурном программировании. Основной идеей там было то, что любую программу можно написать используя только три основных конструкции: следование, условие и цикл. Теперь к этим конструкциям мы добавим ещё одну – «подпрограммы» – и получим новую парадигму процедурное программирование» .

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

В принципе, мы уже используем эту парадигму. Если вам пока ещё не совсем ясно, почему это проще, то просто представьте, что вместо того чтобы вызвать функцию exp(x) из заголовочного файла math.h вам каждый раз необходимо было бы описывать подробно, как вычислить значение этой функции.

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

Как устроены функции

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

int main(void)< // заголовок функции // в фигурных скобках записано тело функции >

С телом функции всё ясно: там описывается алгоритм работы функции. Давайте разберёмся с заголовком. Он состоит из трёх обязательных частей:

• тип возвращаемого значения;
• имя функции;
• аргументы функции.

Сначала записывается тип возвращаемого значения, например, int , как в функции main . Если функция не должна возвращать никакое значение в программу, то на этом месте пишется ключевое слово void . Казалось бы, что раз функция ничего не возвращает, то и не нужно ничего писать. Раньше, кстати, в языке Си так и было сделано, но потом для единообразия всё-таки добавили. Сейчас современные компиляторы будут выдавать предупреждения/ошибки, если вы не укажете тип возвращаемого значения.
В некоторых языках программирования функции, которые не возвращают никакого значения, называют процедурами (например, pascal). Более того, для создания функций и процедур предусмотрен различный синтаксис. В языке Си такой дискриминации нет.

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

Давайте посмотрим на заголовки уже знакомых нам функций.

// функция с именем srand, принимающая целое число, ничего не возвращает void srand(int) //функция с именем sqrt, принимающая вещественное число типа float, возвращает вещественное число типа float float sqrt(float) //функция с именем rand, которая не принимает аргументов, возвращает целое число int rand(void) //функция с именем pow, принимающая два аргумента типа double, возвращает вещественное число типа double double pow(double, double)

Как создать свою функцию

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

Рис.1 Уточнение структуры программы. Объявление функций.

Как видите, имеется аж два места, где это можно сделать.

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

#include // объявляем пользовательскую функцию с именем max_num // вход: два целочисленных параметра с именами a и b // выход: максимальное из двух аргументов int max_num(int a, int b) < int max = b; if (a >b) max = a; return max; > //основная программа int main(void)

Давайте я подробно опишу, как будет работать эта программа. Выполняется тело функции main . Создются целые переменные x , y и m . В переменные x и y считываются данные с клавиатуры. Допустим мы ввели 3 5 , тогда x = 3 , y = 5 . Это вам всё и так должно быть понятно. Теперь следующая строчка

m = max_num(x,y);

Переменной m надо присвоить то, что находится справа от знака = . Там у нас указано имя функции, которую мы создали сами. Компьютер ищет объявление и описание этой функции. Оно находится выше. Согласно этому объявлению данная функция должна принять два целочисленных значения. В нашем случае это значения, записанные в переменных x и y . Т.е. числа 3 и 5 . Обратите внимание, что в функцию передаются не сами переменные x и y , а только значения (два числа), которые в них хранятся. То, что на самом деле передаётся в функцию при её вызове в программе, называется фактическими параметрами функции.

Теперь начинает выполняться функция max_num . Первым делом для каждого параметра, описанного в заголовке функции, создается отдельная временная переменная. В нашем случае создаются две целочисленных переменных с именами a и b . Этим переменным присваиваются значения фактических параметров. Сами же параметры, описанные в заголовке функции, называются формальными параметрами. Итак, формальным параметрам a и b присваиваются значения фактических параметров 3 и 5 соответственно. Теперь a = 3 , b = 5 . Дальше внутри функции мы можем работать с этими переменными так, как будто они обычные переменные.

Создаётся целочисленная переменная с именем max , ей присваивается значение b . Дальше проверяется условие a > b . Если оно истинно, то значение в переменной max следует заменить на a .

Далее следует оператор return , который возвращает в вызывающую программу (функцию main ) значение, записанное в переменной max , т.е. 5 . После чего переменные a , b и max удаляются из памяти. А мы возвращаемся к строке

m = max_num(x,y);

Функция max_num вернула значение 5 , значит теперь справа от знака = записано 5 . Это значение записывается в переменную m. Дальше на экран выводится строчка, и программа завершается.

Внимательно прочитайте последние 4 абазаца ещё раз, чтобы до конца уяснить, как работает программа.

А я пока расскажу, зачем нужен нижний блок описания функций. Представьте себе, что в вашей программе вы написали 20 небольших функций. И все они описаны перед функцией main . Не очень-то удобно добираться до основной программы так долго. Чтобы решить эту проблему, функции можно описывать в нижнем блоке.

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

Прототип функции полностью повторяет заголовок функции, после которого стоит ; . Указав прототип в верхнем блоке, в нижнем мы уже можем полностью описать функцию. Для примера выше это могло бы выглядеть так:

#include int max_num(int, int); int main(void) < int x =0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num(x,y); printf("max(%d,%d) = %d\n",x,y,m); return 0; >int max_num(int a, int b) < int max = b; if (a >b) max = a; return max; >

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

Сохрани в закладки или поддержи проект.

Практика

Решите предложенные задачи:

Для удобства работы сразу переходите в полноэкранный режим

Дополнительные материалы

1. пока нет

Функции в Python для начинающих

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

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

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

f(x) = x * 2

Левая часть определяет функцию f , принимающую один параметр, x . А правая часть — это определение функции, которое использует переданный параметр x , чтобы произвести вычисление и вернуть результат. В этом случае значением функции является ее параметр, умноженный на два.

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

def имя_функции(параметры): определениие_функции

Математическая функция f(x) = x * 2 в Python будет выглядеть вот так:

def f(x):
 
return x * 2

Ключевое слово def сообщает Python, что вы определяете функцию. После def вы указываете имя функции; оно должно отвечать тем же правилам, что и имена переменных. Согласно конвенции, в имени функции нельзя использовать заглавные буквы, а слова должны быть разделены подчеркиванием вот_так .

Как только вы присвоили своей функции имя, укажите после него круглые скобки. Внутри скобок должен содержаться один или несколько параметров.

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

return x * 2

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

Чтобы вызвать функцию в Python, мы используем синтаксис имя_функции(параметры, через, запятую) .

Ниже описан вызов функции f из предыдущего примера с параметром 2 .

Консоль ничего не вывела. Можно сохранить вывод вашей функции в переменной и передать ее функции print .

# Продолжение
# предыдущего примера
def f(x):
 
return x * 2
result = f(2)
print(result) # 4

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

def f(x):
 
return x + 1
 
z = f(4)
if z == 5:
 
print("z равно 5")
else:
 
print ("z не равно 5")

У функции может быть один параметр, несколько параметров или вообще их не быть. Чтобы определить функцию, не требующую параметров, оставьте круглые скобки пустыми.

def f():
 
return 1 + 1
 
result = f()
print(result) # 2

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

def f(x, y, z):
 
return x + y + z
 
result = f(1, 2, 3)
print(result) # 6

Наконец, функция не обязана содержать инструкцию return. Если функции нечего возвращать, она возвращает значение None .

def f():
 z = 1 + 1
result = f()
print(result) # None

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

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

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

def f(x=2):
 
return x**x
 
print (f()) # 4
print (f(4)) # 16

Сначала функция вызывается без передачи параметра. Так как параметр необязательный, x автоматически становится равен 2 , и функция возвращает 4 .

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

def add(x, y=10):
 
return x + y
result = add(2)
print(result)

Хотите выучить Python на практике?

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

Изучая Python , наткнулся на lambda -функции. Но нигде я пока не нашел примера, где они действительно нужны — только элементарные примеры вида print(lambda x, y: x**2 + y**2) , где вполне можно убрать функциональную обертку. Для чего они действительно нужны и полезны?

Отслеживать
user207618
задан 12 июн 2016 в 17:10
andrey_Kox andrey_Kox
113 1 1 золотой знак 1 1 серебряный знак 5 5 бронзовых знаков
print(lambda: . ) печатает саму функцию (объект), что практически всегда бесполезно.
12 июн 2016 в 18:33

5 ответов 5

Сортировка: Сброс на вариант по умолчанию

Они не могут быть 100% нужны, то есть без операций сложений написать программу нельзя, без лямбда-функций — можно, но с ними короче и удобней. Например, нужно напечатать словарь в порядке убывания суммы каждого значения:

bigrams = sorter = sorted(bigrams, key=lambda key: sum(bigrams[key]), reverse=True) for key in sorter: print(key, bigrams[key]) 

Иначе нужно написать функцию:

from functools import partial def sort_func(key, dict): return sum(dict[key]) bigrams = partial_sort = partial(sort_func, dict=bigrams) sorter = sorted(bigrams.keys(), key=partial_sort, reverse=True) for key in sorter: print(key, bigrams[key]) 

Результат одинаков, но с лямбдой короче, не нужно искать глазами sort_func — сразу ясно, как именно сортируется коллекция. В стандартной библиотеке полно функций, которые принимают другие функции: map , reduce , filter , sorted , any , all

Можно написать замыкание:

def addition(x): return lambda y: x + y add_to_ten = addition(10) print(add_to_ten(8)) print(add_to_ten(6)) 

По идее, лямбда функции абсолютно то же самое, что и обычные функции, но без имени:

def func(x): func = lambda x: x + 1 return 100 import dis print(dis.dis(func)) 

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

Отслеживать
ответ дан 12 июн 2016 в 18:28
6,389 4 4 золотых знака 35 35 серебряных знаков 57 57 бронзовых знаков

lambda создаёт анонимные функции в Питоне. Основные отличия от def f() это отсутствие имени и ограничение на тело функции до одного выражения.
Фактически создаваемые объекты c помощью lambda выражения или def конструкции могут быть одинаковыми:

>>> type(lambda: None) >>> def f(): return None . >>> type(f)

lambda часто используется для callback в GUI и сетевых библиотеках (асинхронный код), например:

d.addBoth(lambda _: reactor.stop()) # twisted signal.signal(signal.SIGCHLD, lambda signum, frame: None) # enable SIGCHLD root.bind("", lambda _: root.destroy()) # exit on Esc root.bind('', app.prev_image) # change font that widgets with 'TButton' style use root.after(3000, lambda: ttk.Style().configure('TButton', font=MyFont)) # in 3 secs 

lambda можно использовать в любом месте, где ожидается функция:

intervals.sort(key=lambda x: (x.end, (x.end - x.start))) problem.addConstraint(lambda a,b: b+1 == a, ["green", "yellow"]) def longest_alphabetical_substring(text, rank=lambda char: char): . 

>>> sorted([(1,-1), (2,-2)]) [(1, -1), (2, -2)] >>> sorted([(1,-1), (2,-2)], key=lambda (a, b): (b, a)) [(2, -2), (1, -1)] 

Этот Python 2 код сортирует пары сначала по b , потом по a в отличии сортировки для кортежей по умолчанию.

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

#XXX DO NOT DO IT files.sort(key=lambda path: os.path.getmtime(path)) # не делайте этого 

Вместо этого следует передать функцию прямо:

files.sort(key=os.path.getmtime) 

Если вам приходится использовать lambda в выражениях с filter() , map() , то следует переписать их, используя генераторы списков, что может сделать код одновременно более читаемым и эффективным, например, вместо:

strings = list(map(lambda b: b.decode('utf-8').replace(os.linesep, '\n'), bytestrings)) 

strings = [b.decode('utf-8').replace(os.linesep, '\n') for b in bytestrings] 

В некоторых случаях, код с lambda может быть менее ясен для новичков, например:

duplicate = reduce(lambda acc, (i, x): acc ^ i ^ x, enumerate(arr), 0) def lcm(*args): """Least common multiple.""" return reduce(lambda a, b: a * b // gcd(a, b), args) 

(что лучше переписать, используя явный цикл). Или наоборот более ясен:

L.sort(key=lambda x: x[0]) # vs: L.sort(key=operator.itemgetter(0)) for chunk in iter(lambda: file.read(1  

import tkinter as tk # Tkinter - Python2, tkinter - Python3 class App: def __init__(self, parent): frame = tk.Frame(parent) frame.pack() for i in range(7): tk.Button( frame, text=str(i), command=lambda numButton=i: self.printNum(numButton) ).pack(side=tk.LEFT) tk.Button(frame, text="Cancel circle", fg="red", command=frame.quit).pack(side=tk.LEFT) def printNum(self, num): print("Вы нажали кнопку: %s" % num) root = tk.Tk() app = App(root) root.mainloop() 

// Объявляем новую функцию. Она будет называться changeScore и принимать один аргумент, который мы для этого фрагмента назовём howMuch. Дальше мы просто будем подавать в функцию число. function changeScore(howMuch) < // Прибавим к старым очкам новые playerScore = playerScore + howMuch; // Выведем новые очки на экран $('#scoretext').text(playerScore) // Узнаем, какой у нас рекорд. Для этого объявим новую переменную highScore, вызовем функцию getHighScore(), запишем её результат в эту переменную var highScore = getHighScore(); // А теперь сравним, больше ли наши очки, чем рекорд по игре if (playerScore >highScore) < //Рекорд побит, значит, надо его записать setHighScore(playerScore, playerName); // Делаем тут что-то, что обычно делают, когда ты побил рекорд игры. Фейерверки? Музыка? Мигание рекордных очков на экране? Мы не знаем пока, что именно будет делать эта функция, и нам это сейчас неважно celebrateHighScore(); >>

function getCircleArea(radius) < // Задаём наше местное определение числа пи var localPi = 3.1415; // Считаем площадь: пи на радиус в квадрате. Это то же самое, что пи умножить на радиус и ещё раз умножить на радиус var circleArea = localPi * radius * radius; // Говорим функции вернуть то, что мы сейчас рассчитали return circleArea; >