Return python значение. Функции и их аргументы

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

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

• print() выводит объект в терминал.
• int() преобразовывает строки или числа в целые числа.
• len() возвращает длину объекта.

Имя функции содержит круглые скобки и может содержать параметры.

Данное руководство научит вас определять пользовательские функции.

Определение функции

Для начала попробуйте преобразовать простую программу «Hello, World!» в функцию.

Создайте новый текстовый файл hello.py, а затем определите функцию.

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

Чтобы определить функцию hello(), добавьте в файл hello.py:

Это исходное определение функции.

def hello():
print("Hello, World!")

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

После определения функции вызовите её:

def hello():
print("Hello, World!")
hello()

Теперь запустите программу:

Она должна вернуть:

Функция hello() – довольно простой пример. Функции могут быть гораздо сложнее: содержать циклы for, условные выражения и другие компоненты.

Достигая оператора return, функция прекращает выполнение.

# Файл return_loop.py
def loop_five():
for x in range(0, 25):
print(x)
if x == 5:
# Stop function at x == 5
return
print("This line will not execute.")
loop_five()

Оператор return в цикле for прекращает выполнение функции, потому строки после функции не будут запущены. Если бы вместо него использовался оператор break, программа прекратила бы выполнение цикла, а не функции, и последнее выражение print() было бы обработано.

Функция main()

В языке Python функцию можно вызвать в конце программы, и она запустится (как показано в предыдущих примерах), однако некоторым языкам программирования (например, C++ или Java) требуется функция main. Функция main() в Python необязательна, но она позволяет логически структурировать программу Python и объединить наиболее важные её компоненты в одну функцию. Также с её помощью программы Python легче читать программистам, которые работают с другими языками.

Вернитесь в файл hello.py и добавьте функцию main(), сохранив при этом функцию hello().

def hello():
print("Hello, World!")
def main():

В функцию main() добавьте выражение print(). Затем вызовите функцию hello() внутри функции main().

def hello():
print("Hello, World!")
def main():
print("This is the main function")
hello()

В конце файла вызовите функцию main().

def hello():
print("Hello, World!")
def main():
print("This is the main function.")
hello()
main()

Теперь можно запустить программу:

python hello.py
This is the main function.
Hello, World!

Теперь попробуйте использовать несколько функций.

Быстрая навигация:
1.31 Списки - массивы. Первое знакомство. 1.30 Функции которые возвращают результат - return 1.29 Подпрограммы: функции и процедуры в Питоне 1.28 Преобразование типов данных - int() 1.27 Ввод данных с клавиатуры - input() 1.26 Типы и размеры данных 1.25 Цикл с предусловием - while. Числа Фибоначчи 1.24 Измерение длины строки, списки 1.23 Срезы строк - вывод определенного количества символов из имеющегося текста 1.22 Строки и управляющие символы 1.21 Системные ошибки в процессе отладки программы 1.20 Оператор ветвления - if, комментарии 1.19 Вывод на печать - print(), быстрый ввод данных, округление, комментарии 1.18 Типы программирования. Часть 2. Объектно-ориентированное программирование 1.17 Типы программирования. Часть 1. Структурное программирование. Циклы 1.16 Представление символьной информации - ASCII 1.15 Деление двоичных чисел 1.14 Математические операции с двоичными числами 1.13 Как хранится и записывается информация. Биты и байты 1.12 Перевод целых чисел десятичной системы счисления в другую систему 1.11 Перевод целых чисел из шестнадцатеричной системы счисления в десятичную 1.10 Перевод целого двоичного числа в шестнадцатеричное 1.9 Перевод целого двоичного числа в другую систему счисления 1.8 Системы счисления 1.7 Булевая алгебра. Логические выражения 1.6 Базовые понятия. Часть 3 - Числа, выражения, операнды, знаки операций 1.5 Базовые понятия. Часть 2 - Программа, данные 1.4 Базовые понятия. Часть 1 - Задача и алгоритм 1.3 Среда разработки СИ 1.2 История языков программирования 1.1 Введение

