Содержание

Функции и их аргументы | Python 3 для начинающих и чайников

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

Именные функции, инструкция def

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

Определим простейшую функцию:

def add(x, y):
    return x + y

Инструкция return говорит, что нужно вернуть значение. В нашем случае функция возвращает сумму x и y.

Теперь мы ее можем вызвать:

>>> add(1, 10)
11
>>> add('abc', 'def')
'abcdef'

Функция может быть любой сложности и возвращать любые объекты (списки, кортежи, и даже функции!):

>>> def newfunc(n):
...     def myfunc(x):
...         return x + n
...     return myfunc
...
>>> new = newfunc(100)  # new - это функция
>>> new(200)
300

Функция может и не заканчиваться инструкцией return, при этом функция вернет значение None:

>>> def func():
...     pass
...
>>> print(func())
None

Аргументы функции

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

>>> def func(a, b, c=2): # c - необязательный аргумент
...     return a + b + c
...
>>> func(1, 2)  # a = 1, b = 2, c = 2 (по умолчанию)
5
>>> func(1, 2, 3)  # a = 1, b = 2, c = 3
6
>>> func(a=1, b=3)  # a = 1, b = 3, c = 2
6
>>> func(a=3, c=6)  # a = 3, c = 6, b не определен
Traceback (most recent call last):
  File "", line 1, in
    func(a=3, c=6)
TypeError: func() takes at least 2 arguments (2 given)

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

>>> def func(*args):
...     return args
...
>>> func(1, 2, 3, 'abc')
(1, 2, 3, 'abc')
>>> func()
()
>>> func(1)
(1,)

Как видно из примера, args — это кортеж из всех переданных аргументов функции, и с переменной можно работать также, как и с кортежем.

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

>>> def func(**kwargs):
...     return kwargs
...
>>> func(a=1, b=2, c=3)
{'a': 1, 'c': 3, 'b': 2}
>>> func()
{}
>>> func(a='python')
{'a': 'python'}

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

Анонимные функции, инструкция lambda

Анонимные функции могут содержать лишь одно выражение, но и выполняются они быстрее. Анонимные функции создаются с помощью инструкции lambda. Кроме этого, их не обязательно присваивать переменной, как делали мы инструкцией def func():

>>> func = lambda x, y: x + y
>>> func(1, 2)
3
>>> func('a', 'b')
'ab'
>>> (lambda x, y: x + y)(1, 2)
3
>>> (lambda x, y: x + y)('a', 'b')
'ab'

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

>>> func = lambda *args: args
>>> func(1, 2, 3, 4)
(1, 2, 3, 4)

pythonworld.ru

Работаем с функциями в Python

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

def, названия функции и двоеточия, пример:

def a_function(): print(«You just created a function!»)

def a_function():

    print(«You just created a function!»)

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

a_function() # You just created a function!

a_function() # You just created a function!

Просто, не так ли?

Пустая функция (stub)

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

def empty_function(): pass

def empty_function():

    pass

А вот здесь кое-что новенькое: оператор pass. Это пустая операция, это означает, что когда оператор pass выполняется, не происходит ничего.

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

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

def add(a, b): return a + b print( add(1, 2) ) # 3

def add(a, b):

    return a + b

 

print( add(1, 2) ) # 3

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

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

add(1) Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: add() takes exactly 2 arguments (1 given)

add(1)

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: add() takes exactly 2 arguments (1 given)

Вы также можете вызвать функцию, указав наименование аргументов:

print( add(a = 2, b = 3) ) # 5 total = add(b = 4, a = 5) print(total) # 9

print( add(a = 2, b = 3) ) # 5

 

total = add(b = 4, a = 5)

print(total) # 9

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

Вы, возможно, подумаете: «А что, собственно, произойдет, если мы укажем аргументы, но они названы неправильно? Это сработает?» Давайте попробуем на примере:

add(c=5, d=2) Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: add() got an unexpected keyword argument ‘c’

add(c=5, d=2)

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: add() got an unexpected keyword argument ‘c’

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

Мы собрали ТОП Книг для Python программиста которые помогут быстро изучить язык программирования Python. Список книг: Книги по Python

Ключевые аргументы

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

def keyword_function(a=1, b=2): return a+b print( keyword_function(b=4, a=5) ) # 9

