python_pd/04_functions/01_args.ipynb

{
 "metadata": {
  "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.9.0-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Аргументы функций\n",
    "\n",
    "Аргументы у функций указываются в ее определении в круглых скобках. Функции в Python могут принимать два вида аргументов:\n",
    "- позиционные;\n",
    "- ключевые.\n",
    "\n",
    "Оба вида аргументов могут быть разделены еще на две группы:\n",
    "- обязательные;\n",
    "- необязательные.\n",
    "\n",
    "Перейдем к подробному рассмотрению каждой группы аргументов.\n",
    "\n",
    "## Позиционные аргументы\n",
    "\n",
    "Позиционные аргументы задаются в определении функции как идентификаторы, перечисленные через запятую. В примере ниже аргументы ```a```, ```b``` и ```c``` будут позиционными. Позиционными эти аргументы называются потому, что при вызове функции передаваемые значения перечисляются через запятую и каждое значение попадает в тот аргумент, на чьем порядковом месте оно находится. Но такое определение функции позволяет вызвать функцию разными способами, в том числе явно указывая имена у всех или части аргументов, т.е. передавать параметры как ключевые.\n",
    "\n",
    "Таким образом, определение функции вида ```def foo(a, b, c)``` имеет следующие особенности:\n",
    "- передавать параметры как позиционные и как ключевые;\n",
    "- все параметры являются обязательными."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(a, b, c):\n",
    "    print(f'{a = }, {b = }, {c = }')"
   ]
  },
  {
   "source": [
    "Вызывать такую функцию можно по-разному:\n",
    "- передавая все аргументы как позиционные, т.е. только значения;\n",
    "- передавая все аргументы как ключевые, т.е. указывая имена и значение через знак ```=```;\n",
    "- передавая часть аргументов как позиционные, а часть как ключевые."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3\na = 2, b = 2, c = 3\na = 3, b = 3, c = 1\na = 4, b = 3, c = 1\na = 5, b = 2, c = 3\n"
     ]
    }
   ],
   "source": [
    "foo(1, 2, 3)  # первое значение попадет в 'a', второе - в 'b' и тд.\n",
    "foo(a=2, b=2, c=3)  # значения запишутся по именам\n",
    "foo(c=1, a=3, b=3)  # если у всех аргументов указаны имена, их порядок не важен\n",
    "foo(4, c=1, b=3)  # все значения с указанными именами должны быть перечислены в конце\n",
    "foo(5, 2, c=3)  # имена можно указывать не для всх параметров"
   ]
  },
  {
   "source": [
    "Есть ряд правил, которые необходимо соблюдать при вызове функции и передаче аргументов:\n",
    "- позиционные аргументы идут перед ключевыми;\n",
    "- нельзя указывать несколько значений для одного аргумента."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "foo() got multiple values for argument 'a'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-ed51ab4da673>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# 1 попадет в аргумент a, затем снова идет a\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;31m# foo(a=1, b=2, 3)  # SyntaxError. Сначала должны идти позиционные параметры\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: foo() got multiple values for argument 'a'"
     ]
    }
   ],
   "source": [
    "# TypeError. 1 попадет в аргумент 'a', затем снова идет 'a'\n",
    "# как ключевой аргумент. Получается для a предусмотрено \n",
    "# несколько значений.\n",
    "foo(1, a=2, c=3)\n",
    "\n",
    "# SyntaxError. Сначала должны идти позиционные параметры.\n",
    "foo(a=1, b=2, 3)"
   ]
  },
  {
   "source": [
    "## Ключевые аргументы\n",
    "\n",
    "Ключевые аргументы задаются в определении функции с помощью указания значения по умолчанию через знак ```=```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(a, b=1, c=196):\n",
    "    print(f'{a = }, {b = }, {c = }')"
   ]
  },
  {
   "source": [
    "Эту функцию можно вызывать разными способами, по аналогии с предыдущим примером."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3\na = 2, b = 2, c = 3\na = 3, b = 3, c = 1\na = 4, b = 1, c = 196\na = 5, b = 42, c = 196\na = 6, b = 1, c = 42\n"
     ]
    }
   ],
   "source": [
    "foo(1, 2, 3)  # первое значение попадет в 'a', второе - в 'b' и тд.\n",
    "foo(a=2, b=2, c=3)  # явно указаны имена для всех параметров\n",
    "foo(c=1, a=3, b=3)  # если имена указаны явно - порядок не имеет значения\n",
    "foo(4)  # ключевые аргументы не обязательно передавать, они будут равны значениям по умолчанию\n",
    "foo(5, 196)  # 196 попадет в 'b', а 'c' примет значение по умолчанию \n",
    "foo(6, b=42)  # можно передавать некоторые из них\n",
    "foo(7, c=42)"
   ]
  },
  {
   "source": [
    "В таблице приведены разные варианты объявления функции. Обратите внимание, что аргументы различаются. Те из них, что заданы только именем -- позиционные, а те, что имеют значение по умолчанию, заданное с помощью знака ```=```, -- ключевые. Несмотря на это, передавать аргументы можно в любом виде: как ключевые или как позиционные. \n",
    "\n",
    "| Определение              | Позиционные параметры     | Ключевые параметры        | Передаются как ключевые   | Передаются как позиционные |\n",
    "|--------------------------|:-------------------------:|:-------------------------:|:-------------------------:|:--------------------------:|\n",
    "| ```foo(a, b, c)```       | ```a```, ```b```, ```c``` | -                         | ```a```, ```b```, ```c``` | ```a```, ```b```, ```c```  |\n",
    "| ```foo(a, b, c=0)```     | ```a```, ```b```          | ```c```                   | ```a```, ```b```, ```c``` | ```a```, ```b```, ```c```  |\n",
    "| ```foo(a=1, b=2, c=3)``` | -                         | ```a```, ```b```, ```c``` | ```a```, ```b```, ```c``` | ```a```, ```b```, ```c```  |\n",
    "\n",
    "Отсутствие дополнительных ограничений на передачу параметров в функцию бывает неудобно. Так это может привести к ухудшению читаемости -- в одном и том же коде одна и та же функция может вызываться по-разному. Для решения этой проблемы в Python предусмотрены некоторые дополнительные возможности для наложения ограничений на передачу аргументов.\n",
    "\n",
    "## Обязательные и необязательные аргументы\n",
    "\n",
    "Python позволяет очень гибко управлять передачей аргументов в функцию с помощью очень простых синтаксических конструкций.\n",
    "\n",
    "Рассмотрим управление передачей позиционных параметров. Для этого существует ```/```. Его смысл очень прост. Все, что идет до ```/``` можно передавать только как позиционные параметры, т.е. указывать имена запрещается. Попытка указать имя у параметра, который следует перед ```/``` вызовет исключение ```TypeError```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(a, b, c, d, /):  # только позиционные аргументы\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 4\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "foo() got some positional-only arguments passed as keyword arguments: 'd'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-6c23e8d037e5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: foo() got some positional-only arguments passed as keyword arguments: 'd'"
     ]
    }
   ],
   "source": [
    "foo(1, 2, 3, 4)\n",
    "\n",
    "foo(1, 2, 3, d=4)  # TypeError"
   ]
  },
  {
   "source": [
    "В определении функции после ```/``` могут следовать другие аргументы. На их передачу не накладывается никаких ограничений."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bar(a, b, /, c, d):  # аргументы после /\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 4\na = 2, b = 3, c = 4, d = 5\na = 3, b = 4, c = 5, d = 6\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "bar() got some positional-only arguments passed as keyword arguments: 'b'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-8f2ab51c5fd2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mbar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mbar\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# TypeError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: bar() got some positional-only arguments passed as keyword arguments: 'b'"
     ]
    }
   ],
   "source": [
    "bar(1, 2, 3, 4)\n",
    "bar(2, 3, 4, d=5)\n",
    "bar(3, 4, c=5, d=6)\n",
    "\n",
    "bar(4, b=5, c=6, d=7)  # TypeError"
   ]
  },
  {
   "source": [
    "Управление передачей ключевых аргументов осуществляется с помощью символа ```*```. Его смысл аналогичен ```/```. Все, что следует после ```*``` - ключевые аргументы. Тут стоит заострить внимание на том, что ключевыми аргументами будут даже те, которые не имеют значения по умолчанию. Это позволяет разделять ключевые аргументы, следующие за ```*``` на:\n",
    "- обязательные ключевые аргументы (которые не имеют значения по умолчанию);\n",
    "- необязательные ключевые аргументы (которые имеют значение по умолчанию).\n",
    "\n",
    "На остальные аргументы, следующие перед ```*```, не накладывается никаких ограничений."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 4\na = 1, b = 2, c = 3, d = 4\na = 1, b = 2, c = 3, d = 4\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "foo() takes 2 positional arguments but 4 were given",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-95fea6b42333>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m \u001b[0mfoo\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: foo() takes 2 positional arguments but 4 were given"
     ]
    }
   ],
   "source": [
    "# a, b - позиционные, но можно передавать как угодно\n",
    "# c, d - обязательные ключевые аргументы, передача только через указание имени\n",
    "def foo(a, b, *, c, d):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')\n",
    "\n",
    "foo(1, 2, c=3, d=4)\n",
    "foo(2, b=3, c=4, d=5)\n",
    "foo(a=3, b=4, c=5, d=6)\n",
    "\n",
    "foo(1, 2, 3, 4)  # TypeError\n",
    "foo(1, 2, 3, d=4)  # TypeError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 4\n"
     ]
    }
   ],
   "source": [
    "# a, b, c, d - обязательные ключевые аргументы\n",
    "def foo(*, a, b, c, d):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')\n",
    "\n",
    "# остальные способы вызова не сработают\n",
    "foo(a=1, b=2, c=3, d=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 42\na = 2, b = 3, c = 4, d = 5\n"
     ]
    }
   ],
   "source": [
    "# a, b - позиционные аргументы с возможностью передачи как ключевые\n",
    "# c - обязательный ключевой аргумент\n",
    "# d - необязательный ключевай аргумент\n",
    "def bar(a, b, *, c, d=42):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')\n",
    "\n",
    "bar(1, 2, c=3)\n",
    "bar(2, 3, c=4, d=5)"
   ]
  },
  {
   "source": [
    "Символы ```/``` и ```*``` можно использовать совместно."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 4\n"
     ]
    }
   ],
   "source": [
    "# a, b - только позиционные аргументы\n",
    "# c, d - только обязательные ключевые аргументы\n",
    "def foo(a, b, /, *, c, d):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')\n",
    "\n",
    "# остальные способы вызова не сработают\n",
    "foo(1, 2, c=3, d=4)"
   ]
  },
  {
   "source": [
    "Между символами ```/``` и ```*``` могут находиться аргументы. На них никаких ограничений накладываться не будет."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 4\na = 2, b = 3, c = 4, d = 5\n"
     ]
    }
   ],
   "source": [
    "# a, b - только позиционные аргументы\n",
    "# c - позиционный, с возможностью передачи по имени\n",
    "# d - только обязательные ключевые аргументы\n",
    "def foo(a, b, /, c, *, d):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')\n",
    "\n",
    "foo(1, 2, 3, d=4)\n",
    "foo(2, 3, c=4, d=5)"
   ]
  },
  {
   "source": [
    "Не только ключевые аргументы могут быть необязательными, но и позиционные. Эта возможность появляется только при использовании ```/```. Необязательные позиционные аргументы должны находиться после обязательных. Это общее правило для всех аргументов."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 4\na = 2, b = 2, c = 3, d = 4\na = 3, b = 4, c = 3, d = 4\na = 4, b = 5, c = 6, d = 4\na = 5, b = 6, c = 7, d = 8\n"
     ]
    }
   ],
   "source": [
    "# a, b, c, d - необязательные позиционные аргументы\n",
    "def foo(a=1, b=2, c=3, d=4, /):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')\n",
    "\n",
    "foo()  # все аргументы примут значения по умолчанию\n",
    "foo(2)  # 2 попадет в 'a'\n",
    "foo(3, 4)  # передали только a, b\n",
    "foo(4, 5, 6)  # передали a, b, c\n",
    "foo(5, 6, 7, 8)  # передали a, b, c, d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 42, d = 6174\na = 2, b = 3, c = 4, d = 6174\na = 3, b = 4, c = 5, d = 6\n"
     ]
    }
   ],
   "source": [
    "# a, b - обязательные позиционные аргументы\n",
    "# c, d - необязательные позиционные аргументы\n",
    "def bar(a, b, c=42, d=6174, /):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')\n",
    "\n",
    "bar(1, 2)\n",
    "bar(2, 3, 4)\n",
    "bar(3, 4, 5, 6)"
   ]
  },
  {
   "source": [
    "Здесь стоит учитывать только одно правило. Необязательные аргументы должны находиться после обязательных. Это делает невозможным указывать обязательные ключевые аргументы после необязательных позиционных, т.к. ключевые аргументы всегда следуют за позиционными."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (<ipython-input-13-f2ab8772fc1f>, line 1)",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-13-f2ab8772fc1f>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def foo(a=0, b=1, /, c, d):  # неправильно\u001b[0m\n\u001b[1;37m                            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "# SyntaxError\n",
    "def foo(a=0, b=1, /, c, d):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }')"
   ]
  },
  {
   "source": [
    "Ниже привидены несколько таблиц для сравнения различных вариантов объявлений функций.\n",
    "\n",
    "Таблица для ```/```.\n",
    "\n",
    "| Определение             | Позиционные параметры     | Ключевые параметры | Передаются как ключевые | Передаются как позиционные |\n",
    "|-------------------------|:-------------------------:|:------------------:|:-----------------------:|:--------------------------:|\n",
    "| ```foo(a, b, c, /)```   | ```a```, ```b```, ```c``` | -                  | -                       | ```a```, ```b```, ```c```  |\n",
    "| ```foo(a, b, c=1, /)``` | ```a```, ```b```, ```c``` | -                  | -                       | ```a```, ```b```           |\n",
    "| ```foo(a, b, /, c)```   | ```a```, ```b```, ```c``` | -                  | ```c```                 | ```a```, ```b```, ```c```  |\n",
    "| ```foo(a, b, /, c=1)``` | ```a```, ```b```          | ```c```            | ```c```                 | ```a```, ```b```, ```c```  |\n",
    "\n",
    "Таблица для ```*```.\n",
    "\n",
    "| Определение                 | Позиционные параметры | Ключевые параметры        | Передаются как ключевые   | Передаются как позиционные |\n",
    "|-----------------------------|:---------------------:|:-------------------------:|:-------------------------:|:--------------------------:|\n",
    "| ```foo(*, a, b, c)```       | -                     | ```a```, ```b```, ```c``` | ```a```, ```b```, ```c``` | -                          |\n",
    "| ```foo(a, *, b, c)```       | ```a```               | ```b```, ```c```          | ```a```, ```b```, ```c``` | ```a```                    |\n",
    "| ```foo(a, *, b, c=1)```     | ```a```               | ```b```, ```c```          | ```a```, ```b```, ```c``` | ```a```                    |\n",
    "| ```foo(a=1, *, b=2, c=3)``` | -                     | ```a```, ```b```, ```c``` | ```a```, ```b```, ```c``` | ```a```                    |\n",
    "\n",
    "Таблица совместного использования ```/``` и ```*```.\n",
    "\n",
    "| Определение                    | Позиционные параметры | Ключевые параметры | Передаются как ключевые | Передаются как позиционные |\n",
    "|--------------------------------|:---------------------:|:------------------:|:-----------------------:|:--------------------------:|\n",
    "| ```foo(a, b, /, *, c)```       | ```a```, ```b```      | ```c```            | ```c```                 | ```a```, ```b```           |\n",
    "| ```foo(a, b, /, *, c=1)```     | ```a```, ```b```      | ```c```            | ```c```                 | ```a```, ```b```           |\n",
    "| ```foo(a, b=1, /, *, c=2)```   | ```a```, ```b```      | ```c```            | ```c```                 | ```a```, ```b```           |\n",
    "| ```foo(a, /, b, *, c)```       | ```a```, ```b```      | ```c```            | ```b```, ```c```        | ```a```, ```b```           |\n",
    "| ```foo(a, /, b, *, c=1)```     | ```a```, ```b```      | ```c```            | ```b```, ```c```        | ```a```, ```b```           |\n",
    "| ```foo(a, /, b=1, *, c=2)```   | ```a```               | ```b```, ```c```   | ```b```, ```c```        | ```a```, ```b```           |\n",
    "| ```foo(a=1, /, b=2, *, c=3)``` | ```a```               | ```b```, ```c```   | ```b```, ```c```        | ```a```, ```b```           |"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Значения по умолчанию\n",
    "\n",
    "Как ранее упоминалось, чтобы определить любые необязательные аргументы нужно задать им значение по умолчанию. Такими значениями могут выступать объекты любых типов данных. Ограничений здесь нет. Однако, стоит быть осторожными с изменяемыми типами данных. Желательно вообще их не использовать в значениях по умолчанию.\n",
    "\n",
    "Рассмотрим пример функции, которая должна добавлять в конец списка число ```42```. При вызове функции без параметра она должна возвращать список с одним элементом ```42```. Вызывая функцию с переданным списком в качестве аргумента, она должна добавлять к нему ```42```. На первый взгляд эту функцию можно реализовать следующим образом."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(1) > spam([]) = [42]\n(2) > spam([0]) = [0, 42]\n(3) > spam([0, 1, 2, 3]) = [0, 1, 2, 3, 42]\n(4) > spam() = [42]\n"
     ]
    }
   ],
   "source": [
    "def spam(xs=[]):\n",
    "    xs.append(42)\n",
    "    return xs\n",
    "\n",
    "print(f'(1) > {spam([]) = }')\n",
    "print(f'(2) > {spam([0]) = }')\n",
    "print(f'(3) > {spam([0, 1, 2, 3]) = }')\n",
    "print(f'(4) > {spam() = }')"
   ]
  },
  {
   "source": [
    "На первый взгляд все работает так как задумывалось. До тех пор, пока функция не будет вызвана повторно без аргументов."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(5) > spam() = [42, 42]\n(6) > spam() = [42, 42, 42]\n(7) > spam() = [42, 42, 42, 42]\n(8) > spam() = [42, 42, 42, 42, 42]\n"
     ]
    }
   ],
   "source": [
    "print(f'(5) > {spam() = }')\n",
    "print(f'(6) > {spam() = }')\n",
    "print(f'(7) > {spam() = }')\n",
    "print(f'(8) > {spam() = }')"
   ]
  },
  {
   "source": [
    "Что происходит? Откуда берутся лишние элементы в списке? Дело в том, что список создался всего один раз, а затем он заполняется с каждым новым вызовом функции без аргументов. Это происходит потому, что значения по умолчанию создаются единожды в момент первого выполнения функции интерпретатором Python. Такая особенность характерна только для изменяемых типов, ведь они не пересоздаются при изменении. \n",
    "\n",
    "Рассмотрим этот момент подробнее. Первым делом интерпретатор Python выполнит определение функции ```def spam(xs=[])```. В этом определении он свяжет имя аргумента ```xs``` и объект пустого списка. В тело функции интерпретатор заходить не будет. В этот момент в текущей области видимости создастся новый объект функции. \n",
    "\n",
    "<img src=\"image/dv.png\">\n",
    "\n",
    "У этого объекта есть ряд \"составных частей\": имя, скомпилированный код тела функции, набор значений по умолчанию и некоторые другие параметры. Значения этих параметров можно узнать, используя соответствующие \"специальные\" имена, начинающиеся и заканчивающиеся на два нижних подчеркивания. Как раз в этот момент происходит создание пустого списка, ссылка на который будет храниться вместе с функцией. Этот список можно напрямую изменить через ```function.__defaults__```, но этого делать настоятельно не рекомендуется."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Имя функции: eggs\nКод тела функции: <code object eggs at 0x0000018DAC3DAF50, file \"<ipython-input-12-e69a6dfc8eae>\", line 1>\nНабор значений по умолчанию: ([],)\n"
     ]
    }
   ],
   "source": [
    "def eggs(xs=[]):\n",
    "    xs.append(42)\n",
    "    return xs\n",
    "\n",
    "print(f'Имя функции: {eggs.__name__}')\n",
    "print(f'Код тела функции: {eggs.__code__}')\n",
    "print(f'Набор значений по умолчанию: {eggs.__defaults__}')"
   ]
  },
  {
   "source": [
    "По этой же причине (сохранение ссылок на значения по умолчанию в специальный кортеж) при вызове функции и передаче в качестве аргумента других объектов эта ссылка обновлена не будет. Как только функция выполниться ее аргумент снова будет указывать на прежнее значение по умолчанию.\n",
    "\n",
    "Такое поведение изменяемых типов в качестве значений по умолчанию вводит новичков в непонимание. Однако оно является полностью прозрачным и удовлетворяет одному из принципов дзен Python: быть очевидным для голландцев.\n",
    "\n",
    "Наглядно проследить что происходит в памяти при работе этой функции можно выполнив код на [pythontutor](http://www.pythontutor.com/visualize.html#code=def%20spam%28xs%3D%5B%5D%29%3A%0A%20%20%20%20xs.append%2842%29%0A%20%20%20%20return%20xs%0A%0Aprint%28spam%28%5B%5D%29%29%0Aprint%28spam%28%5B0%5D%29%29%0Aprint%28spam%28%5B1,%202,%203%5D%29%29%0A%0Aprint%28spam%28%29%29%0Aprint%28spam%28%29%29%0Aprint%28spam%28%29%29%0Aprint%28spam%28%29%29&cumulative=false&curInstr=0&heapPrimitives=true&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false).\n",
    "\n",
    "Исправить эту проблему довольно просто. Достаточно установить значение неизменяемого типа данных в качестве значения по умолчанию. Часто в таких случаях используют ```None```. Корректная версия этой функции будет выглядеть следующим образом."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eggs(xs=None):\n",
    "    xs = xs or []\n",
    "    xs.append(42)\n",
    "    return xs\n",
    "\n",
    "# или попроще\n",
    "def spam(xs=None):\n",
    "    # проверка на None обязательна, неправильно \n",
    "    # делать проверку как if xs, может буть передан \n",
    "    # пустой список.\n",
    "    if xs is None:\n",
    "        xs = []\n",
    "    xs.append(42)\n",
    "    return xs"
   ]
  },
  {
   "source": [
    "Для более детального изучения этого вопроса приведен ряд ссылок в разделе \"[Полезные ссылки](#Полезные-ссылки)\".\n",
    "\n",
    "## Произвольное количество аргументов (упаковка и распаковка аргументов)\n",
    "\n",
    "На этом возможности функций и их аргументов не заканчиваются. Передача произвольного количества аргументов -- это еще одна возможность, которую предоставляет Python. Передавать произвольное количество аргументов можно с помощью ```*args```. Имя ```args``` не является стандартизованным, оно негласно принято. Выражение ```*args``` размещается после всех позиционных аргументов, после ```*args``` могут идти только именованные аргументы. В ```args``` попадаются все значения, которые не предназначены для обязательных позиционных аргументов. В теле функции можно использовать переменную ```args```, она будет иметь тип ```tuple```. В случае, если нет аргументов для ```args``` - кортеж будет пуст. \n",
    "\n",
    "В объявлении функции можно использовать только один аргумент со звездочкой, т.к. она работает жадно и соберет в себе все значения, которые не поместятся в остальные аргументы."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "args = ()\nargs = (1,)\nargs = (1, 2, 3)\nargs = (1, 2, 3, 4, 5, 6, 7, 8)\n"
     ]
    }
   ],
   "source": [
    "# функция принимает любое количество позиционных параметров\n",
    "def foo(*args):\n",
    "    print(f'{args = }')\n",
    "\n",
    "foo()\n",
    "foo(1)\n",
    "foo(1, 2, 3)\n",
    "foo(1, 2, 3, 4, 5, 6, 7, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, args = ()\na = 2, args = (2, 3)\na = 3, args = (2, 3, 4, 5, 6, 7)\n"
     ]
    }
   ],
   "source": [
    "# функция принимает минимум 1 аргумент\n",
    "def bar(a, *args):\n",
    "    print(f'{a = }, {args = }')\n",
    "\n",
    "bar(1)\n",
    "bar(2, 2, 3)\n",
    "bar(3, 2, 3, 4, 5, 6, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, args = (), c = 2, d = 3\na = 1, args = (2, 3, 4), c = 2, d = 3\n"
     ]
    }
   ],
   "source": [
    "# a - обязательный позиционный аргумент\n",
    "# args - прочие позиционный аргумент\n",
    "# c, d - обязательные ключевые аргументы\n",
    "def baz(a, *args, c, d):\n",
    "    print(f'{a = }, {args = }, {c = }, {d = }')\n",
    "\n",
    "baz(1, c=2, d=3)\n",
    "baz(2, 2, 3, 4, c=2, d=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, args = (), c = 2, d = 1\na = 2, args = (2, 3, 4), c = 2, d = 1\na = 3, args = (2, 3, 4), c = 2, d = 5\n"
     ]
    }
   ],
   "source": [
    "# a - обязательный позиционный аргумент\n",
    "# args - прочие позиционный аргумент\n",
    "# c - обязательные ключевые аргументы\n",
    "# d - необязательные ключевые аргументы\n",
    "def quz(a, *args, c, d=1):\n",
    "    print(f'{a = }, {args = }, {c = }, {d = }')\n",
    "\n",
    "quz(1, c=2)\n",
    "quz(2, 2, 3, 4, c=2)\n",
    "quz(3, 2, 3, 4, c=2, d=5)"
   ]
  },
  {
   "source": [
    "Для передачи произвольного количества позиционных аргументов в объявление функции нужно добавить ```**kwargs```. Имя ```kwargs``` также не является стандартизованным. В теле функции переменная ```kwargs``` будет представлена словарем, где ключами будут строковые представления имен переданных аргументов, а значениями - значения этих аргументов. ```**kwargs``` должно располагаться после всех прочих аргументов. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "kwargs = {}\nkwargs = {'a': 1}\nkwargs = {'a': 1, 'b': 2}\n"
     ]
    }
   ],
   "source": [
    "# функция с произвольным количеством именованных параметров\n",
    "def foo(**kwargs):\n",
    "    print(f'{kwargs = }')\n",
    "\n",
    "foo()\n",
    "foo(a=1)\n",
    "foo(a=1, b=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 1, d = 2, kwargs = {}\na = 2, b = 3, c = 4, d = 2, kwargs = {}\na = 3, b = 4, c = 1, d = 5, kwargs = {}\na = 4, b = 5, c = 6, d = 7, kwargs = {}\na = 5, b = 6, c = 1, d = 2, kwargs = {'k': 7}\na = 6, b = 7, c = 8, d = 9, kwargs = {'k': 10}\n"
     ]
    }
   ],
   "source": [
    "# a, b - позиционные аргументы\n",
    "# c, d - ключевые аргументы\n",
    "# kwargs - прочие ключевые аргументы\n",
    "def bar(a, b, c=1, d=2, **kwargs):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }, {kwargs = }')\n",
    "\n",
    "bar(1, 2)\n",
    "bar(2, 3, c=4)\n",
    "bar(3, 4, d=5)\n",
    "bar(4, 5, c=6, d=7)\n",
    "bar(5, 6, k=7)\n",
    "bar(6, 7, c=8, d=9, k=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-93078ff22f37>, line 1)",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-11-93078ff22f37>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def bar(**kwargs, a=0):\u001b[0m\n\u001b[1;37m                      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# SyntaxError\n",
    "def baz(**kwargs, a=0):\n",
    "    print(f'{kwargs = }')"
   ]
  },
  {
   "source": [
    "Функция может принимать произвольное количество любых аргументов, т.е. содержать ```*args``` и ```**kwargs``` одновременно."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "args = ()\nkwargs = {}\n-------------------------\nargs = (1, 2, 3)\nkwargs = {}\n-------------------------\nargs = ()\nkwargs = {'a': 3}\n-------------------------\nargs = (1, 2, 3)\nkwargs = {'a': 4, 'b': 5}\n-------------------------\n"
     ]
    }
   ],
   "source": [
    "def quz(*args, **kwargs):\n",
    "    print(f'{args = }\\n{kwargs = }')\n",
    "    print('-' * 25)\n",
    "\n",
    "quz()\n",
    "quz(1, 2, 3)\n",
    "quz(a=3)\n",
    "quz(1, 2, 3, a=4, b=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3, d = 0\nargs = ()\nkwargs = {}\n--------------------------\na = 1, b = 2, c = 3, d = 0\nargs = (3, 4)\nkwargs = {}\n--------------------------\na = 1, b = 2, c = 3, d = 1\nargs = (3,)\nkwargs = {}\n--------------------------\na = 1, b = 2, c = 3, d = 0\nargs = (3,)\nkwargs = {'k': 8, 'h': 9}\n--------------------------\na = 1, b = 2, c = 3, d = 5\nargs = (3,)\nkwargs = {'q': 9}\n--------------------------\n"
     ]
    }
   ],
   "source": [
    "# a, b - позиционные аргументы\n",
    "# args - прочие позиционные аргументы\n",
    "# c - обязательный ключевой аргумент\n",
    "# d - необязательный ключевой аргумент\n",
    "# kwargs - прочие ключевые аргументы\n",
    "def quuz(a, b, *args, c, d=0, **kwargs):\n",
    "    print(f'{a = }, {b = }, {c = }, {d = }\\n{args = }\\n{kwargs = }')\n",
    "    print('-' * 26)\n",
    "\n",
    "quuz(1, 2, c=3)\n",
    "quuz(1, 2, 3, 4, c=3)\n",
    "quuz(1, 2, 3, c=3, d=1)\n",
    "quuz(1, 2, 3, c=3, k=8, h=9)\n",
    "quuz(1, 2, 3, c=3, d=5, q=9)"
   ]
  },
  {
   "source": [
    "Механизм распаковки коллекций позволяет легко передавать их значения в разные функции."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1, b = 2, c = 3\na = 1, b = 2, c = 3\na = 1, b = 2, c = 3\n"
     ]
    }
   ],
   "source": [
    "def foo(a, b, c):\n",
    "    print(f'{a = }, {b = }, {c = }')\n",
    "\n",
    "xs = [1, 2, 3]\n",
    "d = {'a': 1, 'b': 2, 'c': 3}\n",
    "\n",
    "# распаковка списка\n",
    "# количество элементов в списке должно совпадать с количеством аргументов\n",
    "foo(*xs)\n",
    "\n",
    "# частичная распаковка списка\n",
    "foo(1, *xs[1:])\n",
    "\n",
    "# распаковка словаря\n",
    "# имена аргументов должны совпадать с ключами словаря\n",
    "foo(**d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "args = (1, 2, 3, 4), kwargs = {}\nargs = (), kwargs = {'q': 1, 'w': 2, 'e': 3}\nargs = (1, 2, 3, 4), kwargs = {'q': 1, 'w': 2, 'e': 3}\n"
     ]
    }
   ],
   "source": [
    "def bar(*args, **kwargs):\n",
    "    print(f'{args = }, {kwargs = }')\n",
    "\n",
    "xs = [1, 2, 3, 4]\n",
    "d = {'q': 1, 'w': 2, 'e': 3}\n",
    "\n",
    "bar(*xs)\n",
    "bar(**d)\n",
    "bar(*xs, **d)"
   ]
  },
  {
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Документация по значениям по умолчанию](https://docs.python.org/3/tutorial/controlflow.html#default-argument-values)\n",
    "- [Принцип \"наименьшего удивления\" и изменяемые аргументы в качестве значений по умолчанию (прекрасный вопрос на stackoverflow)](https://stackoverflow.com/questions/1132941/least-astonishment-and-the-mutable-default-argument?page=1&tab=votes#tab-top)\n",
    "- [Code Like a Pythonista: Idiomatic Python](http://www.omahapython.org/IdiomaticPython.html)\n",
    "- [Отличная статья, поясняющая каким образом работают значения по умолчанию](http://effbot.org/zone/default-values.htm)\n",
    "- [Вопрос на stackoverflow о хороших примерах использования изменяемых типов в качестве значений по умолчанию](https://stackoverflow.com/questions/9158294/good-uses-for-mutable-function-argument-default-values)\n",
    "- [Вопрос на stackoverflow о методе устранения проблемы с изменяемыми аргументами по умолчанию](https://stackoverflow.com/questions/10676729/why-does-using-arg-none-fix-pythons-mutable-default-argument-issue)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}