При написании программ в любом языке программирования необходимо стремиться к написанию компактных кодов, чтобы можно было легко ориентироваться в самом коде.
Бывает что реализовать таким образом свой код не представляется возможным и, зачастую, программный код выглядит как нескончаемой длинны свиток древнего документа, который занимает 10 - 15 экранов монитора по вертикали...
Конечно же разобраться в такой программе бывает крайне сложно самому автору такого творения.

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

Подпрограмма - это некая законченная программа, но не самостоятельная.
Она вызывается из какой то программы более высокого уровня только для выполнения того или иного действия.

Как это выглядит на практике?
К примеру в какой то очень большой программе вам необходимо произвести (мы с вами уже рассматривали алгоритм его работы).
И вместо того, чтобы в этом большом программном коде каждый раз писать еще и код для расчета чисел Фибоначчи, мы просто выносим его в отдельный файл. Это и будет подпрограмма.
Тогда в том месте где должен производиться необходимый расчет этих чисел мы вставляем лишь некое указание на то, чтобы в этом месте была вызвана наша подпрограмма.

В этом случае программный код значительно уменьшается в объеме и разобраться в работе программы будет намного легче.

В разных языках программирования такие подпрограммы называются:

Процедурами или
- функциями

В языке СИ такие подпрограммы называются функциями.

Кстати мы с вами уже применяли функции на практике!
Например мы с вами использовали ВСТРОЕННЫЕ в интерпретатор функции:

Print() - для вывода данных на печать неких параметров, которые были заключены в круглые скобки
- str() - для преобразования данных к строковому типу. Именно ее предварительно запускает функция print()
- int() - для преобразования данных к целому числу
- float() - для преобразования целых чисел в дробный тип
- round() - для округления некоего значения
и т.п.

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

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

def ИМЯ_ФУНКЦИИ(СПИСОК_ПАРАМЕТРОВ):
ПОСЛЕДОВАТЕЛЬНОСТЬ_ВЫРАЖЕНИЙ

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

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

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

Def fib(n): a, b = 0, 1 while a < n: print(a, end = " ") a, b = b, a + b print()

Если вкратце, то строка:
a, b = 0, 1
означает запись (но не полностью эквивалентна ей):
a = 0 b = 1

А строка
a, b = b, a + b
означает запись:
a = b b = a + b

Рассмотрим код по строкам:

1
def fib(n):
- определить (def ) функцию по имени fib с параметрами (аргументами) указанными в круглых скобках которые мы хотим передать в эту самую функцию по имени fib .
Т.е. в качестве параметра n мы будем передавать значение для которого будет производиться расчет. Это число будет передаваться в нашу функцию в качестве аргумента.

После двоеточия вводимые данные в интерпретаторе Python печатаются с отступом. Это говорит о том, что эти данные имеют непосредственное отношение к данной функции.

2
a, b = 0, 1
Инициализируем переменные соответствующими значениями:
a = 0 b = 1

3
while a < n:
Оператор цикла while - будет выполняться до тех пор, пока будет выполнено условие цикла a
Здесь также после двоеточия открывается новый блок имеющий НЕПОСРЕДСТВЕННОЕ отношение только к циклу.
Этот блок будет печататься после перевода строки с дополнительным отступом.

4
print(a, end = " ")
Выводим на печать данные переменной а и пробел после каждого витка цикла

5
a, b = b, a + b
Присваиваем переменным соответствующие значения:
a = b b = a + b
Для изменения исходных данных и продолжения работы расчета чисел Фибоначчи

6
print()

Обратите внимание на то, что данный print() нужно печатать ПОД while ... т.е. он уже относится не к телу цикла while , а к телу функции fib
Однако для чего нам нужен второй print() да еще и с пустыми скобками?

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

Итак мы определили функцию fib для расчета чисел Фибоначчи и она, как вы заметили - не работает.

