python_lectures/python_lesson_part_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "975f9493",
   "metadata": {},
   "source": [
    "## Содержание:\n",
    "- Многомерные списки\n",
    "- Вывод вложенного списка\n",
    "- Словари\n",
    "- Таблица сравнения структур данных (список, кортеж, множество, словарь)\n",
    "- Устройство функций в Python. Написание простейших функций. Написание сложных функций.\n",
    "- Тернарный оператор\n",
    "- Необязательные параметры функций\n",
    "- Именованные аргументы\n",
    "- Аннотации типов в функциях\n",
    "- Функция-предикат (функция-вопрос)\n",
    "- Оператор Match\n",
    "- Распаковка (*args и **kwargs)\n",
    "- Локальные и глобальные переменные. Области видимости\n",
    "- Рекурсия\n",
    "- Функции как объект\n",
    "- Функции высших порядков\n",
    "- Lambda-функции"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2de9ef42",
   "metadata": {},
   "source": [
    "# Списковые включения (list comprehension)\n",
    "\n",
    "Для генерации списков из неповторяющихся элементов в Python имеется удобная синтаксическая конструкция – списочное выражение (list comprehension). Она позволяет создавать элементы списка в цикле for, не записывая цикл целиком.\n",
    "\n",
    "Для создания списка, заполненного одинаковыми элементами, можно использовать оператор повторения списка, например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9dda1ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "a = [0] * n\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b016f937",
   "metadata": {},
   "source": [
    "Для создания списков, заполненных по более сложным формулам можно использовать генераторы: выражения, позволяющие заполнить список некоторой формулой. Общий вид генератора следующий:\n",
    "\n",
    "[`выражение` **for** `переменная` **in** `список`]\n",
    "\n",
    "где `переменная` – идентификатор некоторой переменной, `список` – список значений, который принимает данная переменная (как правило, полученный при помощи функции range), `выражение` – некоторое выражение, которым будут заполнены элементы списка, как правило, зависящее от использованной в генераторе переменной.\n",
    "\n",
    "Вот несколько примеров использования генераторов.\n",
    "\n",
    "Создать список, состоящий из n нулей можно и при помощи генератора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5d31355",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [0 for i in range(n)]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "348118a3",
   "metadata": {},
   "source": [
    "Если нужно заполнить список квадратами чисел от 1 до n, то можно изменить параметры функции `range` на `range(1, n + 1)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85b0c0ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [i ** 2 for i in range(n)]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e020e51f",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 6\n",
    "a = [i ** 2 for i in range(n)]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98d50616",
   "metadata": {},
   "source": [
    "Вот так можно получить список, заполненный случайными числами от 1 до 9 (используя функцию `randint()` из модуля random):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cdc49ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "a = [randint(1, 9) for i in range(n)]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfb31ada",
   "metadata": {},
   "source": [
    "А в этом примере список будет состоять из строк, считанных со стандартного ввода: сначала нужно ввести число элементов списка (это значение будет использовано в качестве аргумента функции range), потом – заданное количество строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1386e2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [input() for i in range(int(input()))]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30abc8a0",
   "metadata": {},
   "source": [
    "В списковое включение можно добавить какое нибудь условие (как мы это делали с **if**).\n",
    "\n",
    "new_list = [expression **for** member **in** iterable **if** conditional]\n",
    "\n",
    "Разберем на примере:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79d716e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1, 2, 3, 4, 5, 45, 67, 8, 765, 854, 76]\n",
    "x = [i for i in lst if i % 2 == 0]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f74fc751",
   "metadata": {},
   "source": [
    "В условии написано iterable, а не list. Значит можно попробовать проделать что-то подобное с любыми другими итерируемыми объектами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b997f240",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Предложение\n",
    "sentence = '''высокоуровневый язык программирования общего назначения с динамической строгой типизацией и \n",
    "                автоматическим управлением памятью...'''\n",
    "\n",
    "# Исключаем часть букв, пробел, точка и перенос строки\n",
    "vowels = 'ауоыийэяюёе .\\n'\n",
    "\n",
    "# Достанем в список все символы строки, которые не являются гласными, пробелом или точной.\n",
    "consonants = [i for i in sentence if i not in vowels]\n",
    "print(consonants, end = '')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d7f8374",
   "metadata": {},
   "source": [
    "Для простой фильтрации можно поместить условие в конец оператора, но что для изменения значение элемента вместо его фильтрации нужно применять следующую конструкцию:\n",
    "\n",
    "    new_list = [expression (if conditional) for member in iterable]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5bdd4c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "original_prices = [1.25, -9.45, 10.22, 3.78, -5.92, 1.16]\n",
    "prices = [i if i > 0 else 0 for i in original_prices]\n",
    "print(prices)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ab31e6b",
   "metadata": {},
   "source": [
    "Здесь, наше выражение **i** содержит условный оператор, **if i> 0** else **0**. Это говорит Python выводить значение **i**, если число положительное, но менять **i** на **0**, если число отрицательное."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45ba9220",
   "metadata": {},
   "source": [
    "## Включения для множеств\n",
    "\n",
    "Хотя **list comprehension** в Python является распространенным инструментом, вы также можете создавать множественные и словарные представления (**set and dictionary comprehensions**). **set comprehension** почти точно такое же, как представление списка. Разница лишь в том, что заданные значения обеспечивают, чтобы выходные данные не содержали дубликатов. Вы можете создать **set comprehension**, используя фигурные скобки вместо скобок:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a98b137d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = '''высокоуровневый язык программирования общего назначения с динамической строгой типизацией и \n",
    "                автоматическим управлением памятью...'''\n",
    "\n",
    "print(sentence)\n",
    "unique_vowels = {i for i in sentence if i in 'ауоыиэяюёе'}\n",
    "print(unique_vowels)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc7fef1",
   "metadata": {},
   "source": [
    "Здесь мы вывели все уникальные гласные, которые встретились в строке."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa894d4a",
   "metadata": {},
   "source": [
    "# Многомерные списки\n",
    "\n",
    "Для создания одномерного списка мы использовали следующую конструкцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b2077d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "a = [0] * n\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61539a83",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "m = 4\n",
    "a = [[0] * m] * n\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a586611e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0][1]  # Обратимся к элементу 0,1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3043882",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Изменим данный элемент и вызовем наш список на печать\n",
    "\n",
    "a[0][1] = 3\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "936dd354",
   "metadata": {},
   "source": [
    "Создадим более удобный, с визуальной точки зрения, вывод нашего списка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e251505",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(a)):\n",
    "    for j in range(len(a[i])):\n",
    "        print(a[i][j], end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46d117fb",
   "metadata": {},
   "source": [
    "Несколько способов создания двухмерного списка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a05f2948",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Первый способ\n",
    "\n",
    "n = 5\n",
    "m = 4\n",
    "a = [0] * n\n",
    "for i in range(n):\n",
    "    a[i] = [0] * m\n",
    "\n",
    "# Изменим элемент\n",
    "a[0][1] = 3  \n",
    "\n",
    "# Печать списка\n",
    "for i in range(len(a)):\n",
    "    for j in range(len(a[i])):\n",
    "        print(a[i][j], end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f69e4fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Второй способ\n",
    "\n",
    "n = 5\n",
    "m = 4\n",
    "a = []\n",
    "for i in range(n):\n",
    "    a.append([1] * m)\n",
    "\n",
    "# Изменим элемент\n",
    "a[0][1] = 3  \n",
    "\n",
    "# Печать списка\n",
    "for i in range(len(a)):\n",
    "    for j in range(len(a[i])):\n",
    "        print(a[i][j], end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "add74a4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Третий способ\n",
    "\n",
    "n = 5\n",
    "m = 4\n",
    "\n",
    "a = [[2] * m for i in range(n)]\n",
    "\n",
    "# Изменим элемент\n",
    "a[0][1] = 3  \n",
    "\n",
    "# Печать списка\n",
    "for i in range(len(a)):\n",
    "    for j in range(len(a[i])):\n",
    "        print(a[i][j], end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1566a9c1",
   "metadata": {},
   "source": [
    "Осуществим ввод двухмерного списка целых чисел с клавиатуры."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6e7c8b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Введите количество строк списка\")\n",
    "n = int(input())\n",
    "\n",
    "a = []\n",
    "for i in range(n):\n",
    "    a.append(list(map(int,input().split())))\n",
    "\n",
    "print(type(a))\n",
    "# Печать списка\n",
    "for i in range(len(a)):\n",
    "    for j in range(len(a[i])):\n",
    "        print(a[i][j], end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98862a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [list(map(int,input().split())) for i in range(int(input()))]\n",
    "\n",
    "# Печать списка\n",
    "for i in range(len(a)):\n",
    "    for j in range(len(a[i])):\n",
    "        print(a[i][j], end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c61d204",
   "metadata": {},
   "source": [
    "Заполнение двухмерного списка случайными числами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "207c0a28",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "print(\"Введите размерность списка\")\n",
    "n, m = map(int, input().split())\n",
    "\n",
    "a = [[0] * m for i in range(n)]\n",
    "\n",
    "print(\"Введите диапозон случайных чисел\")\n",
    "r_min, r_max = map(int, input().split())\n",
    "\n",
    "for i in range(n):\n",
    "    for j in range(m):\n",
    "        a[i][j] = random.randint(r_min, r_max)\n",
    "\n",
    "for i in a:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0deaca98",
   "metadata": {},
   "source": [
    "Создадим квадратный двухмерный список, у которого главная диагональ будет заполнена единицами. Выши главной диагонали список будет заполнен нулями, нижи главной диагонали будут двойки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "350beed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Первый способ\n",
    "\n",
    "print(\"Введите размерность матрицы \")\n",
    "n = int(input())\n",
    "\n",
    "a = [[0] * n for i in range(n)]\n",
    "\n",
    "for i in range(n):\n",
    "    for j in range(n):\n",
    "        if i < j:\n",
    "            a[i][j] = 0\n",
    "        elif i > j:\n",
    "            a[i][j] = 2\n",
    "        else:\n",
    "            a[i][j] = 1\n",
    "\n",
    "for i in a:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7227683",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Второй способ\n",
    "\n",
    "print(\"Введите размерность матрицы \")\n",
    "n = int(input())\n",
    "\n",
    "a = [[0] * n for i in range(n)]\n",
    "for i in range(n):\n",
    "    a[i][i] = 1\n",
    "#     for j in range(i + 1, n):\n",
    "#          a[i][j] = 3\n",
    "    for j in range(0, i):\n",
    "         a[i][j] = 2\n",
    "\n",
    "for i in a:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fee9629",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Третий способ\n",
    "\n",
    "print(\"Введите размерность матрицы \")\n",
    "n = int(input())\n",
    "\n",
    "a = [[2] * i + [1] + [0] * (n - 1 - i) for i in range(n)]\n",
    "\n",
    "for i in a:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba9b6ec6",
   "metadata": {},
   "source": [
    "Транспонирование нашей матрицы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cefb2b84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Первый способ\n",
    "\n",
    "a_transposed = []\n",
    "a_temp = []\n",
    "\n",
    "for i in range(len(a[0])):\n",
    "    for j in range(len(a)):\n",
    "        a_temp.append(a[j][i])\n",
    "    a_transposed.append(a_temp)\n",
    "    a_temp = []\n",
    "\n",
    "for i in a_transposed:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b852df6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Второй способ\n",
    "\n",
    "a_transposed = [[row[i] for row in a] for i in range(len(a[0]))]\n",
    "\n",
    "for i in a_transposed:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b4665d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Без создания нового списка\n",
    "\n",
    "for i in range(len(a)):\n",
    "    for j in range(i + 1, len(a)):\n",
    "        a[i][j], a[j][i] = a[j][i], a[i][j]\n",
    "\n",
    "\n",
    "for i in a_transposed:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a95d5296",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Если список не квадратный\n",
    "\n",
    "a = [[1, 2, 3],\n",
    "    [4, 5, 6]]\n",
    "\n",
    "a_transposed = [[row[i] for row in a] for i in range(len(a[0]))]\n",
    "\n",
    "for i in a_transposed:\n",
    "    for j in i:\n",
    "        print(j, end = \"\\t\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1169add9",
   "metadata": {},
   "source": [
    "Заполнение трехмерного списка случайными числами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36943cb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "print(\"Введите размерность списка\")\n",
    "n, m, z = map(int, input().split())\n",
    "\n",
    "a = [[[0] * z for j in range(m)] for i in range(n)]\n",
    "\n",
    "print(\"Введите диапозон случайных чисел\")\n",
    "r_min, r_max = map(int, input().split())\n",
    "\n",
    "for i in range(n):\n",
    "    for j in range(m):\n",
    "        for k in range(z):\n",
    "             a[i][j][k] = random.randint(r_min, r_max)\n",
    "\n",
    "for i in a:\n",
    "    for j in i:\n",
    "        for k in j:\n",
    "            print(k, end = \"\\t\")\n",
    "        print()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b7a7c4b",
   "metadata": {},
   "source": [
    "## Вывод вложенного списка\n",
    "\n",
    "Для вывода вложенного списка можно сначала перебрать в цикле элементы внешнего списка, а затем, в другом цикле, перебрать элементы внутреннего. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "511db8a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    " \n",
    "for sublist in nested_list:\n",
    "    for item in sublist:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8beb293",
   "metadata": {},
   "source": [
    "Списки также можно вывести на разных строках:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60fff220",
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "for sublist in nested_list:\n",
    "    print(*sublist, sep = \", \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a899ee5c",
   "metadata": {},
   "source": [
    "Еще можно создать новый список из элементов вложенного при помощи list comprehension и вывести его при помощи print():"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c076bbb",
   "metadata": {},
   "outputs": [],
   "source": [
    "nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "result = [item for sublist in nested_list for item in sublist]\n",
    "print(result)\n",
    "\n",
    "# Результат:\n",
    "# [1, 2, 3, 4, 5, 6, 7, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15f7291c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример вывода в каждой строке, суммы рандомно сгенерированных чисел:\n",
    "\n",
    "from random import random\n",
    "\n",
    "M = 3\n",
    "N = 4\n",
    "\n",
    "a = []\n",
    "for i in range(N):\n",
    "    b = []\n",
    "    for j in range(M):\n",
    "        b.append(int(random() * 11))\n",
    "        print(\"%4d\" % b[j], end = '')\n",
    "    print('   |', sum(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "491b8147",
   "metadata": {},
   "source": [
    "В Python есть несколько встроенных функций, которые позволяют перебирать данные. Одна из них – функция `zip()` в Python создает итератор, который объединяет элементы из нескольких источников данных. Побробнее можно ознакомиться [по ссылке](https://pythonru.com/uroki/funkcija-zip-dlja-nachinajushhih)\n",
    "\n",
    "У функции zip() множество сценариев применения. Например, она пригодится, если нужно создать набор словарей из двух массивов, каждый из которых содержит имя и номер сотрудника."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9da2522",
   "metadata": {},
   "outputs": [],
   "source": [
    "employee_numbers = [2, 9, 18, 28]\n",
    "employee_names = [\"Дима\", \"Марина\", \"Андрей\", \"Никита\"]\n",
    "\n",
    "zipped_values = zip(employee_names, employee_numbers)\n",
    "zipped_list = list(zipped_values)\n",
    "\n",
    "print(zipped_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72c564ea",
   "metadata": {},
   "source": [
    "Чтобы разбить список на равные части, можно воспользоваться функцией `zip()` в сочетании с функцией `iter()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65d0b575",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Наш список `x`\n",
    "x = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "# Разбиваем `x` на 3 части\n",
    "y = zip(*[iter(x)] * 3)\n",
    "\n",
    "# Выводим результат\n",
    "list(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2e62d92",
   "metadata": {},
   "source": [
    "# Словари\n",
    "\n",
    "Словари(dict) в Python – неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.\n",
    "\n",
    "Первый способ создать словарь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71cf2e4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пустой словарь\n",
    "empty_dict = {}\n",
    "\n",
    "# Словарь с двумя парами ключ-значение\n",
    "value_dict = {\"cat\": \"кошка\", \"dog\": \"собака\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0f0bf64",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(value_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f81256b",
   "metadata": {},
   "source": [
    "Второй способ создать словарь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60c84db0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct = dict(cat = \"кошка\", dog = \"собака\", hedgehog = \"ежик\")\n",
    "print(dct)\n",
    "dct[\"animals\"] = [\"кошка\", \"собака\", \"ежик\"]\n",
    "print(dct)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3633cea6",
   "metadata": {},
   "source": [
    "Вернуть значение ключа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9e5e5fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct[\"hedgehog\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34399200",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct.get(\"hedgehog\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb3de3d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct.get(\"hedgeho\", \"Такого ключа нет\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "457e651a",
   "metadata": {},
   "source": [
    "Вернуть пары."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65929098",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct.items()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3655cf3f",
   "metadata": {},
   "source": [
    "Вернуть ключи."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d05057d",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff99f405",
   "metadata": {},
   "source": [
    "Вернуть значения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba895c17",
   "metadata": {},
   "outputs": [],
   "source": [
    "dct.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9afc8b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Если пройтись циклом по словарю, то выведутся только ключи\n",
    "\n",
    "for k in dct:\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73a4794d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Так посмотрим только на значения\n",
    "\n",
    "for v in dct.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "176d3db6",
   "metadata": {},
   "outputs": [],
   "source": [
    "for k,v in dct.items():\n",
    "    print(\"Ключ: {} -> Значение: {}\".format(k, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f65ef3cd",
   "metadata": {},
   "source": [
    "Методы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d195a519",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создать словарь\n",
    "df = dict(apple = 'яблоко', pineapple = \"ананас\", banana = \"банан\")\n",
    "\n",
    "# Получить значение по ключу\n",
    "print(df['apple'])\n",
    "\n",
    "# Получить значение по ключу\n",
    "print(df.get('apple'))\n",
    "\n",
    "# Получить пары ключ-значение\n",
    "print(df.items())\n",
    "\n",
    "# Получить все ключи в словаре\n",
    "print(df.keys())\n",
    "\n",
    "# Получить все значения в словаре\n",
    "print(df.values())\n",
    "\n",
    "# Удалить значение из словаря\n",
    "del df[\"banana\"]\n",
    "print(df)\n",
    "\n",
    "# Получить значение по ключу, после чего удалить\n",
    "print(df.pop('apple'))\n",
    "print(df)\n",
    "\n",
    "# Если элемента нет\n",
    "print(df.pop('lemon', \"Элемента в словаре нет\"))\n",
    "\n",
    "# Добавить новое значение в словарь\n",
    "df['cherry'] = 'вишня'\n",
    "print(df)\n",
    "\n",
    "# Изменение значения\n",
    "df.update({\"banana\": \"БАНАН\"})\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad51b04b",
   "metadata": {},
   "source": [
    "Включения для словарей."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ab60d3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = {i: i * i for i in range(10)}\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fd7cd6b",
   "metadata": {},
   "source": [
    "## Пример применения словарей\n",
    "\n",
    "Найдем пять самых часто встречающихся слова в утверждениях Zen of Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69258c7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "153c6ba7",
   "metadata": {},
   "source": [
    "Создадим переменную zen, куда считаем все утверждения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32841e97",
   "metadata": {},
   "outputs": [],
   "source": [
    "zen = '''Beautiful is better than ugly.\n",
    "Explicit is better than implicit.\n",
    "Simple is better than complex.\n",
    "Complex is better than complicated.\n",
    "Flat is better than nested.\n",
    "Sparse is better than dense.\n",
    "Readability counts.\n",
    "Special cases aren't special enough to break the rules.\n",
    "Although practicality beats purity.\n",
    "Errors should never pass silently.\n",
    "Unless explicitly silenced.\n",
    "In the face of ambiguity, refuse the temptation to guess.\n",
    "There should be one-- and preferably only one --obvious way to do it.\n",
    "Although that way may not be obvious at first unless you're Dutch.\n",
    "Now is better than never.\n",
    "Although never is often better than *right* now.\n",
    "If the implementation is hard to explain, it's a bad idea.\n",
    "If the implementation is easy to explain, it may be a good idea.\n",
    "Namespaces are one honking great idea -- let's do more of those!'''"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f15e620d",
   "metadata": {},
   "source": [
    "Разобьем данную строку на слова и очистим от знаков. Очищенные слова будем поочередно добавлять в словарь zen_map. В качестве ключей в этом словаре будут выступать слова, а значениями – частота использования слов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b90bddf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "zen_map = dict()\n",
    "\n",
    "for word in zen.split():\n",
    "    cleaned_word = word.strip('.,!-* \"').lower()\n",
    "    if cleaned_word not in zen_map:\n",
    "        zen_map[cleaned_word] = 1  # Если слово ранее не встречалось, добавляем в словарь с ключом 1\n",
    "    else: \n",
    "        zen_map[cleaned_word] += 1  # Увеличиваем счетчик слов\n",
    "\n",
    "for k,v in zen_map.items():\n",
    "    print(\"Слово: {} -> Встречается: {}\".format(k, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c3d1478",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вариант программы, которая создает словарь без \"сорных\" слов\n",
    "\n",
    "zen_map = dict()\n",
    "for word in zen.split():\n",
    "    cleared_word = word.strip('.,!-* \"').lower()\n",
    "    if cleared_word not in zen_map:\n",
    "        if cleared_word not in ('this', 'is','and', 'not', 'to', 'the', 'in', 'of','for', 'than', 'there', 'at', 'if', \"\"):\n",
    "            zen_map[cleared_word]  = 1\n",
    "    else:\n",
    "        zen_map[cleared_word] += 1\n",
    "\n",
    "for k,v in zen_map.items():\n",
    "    print(\"Слово: {} -> Встречается: {}\".format(k, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "556a0486",
   "metadata": {},
   "source": [
    "Ключи и значения не упорядочены, поэтому организуем сортировку. Для этого можно воспользоватьс методом items(). Так мы получим zen_items – список множеств. Элементами множества будут – (ключ, значение)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c7419b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "\n",
    "zen_items = zen_map.items() \n",
    "word_count_items = sorted(zen_items, key = operator.itemgetter(1), reverse = True)\n",
    "\n",
    "print(word_count_items[:8])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c52e7bc0",
   "metadata": {},
   "source": [
    "Однако, как это часто бывает в Python, уже есть встроенный модуль, который поможет решить эту задачу проще:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "557f8890",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "cleaned_list = []\n",
    "for word in zen.split():\n",
    "    cleaned_list.append(word.strip('.,!-* \"').lower())  # Очищаем строку от знаков и приводим к нижнему регистру\n",
    "\n",
    "print(Counter(cleaned_list).most_common(5)) # Вызываем Counter и обращаемся к методу most_common"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "571763fc",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Напишите программу для создания словаря из строки, где ключ – это значение символа сороки, а значение – количество их встречаемости.\n",
    "\n",
    "Пример строки: ' w3resource'\n",
    "\n",
    "Ожидаемый результат: {'w': 1, '3': 1, 'r': 2, 'e': 2, 's': 1, 'o': 1, 'u': 1, 'c': 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e333bc46",
   "metadata": {},
   "outputs": [],
   "source": [
    "di = dict()\n",
    "st = input()\n",
    "for i in st:\n",
    "    if i is not di:\n",
    "        di[i] = st.count(i)\n",
    "print(di)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e67492c",
   "metadata": {},
   "source": [
    "## Таблица сравнения структур данных (список, кортеж, множество, словарь)\n",
    "\n",
    "Теперь, когда мы познакомились со структурами данных, сведём основную информацию по ним в таблицу.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/Data_structure.jpg?raw=true)\n",
    "\n",
    "### Заключение.\n",
    "\n",
    "Списки – подходят для хранения упорядоченных коллекций элементов, когда важна изменяемость.\n",
    "\n",
    "Кортежи – используются для хранения неизменяемых данных и передачи множества значений в функции.\n",
    "\n",
    "Множества – полезны для хранения уникальных элементов и выполнения операций над множествами.\n",
    "\n",
    "Словари – идеальны для хранения данных с быстрым доступом по ключу, особенно когда необходимо часто искать и обновлять данные.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe581411",
   "metadata": {},
   "source": [
    "# Устройство функций в Python. Написание простейших функций. Написание сложных функций.\n",
    "\n",
    "## Функция\n",
    "\n",
    "Функцией называют именованный фрагмент программного кода, к которому можно обратиться из другого места вашей программы (но есть lambda-функции, у которых нет имени, о них будет рассказано ниже). Как правило, функции создаются для работы с данными, которые передаются ей в качестве аргументов, также функция может формировать некоторое возвращаемое значение.\n",
    "\n",
    "**Объявляя функцию, нужно следовать определенным правилам**:\n",
    "\n",
    "Объявление происходит с помощью ключевого слова **def**, за ним идёт имя функции и круглые скобки ().\n",
    "\n",
    "**Аргументы**, передаваемые в функцию, должны находится в круглых скобках. Там же можно определить их значения по умолчанию, указав их после знака равно.\n",
    "\n",
    "Перед основным содержимым желательно включить **строку документации** (docstring), которая обычно описывает назначение  и основные принципы работы функции.\n",
    "\n",
    "**Тело функции** начинается после знака двоеточия. Важно не забыть об отступах.\n",
    "\n",
    "Чтобы выйти из функции в Python, используют оператор **return [значение]**. Если оператор опущен, будет возвращено значение None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30720cff",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(\"123\")  # Пример работы функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c2a17b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "'asdf'.upper()  # Пример работы метода"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5817cdf",
   "metadata": {},
   "source": [
    "Функция имеет следующую конструкцию:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "889791d9",
   "metadata": {},
   "source": [
    "def Имя(аргументы):\n",
    "    '''Документация\n",
    "    '''\n",
    "    Тело (инструкции)\n",
    "    return [значение]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4abf30f2",
   "metadata": {},
   "source": [
    "Попробуем самостоятельно реализовать функцию, складывающую два числа и выводящую результат на печать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f6d4ea3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def summarize(a, b):\n",
    "    summ = a + b\n",
    "    print(summ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "144a4bda",
   "metadata": {},
   "outputs": [],
   "source": [
    "summarize(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00ab4715",
   "metadata": {},
   "source": [
    "Или с return:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9d96b34",
   "metadata": {},
   "outputs": [],
   "source": [
    "def summarize(a, b):\n",
    "    summ = a + b\n",
    "    return summ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4a1ec8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = summarize(1, 2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24c3a527",
   "metadata": {},
   "source": [
    "Теперь эту функцию можно вызвать в любом месте кода.\n",
    "\n",
    "При описании функции в Python 3 можно задать аргументы с какими-либо начальными значениями, такие аргументы являются \"необязательными\". Вначале нужно описывать обязательные параметры, а после них – необязательные. При вызове функции не обязательно указывать значения \"необязательных\" параметров. Если мы хотим изменить значение аргумента, не меняя начальные значения других аргументов, можно обращаться к нему по ключу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b57cf0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def example(first, second = 3, third = 5):\n",
    "    print(first)\n",
    "    print(second)\n",
    "    print(third)\n",
    "    \n",
    "example('my string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ab56d8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "example('my string',second = 'dfgh')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab0f7b47",
   "metadata": {},
   "source": [
    "Пример использования функции\n",
    "вычислим значение n! + k! - p!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b404d17e",
   "metadata": {},
   "outputs": [],
   "source": [
    "n, k, p = 5, 6, 3\n",
    "\n",
    "fn = 1\n",
    "for i in range(2, n + 1):\n",
    "    fn *= i\n",
    "fk = 1\n",
    "for i in range(2, k + 1):\n",
    "    fk *= i\n",
    "fp = 1\n",
    "for i in range(2, p + 1):\n",
    "    fp *= i\n",
    "\n",
    "fn + fk - fp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66b3962f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(N):\n",
    "    f = 1\n",
    "    for i in range(1, N + 1):\n",
    "        f *= i\n",
    "    return f\n",
    "\n",
    "factorial(5) + factorial(6) - factorial(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "332c847c-c261-43c6-8089-297b2e396fda",
   "metadata": {},
   "source": [
    "**return** может находиться в любом месте функции – даже внутри блока кода с условием:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa69d992-d146-4f81-8a7c-d18672d7170d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Функция проверяет введённый адрес и корректирует начало, если оно не соответствует условию\n",
    "\n",
    "def normalize_url(url):\n",
    "    prefix = 'https://'\n",
    "    if url[:8] == prefix:\n",
    "        return url\n",
    "    else:\n",
    "        if url[:7] == 'http://':\n",
    "            return prefix + url[7:]\n",
    "        else:\n",
    "            return prefix + url\n",
    "\n",
    "print(normalize_url('https://ya.ru'))      # => 'https://ya.ru'\n",
    "print(normalize_url('google.com'))         # => 'https://google.com'\n",
    "print(normalize_url('http://ai.fi'))       # => 'https://ai.fi'\n",
    "print(normalize_url('httpssecurity.com'))  # => 'https://httpssecurity.com'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10fe65f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Реализуйте функцию, которая принимает два числа, границы диапазона, и перемножает числа в нем, включая границы диапазона\n",
    "\n",
    "def multiply_numbers_from_range(start, finish):\n",
    "    i = start\n",
    "    multiply = 1\n",
    "    while i <= finish:\n",
    "        multiply *= i\n",
    "        i += 1\n",
    "    return multiply\n",
    "\n",
    "print(multiply_numbers_from_range(1, 5))  # 1 * 2 * 3 * 4 * 5 = 120\n",
    "print(multiply_numbers_from_range(2, 3))  # 2 * 3 = 6\n",
    "print(multiply_numbers_from_range(6, 6))  # 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da2cc370",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Реализуйте функцию, которая объединяет все числа из переданного диапазона в строку\n",
    "\n",
    "def join_numbers_from_range(start, finish):\n",
    "    i = start\n",
    "    result = ''\n",
    "    while i <= finish:\n",
    "        result += str(i)\n",
    "        i += 1\n",
    "    return result\n",
    "\n",
    "print(join_numbers_from_range(1, 1))  # '1'\n",
    "print(join_numbers_from_range(2, 3))  # '23'\n",
    "print(join_numbers_from_range(5, 10))  # '5678910'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53134e28",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Реализуйте функцию, которая печатает переданное слово посимвольно, в обратном порядке\n",
    "\n",
    "def print_reversed_word_by_symbol(text):\n",
    "    i = len(text)\n",
    "    while i > 0:\n",
    "        print(text[i - 1])\n",
    "        i -= 1\n",
    "\n",
    "print_reversed_word_by_symbol('Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9603999",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Задача посчитать, сколько раз встречается буква в тексте, не зависимо от её регистра. Через while\n",
    "\n",
    "def count_chars(string, char):\n",
    "    index = 0\n",
    "    count = 0\n",
    "    while index < len(string):\n",
    "        if string[index].lower() == char.lower():\n",
    "            count += 1\n",
    "        index += 1\n",
    "    return count\n",
    "\n",
    "print(count_chars('rEversEd', 'e'))  # 3\n",
    "print(count_chars('revErsed', 'E'))  # 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbda2d24",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Задача посчитать, сколько раз встречается буква в тексте, не зависимо от её регистра. Через for\n",
    "\n",
    "def count_chars(text, char):\n",
    "    result = 0\n",
    "    for current_char in text:\n",
    "        if current_char.lower() == char.lower():\n",
    "            result += 1\n",
    "    return result\n",
    "\n",
    "print(count_chars('rEversEd', 'e'))  # 3\n",
    "print(count_chars('revErsed', 'E'))  # 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5090c72",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Функция возвращает строку, в которой удалён переданный символ во всех его позициях, не зависимо от регистра. Через while\n",
    "\n",
    "def filter_string(text, letter):\n",
    "    i = 0\n",
    "    result = ''\n",
    "    while i < len(text):\n",
    "        if letter != text[i]:\n",
    "            result += text[i]\n",
    "        i += 1\n",
    "    return result\n",
    "\n",
    "text = 'If I look back I am lost'\n",
    "print(filter_string(text, 'I'))  # 'f  look back  am lost'\n",
    "print(filter_string(text, 'o'))  # 'If I lk back I am lst'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eafd70f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Функция возвращает строку, в которой удалён переданный символ во всех его позициях, не зависимо от регистра. Через for\n",
    "\n",
    "def filter_string(text, letter):\n",
    "    result = ''\n",
    "    for char in text:\n",
    "        if char.lower() != letter.lower():\n",
    "            result += char\n",
    "    return result\n",
    "\n",
    "text = 'If I look back I am lost'\n",
    "print(filter_string(text, 'I'))  # 'f  look back  am lost'\n",
    "print(filter_string(text, 'o'))  # 'If I lk back I am lst'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f1234c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Реализуйте функцию, которая извлекает из переданной строки подстроку указанной длины, начиная с определённого символа\n",
    "\n",
    "def my_substr(string, start, length):\n",
    "    i = start\n",
    "    result = ''\n",
    "    while i < start + length:\n",
    "        result += string[i]\n",
    "        i += 1\n",
    "    return result\n",
    "\n",
    "string = \"I'm going to make him an offer he can't refuse\"\n",
    "print(my_substr(string, 4, 13))  # => 'going to make'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63dd7df9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Проверка, является ли строка палиндромом. Во второй функции, с помощью первой задаётся обратное условие\n",
    "\n",
    "def is_palindrome(line):\n",
    "    line_lower = line.lower()\n",
    "    return line_lower == line_lower[::-1]\n",
    "\n",
    "def is_not_palindrome(line):\n",
    "    return not is_palindrome(line)\n",
    "\n",
    "print(is_palindrome('шалаш'))  # true\n",
    "print(is_palindrome('хекслет'))  # false\n",
    "print(is_palindrome('Довод'))  # true\n",
    "print(is_palindrome('Функция'))  # false\n",
    "\n",
    "print(is_not_palindrome('шалаш'))  # false\n",
    "print(is_not_palindrome('Ага'))  # false\n",
    "print(is_not_palindrome('хекслет'))  # true"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d70198f-7af5-4be2-a3f4-5b8ac0705229",
   "metadata": {},
   "source": [
    "## Тернарный оператор\n",
    "\n",
    "В Python есть конструкция, которая работает как if-else, но считается выражением. Она называется **тернарный оператор** – единственный оператор в Python, который требует три операнда.\n",
    "\n",
    "Общий паттерн выглядит так: `<expression on true> if <predicate> else <expression on false>`.\n",
    "\n",
    "Тернарный оператор можно вкладывать в тернарный оператор. Но не нужно так делать, так как такой код тяжело читать и отлаживать.\n",
    "\n",
    "Пример написания с обычным if-else, и с тернарным оператором:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dd29ef7-c5aa-4b78-80c0-121bc806d725",
   "metadata": {},
   "outputs": [],
   "source": [
    "def abs(number):\n",
    "    if number >= 0:\n",
    "        return number\n",
    "    return -number\n",
    "\n",
    "def abs(number):\n",
    "    return number if number >= 0 else -number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "941a0e19",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример решения задачи по определению \"високосный год или нет?\" через if-else\n",
    "\n",
    "a = int(input())\n",
    "\n",
    "if a % 400 == 0:\n",
    "    print('true')\n",
    "else:\n",
    "    if a % 100 == 0:\n",
    "        print('false')\n",
    "    else:\n",
    "        if a % 4 == 0:\n",
    "            print('true')\n",
    "        else:\n",
    "                print('false')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ecbfaba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Решение той же задачи, но уже с помощью тернарного оператора\n",
    "\n",
    "def is_leap_year(year: int) -> bool:\n",
    "    return year % 400 == 0 or (year % 4 == 0 and year % 100 != 0)\n",
    "\n",
    "print(is_leap_year(2018))  # false\n",
    "print(is_leap_year(2017))  # false\n",
    "print(is_leap_year(2016))  # true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12af4139",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Важно не переусердствовать. Закомментированная функция равносильна не закомментированной, но чтобы в ней разобраться, потребуется больше времени\n",
    "\n",
    "def is_arguments_for_substr_correct(string, start, lenght):\n",
    "    if lenght < 0:\n",
    "        return False\n",
    "    elif start < 0:\n",
    "       return False \n",
    "    elif start >= len(string):\n",
    "       return False\n",
    "    elif start + lenght > len(string):\n",
    "       return False\n",
    "    else:\n",
    "        return True\n",
    "\n",
    "# def is_arguments_for_substr_correct(string, start, lenght):\n",
    "#     return False if lenght < 0 or start < 0 or start >= len(string) or start + lenght > len(string) else True\n",
    "\n",
    "string = 'Sansa Stark'\n",
    "print(is_arguments_for_substr_correct(string, 2, -3))   # => False\n",
    "print(is_arguments_for_substr_correct(string, -1, 3))   # => False\n",
    "print(is_arguments_for_substr_correct(string, 4, 100))  # => False\n",
    "print(is_arguments_for_substr_correct(string, 10, 10))  # => False\n",
    "print(is_arguments_for_substr_correct(string, 11, 0))   # => False\n",
    "print(is_arguments_for_substr_correct(string, 10, 1))   # => True\n",
    "print(is_arguments_for_substr_correct(string, 10, 0))   # => True\n",
    "print(is_arguments_for_substr_correct(string, 3, 3))    # => True\n",
    "print(is_arguments_for_substr_correct(string, 0, 5))    # => True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9c6231f",
   "metadata": {},
   "source": [
    "## Необязательные параметры функций\n",
    "\n",
    "В программировании у многих функций и методов есть параметры, которые редко меняются. В таких случаях этим параметрам задают значения по умолчанию, которые можно поменять по необходимости. С помощью этого сокращается количество одинакового кода. Рассмотрим, как это выглядит на практике.\n",
    "\n",
    "Разберем пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87fa858e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Функция возведения в степень\n",
    "# Второй параметр имеет значение по умолчанию два\n",
    "def pow(x, base = 2):\n",
    "    return x ** base\n",
    "\n",
    "# Три во второй степени (двойка задана по умолчанию)\n",
    "pow(3)  # 3 * 3 = 9\n",
    "\n",
    "# Три в третьей степени\n",
    "pow(3, 3)  # 3 * 3 * 3 = 27"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df09790d",
   "metadata": {},
   "source": [
    "Значение по умолчанию выглядит как обычное присваивание в определении. Оно срабатывает только в том случае, если параметр не передали.\n",
    "\n",
    "Представьте, что вы не привезли с собой в автосервис запчасти для вашего автомобиля. Тогда автомеханик предложит вам поставить те, которые есть у него – по умолчанию.\n",
    "\n",
    "Значение по умолчанию может быть даже в том случае, когда параметр один:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd6122c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_print(text = 'nothing'):\n",
    "    print(text)\n",
    "\n",
    "my_print()  # => \"nothing\"\n",
    "my_print(\"Python\")  # => \"Python\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9deac56",
   "metadata": {},
   "source": [
    "Параметров со значениями по умолчанию может быть любое количество:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72297549",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a = 5, b = 10, c = 100):"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "416cce32",
   "metadata": {},
   "source": [
    "У значений по умолчанию есть одно ограничение. Они должны идти в самом конце списка параметров. С точки зрения синтаксиса, невозможно создать функцию, у которой после необязательного параметра идет обязательный:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81f92117",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Такой код завершится с ошибкой\n",
    "def f(a = 5, b = 10, c = 100, x):\n",
    "\n",
    "# И такой\n",
    "def f(a = 5, b = 10, x, c = 100):\n",
    "\n",
    "# Этот код сработает\n",
    "def f(x, a = 5, b = 10, c = 100):\n",
    "\n",
    "# Этот тоже сработает\n",
    "def f(x, y, a = 5, b = 10, c = 100):"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15b9bf49",
   "metadata": {},
   "source": [
    "Значения параметров по умолчанию могут быть как у нескольких параметров, так и у одного.\n",
    "\n",
    "Важно – значения по умолчанию должны быть в самом конце списка параметров. Эти знания помогут сократить количество одинакового кода.\n",
    "\n",
    "Ниже примеры кода с необязательными параметрами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d717feb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**5678\n"
     ]
    }
   ],
   "source": [
    "def get_hidden_card(number, amount_of_stars = 4):\n",
    "    return '*' * amount_of_stars + number[-4:]\n",
    "\n",
    "print(get_hidden_card('1234567812345678', 2))  # Если не указать при вводе второй параметр, то результат будет ****5678"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6e9c5ce",
   "metadata": {},
   "source": [
    "## Именованные аргументы\n",
    "\n",
    "**Аргументы** – это данные, которые передаются в вызов функции. Они бывают двух типов.\n",
    "\n",
    "Первый тип – **позиционные аргументы**. Они передаются в том же порядке, в котором определены параметры функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e353a604",
   "metadata": {},
   "outputs": [],
   "source": [
    "# (text, length)\n",
    "truncate('My Text', 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e333734",
   "metadata": {},
   "source": [
    "Второй тип – **именованные аргументы**. Они передаются не просто как значения, а как пара «имя = значение». Поэтому их можно передавать в любом порядке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85e877f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Аргументы переданы в другом порядке\n",
    "truncate(length = 3, text = 'My Text')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7159f30",
   "metadata": {},
   "source": [
    "Если внимательно посмотреть на два примера выше, то можно понять, что это две одинаковые функции.\n",
    "\n",
    "Теперь разберемся, в каких случаях нужно применять эти типы аргументов. Выбор типа параметра зависит от того, кто вызывает функцию. Есть две причины использовать именованные аргументы:\n",
    "\n",
    "- Они повышают читаемость, так как сразу видно имена\n",
    "- Можно не указывать все промежуточные параметры, которые нам сейчас не нужны\n",
    "\n",
    "Последнее полезно, если у функции много необязательных параметров. Посмотрим на примере:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91384f08",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_params(a = 1, b = 2, c = None, d = 4):\n",
    "    print(a, b, c, d)\n",
    "\n",
    "# Нужно передать только d, но приходится передавать все\n",
    "f(1, 2, 3, 8)\n",
    "\n",
    "# Именованные аргументы позволяют передавать только d\n",
    "# Для остальных аргументов используются значения по умолчанию\n",
    "f(d = 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f330abf6",
   "metadata": {},
   "source": [
    "Именованные аргументы можно передавать одновременно с позиционными. Тогда позиционные должны идти в самом начале:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a673598",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Передаем только a (позиционно) и d (как именованный)\n",
    "f(3, d = 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d9550ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример работы\n",
    "\n",
    "def trim_and_repeat(text, offset = 0, repetitions = 1):\n",
    "    return text[offset:] * repetitions\n",
    "\n",
    "text = 'python'\n",
    "print(trim_and_repeat(text, offset = 3, repetitions = 2))  # => honhon\n",
    "print(trim_and_repeat(text, repetitions = 3))  # => pythonpythonpython\n",
    "print(trim_and_repeat(text))  # => python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fd0733d",
   "metadata": {},
   "source": [
    "## Аннотации типов в функциях\n",
    "\n",
    "**Аннотации типов** – это возможность указать типы параметров и возвращаемое значение у функции в Python. Это не является обязательным требованием языка, но может помочь в дальнейшей разработке, улучшить читаемость кода и повысить его надёжность.\n",
    "\n",
    "Рассмотрим простой пример функции без аннотаций типов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6264d2cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def concat(first, second):\n",
    "    return first + second"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2418e76",
   "metadata": {},
   "source": [
    "Эта функция конкатенирует две строки в одну. При этом с первого взгляда на код сложно понять, что происходит в нём: какие типы у аргументов, почему функция работает со строками, а не складывает, например, два числа.\n",
    "\n",
    "Если в дальнейшем использовать эту функцию в коде, то может возникнуть необходимость проверять типы аргументов перед передачей их в функцию, что увеличивает объём кода и затрудняет его понимание.\n",
    "\n",
    "Теперь давайте добавим аннотации типов к функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34ae5daf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def concat(first: str, second: str) -> str:\n",
    "    return first + second"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db61dad2",
   "metadata": {},
   "source": [
    "Здесь мы указали, что аргументы first и second должны быть строкового типа (str). Возвращаемое значение тоже будет строковым. Когда мы будем использовать эту функцию в коде, нам будет проще понять, какие типы аргументов можно передавать и какой тип возвращаемого значения ожидается.\n",
    "\n",
    "Аннотации типов также могут быть использованы для определения типов переменных внутри функции. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e8453f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def double(n: int) -> int:\n",
    "    result: int = n * 2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ffdd443",
   "metadata": {},
   "source": [
    "В этом примере мы определили тип переменной result как int, используя аннотацию типа.\n",
    "\n",
    "Аннотации типов – это не строгая проверка типов в Python. Их использование не гарантирует, что функция будет вызвана с аргументами и возвращаемым значением указанных типов. Всё таки Python остается динамически типизированным языком. В нём аннотации типов не влияют на возможность передачи аргументов различных типов или возвращения значений других типов. Тем не менее их использование упрощает чтение и понимание кода и помогает отслеживать ошибки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d644788",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ещё один пример аннотации типов\n",
    "\n",
    "def word_multiply(text: str, number: int) -> str:\n",
    "    result = text * number\n",
    "    return result\n",
    "\n",
    "input_text = 'python'\n",
    "input_number = 2\n",
    "print(word_multiply(input_text, input_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe2ed16d",
   "metadata": {},
   "source": [
    "## Предикаты\n",
    "\n",
    "Функция `is_infant()` – это функция-предикат или функция-вопрос. Предикат отвечает на утвердительный вопрос «да» или «нет», возвращая значение типа bool. Предикаты во всех языках принято именовать особым образом для простоты анализа. В Python предикаты начинаются с префикса **is** или **has**:\n",
    "\n",
    "    is_infant() – «младенец ли?»\n",
    "    has_children() – «есть ли дети?»\n",
    "    is_empty() – «пустой ли?»\n",
    "    has_errors() – «есть ли ошибки?»\n",
    "\n",
    "Функция считается предикатом, если она возвращает булевы значения True или False.\n",
    "\n",
    "Напишем еще одну функцию-предикат. Она принимает строку и проверяет, является ли она словом 'Castle':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3c3d3ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_castle(string):\n",
    "    return string == 'Castle'\n",
    "\n",
    "print(is_castle('Sea'))  # False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd9b0fb-56ba-4144-8eea-b7dbb8abfad4",
   "metadata": {},
   "source": [
    "## Оператор Match\n",
    "\n",
    "Оператор **match** – это специализированная версия if, которую создали для особых ситуаций. Например, ее нужно использовать там, где есть цепочка if else с проверками на равенство:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2ed0f4f-2979-47b1-b4ae-0056733a8a4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "if status == 'processing':\n",
    "    # Делаем раз\n",
    "elif status == 'paid':\n",
    "    # Делаем два\n",
    "elif status == 'new':\n",
    "    # Делаем три\n",
    "else:\n",
    "    # Делаем четыре"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f6cbb86-a24e-44cc-b7ad-2ee5f9203d82",
   "metadata": {},
   "source": [
    "У этой составной проверки есть одна отличительная черта: каждая ветка здесь – это проверка значения переменной status. Оператор match позволяет записать этот код короче и выразительнее:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ce9fa1f-e72b-4649-9064-4ad88dc7b952",
   "metadata": {},
   "outputs": [],
   "source": [
    "match status:\n",
    "    case 'processing':  # status == 'processing'\n",
    "        # Делаем раз\n",
    "    case 'paid':  # status == 'paid'\n",
    "        # Делаем два\n",
    "    case 'new':  # status == 'new'\n",
    "        # Делаем три\n",
    "    case _:  # else\n",
    "        # Делаем четыре"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "630e7f8a-28ca-4d15-b4be-059b5f64afac",
   "metadata": {},
   "source": [
    "С точки зрения количества элементов match – это сложная конструкция. Она состоит из таких элементов:\n",
    "\n",
    "- Внешнее описание, в которое входит ключевое слово `match`. Это переменная, по значениям которой `match` будет выбирать поведение.\n",
    "\n",
    "- Конструкции `case`, внутри которых описывается поведение для разных значений рассматриваемой переменной. Каждый case соответствует `if` в примере выше. При этом `case _` – это особая ситуация, которая соответствует ветке `else` в условных конструкциях. Как и `else`, указывать `case _` необязательно.\n",
    "\n",
    "Внутри match допустим только тот синтаксис, который показан выше. Другими словами, там можно использовать case. А вот внутри каждого case ситуация другая. Здесь можно выполнять любой произвольный код:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f1cb813-db8e-47dd-b529-8c56946c2c84",
   "metadata": {},
   "outputs": [],
   "source": [
    "match count:\n",
    "    case 1:\n",
    "        # Делаем что-то полезное\n",
    "    case 2:\n",
    "        # Делаем что-то полезное\n",
    "    case _:\n",
    "        # Что-то делаем"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ece7d361-4e49-473a-9b54-9c5c91b138d3",
   "metadata": {},
   "source": [
    "Иногда результат, полученный внутри case – это конец выполнения функции, которая содержит match. В таком случае его нужно как-то вернуть наружу. Для решения этой задачи, один из способов – сделать обычный возврат из функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4028f875-6a7f-4774-9be4-6df397d7253b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_items(count):\n",
    "    match count:\n",
    "        case 1:\n",
    "            return 'one'\n",
    "        case 2:\n",
    "            return 'two'\n",
    "        case _:\n",
    "            return None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c536e2d8-d12e-41f3-a842-b829a5079cbe",
   "metadata": {},
   "source": [
    "Оператор match хоть и встречается в коде, но технически всегда можно обойтись без него. Ключевая польза при его использовании в том, что он лучше выражает намерение программиста, когда нужно проверять конкретные значения переменной. Хотя кода и стало физически чуть больше, читать его легче, в отличие от блоков elif."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44278570-5d31-4fa4-b908-7f61dbb6c6dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример написания функции, которая принимает на вход число и возвращает объяснение этого числа.\n",
    "# Если для числа нет объяснения, то возвращается just a number.\n",
    "\n",
    "def get_number_explanation(number):\n",
    "    match number:\n",
    "        case 666:\n",
    "            return 'devil number'\n",
    "        case 42:\n",
    "            return 'answer for everything'\n",
    "        case 7:\n",
    "            return 'prime number'\n",
    "        case _:\n",
    "            return 'just a number'\n",
    "\n",
    "print(get_number_explanation(8))  # just a number\n",
    "print(get_number_explanation(666))  # devil number\n",
    "print(get_number_explanation(42))  # answer for everything\n",
    "print(get_number_explanation(7))  # prime number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7280f727",
   "metadata": {},
   "source": [
    "## Распаковка (*args и **kwargs)\n",
    "\n",
    "Если мы хотим сожержимое двух списков положить в третий список или содержимое двух словарей положить в третий словарь, на помощь нам приходит так называемый \"звездочный синтаксис\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93f7f1f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1, 2, 3]\n",
    "list2 = [4, 5, 6]\n",
    "\n",
    "list3 = [*list1, *list2]  # Положили все элементы обоих списков в третий\n",
    "print(list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f9a9d1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'a' : 1, 'b' : 2, 'c' : 3}\n",
    "dict2 = {'a' : 4, 'e' : 5, 'f' : 6}\n",
    "\n",
    "dict3 = {**dict1, **dict2}  # Положили все элементы обоих словарей в третий\n",
    "print(dict3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "730bb792",
   "metadata": {},
   "source": [
    "Точно таким же образом можно что-то указать \"в явном виде\", а что-то распаковать из структуры (например, вы хотите дописать в новый список числа 3 и 4):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d14ff02d",
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [0, 1, 2]\n",
    "print([3, 4, list1])  # Тут элементом стал сам список\n",
    "print([3, 4, *list1])  # А тут мы элементы списка распаковали"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de1d3dbb",
   "metadata": {},
   "source": [
    "**В функции точно так же можно подавать несколько аргументов**\n",
    "\n",
    "Даже если вы заранее не знаете, сколько их будет. Вспомните, например, функцию print(). Она умеет давать ответ и при одном аргументе, и при двух и при любом N."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21bce14c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87a6a0ca",
   "metadata": {},
   "source": [
    "**\\*args и \\*\\*kwargs спешат на помощь**\n",
    "\n",
    "В Python можно передать переменное количество аргументов двумя способами:\n",
    "\n",
    "* \\*args для неименованных аргументов;\n",
    "* \\*\\*kwargs для именованных аргументов.\n",
    "\n",
    "Мы используем \\*args и \\*\\*kwargs в качестве аргумента, когда заранее не известно, сколько значений мы хотим передать функции.\n",
    "\n",
    "`*args`\n",
    "\n",
    "args нужен, когда мы хотим передать неизвестное количество неименованных аргументов. Если поставить * перед именем, это имя будет принимать не один аргумент, а несколько. Аргументы передаются как кортеж и доступны внутри функции под тем же именем, что и имя параметра, только без *."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2be02c33",
   "metadata": {},
   "outputs": [],
   "source": [
    "def adder(*nums):\n",
    "    summ = 0\n",
    "    for n in nums:\n",
    "        summ += n\n",
    "\n",
    "    print(\"Sum: \", summ)\n",
    "\n",
    "adder(3, 5)\n",
    "adder(4, 5, 6, 7)\n",
    "adder(1, 2, 3, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a2e9bf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def adder(*nums):\n",
    "    summ = 1\n",
    "    for n in nums:\n",
    "        summ *= n\n",
    "\n",
    "    print(\"Sum: \", summ)\n",
    "\n",
    "adder(3, 5)\n",
    "adder(4, 5)\n",
    "adder(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3b685de",
   "metadata": {},
   "source": [
    "`**kwargs`\n",
    "\n",
    "По аналогии с \\*args мы используем \\*\\*kwargs для передачи переменного количества именованных аргументов. Схоже с \\*args, если поставить ** перед именем, это имя будет принимать любое количество именованных аргументов. Кортеж/словарь из нескольких переданных аргументов будет доступен под этим именем. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3e8b6cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dct(**data):\n",
    "    print(\"\\nData type of argument: \", type(data))\n",
    "\n",
    "    for key, value in data.items():\n",
    "        print(\"{} -> {}\".format(key, value))\n",
    "\n",
    "dct(cat = \"кошка\", dog = \"собака\", hedgehog = \"ежик\")\n",
    "dct(animals = [\"кошка\", \"собака\", \"ежик\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "818d4b5b",
   "metadata": {},
   "source": [
    "В этом случае у нас есть функция **dct()** с параметром \\*\\*data. В функцию мы передали два словаря разной длины. Затем внутри функции мы прошлись в цикле по словарям, чтобы вывести их содержимое."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92cb99f4",
   "metadata": {},
   "source": [
    "# Локальные и глобальные переменные. Области видимости\n",
    "\n",
    "**Локальные переменные**\n",
    "\n",
    "Для создания переменных, обладающих локальной областью видимости, необходимо всего лишь поместить их в отдельный блок кода, изолированный от остальной программы. Например, у нас таким свойством обладают все переменные, которые мы прежде использовали в функциях:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df3f27b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    output = x + 1\n",
    "    output2 = output + 1\n",
    "    return output2\n",
    "\n",
    "print(f(4))\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ca85be9",
   "metadata": {},
   "source": [
    "Функция у нас сработала, а вот переменную за пределами функции мы не видим. Попробуем изнутри функции использовать переменную определенную вовне."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a993b27d",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 11\n",
    "\n",
    "def foo(z):\n",
    "    print(x)\n",
    "    return None\n",
    "\n",
    "foo(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "623cd423",
   "metadata": {},
   "source": [
    "Если нам все-таки нужно использовать значение переменной \"изнутри\" функции, можно сказать , что мы объявляем глобальную переменную. Для этого используется выражение **global**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec906bef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    global s\n",
    "    print(s)\n",
    "    s = \"Переменная задана внутри функции\"\n",
    "    print(s)\n",
    "\n",
    "s = \"Переменная задана в основном теле программы\" \n",
    "f()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9bf10e8",
   "metadata": {},
   "source": [
    "Здесь мы вызвали функцию и она перезаписала нам значение в переменную s.\n",
    "\n",
    "**Возврат нескольких значений**\n",
    "\n",
    "Нужно упомянуть еще один факт: по команде return функция может возвращать несколько значений. Например вот функция, которая умеет выводить сумму и разность двух аргументов функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56214909",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_diff(a,b):\n",
    "    return a+b, a-b\n",
    "\n",
    "sum1, diff = sum_diff(4,1)\n",
    "print(sum1)\n",
    "print(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87f4a89f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_diff(a):\n",
    "    return a+a, a-a\n",
    "\n",
    "sum1, diff = sum_diff(4)\n",
    "print(sum1)\n",
    "print(diff)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e7c43fb",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Напишите функцию для вычисления факториала данного числа без рекурсии.\n",
    "\n",
    "Ввод: 3\n",
    "\n",
    "Вывод: 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d55cb470",
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(N):\n",
    "    f = 1\n",
    "    for i in range(1, N+1):\n",
    "        f *= i\n",
    "    return f\n",
    "\n",
    "factorial(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d220a46f",
   "metadata": {},
   "source": [
    "## Рекурсия\n",
    "\n",
    "Рекурсия – функция вызывает сама себя. Самый известный пример – вычисление факториала n! = 1 * 2 * 3 * ... * (n-2) * (n-1) * n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d4c73b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n != 0:\n",
    "        return n * factorial(n-1)\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c41073e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "factorial(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e4bdfdf",
   "metadata": {},
   "source": [
    "А еще таким же образом можно вычислять N-ое число Фибоначчи (они как раз задаются рекурсивно).\n",
    "\n",
    "Заодно здесь мы видим, что выражений return может быть несколько (для различных условий).\n",
    "\n",
    "1, 1, 2, 3, 5, 8, 13, 21, ...\n",
    "\n",
    "f(5) -> f(4) + f(3) #3 + 2 = 5\n",
    "\n",
    "f(4) -> f(3) + f(2) #2 + 1 = 3\n",
    "\n",
    "f(3) -> f(2) + f(1) #1 + 1 = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "699298da",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n in (1, 2):\n",
    "        return 1\n",
    "    return fibonacci(n - 1) + fibonacci(n - 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ead3c1f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "fibonacci(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3476734",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n in (1, 2):\n",
    "        return 1\n",
    "    f1 = 1\n",
    "    f2 = 1\n",
    "    for i in range(1, n-1):\n",
    "        f3 = f1 + f2 \n",
    "        f1 = f2\n",
    "        f2 = f3\n",
    "    return f3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7031065",
   "metadata": {},
   "outputs": [],
   "source": [
    "fibonacci(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3af4de71",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Рекурсивно посчитать сумму чисел от 1 до N\n",
    "\n",
    "Вход: N\n",
    "\n",
    "Выход: sum(1,2,3,...,N)\n",
    "\n",
    "Вход: 3\n",
    "\n",
    "Выход: 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b277d26",
   "metadata": {},
   "outputs": [],
   "source": [
    "def summe(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    return n + summe(n - 1)\n",
    "\n",
    "n = int(input())\n",
    "print(summe(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b3edf46",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Рекурсивно проверить, является ли строка палиндромом (читается наоброт)\n",
    "\n",
    "Вход: шалаш\n",
    "\n",
    "Выход: True\n",
    "\n",
    "Вход: мама\n",
    "\n",
    "Выход: False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f10e910a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Palindrom(s):\n",
    "    if len(s) <= 1:\n",
    "        return True\n",
    "    else:\n",
    "        return s[0] == s[-1] and Palindrom(s[1:-1])\n",
    "    \n",
    "st = input()\n",
    "Palindrom(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7770a55b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вариант решения без применения рекурсии (просто пример)\n",
    "\n",
    "def Palindrom(s):\n",
    "    if  s == s[::-1]:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "st = input()\n",
    "Palindrom(st)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b771d13",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Напишите функцию, которая принимает три числа и возвращает их произведение."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35662eec",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multi_num(n1, n2, n3):\n",
    "    return n1 * n2 * n3\n",
    "\n",
    "num1, num2, num3 = map(float, input().split())\n",
    "print(multi_num(num1, num2, num3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dab21a58",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Напишите функцию для вычисления среднего арифметического числа в заданном списке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77f13047",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_lt(mas):\n",
    "    len_mas = len(mas)\n",
    "    sum_mas = 0\n",
    "    \n",
    "    for i in mas:\n",
    "        sum_mas += i\n",
    "    \n",
    "    return sum_mas / len_mas\n",
    "\n",
    "ls = list(map(float, input().split()))\n",
    "print(mean_lt(ls))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf8621e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вариант написания, без цикла for\n",
    "\n",
    "def mean_lt(mas):\n",
    "    len_mas = len(mas)\n",
    "    sum_mas = sum(mas)\n",
    "    \n",
    "    return sum_mas / len_mas\n",
    "\n",
    "ls = list(map(float, input().split()))\n",
    "print(mean_lt(ls))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad057a65",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Напишите функцию, которая принимает на вход число и выдаёт сумму цифр в числе. Реализуйте два варианта, с использованием строки без использования строки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6b132a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вариант решения через строку №1\n",
    "\n",
    "def sum_st(num):\n",
    "    num = str(num)\n",
    "    sum_num = 0\n",
    "    \n",
    "    for i in num:\n",
    "        sum_num += int(i)\n",
    "    \n",
    "    return sum_num\n",
    "\n",
    "n = int(input())\n",
    "print(sum_st(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c080c5da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вариант решения через строку №2\n",
    "\n",
    "def sum_of(num):\n",
    "    return sum(int(digit) for digit in str(num))\n",
    "\n",
    "num = int(input())\n",
    "print(sum_of(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe2df0b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вариант решения через цикл while\n",
    "\n",
    "def sum_int(num):\n",
    "    sum_num = 0\n",
    "    \n",
    "    while num > 0:\n",
    "        sum_num += num % 10\n",
    "        num //= 10\n",
    "    \n",
    "    return sum_num\n",
    "\n",
    "n = int(input())\n",
    "print(sum_int(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecf13da2",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Напишите функцию, которая будет преобразовывать десятичное число в двоичное."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96cf8fbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def translator(num):\n",
    "    st = \"\"\n",
    "    while num > 0:\n",
    "        st += str(num % 2)\n",
    "        num //= 2\n",
    "    \n",
    "    return st[::-1]\n",
    "\n",
    "n = int(input())\n",
    "print(translator(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8090054e",
   "metadata": {},
   "source": [
    "# Функции как объект\n",
    "\n",
    "Функцию можно присвоить любой переменной."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e19fd66",
   "metadata": {},
   "outputs": [],
   "source": [
    "writeline = print\n",
    "x = 5\n",
    "writeline(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54444138",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Привет мир!!!\"\n",
    "writeline(s[:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61574907",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Исполнитель калькулятор может выполнить одно из действий: сложение, умножение или возведение в степень. Опишем функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6eebbc6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Первое решение\n",
    "\n",
    "def addition(x, y):  # Команда \"+\"\n",
    "    return x + y\n",
    "def multiplication(x, y):  # Команда \"*\"\n",
    "    return x * y\n",
    "def exponentiation(x, y):  # Команда \"^\"\n",
    "    return x ** y\n",
    "\n",
    "func = addition  # Значение по умолчанию\n",
    "\n",
    "operation_sign = input()\n",
    "\n",
    "if operation_sign == \"*\":\n",
    "    func = multiplication\n",
    "elif operation_sign == \"^\":\n",
    "    func = exponentiation\n",
    "\n",
    "x, y = 3, 4\n",
    "func(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed0f5aa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Второе решение\n",
    "\n",
    "def addition(x, y):  # Команда \"+\"\n",
    "    return x + y\n",
    "def multiplication(x, y):  # Команда \"*\"\n",
    "    return x * y\n",
    "def exponentiation(x, y):  # Команда \"^\"\n",
    "    return x ** y\n",
    "\n",
    "operation = {\"+\" : addition,\n",
    "            \"*\" : multiplication,\n",
    "            \"^\" : exponentiation}\n",
    "\n",
    "operation_sign = input()\n",
    "func = operation[operation_sign]\n",
    "\n",
    "x, y = 3, 4\n",
    "func(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58ac23cf",
   "metadata": {},
   "source": [
    "Напишем функции для преобразования стилистики текста:\n",
    "- все строчные\n",
    "- ВСЕ ПРОПИСНЫЕ\n",
    "- иЗМЕНИТЬ РЕГИСТР\n",
    "- Начинается С Прописных\n",
    "- Как в предложениях"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a96c78b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "st = \"привет мир. hello, world.\"  # Тестовая строка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "196c61ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# все строчные\n",
    "\n",
    "def all_lower(s): \n",
    "    return s.lower()\n",
    "\n",
    "all_lower(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae182de5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ВСЕ ПРОПИСНЫЕ\n",
    "\n",
    "def all_upper(s):\n",
    "    return s.upper()\n",
    "\n",
    "all_upper(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdc1d313",
   "metadata": {},
   "outputs": [],
   "source": [
    "# иЗМЕНИТЬ РЕГИСТР\n",
    "# swapcase() - можно было использовать, но напишем сами\n",
    "\n",
    "def change_register(s):\n",
    "    str_as_list = list(s)\n",
    "    for i in range(len(str_as_list)):\n",
    "        if str_as_list[i].isupper():\n",
    "            str_as_list[i] = all_lower(str_as_list[i])\n",
    "        else:\n",
    "            str_as_list[i] = all_upper(str_as_list[i])\n",
    "    return \"\".join(str_as_list)\n",
    "\n",
    "change_register(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a23079cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Как в предложениях\n",
    "\n",
    "def start_with_upper(s):\n",
    "    return s[0].upper() + s[1:]\n",
    "\n",
    "# Будем предполагать, что предложение заканчивается точкой.\n",
    "# capitalize()\n",
    "\n",
    "def as_sentence(s):\n",
    "    seq = s.split(sep = \". \")\n",
    "    for i in range(len(seq)):\n",
    "        seq[i] = start_with_upper(seq[i])\n",
    "\n",
    "    return \". \".join(seq)\n",
    "\n",
    "as_sentence(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef1dcc3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Начинается С Прописных\n",
    "\n",
    "# title\n",
    "def words_with_upper(s):\n",
    "    words = s.split()\n",
    "    for i in range(len(words)):\n",
    "        words[i] = start_with_upper(words[i])\n",
    "    return \" \".join(words)\n",
    "\n",
    "words_with_upper(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d712835",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создадим словарь для хранения функций\n",
    "# Ключ - номер, значение функция\n",
    "\n",
    "regiter = {1: all_lower, \n",
    "           2: all_upper, \n",
    "           3: change_register, \n",
    "           4: as_sentence, \n",
    "           5: words_with_upper}\n",
    "\n",
    "number = int(input())\n",
    "if number not in range(1, 6):\n",
    "    print(\"Ошибочный ввод\")\n",
    "else:\n",
    "    func = regiter[number]\n",
    "    print(func(st))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c46241d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создадим дополнительную функцию\n",
    "\n",
    "def register_fun(n):\n",
    "    register = {1: all_lower, \n",
    "       2: all_upper, \n",
    "       3: change_register, \n",
    "       4: as_sentence, \n",
    "       5: words_with_upper}\n",
    "    return register[number]\n",
    "\n",
    "number = int(input())\n",
    "if number not in range(1, 6):\n",
    "    print(\"Ошибочный ввод\")\n",
    "else:\n",
    "    func = register_fun(number)\n",
    "    print(func(st))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5a5fd0e",
   "metadata": {},
   "source": [
    "# Функции высших порядков\n",
    "\n",
    "Функции, которые могут принимать в качестве аргумента другую функцию и/или возвращать функцию в качестве результата своей работы.\n",
    "\n",
    "map, filter, sorted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c57b15f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Как в предложениях\n",
    "\n",
    "def start_with_upper(s):\n",
    "    return s[0].upper() + s[1:]\n",
    "\n",
    "# Будем предполагать, что предложение заканчивается точкой.\n",
    "# capitalize()\n",
    "\n",
    "def as_sentence(s):\n",
    "    seq = s.split(sep = \". \")\n",
    "    s = map(start_with_upper, seq)\n",
    "\n",
    "    return \". \".join(s)\n",
    "\n",
    "as_sentence(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f15e8e73",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Применение filter\n",
    "\n",
    "def is_odd(x):\n",
    "    return x % 2 == 1\n",
    "\n",
    "sp = [34, 45, 22, 65, 11, 87]\n",
    "\n",
    "sp2 = list(filter(is_odd, sp))\n",
    "print(sp2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae5a0f15",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Применение sorted\n",
    "\n",
    "fruits = ['apple', 'orange', 'banana', 'cherry', 'date', 'apricot']\n",
    "print(sorted(fruits))\n",
    "print(sorted(fruits, reverse = True))\n",
    "print(sorted(fruits, key = len))\n",
    "print(sorted(fruits, key = len, reverse = True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a294951",
   "metadata": {},
   "source": [
    "# Lambda-функции\n",
    "\n",
    "Это особый вид функций, которые объявляются с помощью ключевого слова **lambda** вместо **def**.\n",
    "\n",
    "Лямбда-функции принимают любое количество аргументов, но не могут содержать несколько выражений и всегда возвращают только одно значение. Пишется так:\n",
    "\n",
    "- lambda arguments: expression\n",
    "\n",
    "arguments – аргументы, expression – выражение, возвращающее значение.\n",
    "\n",
    "Пример (lambda функция, которая добавляет к переданному аргументу 1 и возвращает результат):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfb71423",
   "metadata": {},
   "outputs": [],
   "source": [
    "add_1 = lambda x: [i for i in range(x + 1)]\n",
    "add_1(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "550ca7bf",
   "metadata": {},
   "source": [
    "Сложение двух числ с помощью лямбда-функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b14c0b67",
   "metadata": {},
   "outputs": [],
   "source": [
    "add_2 = lambda x, y: x + y\n",
    "add_2(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d3d897f",
   "metadata": {},
   "source": [
    "Выше, мы присвоили имя каждой из функций. Попробуем без имени. Аргументы передаются в скобках после скобок, содержащих определение lambda функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2be76cd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "(lambda x, y: x * y)(3, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6715b9dc",
   "metadata": {},
   "source": [
    "По сути, лямбда-функции умеют все, что и обычные функции, только они обязаны возвращать всего одно значение.\n",
    "\n",
    "- Они умеют работать с разными типами данных (Строками, например)\n",
    "- Можно вызывать функцию без параметров\n",
    "- Параметрам функции можно задать значения по умолчанию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fd9c9b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Со строками\n",
    "\n",
    "(lambda x, y: x * y)(\"Ха-\", 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caadcda4",
   "metadata": {},
   "outputs": [],
   "source": [
    "(lambda x, y: x + y)(\"Первая \", \"Вторая\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25746a7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# А вот тут без аргументов\n",
    "\n",
    "(lambda: [0, 1, 2, 3])()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d2dd953",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Значения по умолчанию\n",
    "\n",
    "(lambda x = 3, y = 5: str(x) + str(y))(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80353955",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Здесь в качестве первого аргумента пришел список, а второй использовался по умолчанию\n",
    "# На выходе должны получить первый элемент первого списка + 3\n",
    "\n",
    "(lambda x, y = 3: x[0] + y)([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd9f2298",
   "metadata": {},
   "outputs": [],
   "source": [
    "print((lambda x, y, z: x + y + z)(1, 2, 3))  # Три аргумента\n",
    "\n",
    "print((lambda x, y, z = 3: x + y + z)(1, 2))  # Три аргумента и у одного default-значение\n",
    "\n",
    "print((lambda x, y, z = 3: x + y + z)(1, y = 2))  # Три аргумента, у одного default-значение и один мы передали \"по имени\"\n",
    "\n",
    "print((lambda *args: sum(args))(1, 2, 3))  # Передали кортеж аргументов и сложили\n",
    "\n",
    "print((lambda **kwargs: sum(kwargs.values()))(one = 1, two = 2, three = 3))  # Передали словарь аргументов и сложили"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d69c6f0",
   "metadata": {},
   "source": [
    "Лямбда-функции очень часто применяются для преобразования каких-то коллекций. Для этого lambda-функции можно подавать в функцию map. Возьмем список и возведем все его элементы в квадрат с помощью map и lambda-функции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1927463",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 3, 4, 6]\n",
    "def to_str(x):\n",
    "    return x * x\n",
    "list(map(to_str, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f6a576d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 3, 4, 6]\n",
    "list(map(lambda x: x * x, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "addfb27e",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [\"ежик\", \"Python\", \"книга\"]\n",
    "print(list(map(lambda x: x[0], lst)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fba85301",
   "metadata": {},
   "source": [
    "`filter` - функция для фильтрации списков. Необходимо отфильтровать все числа меньше 4 из списка. С помощью цикла:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebe0a140",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "numbers_under_4 = []\n",
    "for number in numbers:\n",
    "    if number < 4:\n",
    "        numbers_under_4.append(number)\n",
    "numbers_under_4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43fecb3f",
   "metadata": {},
   "source": [
    "С помощью спискового включения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b6fb699",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "numbers_under_4 = [number for number in numbers if number < 4]\n",
    "numbers_under_4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aa183cf",
   "metadata": {},
   "source": [
    "filter + Lambda-функция:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "759e873c",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "numbers_under_4 = list(filter(lambda x: x < 4, numbers))\n",
    "numbers_under_4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c5e142f",
   "metadata": {},
   "source": [
    "Видно, что синтаксис такой же, как и у map. Первый аргумент – функция, которую надо применять, а второй – коллекция, на которую надо применять. Но как и для map, функция возвращает итератор, поэтому, чтобы получить список, его нужно обернуть функцией list.\n",
    "\n",
    "sorted + Lambda-функция:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ad5fcfb",
   "metadata": {},
   "outputs": [],
   "source": [
    "sp = [34, 45, 22, 65, 19, 87, 21]\n",
    "sorted(sp, key = lambda x: x % 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "444c9a79",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = [(1, 1), (2, 3), (5, 4), (1, 3), (8, 0), (1, 0)]\n",
    "sorted(points, key = lambda x: x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b41c2c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "points = [(1, 1), (2, 3), (5, 4), (1, 3), (8, 0), (1, 0)]\n",
    "sorted(points, key = lambda x: (x[0], x[1]))"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}