python/function.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "706b2cd1",
   "metadata": {},
   "source": [
    "# Функции\n",
    "\n",
    "\n",
    "Функции в Python это объекты, принимающие аргументы и возвращающие значение. Функции определяются с помощью инструкции `def`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b2171b56",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79c80ab4",
   "metadata": {},
   "source": [
    "Функции позволяют упаковывать часть кода для его последующего повторного вызова. В примере выше определена функция с именем `sum`, которая принимает два параметра `x` и `y`, и возвращает результат их суммы. Обратившись к этой функции по имени и задав параметры, мы можем получить результат:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5e089688",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(34, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "187d9bda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum('abc', 'def')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e807e47",
   "metadata": {},
   "source": [
    "Инструкция `return` позволяет вернуть значение, которое нам необходимо. Это необходимо для того, чтобы получить определенный результат и затем дальше использовать его в программе.\n",
    "\n",
    "Функция может быть любой сложности, внутри конструкции `def -> return`, мы можем написать любой код. Смысл в функциях заключается в том, чтобы не писать один и тот же код повторно, а просто, в нужный момент, вызывать заранее написанную функцию. Так же функция может быть без параметров или может не возвращать какое-то конкретное значение или не заканчиваться инструкцией `return` вовсе:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c910e720",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun():\n",
    "    var = 'Python'\n",
    "    if len(var) >= 6:\n",
    "        print(var)\n",
    "    return           # В этом случае функция вернет значение None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "073d80df",
   "metadata": {},
   "source": [
    "Код под инструкцией `def` будет относиться к функции до тех пор, пока он вложен в эту инструкцию, то есть отступает от `def`.\n",
    "\n",
    "Функции бывают разных типов:\n",
    "\n",
    "**Глобальные функции** - такие функции доступны из любой части кода файла, в котором они написаны. Глобальные функции доступны из других модулей, но об этом мы расскажем в разделе \"Подключение модулей\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b15c0a52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "# Объявляем функцию \n",
    "def solve(s):\n",
    "    c = []\n",
    "    for i in range(len(s)):\n",
    "        if i%2 == 0:\n",
    "            c.append(s[i])\n",
    "    return c \n",
    "# вызываем функцию solve с заданными параметрами и выводим результат ее работы\n",
    "print(solve([1, 2, 3, 4, 5, 6, 7, 8]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b73bcfe5",
   "metadata": {},
   "source": [
    "**Локальные функции** - функции, объявленные внутри других функций. Вызвать их можно только внутри функции, в которой они объявлены. Их удобно использовать, если необходима небольшая вспомогательная функция, которая больше нигде не используется.\n",
    "\n",
    "**Лямбда-функции** - особые, анонимные функции, имеющие ряд ограничений, по сравнению с обычными функциями. Они локально решают единственную задачу. Применение такой функции выглядит, как выражение, давайте посмотрим на примере:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "11f65acd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Обычная функция \n",
    "def search_len(arg_1):\n",
    "    return len(arg_1) \n",
    "# Лямбда-функция \n",
    "result = filter(lambda x: x % 2, [1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b538e03",
   "metadata": {},
   "source": [
    "Обычно, лямбда-функции применяют при вызове функций, которые в качестве аргументов содержат функции. Проблема использования лямбда-функций состоит в том, что иногда усложняется читаемость кода."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "89c4c21a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 'abc')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func(*args):\n",
    "    return args\n",
    "func(1, 2, 3, 'abc')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "923e1afb",
   "metadata": {},
   "source": [
    "Как мы видим в таком случае образуется кортеж из этих аргументов. Также можно принимать аргументы в виде словаря, для этого необходимо использовать символ **:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "75f9e14c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func(**kwargs):\n",
    "    return kwargs\n",
    "func(a=1, b=2, c=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10ae6c83",
   "metadata": {},
   "source": [
    "Очень важно документировать описание к любой функции, чтобы каждый раз не разбирать написанное заново. Для этого используют строки, заключенные в тройные кавычки. Поскольку описание функции зачастую состоит более, чем из 1 строки, использование строк с тройными кавычками очень удобно. Обычно под документирование выделяют место между определением функции и началом основного кода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "901a60be",
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve(s):\n",
    "    ''' Функция solve(s) принимает список \n",
    "        создает пустой список   \n",
    "        находит элементы с четным индексом (включая 0) \n",
    "        заносит их в созданный список и возвращает его \n",
    "    '''\n",
    "    c = []\n",
    "    for i in range(len(s)):\n",
    "        if i%2 == 0:\n",
    "            c.append(s[i])\n",
    "    return c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4449c885",
   "metadata": {},
   "source": [
    "Переменные, которые объявляются внутри функций являются локальными. Изменение этих переменных и обращение к ним происходят только внутри функций, где они были объявлены. Если же переменные объявлены вне функций, они являются глобальными. С глобальными переменными надо обходиться осторожно. Их удобно использовать, потому что к ним можно обращаться из любой части кода и даже из других модулей, но, если в коде происходит неконтролируемое изменение глобальной переменной, то поиск ошибки может перерасти в головную боль. \n",
    "\n",
    "Рассмотрим пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "24722965",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "var_1 = [1,2,3]\n",
    "  \n",
    "def func(a):\n",
    "    var_1 = []\n",
    "    for i in a:\n",
    "        var_1.append(i*2)\n",
    "    return var_1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72df1de5",
   "metadata": {},
   "source": [
    "Внешняя переменная `var_1` -Глобальная переменная, а внутреняя пременная `var_1` - локальной переменной.\n",
    "Глобальная переменная `var_1` в данном случае остается неизменной, т.к. она используется только в качестве параметра для функции и нигде не происходит манипуляций над ней. Внутри этой функции изменения происходят с локальной переменной `var_1`. Результат выполнения такой программы будет следующий:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "50b86d53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "print(func(var_1))\n",
    "print(var_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "781f8165",
   "metadata": {},
   "source": [
    "Теперь приведем пример плохого кода, в котором происходят манипуляции с глобальной переменной:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7b3e913b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 24]\n",
      "[1, 2, 3, 12]\n"
     ]
    }
   ],
   "source": [
    "var_1 = [1,2,3]\n",
    "  \n",
    "def func(a):\n",
    "    var_2 = []\n",
    "    for i in a:\n",
    "        var_2.append(i*2)\n",
    "    return var_2\n",
    "var_3 = var_1\n",
    "var_3.append(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0c5455a",
   "metadata": {},
   "source": [
    " Попробуйте угадать, каким будет результат выполнения из примера выше?\n",
    " \n",
    " ## Дополнительно\n",
    " \n",
    " Давайте еще раз рассмотрим один из примеров данного раздела:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5570d50f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve(s):\n",
    "    ''' Функция solve(s) принимает список\n",
    "        создает пустой список   \n",
    "        находит элементы с четным индексом (включая 0)\n",
    "        заносит их в созданный список и возвращает его\n",
    "    ''' \n",
    "    c = []\n",
    "    for i in range(len(s)):\n",
    "        if i%2 == 0:\n",
    "            c.append(s[i])\n",
    "    return c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f566fd1e",
   "metadata": {},
   "source": [
    "В описании к функции написано, что она принимает список. А что, если ей на вход попадёт строка или словарь? \n",
    "\n",
    "В случае со строкой все будет нормально, но вот словарь вызовет ошибку. Чтобы избежать подобную ситуацию, мы можем прописать условия проверки входного параметра. Сделать это можно с помощью условия `assert`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cd24d189",
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve(s):\n",
    "    ''' Функция solve(s) принимает список\n",
    "        создает пустой список   \n",
    "        находит элементы с четным индексом (включая 0)\n",
    "        заносит их в созданный список и возвращает его\n",
    "    '''\n",
    "    # isinstance вернет True, если проверяемый объект object является экземпляром указанного\n",
    "    # класса (классов) или его подкласса (прямого, косвенного или виртуального).\n",
    "    # Если в Вашей программе не нарушался принцип подстановки Барбары-Лисков,\n",
    "    # то лучше использовать его, вместо прямой проверки типов\n",
    "    assert isinstance(s, list)\n",
    "    c = []\n",
    "    for i in range(len(s)):\n",
    "        if i%2 == 0:\n",
    "            c.append(s[i])\n",
    "    return c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43250059",
   "metadata": {},
   "source": [
    "Теперь, если на вход функции `solve()` попадет какой-либо тип кроме списка, `assert` проверит это и выведет ошибку определенного рода:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "81233dfb",
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mAssertionError\u001B[0m                            Traceback (most recent call last)",
      "\u001B[0;32m<ipython-input-14-2fd1d2ae175f>\u001B[0m in \u001B[0;36m<module>\u001B[0;34m\u001B[0m\n\u001B[0;32m----> 1\u001B[0;31m \u001B[0msolve\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m''\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m",
      "\u001B[0;32m<ipython-input-13-65375417b8ca>\u001B[0m in \u001B[0;36msolve\u001B[0;34m(s)\u001B[0m\n\u001B[1;32m      5\u001B[0m         \u001B[0mзаносит\u001B[0m \u001B[0mих\u001B[0m \u001B[0mв\u001B[0m \u001B[0mсозданный\u001B[0m \u001B[0mсписок\u001B[0m \u001B[0mи\u001B[0m \u001B[0mвозвращает\u001B[0m \u001B[0mего\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      6\u001B[0m     '''\n\u001B[0;32m----> 7\u001B[0;31m     \u001B[0;32massert\u001B[0m \u001B[0mtype\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0ms\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;34m==\u001B[0m \u001B[0mlist\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m      8\u001B[0m     \u001B[0mc\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0;34m[\u001B[0m\u001B[0;34m]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      9\u001B[0m     \u001B[0;32mfor\u001B[0m \u001B[0mi\u001B[0m \u001B[0;32min\u001B[0m \u001B[0mrange\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mlen\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0ms\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;31mAssertionError\u001B[0m: "
     ]
    }
   ],
   "source": [
    "solve('')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b41b454a",
   "metadata": {},
   "source": [
    "Данный инструмент полезно использовать для выявления неустранимых ошибок программы. То есть, в данном случае, наша функция не предполагает получения данных отличных от типа \"список\". Однако, в случае, когда что-то пошло не так, с помощью `assert`, мы будем знать об этом."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}