Для того, чтобы она заработала необходимо ее ВЫЗВАТЬ и передать ей некий параметр для расчетов.
Вызываем нашу функцию и передаем в качестве аргумента значение 40 .
В результате мы должны получить расчет чисел Фибоначчи для всех чисел до 40 :

Печатаем в интерпретаторе Python:
fib(40)
Получаем:

0 1 1 2 3 5 8 13 21 34

Вы можете еще раз вызвать функцию fib() с другим параметром и точно также получите вывод необходимых данных.
Например введем
fib(400)
И получим:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Таким образом нашу функцию можно запускать необходимое количество раз.

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

Функция - возвращает значение
- Процедура - не возвращает значение

Поясним на примере:

Если мы можем использовать такую запись (только в качестве примера):
x = fib(n) - то это функция, она присваивает полученное значение переменной x (в данном случае переменной x ничего записано не будет)

Если же возможна только запись fib(n) - то это процедура.

Таким образом мы можем сказать, что наш пример является ПРОЦЕДУРОЙ.

Как в Питоне использовать наш код для расчета чисел Фибоначчи в качестве функции мы рассмотрим несколько позже...

Начав писать главу про ООП, понял что совсем забыл освятить такой большой и нужный раздел Пайтона как функции. Тема это большая и обширная, потому, чтобы не сильно растягивать паузу между уроками, решил разделить ее на 2 части. Сначала расскажу основы, потом уже углубленные особенности Пайтоновского функциестроения.

Функции в Пайтоне объявляются не просто, а очень просто. Вот пример самой простой:

Def empty_func(): pass
Начинается объявление с ключевого слова def, что как не сложно догадаться является сокращением от define. После него идет имя функции. После имени в круглых скобках задается список параметров, в данном случае отсутствующих.
Тело функции пишется с отступом со следующей строки. учтите, что в Пайтоне функции с пустым телом запрещены, потому в качестве тела приведенной выше функции используется «пустой оператор» pass.
Теперь рассмотрим пример посерьезнее.

Def safe_div(x, y): """Do a safe division:-) for fun and profit""" if y != 0: z = x / y print z return z else: print "Yippie-kay-yay, motherf___er!"
В этом примере есть несколько нововведений. первое, что бросается в глаза - это строка документации (docstring), идущая сразу после тела функции.
Обычно эта строка занимает не одну строку исходного текста (простите за каламбур) и потому задается в тройных кавычках. Она предназначена для описания функции, ее предназначения, параметров и т.п. Все хорошие ИДЕ умеют с этой строкой работать. Получить к ней доступ можно и из самой программы, используя свойство __doc__:

Print safe_div.__doc__
Этим свойством (да, да, именно свойством, в Пайтоне даже функции на самом деле - классы) удобно пользоваться во время сеансов работы интерактивной консоли.
>>> from ftplib import FTP >>> print FTP.__doc__ An FTP client class. To create a connection, call the class using these argument: host, user, passwd, acct These are all strings, and have default value "". Then use self.connect() with optional host and port argument. # дальнейшее почикано мною:-)
Вернемся к нашей исходной функции. Суть ее очень проста, она принимает 2 параметра: х и у. Если у не равен 0, она делит х на у, выводит результат на экран и возвращает свое частное в виде результата. Результат функции возвращают с помощью команды return. Благодаря механизму кортежей, описанному в прошлом уроке, функции в Пайтоне могут возвращать одновременно множество объектов.
Если же делитель все-таки равен нулю, функция выводит сообщение об ошибке. Неверно было бы предположить что в этом случае функция ничего не вернет. Правильнее будет сказать что функция вернет «ничего»:) Иначе говоря, если в функции отсутствует оператор return, или же он вызван без параметров, то функция возвращает специальное значение None. В этом легко убедиться вызвав что-то типа print safe_div(10, 0).