def keyword_function(a=1, b=2):

    return a+b

 

print( keyword_function(b=4, a=5) ) # 9

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

Функция вернулась к нам с числом 3. Почему? Причина заключается в том, что а и b по умолчанию имеют значение 1 и 2 соответственно. Теперь попробуем создать функцию, которая имеет обычный аргумент, и несколько ключевых аргументов:

def mixed_function(a, b=2, c=3): return a+b+c mixed_function(b=4, c=5) Traceback (most recent call last): File «<string>», line 1, in <fragment> TypeError: mixed_function() takes at least 1 argument (2 given)

def mixed_function(a, b=2, c=3):

    return a+b+c

 

mixed_function(b=4, c=5)

 

Traceback (most recent call last):

    File «<string>», line 1, in <fragment>

TypeError: mixed_function() takes at least 1 argument (2 given)

print( mixed_function(1, b=4, c=5) ) # 10 print( mixed_function(1) ) # 6

print( mixed_function(1, b=4, c=5) ) # 10

 

print( mixed_function(1) ) # 6

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

вызывает ошибку. Во втором примере мы вызвали смешанную функцию, с тремя значениями, два из которых имеют название. Это работает, и выдает нам ожидаемый результат: 1+4+5=10. Третий пример показывает, что происходит, если мы вызываем функцию, указывая только на одно значение, которое не рассматривается как значение по умолчанию. Это работает, если мы берем 1, и суммируем её к двум значениям по умолчанию: 2 и 3, чтобы получить результат 6! Удивительно, не так ли?

*args и **kwargs

Вы также можете настроить функцию на прием любого количества аргументов, или ключевых аргументов, при помощи особого синтаксиса. Чтобы получить бесконечное количество аргументов, мы используем *args, а чтобы получить бесконечное количество ключевых аргументов, мы используем

*kwargs. Сами слова “args” и “kwargs” не так важны. Это просто сокращение. Вы можете назвать их *lol и *omg, и они будут работать таким же образом. Главное здесь – это количество звездочек. Обратите внимание: в дополнение к конвенциям *args и *kwargs, вы также, время от времени, будете видеть andkw. Давайте взглянем на следующий пример:

def many(*args, **kwargs): print( args ) print( kwargs ) many(1, 2, 3, name=»Mike», job=»programmer») # Результат: # (1, 2, 3) # {‘job’: ‘programmer’, ‘name’: ‘Mike’}

def many(*args, **kwargs):

    print( args )

    print( kwargs )

 

many(1, 2, 3, name=»Mike», job=»programmer»)

 

# Результат:

# (1, 2, 3)

# {‘job’: ‘programmer’, ‘name’: ‘Mike’}

Сначала мы создали нашу функцию, при помощи нового синтаксиса, после чего мы вызвали его при помощи трех обычных аргументов, и двух ключевых аргументов. Функция показывает нам два типа аргументов. Как мы видим, параметр args превращается в кортеж, а kwargs – в словарь. Вы встретите такой тип кодинга, если взгляните на исходный код Пайтона, или в один из сторонних пакетов Пайтон.

Область видимость и глобальные переменные

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

def function_a(): a = 1 b = 2 return a+b def function_b(): c = 3 return a+c print( function_a() ) print( function_b() )

def function_a():

    a = 1

    b = 2

    return a+b

 

 

def function_b():

    c = 3

    return a+c

 

print( function_a() )

print( function_b() )

Если вы запустите этот код, вы получите ошибку:

NameError: global name ‘a’ is not defined

NameError: global name ‘a’ is not defined

Это вызвано тем, что переменная определенна только внутри первой функции, но не во второй. Вы можете обойти этот момент, указав в Пайтоне, что переменная а – глобальная (global). Давайте взглянем на то, как это работает:

def function_a(): global a a = 1 b = 2 return a+b def function_b(): c = 3 return a+c print( function_a() ) print( function_b() )

def function_a():

    global a

    a = 1

    b = 2

    return a+b

 

 

def function_b():

    c = 3

    return a+c

 

print( function_a() )

print( function_b() )

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

Советы в написании кода

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

