Функции питона: создать, вызвать, разные параметры и примеры аргументов

создать, вызвать, разные параметры и примеры аргументов

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

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

Синтаксис функций в Python

Любые функции и методы начинаются с инструкции def (от английского define — «определять»). За def в Python идет название функции, после — набор аргументов. Двоеточие в конце открывает блок тела функции, которое располагают с новой строки.

В Python нет фигурных скобок для блока кода. Вместо них применяют отступы в четыре пробела. Новая инструкция — новая строка. Или можно отделить их точкой с запятой.Чтобы завершить функцию и вернуть из нее значение, используют ключевое слово return. Если этого не указать, то, когда тело функции достигает конца, функция завершится. Возвращается объект типа None.

https://sky.pro/media/modul-requests-v-python/

Аргументы и их виды

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

🚀 Позиционные

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

def addfunc(val1, val2):
    return val1 + val2

result = addfunc(3, 2)
print(result)
5

addfunc() # вызов без аргументов
Traceback (most recent call last):
...
TypeError: addfunc() missing 2 required positional arguments: 'val1' and 'val2'

addfunc(1) # вызов с одним аргументом
Traceback (most recent call last):
...
TypeError: addfunc() missing 1 required positional argument: 'val2'

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

Они  будут доступны внутри тела функции и ассоциированы с переменными val1 и val2. Если этого не сделаете, получите ошибку TypeError.

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

def addconcat(*args):
    value = 0

    for item in args:
        if isinstance(item, (int, float)):
            value += item
        else:
            print(f"{item} is not a digit")

    return value

total = addconcat(1, "Hello", 2, 3, 4, "Python", 5.0, 6.25, 7.15, 'string')
Hello is not a digit
World is not a digit
string is not a digit

print("Total:", total)
Total: 28.4

Обращаются к позиционному аргументу такого множества с помощью операции индексации:

def demo_func(*args):
    try:
        print(args[0])
        print(args[1])
    except IndexError:
        pass

🚀 Именованные

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

def hey_concat(*args, name="World!"):
    print("Hey there,", name)

hey_concat()
Hey there, World!

hey_concat(name="Alex")
Hey there, Alex

Атрибуту name присвоили иное значение. Это поменяет результат склеивания строк и последующий вывод.

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

def print_kwargs(**kwargs):
    print(kwargs) # отобразит словарь

print_kwargs(kone="One", ktwo=2, kthree=3.0)
{'kone': 'One', 'ktwo': 2, 'kthree': 3.0}

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

def kwargs_addconcat(**kwargs):

    a = kwargs. get("a", None)
    b = kwargs.get("b", None)

    if not isinstance(a, type(b)):
        raise TypeError("Ошибка! Разные типы")

    if isinstance(a, str):
        return f"Результат конкатенации строк\n{a + b}"

    elif isinstance(a, int):
        return f"Результат сложения чисел\n{a + b}"

    return "Ошибка"


print(kwargs_addconcat(a=1, b=2))
Результат сложения чисел
3

print(kwargs_addconcat(a=1, b="World!"))
...
TypeError: Ошибка! Разные типы

print(kwargs_addconcat(a="Hello, ", b="World!"))
Результат конкатенации строк
Hello, World!

# Без аргументов
print(kwargs_addconcat())
Ошибка

В примере упаковываем именованные аргументы в переменную с названием kwargs. Из нее в теле функции по ключам a и b пытаемся получить значения. А если они не найдутся — объект

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

Еще можно комбинировать позиционные и именованные параметры. Сначала располагают позиционные (обязательные) аргументы. Сразу за ними идет переменная, в которую записывают все остальные параметры без явного ключа. Далее — именованные аргументы с предустановленным значением (значением по умолчанию). После него располагают переменную словаря с остальными именованными параметрами.

Общая форма последовательности:

def func(a, b, *args, name="Default", **kwargs):
    return None

Функции и области видимости

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

✈️ Глобальная

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

var1 = 12

def global_func():
    print(x)

Здесь целочисленный объект

var1 и функция global_func — в глобальной области видимости.

✈️ Локальная

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

var1 = 2213 # глобальная переменная

# глобальная функция, использующая глобальную переменную
def func_one():
    print(var1)

# глобальная функция, использующая локальную переменную
def func_two():
    var1 = "Local value" # создание локальной переменной
    print(var1)

# функция, изменяющая значение глобальной переменной
def func_three():
    global var1
    var1 = "Local to global"

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

func_one()
2213

func_two()
Local value

func_three() # функция меняет значение глобальной переменной
func_one() # и результат функции func_one
Local to global

✈️ Область объемлющих функций

В Python есть ключевое слово

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

Так реализуют декоратор счетчика вызова функции Python с этим ключевым словом:

def count_deco(wrapper_func):
    var = 0

    def inner():
        nonlocal var
        wrapper_func()
        var += 1
        print(var)
    return inner


@count_deco
def deco_demo():
    print("A few of example text...")


for _ in range(5):
    deco_demo()

A few of example text...
1
A few of example text.  ..
2
A few of example text...
3
A few of example text...
4
A few of example text...
5

Lambda-функции (анонимные)

Одна из интересных особенностей Python — это анонимные (лямбда) функции. Это простое выражение, которое можно присвоить переменной и использовать повторно. Чаще применяют для фильтрации элементов множества:

list_values = [1, 3, 4, 2, 6, 7, 5, 8, 9]
filter(lambda x : x % 2 == 0, list_values)
[2, 4, 6, 8]

Оператор возврата return

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

Если функция возвращает несколько объектов, они будут запакованы в кортеж (tuple). Тогда к конкретным элементам обращаются либо по индексу, либо с помощью распаковки множества, где каждый элемент присваивают отдельной переменной. Функция, где явно не указано возвращаемое значение, по умолчанию вернет объект типа None.

def arithmetics(x, y):
    return x + y, x - y, x * y, x / y, x // y

results = arithmetics(22, 3)

print(results)
(25, 19, 66, 7.333333333333333, 7)

print(results[0])
25

r1, r2, r3, r4, r5 = arithmetics(4, 4)

# результаты сложения и умножения
print(r1)
8

print(r3)
16

Оператор возврата yield

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

QA-автоматизатор. Знакомство с Python. Урок 1 Чтобы передать аргументы генератору и вернуть значения, применяют ключевое слово yield. Когда элементы объекта-генератора заканчиваются, тот возбуждает исключение типа StopIteration:

def gen_demo(times, var):
    for _ in range(times):
        yield var

gen_inst = gen_demo(25, "Gen demo text")

for _ in range(26):
    print(next(gen_inst))

Gen demo text
Gen demo text
Gen demo text
Gen demo text
. ..

Traceback (most recent call last):
...
StopIteration

[FAQ] Частые вопросы

Функции vs процедуры — в чём отличие?

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

Для чего нужна область видимости? 

Чтобы решить конфликт имен.

Как провести распаковку множества? 

Нужно присвоить его такому же количеству переменных, сколько в нём содержится объектов.

Обязательно ли наличие аргументов для функции? 

Нет, но чаще у функции есть один или несколько аргументов.

Вебинары

Главное о функциях в Python

• У каждой функции есть своя область видимости, в которую входят все пространства имен уровнем выше.
• Если явно не задать возвращаемое значение, функция вернет объект типа None.
• Функция с одной или несколькими инструкциями yield будет генератором.
• В Python аргументы функции бывают двух видов — именованные и позиционные. Оба типа аргументов могут быть переменной длины.

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

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

Функции и методы в Python: передача функции в функцию. Декоратор

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

Что надо знать о методах и функциях в Python?

Говоря о функциях в Python, нужно упомянуть два аспекта: 1) функция в Python — есть объект специального вида, который можно передавать в виде аргумента другим функциям; 2) внутри функций в Python вы можете создавать другие функции, а также вызывать их, возвращая результат посредством return.

Теперь давайте поговорим об этом подробнее.

Функция как объект в Python

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

>>> # исходный список
>>> a = [1, 2, 3, 4, 5]
>>> # функция, которая возводит в квадрат переданное ей число 
>>> sq = lambda x: x**2
>>> # проверка работы функции в Python
>>> print(sq(5))
25
>>> # получение списка квадратов
>>> b = list(map(sq, a))
>>> print(b)
[1, 4, 9, 16, 25]

В нашем примере мы передали функции map в виде первого аргумента функцию sq. Последняя будет по очереди применяться ко всем элементам нашего списка a.

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

class DemoCall():
def __call__(self):
return "Hello!"

Объект такого класса в Python мы сможем вызывать как функцию:

>>> hello = DemoCall()
>>> hello()
'Hello!'

Функция внутри функции в Python

Функции в Python мы можем создавать, вызывать и возвращать из других функций. Кстати, на этом основана идея замыкания (closures) в Python.

Давайте создадим функцию, умножающую 2 числа:

def mul(a):
def helper(b):
return a * b
return helper

В этой функции в Python реализованы два важных свойства: 1) внутри функции mul() мы создаём ещё одну функцию helper(); 2) функция mul() возвращает нам функцию helper() в качестве результата работы.

Вызов этой функции в Python:

>>>mul(4)(2)
8

Особенность заключается в том, что мы можем создавать на базе функции mul() собственные кастомизированные функции. Давайте создадим функцию в Python, умножающую на 3:

>>>three_mul = mul(3)
>>>three_mul(5)
15

В результате была построена функция three_mul(), умножающая на 3 любое переданное ей число.

Декоратор функции в Python

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

Создание

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

def first_test():
print("Test function 1")
def second_test():
print("Test function 2")

При этом мы желаем их дополнить таким образом, чтобы перед вызовом основного кода нашей функции печаталась строчка “Start function”, а в конце – строка “Stop function”.

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

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

def simple_decore(fn):
def wrapper():
print("Start function")
fn()
print("Stop function")
return wrapper

Теперь нужно обернуть функции в оболочку:

first_test_wrapped = simple_decore(first_test)
second_test_wrapped = simple_decore(second_test)

Обратите внимание, что функции first_test и second_test не поменялись.

>>> first_test()
Test function 1
>>> second_test()
Test function 2

Наши функции second_test_wrapped и first_test_wrapped обладают функционалом, который нам и нужен.

>>> first_test_wrapped()
Start function
Test function 1
Stop function
>>> first_test_wrapped()
Start function
Test function 1
Stop function

Теперь, если надо, чтобы так работали функции с именами first_test и second_test, делаем следующее:

first_test = first_test_wrapped
second_test = second_test_wrapped

Проверяем:

>>> first_test()
Start function
Test function 1
Stop function
>>> second_test()
Start function
Test function 2
Stop function

Выполненные нами действия и являются реализацией идеи декоратора.

Правда, вместо строк:

def first_test():
print("Test function 1")
first_test_wrapped = simple_decore(first_test)
first_test = first_test_wrapped 

мы можем написать иначе:

@simple_decore
def first_test():
print("Test function 1")

В нашем случае @simple_decore – это не что иное, как декоратор функции.

Передаём аргументы в функцию с помощью декоратора

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

def param_transfer(fn):
def wrapper(arg):
print("Start function: " + str(fn.__name__) + "(), with param: " + str(arg))
fn(arg)
return wrapper

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

@param_transfer
def print_sqrt(num):
print(num**0.5)

Теперь давайте выполним данную функцию с аргументом 4:

>>> print_sqrt(4)
Start function: print_sqrt(), with param: 4
2.0

Декораторы для методов класса в Python

С декоратором можно объявлять и методы классов. Давайте выполним модификацию декоратора param_transfer:

def method_decor(fn):
def wrapper(self):
print("Start method: " + str(fn. __name__))
fn(self)
return wrapper

Теперь приступим к созданию класса для представления 2-мерного вектора (математического). В классе определим метод norm(), выводящий модуль вектора.

class Vector():
def __init__(self, px = 0, py = 0):
self.px = px
self.py = py
@method_decor
def norm(self):
print((self.px**2 + self.py**2)**0.5)

Что же, осталось продемонстрировать работу нашего метода:

>>> vc = Vector(px=10, py=5)
>>> vc.norm()
Start method: norm
11.180339887498949

Возвращаем результат работы функции через декоратор

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

def decor_with_return(fn):
def wrapper(*args, **kwargs):
print("Start method: " + str(fn.__name__))
return fn(*args, **kwargs)
return wrapper

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

@decor_with_return
def calc_sqrt(val):
return val**0. 5

Осталось выполнить функцию calc_sqrt() с параметром 16:

>>> tmp = calc_sqrt(16)
Start method: calc_sqrt
>>> print(tmp)

Узнайте от А до Я о функциях Python

Python — один из самых популярных языков программирования, доступных сегодня. Он широко используется в различных секторах бизнеса, таких как программирование, веб-разработка, машинное обучение и наука о данных. Учитывая его широкое распространение, неудивительно, что Python превзошел Java как лучший язык программирования.

Что такое функции Python?

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

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

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

Синтаксис: имя определения (аргументы) :

  Заявление

  возвращаемое значение

Пример:

Рис: Функция Python

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

Пример:

Рис. Для вызова функции Python

Распространенная ошибка программирования:

Отсутствие отступа в теле функции является синтаксической ошибкой.

Надлежащая практика программирования :

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

Что такое аргументы в функции Python?

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

Пример :

Рис: Функциональные параметры

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

Общая ошибка программирования:

Отсутствие двоеточия (:) после списка параметров функции является синтаксической ошибкой.

Типы аргументов

1. Аргументы по умолчанию

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

Пример:

 

Рис: Аргументы по умолчанию

2. Произвольные аргументы

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

Пример:

Рис: Произвольные аргументы

3. Аргументы ключевых слов

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

Пример:

Рис: Аргумент ключевого слова

Чтобы вернуть значение из функции, мы используем оператор return. Он «возвращает» результат вызывающей стороне.

Пример:

Рис. Оператор возврата в функциях Python

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

Вложенные функции

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

Пример:

Рис. Вложенные функции

Рекурсивная функция

Рекурсивная функция — это функция, которая повторяет свое поведение до тех пор, пока не будет выполнено заданное условие.

Пример:

Рис.: Рекурсивная функция

Практические упражнения

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

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

Программа:

Рис. Решение 1

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

Программа:

Рис. Решение 2

Следующий код выполняется следующим образом: мы создаем функцию для умножения и передачи параметра «числа». «числа». Цикл for выполняет итерацию по каждому элементу в списке и умножает его на сумму, пока не будет достигнуто последнее число.

Заключение

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

Если у вас есть какие-либо вопросы, оставьте их ниже, и наши специалисты ответят на них.

Хотите узнать больше о Python?

Python — это один из самых востребованных навыков, которые сегодня ищут работодатели во всех отраслях. Если вы готовы поднять ставки в своей карьере, запишитесь на наш учебный курс Python сегодня!

Функции и логика Python: Памятка по функциям Python

Параметры функций

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

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

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

 
 def write_a_book(персонаж, настройка, special_skill): 
 
 print(персонаж + "находится в" + 
 
 настройка + "практиковать ее" + 
 
 special_skill) 
 

Множественные параметры

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

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

 
 def ready_for_school(рюкзак, пенал): 
 
 if (рюкзак == 'полный' и пенал == 'полный'): 
 
 print ("Я готов к школе!") 
 

Функции

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

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

 
 # Определение функции my_function() с параметром x 
 
 def my_function(x): 
 
 return x + 1 
 
 # Вызов функции 
 
 print(my_function(2)) # Вывод: 3 
 
 print ( my_function(3 + 5)) # Вывод: 9 
 

Отступ функции

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

 
 # Отступ используется для идентификации кодовых блоков 
 
 def testfunction(number): 
 
 # Этот код является частью testfunction 
 
 print("Внутри тестовой функции") number): 
 
 # Больше отступов, потому что 'for' имеет кодовый блок 
 
 # но все еще является частью функции 
 
 sum += x 
 
 возвращаемая сумма 
 
 print("Это не часть тестовой функции") 
 

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

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

Например, предоставленный код вызовет метод doHomework() .

 
 doHomework() 
 

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

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

Например, в функцию .sales() передаются аргументы «Фермерский рынок», «зубная паста» и «1 доллар», которые соответствуют параметрам product_store , item_on_sale и cost .

 
 по определению продаж (продуктовый_магазин, товар_в продаже, стоимость): 
 
 print(продуктовый_магазин + "продается" + товар_в продаже + " за " + стоимость) 
 
 продажи("Фермерский рынок", "зубная паста", "1$") 
 

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

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

 
 def findvolume(длина=1, ширина=1, глубина=1): 
 
 print("Длина = " + str(длина)) 
 
 print("Ширина = " + str(ширина)) 
 
 print ("Глубина = " + str(глубина)) 
 
 возврат длина * ширина * глубина; 
 
 findvolume(1, 2, 3) 
 
 findvolume(длина=5, глубина=2, ширина=4) 
 
 findvolume(2, depth=3, width=4) 
 

Возврат нескольких значений

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

В примере функция Square_point() возвращает x_squared , y_squared и z_squared .

 
 по определению Square_point(x, y, z): 
 
 x_squared = x * x 
 
 y_squared = y * y 
 
 z_squared = z * z 
 
 # Вернуть все три значения: 
 
 return x_squared, y_squared, z_squared 900 03 
 три_в квадрате, четыре_в квадрате, пять_в квадрате = квадрат_точка(3, 4 , 5) 
 

Область действия переменных

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

В примере переменная a определена как внутри, так и вне функции. Когда реализована функция f1() , a печатается как 2 , потому что локально определено так. Однако при печати a вне функции, a печатается как 5 , потому что это реализовано вне области действия функции.

 
 а = 5 
 
 def f1(): 
 
 а = 2 
 
 print(a) 
 
 print(a) # Будет напечатано 5 
 
 f1() # Будет напечатано 2 
 

Возврат значения из функции

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

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

 
 def check_leap_year(year): 
 
 if year % 4 == 0: 
 
 return str(year) + "это високосный год." 
 
 иначе: 
 
 return str(год) + "год не високосный." 
 
 year_to_check = 2018 
 
 return_value = check_leap_year(year_to_check) 
 
 print(returned_value) # 2018 год не високосный. 
 

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

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

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

 
 a = "Привет" 
 
 def prints_a(): 
 
 print(a) 
 
 # будет печатать "Привет" 
 
 prints_a() 
 

Параметры как локальные переменные

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

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

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