Вот пример слегка посложнее, он взят из доклада-презентации Гвидо ван Россума.

Def gcd(a, b): "Нахождение НОД" while a != 0: a,b = b%a,a # параллельное определение return b
Данная функция находит наибольший общий делитель двух чисел.

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

Mystic_function = safe_div print mystic_function(10, 4)
Вот на этот раз и все, «за бортом» осталось еще много аспектов определения функций в Пайтоне, которые будут освещены в следующий раз.

Упражнения для проверки.
1. На основе существующей функции нахождения НОД, напишите функцию поиска НОК двух чисел.
2. Напишите подпрограмму табулирования функции, переданной в качестве аргумента. Так же аргументами задается начальное, конечное значение и шаг табуляции.

PS кстати, каков оптимальный объем «урока»? Что лучше - реже выходящие большие главы, или «лучше меньше да чаще».

Напоминалка по использованию параметров (аргументов) функций в Python.

Позиционные параметры

Замечания:

• Все как обычно.
• При вызове указывать обязательно все позиционные аргументы.

Произвольное количество аргументов

Замечания:

• Обозначается звездочкой перед аргументом - *args
• Внутри функции выглядит как кортеж, элементы кортежа расположены в том же порядке, что и аргументы функции, указанные при вызове.
• Передать список при вызове функции как набор аргументов можно, приписав к обозначению списка спереди звездочку

Пример 1. Определение функции с переменным количеством аргументов:

Пример 2. Передача списка в функцию, как набора аргументов:

Комментарии к примеру 2:

• Строка 8: Переменное к-во аргументов
• Строка 9: Список (передается как один аргумент)
• Строка 10: Список со звездочкой (передается как переменное к-во аргументов)

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

Замечания:

• При вызове указывать необязательно. Если не указаны, им присваиваются дефолтные значения.

Примечания:

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

Пример к примечанию:

Произвольное количество именованных аргументов

Замечания:

• Обозначается двумя звездочками перед аргументом - **kwargs
• Внутри функции выглядит как словарь, с ключами, соответствующими именам аргументов, указанными при вызове функции.
• Передать словарь при вызове функции как набор именованных аргументов можно, приписав две звездочки перед обозначением словаря. Напримиер так: **kwargs

Пример 1. Определение функции с произвольным количество именованных аргументов:

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

Комментарии к примеру 2:

• Строка 9: Словарь передан как один именованный аргумент.
• Строка 10: Словарь передан как произвольное количество именованных аргументов.

Все виды параметров вместе

Передача параметра по ссылке (изменение параметра внутри функции)

Если при вызове функции подставим в качестве значения аргумента переменную, а в теле функции мы меняем значение аргумента, то то, что произойдет, зависит от того, с каким значение связана наша переменная. Если переменная связана с неизменяемым значением, например int, str, tulpe, то естественно, это значение не изменится. А вот если переменная связана со списком, словарем или классом, то значение связанного с переменной объекта изменится.

Не изменяется:

Изменяется:

Следствие 1: если нам нужно "передать параметр по ссылке", как в Си, делать этого не следует, может получиться не то, что хотим. Цель передачи параметра по ссылке в Си - вернуть несколько значений из функции, путем изменения значений по ссылкам внутри функции. В питоне можно возвращать кортеж, поэтому, если нужно вернуть нескоько значений, нужно возвращать кортеж и присваивать его значения переменным.

Следствие 2: во избежание "боковых эффектов", значениями по умолчанию лучше делать неизменяемые типы (None, int, str, tulpe)

Комментарии:

Имя: Игорь

Спасибо, пригодилась

Имя: Den

За a(**d) отдельное спасибо.

Имя: test

Имя: alex

Имя: Serg

Спасибо за доходчивые разъяснения!

Имя: Vlad2030

def fprintf(*args,**kwargs):
print kwargs...
print args...

KP=2
N_elem =
c="privet"

KP = 2
N_elem =
c = "privet"

fprintf(KP, N_elem, c)

