{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Объектно-ориентированное программирование и информационная безопасность\n", "\n", "*Валерий Семенов, Самарский университет*\n", "\n", "
\n", "\n", "\n", "

Функции

\n", " \n", "
Функции в Python — это один из основных инструментов для создания удобного и структурированного кода. Они позволяют группировать набор инструкций, которые выполняют определенную задачу, и использовать их многократно в вашей программе.
\n", "\n", "
\n", "\n", "

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

\n", "\n", "
Для создания функции используется ключевое слово def, за которым следует имя функции и круглые скобки (). В скобках указываются параметры функции (если они есть), а после скобок ставится двоеточие :. Тело функции записывается с отступом.
\n", "\n", "
Пример простой функции без параметров:
" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "def greet():\n", " print(\"Hello, world!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

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

\n", "\n", "
Чтобы вызвать функцию, достаточно написать ее имя с круглыми скобками () в любом месте кода:
" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello, world!\n" ] } ], "source": [ "greet() # Выведет \"Hello, world!\"" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Функция, которая ничего не делает\n", "# Определение функции\n", "def do_nothing(): \n", " pass" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Вызов функции\n", "do_nothing()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Функция с параметрами

\n", "\n", "
Функция в Python - объект, принимающий аргументы и возвращающий значение.
\n", " \n", "
Пример функции с параметрами:
" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Определение функции\n", "def func(a, b):\n", " print(a+b)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "func(2,3) # Вызов функции" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "string\n" ] } ], "source": [ "func('str', 'ing') # Вызов функции" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def f(x,y):\n", " if x > y: print(x)\n", " else: print(y)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "f(3,4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Функция может и не заканчиваться инструкцией return, при этом функция вернет значение None:
" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "None\n" ] } ], "source": [ "print(f(3,4)) # Эта функция возвращает значение None" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "a = f(3,4)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "None\n" ] } ], "source": [ "print(a) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Возвращение значения

\n", "\n", "
Функция может возвращать значение (значения) с помощью ключевого слова return. Значение, следующее после return, будет результатом работы функции.
\n", "\n", "
Инструкция return осуществляет выход из функции и передает управление и полученное значение в то место, откуда она была вызвана.
\n", "\n", "
Функция может быть любой сложности и возвращать любые объекты (списки, кортежи, и даже функции!).
" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n" ] } ], "source": [ "def add(a, b):\n", " return a + b\n", " \n", "result = add(2, 3)\n", "print(result)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "def f(x,y):\n", " if x > y: return x\n", " else: return y" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "a = f(3,4)\n", "print(a)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "def func(a,b):\n", " return a**b" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "func(2,3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

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

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

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

\n", "\n", "
Все ранее написанные нами функции имели позиционные аргументы. Такие аргументы передаются без указания имен. Они называются позиционными, потому что именно по позиции, расположению аргумента, функция понимает, какому параметру он соответствует.
\n", "\n", "
Рассмотрим следующий код:
" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] } ], "source": [ "def diff(x, y):\n", " return x - y\n", "\n", "res = diff(10, 3) # Используем позиционные аргументы\n", "print(res)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
При вызове функции diff() первому параметру x будет соответствовать первый переданный аргумент = 10, а второму параметру y — второй аргумент = 3.
\n", "\n", "
В Python можно использовать не только позиционные, но и именованные аргументы.
\n", "\n", "

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

\n", "\n", "
Аргументы, передаваемые с именами, называются именованными. При вызове функции можно использовать имена параметров из ее определения. Исключение составляют списки аргументов неопределенной длины, где используются аргументы со звездочкой (об этом чуть позже).
\n", "\n", "
Рассмотрим следующий код:
" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] } ], "source": [ "def diff(x, y):\n", " return x - y\n", "\n", "res = diff(x=10, y=3) # Используем именованные аргументы\n", "print(res)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Такой код по-прежнему выведет число 7.
\n", " \n", "
При вызове функции diff() мы явно указываем, что параметру x соответствует аргумент 10, а параметру y — аргумент 3.
\n", "\n", "
Использование именованных аргументов позволяет нарушать их позиционный порядок при вызове функции.
\n", " \n", "
Порядок упоминания именованных аргументов не имеет значения!
\n", "\n", "
Мы можем вызвать функцию diff() и так:
" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7\n" ] } ], "source": [ "res = diff(y=3, x=10) # Используем именованные аргументы\n", "print(res)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", "
\n", "
\"\"Возможность использования именованных аргументов — еще один повод давать параметрам значащие, а не однобуквенные имена.
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Когда стоит применять именованные аргументы?

\n", "\n", "
Каких-то строгих правил на этот счет не существует. Однако широко практикуется такой подход: если функция принимает больше трех аргументов, желательно хотя бы часть из них указать по имени. Особенно важно именовать значения аргументов, когда они относятся к одному типу, ведь без имен очень трудно понять, что делает функция с подобным вызовом.
\n", "\n", "
Рассмотрим определение функции make_circle() для рисования круга:
" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "def make_circle(x, y, radius, line_width, fill):\n", " # Тело функции\n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Вызвать такую функцию можно так:
" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "make_circle(200, 300, 17, 2.5, True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Тут непросто понять, какие параметры круга задают числа 200, 300 или 17.
\n", "\n", "
Сравните:
" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "make_circle(x=200, y=300, radius=17, line_width=2.5, fill=True) # Используем именованные аргументы" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Такой код читать значительно проще!
\n", "\n", "
Когда значение аргументов очевидно, можно их не именовать. Да, очевидность относительна, но обычно легко понять, что скрывается за значениями при вызове функции point3d(7, 50, 13) или rgb(7, 255, 45).
\n", " \n", "
В первом случае переданные аргументы – координаты точки в трехмерном пространстве, во втором – значения компонент red, green, blue некоторого цвета. Тут можно ориентироваться только на здравый смысл, жестких правил нет.
\n", "\n", "
Мы уже сталкивались с именованными аргументами, когда вызывали функцию print().
\n", "\n", "
Приведенный ниже код, использует именованные аргументы sep и end:
" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "aaa*bbb##ccc()ddd\n", "eee123fffpython" ] } ], "source": [ "print('aaa', 'bbb', sep='*', end='##')\n", "print('ccc', 'ddd', sep='()')\n", "print('eee', 'fff', sep='123', end='python')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Используя именованные аргументы sep и end можно не беспокоиться, какой из них указать первым.
\n", "\n", "
Напомним, что значение по умолчанию для sep=' ' (символ пробела), а для end='\\n' (символ перевода строки).
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Комбинирование позиционных и именованных аргументов

\n", "\n", "
Мы можем вызывать функции, используя именованные и позиционные аргументы одновременно. Но позиционные значения должны быть указаны до любых именованных!
\n", "\n", "
Для вызова функции diff() используем следующий код:
" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "res = diff(10, y=3) # Используем сначала позиционный, затем именованный аргумент\n", "\n", "res" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Работает как полагается, при этом параметру x соответствует значение 10.
\n", "\n", "
Зато приведенный ниже код:
" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "positional argument follows keyword argument (1182158178.py, line 1)", "output_type": "error", "traceback": [ "\u001b[1;36m Cell \u001b[1;32mIn[26], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m res = diff(x=10, 3) # Используем сначала именованный, затем позиционный аргумент\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n" ] } ], "source": [ "res = diff(x=10, 3) # Используем сначала именованный, затем позиционный аргумент" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
приводит к возникновению ошибки SyntaxError: positional argument follows keyword argument.
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Необязательные аргументы

\n", "\n", "
Бывает, что какой-то параметр функции часто принимает одно и то же значение. Например, для функции print() создатели языка Python установили значения параметров sep и end равными символу пробела и символу перевода строки, поскольку эти значения используют наиболее часто.
\n", "\n", "
Другим примером служит функция int() , преобразующая строку в число.
\n", " \n", "
Она принимает два аргумента:
\n", "\n", "
\n", "
  • первый аргумент - строка, которую нужно преобразовать в число;
    • \n", "
  • второй аргумент - основание системы счисления.
    • \n", "
    \n", " \n", "
    Это позволяет ей считывать числа в различных системах счисления.
    \n", "\n", "
    Приведенный ниже код, преобразует двоичное число 101:
    " ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "num = int('101', 2) # Аргумент 2 указывает на то, что число 101 записано в двоичной системе\n", "\n", "num" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Но чаще всего эта функция используется для преобразования строки чисел, записанных в десятичной системе счисления. Утомительно каждый раз писать 10 вторым аргументом. В таких ситуациях Python позволяет задавать некоторым параметрам значения по умолчанию. У функции int() второй параметр по умолчанию равен 10, и потому можно вызывать эту функцию с одним аргументом. Значение второго подставится автоматически.
    \n", "\n", "
    Чтобы задать значение параметра по умолчанию, в списке параметров функции достаточно после имени переменной написать знак равенства и нужное значение.
    \n", "\n", "
    Параметры со значением по умолчанию идут последними, ведь иначе интерпретатор не смог бы понять, какой из аргументов указан, а какой пропущен, и для него нужно использовать значение по умолчанию.
    \n", "\n", "
    Рассмотрим все то же определение функции make_circle(), которая рисует круг:
    " ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "def make_circle(x, y, radius, line_width, fill):\n", " # тело функции\n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Предположим, что чаще всего нам нужно рисовать круг с шириной линии, равной 2, и с заливкой.
    \n", "
    Поэтому логично установить данные значения в качестве значений по умолчанию:
    " ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "def make_circle(x, y, radius, line_width=2, fill=True):\n", " # тело функции\n", " return" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Теперь для того, чтобы нарисовать стандартный круг, то есть круг имеющий ширину линии, равную 2 с заливкой, мы вызываем функцию так:
    " ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "make_circle(100, 50, 20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    или так:
    " ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "make_circle(x=100, y=50, radius=20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Если же вам захочется поменять ширину линии и заливку, то вы легко можете это сделать:
    " ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "make_circle(x=100, y=50, radius=20, fill=False) # line_width=2, fill=False\n", "make_circle(x=100, y=50, radius=20, line_width=3) # fill=True, line_width=3\n", "make_circle(x=100, y=50, radius=20, line_width=5, fill=False) # line_width=5, fill=False" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Примечания

    \n", "\n", "
    Примечание 1. При написании функций стоит указывать более важные параметры первыми.
    \n", "\n", "
    Примечание 2. Именованные аргументы часто используют вместе со значениями по умолчанию.
    \n", "\n", "
    Примечание 3. При вызове функции позиционные аргументы должны обязательно идти перед именованными аргументами.
    \n", "\n", "
    Примечание 4. Параметр в программировании — принятый функцией аргумент. Термин «аргумент» подразумевает, что конкретно и какой конкретной функции было передано, а параметр — в каком качестве функция применила это принятое. То есть вызывающий код передает аргумент в параметр, который определен в описании (заголовке) функции.
    \n", "\n", "\n", " \n", " \n", " \n", "
    \n", "
    Параметр - формальное значение, которое принадлежит функции и используется в теле функции.
    \n", "
    Аргумент - фактическое значение, которое передается при вызове функции.
    \n", "
    " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Функции с переменным количеством аргументов

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

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

    \n", "\n", "
    Вспомним функцию print(), которой мы пользуемся почти в каждой задаче.
    \n", "
    Функция print() принимает столько аргументов, сколько ей передано. Причем эта функция делает полезную работу, даже когда вызывается вообще без аргументов. В этом случае она переносит каретку печати на новую строку.
    \n", " \n", "
    Пример:
    " ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a\n", "a b\n", "a b c\n", "a b c d\n" ] } ], "source": [ "print('a')\n", "print('a', 'b')\n", "print('a', 'b', 'c')\n", "print('a', 'b', 'c', 'd')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Было бы полезно научиться писать свои собственные функции, способные принимать переменное количество аргументов. Для этого потребуется специальный, совсем не сложный во всех смыслах, синтаксис.
    \n", "\n", "
    Рассмотрим определение функции my_func():
    " ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "()\n", "\n", "(1, 2, 3)\n", "\n", "('a', 'b')\n" ] } ], "source": [ "def my_func(*args):\n", " print(type(args))\n", " print(args)\n", "\n", "\n", "my_func()\n", "my_func(1, 2, 3)\n", "my_func('a', 'b')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    В заголовке функции my_func() указан всего один параметр args, но со звездочкой перед ним.
    \n", " \n", "
    Звездочка в определении функции означает, что переменная (параметр) args получит в виде кортежа все аргументы.
    \n", "\n", "
    При описании функции можно использовать только один параметр помеченный звездочкой, причем располагаться он должен в конце списка параметров, иначе последующим параметрам не достанется значений.
    \n", "\n", "
    Приведенный ниже код, не является рабочим, так как параметр со звездочкой в заголовке функции указан раньше позиционного num:
    " ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "my_func() missing 1 required keyword-only argument: 'num'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[35], line 5\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(args)\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(num)\n\u001b[1;32m----> 5\u001b[0m my_func(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m)\n", "\u001b[1;31mTypeError\u001b[0m: my_func() missing 1 required keyword-only argument: 'num'" ] } ], "source": [ "def my_func(*args, num): # Неправильная запись заголовка функции!\n", " print(args)\n", " print(num)\n", "\n", "my_func(1, 2, 3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Другой пример:
    " ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('Python', 2, 'C#')\n", "17\n" ] } ], "source": [ "def my_func(num, *args):\n", " print(args)\n", " print(num)\n", "\n", "my_func(17, 'Python', 2, 'C#')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Приведенный выше код связывает с переменной num значение 17, а с переменной args значение кортежа ('Python', 2, 'C#').\n", "\n", "
    Помеченный звездочкой параметр *args нормально переживает и отсутствие аргументов, в то время как позиционные параметры всегда обязательны.
    \n", "\n", "
    Вот пример вызова функции, который связывает с переменной num значение 17, а с переменной *args значение пустого кортежа ():
    " ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "()\n", "17\n" ] } ], "source": [ "my_func(17)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Обратите внимание: функция my_func() принимает несколько аргументов, но как минимум один аргумент должен быть передан обязательно. Этот первый аргумент станет значением переменной num, а остальные аргументы сохранятся в переменной args. Подобным образом можно делать любое количество обязательных аргументов.
    \n", "\n", "\n", "\n", " \n", " \n", " \n", "
    \n", "
    \"\"   Параметр args в определении функции пишется после позиционных параметров перед первым параметром со значением по умолчанию.
    \n", "
    " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

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

    \n", "\n", "
    Иногда хочется сначала сформировать набор аргументов, а потом передать их функции. Тут поможет оператор распаковки коллекций, который также обозначается звездочкой *.
    \n", "\n", "
    Вспомним, что встроенная функция sum() принимает на вход коллекцию чисел (список, кортеж, и т.д).
    \n", "\n", "
    Рассмотрим пример:
    " ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 100\n" ] } ], "source": [ "sum1 = sum([1, 2, 3, 4]) # Считаем сумму чисел в списке\n", "sum2 = sum((10, 20, 30, 40)) # Считаем сумму чисел в кортеже\n", "\n", "print(sum1, sum2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Однако функция sum() не может принимать переменное количество аргументов.
    \n", "\n", "
    Приведенный ниже код приводит к возникновению ошибки:
    " ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "sum() takes at most 2 arguments (5 given)", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[39], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28msum\u001b[39m(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m)\n", "\u001b[1;31mTypeError\u001b[0m: sum() takes at most 2 arguments (5 given)" ] } ], "source": [ "sum(1, 2, 3, 4, 5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Напишем свою версию функции sum(), функцию my_sum(), которая принимает переменное количество аргументов и вычисляет их сумму:
    " ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "3\n", "6\n", "10\n" ] } ], "source": [ "def my_sum(*args):\n", " return sum(args) # args - это кортеж\n", "\n", "print(my_sum())\n", "print(my_sum(1))\n", "print(my_sum(1, 2))\n", "print(my_sum(1, 2, 3))\n", "print(my_sum(1, 2, 3, 4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Мы также можем вызывать нашу функцию функцию my_sum(), передавая ей списки или кортежи, предварительно распаковав их.
    \n", "\n", "
    Например:
    " ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "15\n", "6\n" ] } ], "source": [ "print(my_sum(*[1, 2, 3, 4, 5])) # Распаковка списка\n", "print(my_sum(*(1, 2, 3))) # Распаковка кортежа" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Более того, часть аргументов можно передавать непосредственно и даже коллекции подставлять не только по одной.
    \n", "\n", "
    Например:
    " ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "49\n" ] } ], "source": [ "print(my_sum(1, 2, *[3, 4, 5], *(7, 8, 9), 10))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", "
    \n", "
    \"\"По соглашению, параметр, получающий подобный кортеж значений, принято называть args (от слова arguments). Старайтесь придерживаться этого соглашения.
    \n", "
    " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Получение именованных аргументов в виде словаря

    \n", "\n", "
    Позиционные аргументы можно получать в виде *args, причем произвольное их количество. Такая возможность существует и для именованных аргументов. Только именованные аргументы получаются в виде словаря, что позволяет сохранить имена аргументов в ключах.
    \n", "\n", "
    Рассмотрим определение функции my_func():
    " ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "{}\n", "\n", "{'a': 1, 'b': 2}\n", "\n", "{'name': 'Timur', 'job': 'Teacher'}\n" ] } ], "source": [ "def my_func(**kwargs):\n", " print(type(kwargs))\n", " print(kwargs)\n", "\n", "my_func()\n", "my_func(a=1, b=2)\n", "my_func(name='Timur', job='Teacher')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    По соглашению параметр, получающий подобный словарь, принято называть kwargs (от словосочетания keyword arguments). Старайтесь придерживаться этого соглашения.
    \n", "\n", "
    Параметр **kwargs пишется в самом конце списка параметров, после последнего параметра со значением по умолчанию. При этом функция может содержать и *args и **kwargs параметры.
    \n", "\n", "
    Рассмотрим определение функции, которая принимает все виды аргументов.
    " ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2\n", "(3, 4)\n", "Timur 28\n", "{'job': 'Teacher', 'language': 'Python'}\n", "1 2\n", "()\n", "Timur 28\n", "{'job': 'Teacher', 'language': 'Python'}\n", "1 2\n", "(3, 4)\n", "Gvido 17\n", "{'job': 'Teacher', 'language': 'Python'}\n" ] } ], "source": [ "def my_func(a, b, *args, name='Gvido', age=17, **kwargs):\n", " print(a, b)\n", " print(args)\n", " print(name, age)\n", " print(kwargs)\n", "\n", "my_func(1, 2, 3, 4, name='Timur', age=28, job='Teacher', language='Python')\n", "my_func(1, 2, name='Timur', age=28, job='Teacher', language='Python')\n", "my_func(1, 2, 3, 4, job='Teacher', language='Python')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Не нужно пугаться, в реальном коде функции редко используют все эти возможности одновременно. Но понимать, как каждая отдельная форма объявления параметров работает, и как такие формы сочетать — очень важно.
    " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Передача именованных аргументов в форме словаря

    \n", "\n", "
    Как и в случае позиционных аргументов, именованные можно передавать в функцию \"пачкой\" в виде словаря. Для этого нужно перед словарём поставить две звёздочки.
    \n", "\n", "
    Рассмотрим определение функции my_func():
    " ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "{'name': 'Timur', 'age': '28', 'job': 'teacher'}\n" ] } ], "source": [ "def my_func(**kwargs):\n", " print(type(kwargs))\n", " print(kwargs)\n", "\n", "info = {'name':'Timur', 'age':'28', 'job':'teacher'}\n", "\n", "my_func(**info)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Рассмотрим еще один пример определения функции print_info(), распечатывающей информацию о пользователе:
    " ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Имя: Меган\n", "Фамилия: Фокс\n", "Возраст: 34\n", "Город проживания: Ок-Ридж\n", "Дети: Бодхи Рансом Грин, Ноа Шэннон Грин, Джорни Ривер Грин\n", "{'height': 163, 'job': 'actress'}\n" ] } ], "source": [ "def print_info(name, surname, age, city, *children, **additional_info):\n", " print('Имя:', name)\n", " print('Фамилия:', surname)\n", " print('Возраст:', age)\n", " print('Город проживания:', city)\n", " if len(children) > 0:\n", " print('Дети:', ', '.join(children))\n", " if len(additional_info) > 0:\n", " print(additional_info)\n", "\n", "children = ['Бодхи Рансом Грин', 'Ноа Шэннон Грин', 'Джорни Ривер Грин']\n", "additional_info = {'height':163, 'job':'actress'}\n", "\n", "print_info('Меган', 'Фокс', 34, 'Ок-Ридж', *children, **additional_info)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    При подстановке аргументов \"разворачивающиеся\" наборы аргументов вроде *positional и **named можно указывать вперемешку с аргументами соответствующего типа: *positional с позиционными, а **named — с именованными. И, конечно, же, все именованные аргументы должны идти после всех позиционных!
    " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Keyword-only аргументы

    \n", "\n", "
    В Python 3 добавили возможность пометить именованные аргументы функции так, чтобы вызвать функцию можно было, только передав эти аргументы по именам. Такие аргументы называются keyword-only и их нельзя передать в функцию в виде позиционных.
    \n", "\n", "
    Рассмотрим определение функции make_circle():
    " ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [], "source": [ "def make_circle(x, y, radius, *, line_width=1, fill=True): pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Здесь звездочка (*) выступает разделителем - отделяет обычные аргументы (их можно указывать по имени и позиционно) от строго именованных.
    \n", "\n", "
    То есть аргументы x, y и radius могут быть переданы как в качестве позиционных, так и именованных аргументов. При этом аргументы line_width и fill могут быть переданы только как именованные аргументы.
    \n", "\n", "
    Приведенный ниже код работает как и полагается (ничего не делает, не вызывает ошибку):
    " ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [], "source": [ "make_circle(10, 20, 5) # x=10, y=20, radius=5, line_width=1, fill=True\n", "make_circle(x=10, y=20, radius=7) # x=10, y=20, radius=7, line_width=1, fill=True\n", "make_circle(10, 20, radius=10, line_width=2, fill=False) # x=10, y=20, radius=10, line_width=2, fill=False\n", "make_circle(x=10, y=20, radius=17, line_width=3) # x=10, y=20, radius=17, line_width=3, fill=True" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Зато следующий код приводит к возникновению ошибок:
    " ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "positional argument follows keyword argument (22430930.py, line 2)", "output_type": "error", "traceback": [ "\u001b[1;36m Cell \u001b[1;32mIn[49], line 2\u001b[1;36m\u001b[0m\n\u001b[1;33m make_circle(x=10, y=20, 15, True)\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n" ] } ], "source": [ "make_circle(10, 20, 15, 20)\n", "make_circle(x=10, y=20, 15, True)\n", "make_circle(10, 20, 10, 2, False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
    Этот пример неплохо демонстрирует подход к описанию аргументов.
    \n", " \n", "
    Первые три аргумента — координаты центра круга и радиус. Координаты центра и радиус присутствуют у круга всегда, поэтому обязательны и их можно не именовать. А вот line_width и fill — необязательные аргументы, ещё и получающие ничего не говорящие значения. Вполне логично ожидать, что вызов вида make_circle(10, 20, 5, 3, False) мало кому понравится! Поэтому ради ясности необязательные аргументы line_width и fill и объявлены так, что могут быть указаны только явно через имя.
    \n", "\n", "
    Мы также можем объявить функцию, у которой будут только строго именованные аргументы, для этого нужно поставить звездочку (*) в самом начале перечня аргументов:
    \n", "\n", "
    Теперь для вызова функции make_circle() нам нужно передать значения всех аргументов явно через их имя:
    " ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [], "source": [ "def make_circle(*, x, y, radius, line_width=1, fill=True): pass\n", "\n", "make_circle(x=10, y=20, radius=15) # line_width=1, fill=True\n", "make_circle(x=10, y=20, radius=15, line_width=4, fill=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", " \n", " \n", " \n", "
    \n", "
    \"\"Такой разделитель можно использовать только один раз в определении функции. Его нельзя применять в функциях с неограниченным количеством позиционных аргументов *args.
    \n", "
    " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

    Примечания

    \n", "\n", "
    Примечание 1. Специальный синтаксис *args и **kwargs в определении функции позволяет передавать функции переменное количество позиционных и именованных аргументов. При этом args и kwargs просто имена. Вы не обязаны их использовать, можно выбрать любые, однако среди Python программистов приняты именно эти.
    \n", "\n", "
    Примечание 2. Вы можете использовать одновременно *args и **kwargs в одной строке для вызова функции. В этом случае порядок имеет значение. Как и аргументы, не являющиеся аргументами по умолчанию, *args должны предшествовать и аргументам по умолчанию, и **kwargs.
    \n", " \n", "
    Правильный порядок параметров:
    \n", "\n", "
      \n", "
    1. Позиционные аргументы без значений по умолчанию.
      2. \n", "
    2. Позиционные аргументы со значениями по умолчанию.
      3. \n", "
    3. Позиционные аргументы, указанные как *args.
      4. \n", "
    4. Именованные аргументы.
      5. \n", "
    5. Именованные аргументы, указанные как **kwargs.
      6. \n", "
    " ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.7" } }, "nbformat": 4, "nbformat_minor": 4 }