Сайт doctorsmm.com предлагает Вам персональные предложения по покупке лайков в ВК к постам и публикациям. Здесь Вы найдете дешевые цены на услуги, а также различные критерии, подходящие к любой ситуации. На сервисе также доступно приобретение репостов, голосов в голосования и опросы сети.

Копировать и вставлять один и тот же кусок кода – хороший пример спагетти-кода. Постарайтесь избегать этого так часто, как только получится. Вы будете сожалеть об этом в какой-то момент либо потому, что вам придется все это исправлять, либо потому, что вы столкнетесь с чужим кодом, с которым вам придется работать и исправлять вот это вот всё.

Подведем итоги

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

python-scripts.com

Python. Урок 10. Функции в Python

Урок посвящен созданию функций в Python и работе с ними (передача аргументов, возврат значения и т.п.). Также рассмотрены lambda-функций, их особенности и использование.

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

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

def fun():
    pass

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

>>> def fun():
    return 1
>>> fun()
1

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

>>> def summa(a, b):
    return a + b
>>> summa(3, 4)
7

Рассмотрим еще два примера использования функции: вычисление числа Фибоначчи с использованием рекурсии и вычисление факториала с использованием цикла.

Вычисление числа Фибоначчи.

>>> def fibb(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fibb(n-1) + fibb(n-2)
>>> print(fibb(10))
55

Вычисление факториала.

>>> def factorial(n):
    prod = 1
    for i in range(1, n+1):
        prod *= i
    return prod

>>> print(factorial(5))
120

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

>>> import math
>>> f = math.factorial
>>> print(f(5))
120

Lambda-функция – это безымянная функция с произвольным числом аргументов и вычисляющая одно выражение. Тело такой функции не может содержать более одной инструкции (или выражения). Данную функцию можно использовать в рамках каких-либо конвейерных вычислений (например внутри filter(), map() и reduce()) либо самостоятельно, в тех местах, где требуется произвести какие вычисление, которые удобно “завернуть” в функцию.

 >>> (lambda x: x**2)(5)
25

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

>>> sqrt = lambda x: x**0.5
>>> sqrt(25)
5.0

Списки можно обрабатывать lambda-функциями внутри таких функций как map(), filter(), reduce(), о них мы ещё поговорим, а пока рассмотрим пример с map(). Функция map принимает два аргумента, первый – это функция, которая будет применена к каждому элементу списка, а второй – это список, который нужно обработать.

>>> l = [1, 2, 3, 4, 5, 6, 7]
>>> list(map(lambda x: x**3, l))
[1, 8, 27, 64, 125, 216, 343]

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
Книга: Pandas. Работа с данными

<<< Python. Урок 9. Словари (dict)   Python. Урок 11. Работа с исключениями>>>

devpractice.ru

Pythonicway — Функции в Python

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

Создание функции

Существуют некоторые правила для создания функций в Python.

  • Блок функции начинается с ключевого слова def, после которого следуют название функции и круглые скобки ( () ).
  • Любые аргументы, которые принимает функция должны находиться внутри этих скобок.
  • После скобок идет двоеточие ( : ) и с новой строки с отступом начинается тело функции.

Пример функции в Python:

def my_function(argument):
    print argument

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

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

Например:

my_function("abracadabra")

Аргументы функции в Python

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

  • Обязательные аргументы (Required arguments)
  • Аргументы-ключевые слова (Keyword argument)
  • Аргументы по умолчанию (Default argument)
  • Аргументы произвольной длины (Variable-length argumens)

Обязательные аргументы функции:

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

Например:

def bigger(a,b):
    if a > b:
        print a
    else:
       print b

# В описании функции указано, что она принимает 2 аргумента

# Корректное использование функции
bigger(5,6)

# Некорректное использование функции
bigger()
bigger(3)
bigger(12,7,3) 

Аргументы — ключевые слова

Аргументы — ключевые слова используются при вызове функции. Благодаря ключевым аргументам, вы можете задавать произвольный (то есть не такой каким он описа при создании функции) порядок аргументов.

Например:

def person(name, age):
    print name, "is", age, "years old"

# Хотя в описании функции первым аргументом идет имя, мы можем вызвать функцию вот так

person(age=23, name="John")

Аргументы, заданные по-умолчанию

Аргумент по умолчанию, это аргумент, значение для которого задано изначально, при создании функции.

Например:

def space(planet_name, center="Star"):
    print planet_name, "is orbiting a", center

# Можно вызвать функцию space так:
space("Mars")
# В результате получим: Mars is orbiting a Star

# Можно вызвать функцию space иначе:
space("Mars", "Black Hole")
# В результате получим: Mars is orbiting a Black Hole

Аргументы произвольной длины

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

Например:

def unknown(*args):
    for argument in args:
        print argument

unknown("hello","world") # напечатает оба слова, каждое с новой строки
unknown(1,2,3,4,5) # напечатает все числа, каждое с новой строки
unknown() # ничего не выведет

Ключевое слово return

Выражение return прекращает выполнение функции и возвращает указанное после выражения значение. Выражение return без аргументов это то же самое, что и выражение return None. Соответственно, теперь становится возможным, например, присваивать результат выполнения функции какой либо переменной.

Например:

def bigger(a,b):
    if a > b:
        return a # Если a больше чем b, то возвращаем b и прекращаем выполнение функции
    return b # Незачем использовать else. Если мы дошли до этой строки, то b, точно не меньше чем a

# присваиваем результат функции bigger переменной num
num = bigger(23,42)

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

В Python две базовых области видимости переменных:

  • Глобальные переменные
  • Локальные переменные

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

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

Например:

# глобальная переменная age
age = 44

def info():
    print age # Печатаем глобальную переменную age

def local_info():
    age = 22 # создаем локальную переменную age 
    print age

info() # напечатает 44
local_info() # напечатает 22

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

Например:

# глобальная переменная age
age = 13

# функция изменяющая глобальную переменную
def get_older():
    global age
    age += 1

print age # напечатает 13
get_older() # увеличиваем age на 1
print age # напечатает 14

Рекурсия

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

Напомним, что факториалом числа, например, 5 является произведение всех натуральных (целых) чисел от 1 до 5. То есть, 1 * 2 * 3 * 4 * 5

Рекурсивная функция вычисления факториала на языке Python будет выглядеть так:

def fact(num):
    if num == 0: 
        return 1 # По договоренности факториал нуля равен единице
    else:
        return num * fact(num - 1) # возвращаем результат произведения num и результата возвращенного функцией fact(num - 1)

Однако следует помнить, что использование рекурсии часто может быть неоправданным. Дело в том, что в момент вызова функции в оперативной памяти компьютера резервируется определенное количество памяти, соответственно чем больше функций одновременно мы запускаем — тем больше памяти потребуется, что может привести к переполнению стека (stack overflow) и программа завершится аварийно, не так как предполагалось. Учитывая это, там где это возможно, вместо рекурсии лучше применять циклы.

Рецепт создания функции в Python

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

  1. Начинать следует с примеров того, что делает функция, и подобрать подходящее название. В нашем случае это будет выглядеть так:
    # На данном этапе мы еще не указываем имена переменных
    def rectangle_area_finder( ):
        """
        >>> rectangle_area_finder(3, 5)
        15
        >>> rectangle_area_finder(17.2, 6)
        103.2
        """
  2. Указать типы данных, которые принимает функция и тип данных, который она возвращает
    # функция принимает два числа, а возвращает одно
    def rectangle_area_finder( ):
        """
        (num, num) -> num    
    
        >>> rectangle_area_finder(3, 5)
        15
        >>> rectangle_area_finder(17.2, 6)
        103.2
        """
  3. Подобрать подходящие названия для переменных
    # Поскольку это математическая функция нам вполне подойдут имена a и b
    def rectangle_area_finder(a, b):
        """
        (num, num) -> num
        
        >>> rectangle_area_finder(3, 5)
        15
        >>> rectangle_area_finder(17.2, 6)
        103.2
        """
  4. Написать краткое, но содержательное описание функции
    def rectangle_area_finder(a, b):
        """
        (num, num) -> num
    
        Returns an area of a rectangle with given sides a and b.    
    
        >>> rectangle_area_finder(3, 5)
        15
        >>> rectangle_area_finder(17.2, 6)
        103.2
        """
  5. Написать собственно тело функции
    def rectangle_area_finder(a, b):
        """
        (num, num) -> num
    
        Returns an area of a rectangle with given sides a and b.    
    
        >>> rectangle_area_finder(3, 5)
        15
        >>> rectangle_area_finder(17.2, 6)
        103.2
        """
        return a * b
  6. Функция готова! Осталось вызвать ее с указанными в примерах аргументами

Как видно, при вызове команды help() с именем нашей функции в качестве аргумента мы получаем написанную нами документацию.

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

pythonicway.com

Функции в Python

Функции в Python

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

Создать функцию в Python

Создание функции в Python, начинается с объявления ключевого слова def (определить), затем идет название функции с круглыми скобками и двоеточие (:). Затем, каждый раз начиная с новой строки и с отступом в 4 пробела, записываются те самые инструкции. Код с инструкциями называется телом функции.

def func_name():
    инструкция_1
    инструкция_2
    ...и.т.д

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

Когда функция написана, то сама по себе она не будет выполняться. Функцию надо вызвать, сделать это можно в разных местах программы. Как вызывается функция? Мы обращается к имени функции, не забывая указать пару круглых скобок на конце. Без скобок функция не выполнится. Нельзя функцию вызвать до её объявления.

func_name()

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

Нужно вывести на экран тело функции.

  1. объявляем функцию
  2. пишем инструкцию в теле функции
  3. вызов функции
  4. получаем результат выполнения тела функции
def f_example() #1
    print('тело функции') #2
f_example() #3
тело функции #4

Аргументы функции в Python

Зачем мы пишем пустые скобочки на конце названия функции? Надо сказать, что не всегда они пустые. В скобочках могут передаваться аргументы, но не обязательно. Аргументы — это входные данные, которые передаются функции при её создании и вызове. Если функция создается с аргументами, то и вызывается с аргументами.

def f_arg(z):
    #тело функции

Главное предназначение функции — это обработка полученных данных и получение результата. Давайте рассмотрим пример функции, которая умножает передаваемое число на два и распечатывает готовый результат. В скобках указываем аргумент x, значение которого функция получит позже. Далее пишем инструкции, что должна делать сама функция multiplay. Функция умножает число на два и распечатывает результат. Вызываем функцию multiplay(4) и передаем в скобках значение 4, с которым функция должна работать. В результате выполнения кода, на экран выведется число 8.

Что происходит при вызове функции? Когда мы вызываем функцию и передаем ей аргумент (4), то этот аргумент внутри функции получает название x и подставляется вместо него в инструкциях.

def multiplay(x):
    result = x * 2
    print(result)
multiplay(4)
8

Возвращаемое значение функции (return)

Когда функция просто выводит что-то на экран print(x), то она ничего не возвращает. Однако функция может получать на входе какие-то данные, обрабатывать их и возвращать полученное значение. С помощью оператора return, функция возвращает какое-то значение, при её вызове.

Мы в скобочках передаем аргумент и говорим: «Верни нам при вызове сумму аргумента n и числа 10″. Далее вызываем функцию с аргументом 5, присваиваем результат вызова функции — переменной b, программа подставляет 5 вместо n и нам возвращается число 15.

Пример 1

def func_r(n):
    return 10+n
b = func_r(5)
print(b)
15

Пример 2

def multi(a, b):
    return a*b
c = multi(2, 3)
print(c)
6

Функция может не принимать на вход аргументы, но возвращать какое-то значение.

def func_v():
    return 7
d = func_v()
print(d)
7

Заключение

Итак, функции в Python, могут быть:

  • без аргументов вообще
  • без аргументов, но с возвращаемым значением
  • с аргументами и возвращаемым значением

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

  • Функции в Python Создано 01.11.2019 11:10:49
  • Функции в Python Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

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

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

myrusakov.ru

Основы Python — кратко. Часть 5. Определение функций, основы. / Habr

Начав писать главу про ООП, понял что совсем забыл освятить такой большой и нужный раздел Пайтона как функции. Тема это большая и обширная, потому, чтобы не сильно растягивать паузу между уроками, решил разделить ее на 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 кстати, каков оптимальный объем «урока»? Что лучше — реже выходящие большие главы, или «лучше меньше да чаще».

habr.com

Python | Функции

Функции

Последнее обновление: 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. В итоге мы получим следующий консольный вывод:

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


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()

metanit.com