результат:
KP = 2
N_elem =
c = privet

Имя: seyalek

>>Как написать функцию чтобы она печатала имена и значения своих переменных??

def fprintf(**kwargs):
for k, v in kwargs.items():
print "%s = %s" % (k, v)

и извратно вызывать:
fprintf(KP=KP, N_elem=N_elem, c=c)

Имя: Александр

Жаль, что такое большое количество примеров нельзя использовать в СРР Ибо фитонки я не знаю. А ведь тема интересная и очень хотелось бы знать, как её применять на практике, а не просто 1,2,3. Например если есть задача воплотить идею в атмегу8 На срр [это индекс массива] = {Привет мир} =)
индекс++ и каждый цикл выводим по букве.

Имя: Denis

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

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

Вообщем как-то так!

Имя: Asya

def even(x):
if x%2==0:
print("Yes")
____?
print("No")

Что поставить в предпоследне

Имя: Asya

def even(x):
if x%2==0:
print("Yes")
____?
print("No")

Что поставить в предпоследней строчке???

Имя: Shitz

Имя: aaa

Имя: Alesha

Asya, тупая!

Имя: Pavlo

Последнее обновление: 11.04.2018

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

Def имя_функции ([параметры]): инструкции

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

Например, определение простейшей функции:

Def say_hello(): print("Hello")

Функция называется say_hello . Она не имеет параметров и содержит одну единственную инструкцию, которая выводит на консоль строку "Hello".

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

Def say_hello(): print("Hello") say_hello() say_hello() say_hello()

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

Hello Hello Hello

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

Def say_hello(name): print("Hello,",name) say_hello("Tom") say_hello("Bob") say_hello("Alice")

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

Hello, Tom Hello, Bob Hello, Alice

Значения по умолчанию

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

Def say_hello(name="Tom"): print("Hello,", name) say_hello() say_hello("Bob")

Здесь параметр name является необязательным. И если мы не передаем при вызове функции для него значение, то применяется значение по умолчанию, то есть строка "Tom".

Именованные параметры

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

Def display_info(name, age): print("Name:", name, "\t", "Age:", age) display_info("Tom", 22)

При вызове функции первое значение "Tom" передается первому параметру - параметру name, второе значение - число 22 передается второму параметру - age. И так далее по порядку. Использование именованных параметров позволяет переопределить порядок передачи:

Def display_info(name, age): print("Name:", name, "\t", "Age:", age) display_info(age=22, name="Tom")

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

Неопределенное количество параметров

С помощью символа звездочки можно определить неопределенное количество параметров:

Def sum(*params): result = 0 for n in params: result += n return result sumOfNumbers1 = sum(1, 2, 3, 4, 5) # 15 sumOfNumbers2 = sum(3, 4, 5, 6) # 18 print(sumOfNumbers1) print(sumOfNumbers2)

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

Возвращение результата

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

Def exchange(usd_rate, money): result = round(money/usd_rate, 2) return result result1 = exchange(60, 30000) print(result1) result2 = exchange(56, 30000) print(result2) result3 = exchange(65, 30000) print(result3)

Поскольку функция возвращает значение, то мы можем присвоить это значение какой-либо переменной и затем использовать ее: result2 = exchange(56, 30000) .

В Python функция может возвращать сразу несколько значений:

Def create_default_user(): name = "Tom" age = 33 return name, age user_name, user_age = create_default_user() print("Name:", user_name, "\t Age:", user_age)

Здесь функция create_default_user возвращает два значения: name и age. При вызове функции эти значения по порядку присваиваются переменным user_name и user_age, и мы их можем использовать.

Функция main

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

Def main(): say_hello("Tom") usd_rate = 56 money = 30000 result = exchange(usd_rate, money) print("К выдаче", result, "долларов") def say_hello(name): print("Hello,", name) def exchange(usd_rate, money): result = round(money/usd_rate, 2) return result # Вызов функции main main()