python_lectures/python_lesson_part_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "364d3b3d",
   "metadata": {},
   "source": [
    "## Содержание:\n",
    "- Цикл While\n",
    "- Инструкции, использующиеся внутри циклов (break, continue, pass, else)\n",
    "- Вложенные циклы\n",
    "- Коллекции (типы данных): множества (class 'set'), списки (class 'list'), кортежи (class 'tuple')\n",
    "- Опасность работы с изменяемыми типами данных\n",
    "- Методы .split(), .join(), функция map(), вывод и ввод списков\n",
    "- Строки: срезы и методы\n",
    "- Цикл For, функция range()\n",
    "- Списковые включения (list comprehension)\n",
    "- Включения для множеств"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "615a195f",
   "metadata": {},
   "source": [
    "# Цикл While\n",
    "\n",
    "`While` – один из самых универсальных циклов в Python, но работает достаточно медленно.\n",
    "\n",
    "Цикл while (в переводе – пока) позволяет выполнить одну и ту же последовательность действий, пока проверяемое условие истинно.\n",
    "\n",
    "Как правило, цикл while используется, когда невозможно определить точное значение количества проходов исполнения цикла.\n",
    "\n",
    "Условие записывается до тела цикла и проверяется до выполнения тела цикла.\n",
    "\n",
    "При выполнении цикла while сначала проверяется условие. Если оно ложно, то выполнение цикла прекращается и управление передается на следующую инструкцию после тела цикла while. Если условие истинно, то выполняется инструкция, после чего условие проверяется снова и снова выполняется инструкция. Так продолжается до тех пор, пока условие будет истинно. Как только условие станет ложно, работа цикла завершится и управление передастся следующей инструкции после цикла.\n",
    "\n",
    "С помощью while очень легко организовать вечный цикл, поэтому необходимо следить за тем, чтобы в блоке команд происходили изменения, которые приведут к тому, что в какой-то момент условие перестанет быть истинным.\n",
    "\n",
    "Синтаксис цикла while в простейшем случае выглядит так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7b469e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "while <<условие>> :\n",
    "    <<блок инструкций>>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4c3ec6d",
   "metadata": {},
   "source": [
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/08.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c087f40",
   "metadata": {},
   "source": [
    "### Примеры задач"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d606fc65",
   "metadata": {},
   "outputs": [],
   "source": [
    "# С помощью цикла while, вывести все числа от 1 до заданного пользователем целого числа N\n",
    "\n",
    "N = int(input())\n",
    "i = 1  # i сокращение от index (порядковый номер), используется по общему соглашению во множестве языков как счетчик цикла\n",
    "while i <= N:\n",
    "    print(i)\n",
    "    i += 1  # Переменная i увеличивается на 1 и перезаписывается. Раносильная запись i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10e048f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вывести числа от заданного до единицы и закончить цикл строкой 'finished!'\n",
    "\n",
    "N = int(input())\n",
    "while N >= 1:\n",
    "    print(N)\n",
    "    N -= 1\n",
    "print('finished!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d3a472b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Посчитать из скольких цифр состоит натуральное число, введенное пользователем с клавиатуры, с помощью цикла while\n",
    "\n",
    "N = int(input())\n",
    "count = 0\n",
    "while N > 0:\n",
    "    print(N)\n",
    "    N //= 10\n",
    "    count += 1\n",
    "print()\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c2b81a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Используя цикл while, выведите на экран для числа 2 его степени от 0 до 10\n",
    "\n",
    "i = 0\n",
    "while i <= 10:\n",
    "    print(2 ** i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1693d50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Программа по вычислению факториала натурального числа, заданного пользователем. Пример вычисления – 5! = 1*2*3*4*5\n",
    "\n",
    "N = int(input())\n",
    "i = 1\n",
    "f = 1\n",
    "while i <= N:\n",
    "    f *= i\n",
    "    i += 1\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e249c5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# По данному целому числу N выведете все квадраты натуральных чисел, не превосходящие N, в порядке возрастания\n",
    "\n",
    "a = int(input())\n",
    "b = 1\n",
    "c = 1\n",
    "while c <= a:\n",
    "    print(c, end=' ')\n",
    "    b += 1\n",
    "    c = b ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c79b0a94",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Задача – расчитать сумму всех вводимых пользователем чисел. Ноль – означает конец вводимой последовательности чисел\n",
    "\n",
    "now = int(input())\n",
    "a = now\n",
    "while now != 0:\n",
    "    now = int(input())\n",
    "    a += now\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e454ce58",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Определите количество чётных элементов в последовательности, завершающейся числом 0\n",
    "\n",
    "a = 0\n",
    "now = int(input())\n",
    "while now != 0:\n",
    "    if now % 2 == 0:\n",
    "        a += 1\n",
    "    now = int(input())\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8cbb85d",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Последовательность состоит из натуральных чисел и завершается числом 0. Определите значение второго по величине элемента в этой последовательности, то есть элемента,\n",
    "который будет наибольшим, если из последовательности удалить одно вхождение наибольшего элемента (на вводе - 1 2 2 3 3 0 - вывод 3, удалён лишь один ввод значения 3).\n",
    "Вводится последовательность натуральных чисел, оканчивающаяся числом 0 (само число 0 в последовательность не входит и служит как признак ее окончания)'''\n",
    "\n",
    "a = int(input())\n",
    "b = 0\n",
    "c = 0\n",
    "while a != 0:\n",
    "    if a >= b:\n",
    "        c = b\n",
    "        b = a\n",
    "    elif c < a < b:\n",
    "        c = a\n",
    "    a = int(input())\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6c25d39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Последовательность состоит из натуральных чисел и завершается числом 0. Определите количество элементов этой последовательности, которые равны её НАИБОЛЬШЕМУ элементу\n",
    "\n",
    "a = int(input())\n",
    "b = a\n",
    "c = 0\n",
    "while a != 0:  # Если 'a' больше нуля, то:\n",
    "    if a > b:  # Если 'a' больше 'b', то:\n",
    "        b = a\n",
    "        c = 1  # В случае обновления значения 'b', значение 'c' становится равной единице\n",
    "    elif a == b:  # Если 'a' равно 'b', то значение 'c' увеличивается на единицу\n",
    "        c += 1\n",
    "    a = int(input())\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a449544",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пользователем вводится последовательность натуральных чисел, завершающаяся числом 0.\n",
    "# Определите, какое наибольшее число подряд идущих элементов этой последовательности, равны друг другу\n",
    "\n",
    "a = int(input())\n",
    "b = a\n",
    "c = 0\n",
    "d = 1  # Добавлется ещё одна переменная, в которую сохраняется наибольшее число подряд идущих значений\n",
    "while a != 0:\n",
    "    if a != b:\n",
    "        b = a\n",
    "        c = 1\n",
    "    elif a == b:\n",
    "        c += 1\n",
    "        if d < c:\n",
    "            d += 1\n",
    "    a = int(input())\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63abb65a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Дано целое число, не меньшее 2. Выведите его наименьший натуральный делитель, отличный от 1. Решение через if-else\n",
    "\n",
    "n = int(input())\n",
    "if n > 1:\n",
    "    if n % 2 == 0:\n",
    "        print(2)\n",
    "    elif n % 3 == 0:\n",
    "        print(3)\n",
    "    elif n % 5 == 0:\n",
    "        print(5)\n",
    "    elif n % 7 == 0:\n",
    "        print(7)\n",
    "    else:\n",
    "        print(n)\n",
    "\n",
    "# Наименьших делителей всего четыре – 2, 3, 5, 7. Выводим первое попадающее под условие – быть равным нулю"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15c72e40",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Дано целое число, не меньшее 2. Выведите его наименьший натуральный делитель, отличный от 1. Решение через while\n",
    "\n",
    "n = int(input())\n",
    "i = 2\n",
    "while n % i != 0:\n",
    "    i += 1\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "680ca9c6",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Игра-угадайка.\n",
    "\n",
    "Программа будет загадывать целое число от 1 до 100, а пользователь его угадывать. Будем генерировать случайное число n из интервала [1, 100]. Задача пользователя угадать это число. Выводится количество попыток сделанное пользователем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8dbe318",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randrange  # Ипортируем функию randrange\n",
    "\n",
    "n = randrange(1, 101)  # n и есть загаданное число. Указываем 101, т.к. последнее значение диапазона, не используется\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "317db7ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 1  # Служит счётчиком попыток угадать число\n",
    "flag = True\n",
    "while flag:\n",
    "    print(\"Ваша попытка\", num, \"Ваше число: \", end = \"\")\n",
    "    guess = int(input())\n",
    "    if guess == n:\n",
    "        print(\"Вы выиграли\")\n",
    "        flag = False\n",
    "    elif guess > n:\n",
    "        print(\"Вы ввели слишком большое число\")\n",
    "        num += 1\n",
    "    else:\n",
    "        print(\"Вы ввели слишком маленькое число\")\n",
    "        num += 1\n",
    "print(f\"Было совершено {num} попыток\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96088edb",
   "metadata": {},
   "source": [
    "# Инструкции, использующиеся внутри циклов (break, continue, pass, else)\n",
    "\n",
    "`break` – производит переход за пределы цикла. Если можно обойтись без break, то пишем без этой команды\n",
    "\n",
    "`continue` – производит переход в начало цикла. Как и команда break - использование continue не желательно\n",
    "\n",
    "`pass` – пустая конструкция-заполнитель, заглушка, на случай если есть код, который планируется дописать, но по каким-то причинам это случится позже\n",
    "\n",
    "`else` – выполняется, только если цикл завершился обычным образом (без использования break)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0e5b442",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i <= 5:\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        break  # Полностью выводит нас из цикла\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"Цикл завершил работу\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "717bfd10",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i <= 5:\n",
    "    i += 1\n",
    "\n",
    "    if i == 3:\n",
    "        print(\"Тройку пропускаем\")\n",
    "        continue  # Пропускаем дальнеший код в теле цикла и возвращаемся к началу\n",
    "\n",
    "    print(i)\n",
    "else:\n",
    "    print(\"Цикл завершил работу\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7b84911",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i <= 5:\n",
    "    if i == 3:\n",
    "        pass  # Ничего не делаем\n",
    "    else:\n",
    "        print(i)\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"Цикл завершил работу\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d288b93",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Задача – по данному натуральному n вычислите сумму 1²+2²+3²+...+n²\n",
    "\n",
    "a = int(input())\n",
    "b = 1\n",
    "c = 1\n",
    "d = 1\n",
    "while b < a:\n",
    "    if a == 1:\n",
    "        break  # Прерывает цикл и выводит единицу\n",
    "    b += 1  # На каждом круге 'b' увеличивается на единицу\n",
    "    c = b ** 2  # Вычисляет квадрат значения\n",
    "    d += c  # На каждом новом кругу прибавляет к ранее сохранённому значению, новый результат вычисления 'c'\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6590782d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример использования continue: пользователем вводится последовательность чисел, оканчивающаяся нулём.\n",
    "# Необходимо вывести все положительные числа из этой последовательности. Решение:\n",
    "\n",
    "now = -1\n",
    "while now != 0:\n",
    "    now = int(input())\n",
    "    if now <= 0:\n",
    "        continue\n",
    "    print(now)\n",
    "\n",
    "# В этом решении есть интересный момент: перед циклом переменная инициализируется с заведомо отрицательным значением.\n",
    "# Команда вывода будет выполняться только в том случае, если не выполнится условие в if."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9535378d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Задача – поиск максимума в последовательности вводимых чисел. Вводим числа до тех пор, пока не введём '0' и получаем на выводе наибольшее из введённых\n",
    "\n",
    "a = int(input())\n",
    "b = a\n",
    "while a != 0:\n",
    "    a = int(input())\n",
    "    if a == 0:\n",
    "        break\n",
    "    if a > b:\n",
    "        b = a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f737164",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вариант рашения задачи выше, но уже без команды break\n",
    "\n",
    "a = int(input())\n",
    "b = a\n",
    "while a != 0:\n",
    "    a = int(input())\n",
    "    if a != 0 and a > b:\n",
    "        b = a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a79fc5bd",
   "metadata": {},
   "source": [
    "# Вложенные циклы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bba50959",
   "metadata": {},
   "source": [
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/09.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5c56584",
   "metadata": {},
   "source": [
    "Вложенные циклы while содержат два основных компонента:\n",
    "\n",
    "1. Внешний цикл while\n",
    "2. Внутренний цикл while\n",
    "\n",
    "\n",
    "Внешний цикл while может содержать несколько внутренних циклов while. Условие приводит к булевому значению, и если оно истинно, только тогда цикл выполняется. На каждой итерации внешнего цикла while внутренний цикл выполняется с самого начала, и этот процесс продолжается до тех пор, пока условие внешнего цикла не станет истинным. Аналогично, внутренний цикл while выполняется только в том случае, если его условие истинно, после чего выполняется блок кода."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9806419",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Выведем таблицу умножения от 1 до 5\n",
    "\n",
    "i = 1\n",
    "while i <= 5:\n",
    "    j = 1\n",
    "    while j <= 10:\n",
    "        print(i, \"*\", j, \"=\", i * j)\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb2d5a23",
   "metadata": {},
   "source": [
    "# Коллекции: множества, списки, кортежи.\n",
    "\n",
    "## Множества (set)\n",
    "\n",
    "`Множество` – cоставной тип данных, представляющий собой **неупорядоченный набор уникальных объектов (элементов множества)** под одним именем. Множества изменяемы и чаще всего используются для удаления дубликатов и всевозможных проверок на вхождение.\n",
    "\n",
    "Чтобы задать множество, нужно в фигурных скобках перечислить его элементы. Множество может содержать и строки, и числа.\n",
    "Создадим множество из нескольких элементов и выведем на экран:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fae2d6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = {1, 2, 3, 4, 5, 0, \"Hello, world!!!\", \"Привет мир!!!\", 'cat', 'dog', 1.4, 5.8}\n",
    "print(num)\n",
    "print(type(num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cfef098",
   "metadata": {},
   "source": [
    "После запуска видим иной порядок, чем мы задали. Так происходит потому, что элементы в множестве Python не упорядочены.\n",
    "\n",
    "У множеств есть три ключевые особенности:\n",
    "\n",
    "- Порядок элементов в множестве не определен\n",
    "- Элементы множеств – строки и/или числа\n",
    "- Множество не может содержать одинаковых элементов\n",
    "\n",
    "### Cоздание множества\n",
    "\n",
    "Для создания пустых множеств обязательно вызывать функцию `set()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eccc19af",
   "metadata": {},
   "outputs": [],
   "source": [
    "empty = set()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13df6141",
   "metadata": {},
   "source": [
    "### Операции над множеством (одним)\n",
    "\n",
    "`len()` – вычисление числа элементов множества:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23add2c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {'a', 'b', 'c'}\n",
    "n = len(my_set)\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cae70f22",
   "metadata": {},
   "source": [
    "#### Добавление элемента в множество\n",
    "\n",
    "Выполняется с помощью метода `.add`.\n",
    "\n",
    "Если элемент, равный новому элементу, уже существует в множестве, оно не изменится, поскольку не может содержать одинаковых элементов. Ошибки при этом не произойдет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d134338e",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = set()\n",
    "my_set.add('a')\n",
    "my_set.add('b')\n",
    "my_set.add('a')\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a30113f4",
   "metadata": {},
   "source": [
    "#### Удаление элемента\n",
    "\n",
    "Для удаления есть три метода:\n",
    "\n",
    "    .discard – удалить заданный элемент, если он есть в множестве, и ничего не делать, если его нет;\n",
    "    .remove – удалить заданный элемент, если он есть, и породить ошибку KeyError, если нет;\n",
    "    .pop – удалить некоторый элемент из множества и возвратить его как результат."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ca11573",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set = {'a', 'b', 'c'} \n",
    "my_set.discard('a')  # Будет удален\n",
    "my_set.discard('d')  # Нет в множестве, ничего не делать\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30fe2f58",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.remove('b')  # Будет удален\n",
    "print(my_set) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3567ec87",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.remove('d')  # Не в множестве, вызовет ошибку KeyError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40f3edcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "elem = my_set.pop()  # Удаляет из множества случайный элемент и возвращает его значение\n",
    "print(elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e2ccef5",
   "metadata": {},
   "source": [
    "#### Очистка множества\n",
    "\n",
    "Очистить множество от всех элементов можно с помощью метода `clear()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e121ae3",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33482f15",
   "metadata": {},
   "source": [
    "### Операции над двумя множествами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50aff233",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = set(\"1234\")\n",
    "b = set(\"3456\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5d54515",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "471617e1",
   "metadata": {},
   "source": [
    "**Объединение множеств**\n",
    "\n",
    "Объединением двух множеств называется множество, состоящее из тех и только тех элементов, которые принадлежат хотя бы одному из данных множеств.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/10.png?raw=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1551a06",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a | b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c104e89",
   "metadata": {},
   "source": [
    "**Пересечение множеств**\n",
    "\n",
    "Пересечением двух множеств называется множество, которому принадлежат те и только те элементы, которые одновременно принадлежат двум данным множествам.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/11.png?raw=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d96805aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a & b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c500d01",
   "metadata": {},
   "source": [
    "**Разность множеств**\n",
    "\n",
    "Разностью двух множеств называется множество, состоящее из тех и только тех элементов, которые входят в первое множество, но не входят во второе.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/12.png?raw=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73363ec0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a - b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15e7046a",
   "metadata": {},
   "source": [
    "**Симметрическая разность множеств**\n",
    "\n",
    "Симметрической разностью двух множеств называется множество, которое состоит из элементов, принадлежащих ровно одному из данных множеств.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/13.png?raw=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a5a87a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a ^ b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26bcbdfb",
   "metadata": {},
   "source": [
    "### Сравнение множеств\n",
    "\n",
    "Для сравнения множеств используются все логические операторы: `==`, `<`, `>`, `!=`. Равными будут считаться множества с одинаковым набором элементов. Операторы сравнения возвращают результат True, если сравнение истинно, и False – если нет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70b9cbfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "setA = {7, 6, 5, 4, 3}\n",
    "setB = {3, 4, 5, 6, 7}\n",
    "setA == setB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4cfdd65f",
   "metadata": {},
   "outputs": [],
   "source": [
    "setA != setB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c39f93d",
   "metadata": {},
   "outputs": [],
   "source": [
    "setA = {7, 6, 5, 4, 3}\n",
    "setB = {3, 4, 5}\n",
    "setB < setA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ecea9d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "setB > setA  # Значение False. Но, если хотя бы один элемент множества setB не будет принадлежать множеству setA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af3100df",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Аня и Маша  играют в игру. Аня вводит число, а Маша должна ввести число, в котором есть только те цифры, которые есть в числе Ани. Если Маша ввела верное число, то выводится \"Верное число!\". В противном случае \"Такое число нельзя использовать\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86a855b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "anya = set(input())\n",
    "mash = set(input())\n",
    "\n",
    "if mash <= anya:\n",
    "    print(\"Верное число!\")\n",
    "else:\n",
    "    print(\"Такое число нельзя использовать\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75c83076",
   "metadata": {},
   "source": [
    "## Списки (list)\n",
    "\n",
    "`Список` – это **упорядоченный набор объектов**, хранящихся в одной переменной. В отличие от массивов в других языках, у списков нет никаких ограничений на тип переменных, поэтому в них могут храниться разные объекты, в том числе и другие коллекции.\n",
    "\n",
    "### Создание списков\n",
    "\n",
    "Создадим список:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ed846bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_num = [1, 2, 3, 4, 5, 0, \"Hello, world!!!\", \"Привет мир!!!\", 'cat', 'dog'] \n",
    "print(list_num)\n",
    "print(type(list_num))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a515e4c3",
   "metadata": {},
   "source": [
    "Пустой список можно создать двумя способами - оператором `[]` и функцией `list()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c170426a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print([])\n",
    "print(list())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dba003c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = list()\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4402a5b6",
   "metadata": {},
   "source": [
    "Список может быть даже смешанным. Например, давайте сохраним в одном списке имя студента, его год рождения, средний балл, и логическую переменную, которая будет равна True, если студент учится на бюджете."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4556ee3",
   "metadata": {},
   "outputs": [],
   "source": [
    "student1 = [\"Иван Иванов\", 1988, 7.5, True]\n",
    "print(student1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbdfb6fd",
   "metadata": {},
   "source": [
    "Список может даже содержать другие списки.\n",
    "\n",
    "Давайте создадим еще одного студента по аналогии со student1 и положим этих двух студентов в еще один список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c098e49a",
   "metadata": {},
   "outputs": [],
   "source": [
    "student2 = [\"Сергей Смирнов\", 1990, 7.9, False]\n",
    "students = [student1, student2]\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1df403ec",
   "metadata": {},
   "source": [
    "### Срезы списков\n",
    "\n",
    "Элементы списков нумеруются, начиная с 0. Мы можем получить доступ к элементу списка по его индексу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e68e5e83",
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Иван Иванов\", \"Сергей Смирнов\", \"Николай Пешков\"]\n",
    "print(students[0])   # Первый элемент\n",
    "print(students[1])   # Второй элемент\n",
    "print(students[-1])  # Последний элемент"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df6c4b9",
   "metadata": {},
   "source": [
    "Индексация работает и в строках. Там отдельными элементами являются символы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a67c39b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"Привет\"\n",
    "print(x[0])\n",
    "print(x[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f45dfbc",
   "metadata": {},
   "source": [
    "Мы можем узнать длину списка с помощью функции len() (работает и для строк)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be76abe3",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(students))  # Количество элементов в списке students\n",
    "print(len(x))         # Количество символов в строке x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d93ca5f5",
   "metadata": {},
   "source": [
    "Но, в отличие от строк, **список можно изменить**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1510eb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\"Иван Иванов\", \"Сергей Смирнов\", \"Николай Пешков\"]\n",
    "students"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a0343b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "students[0] = 'Петр Иванов'\n",
    "students"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "144d1b75",
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"Привет\"\n",
    "string[1] = \"a\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6f31a68",
   "metadata": {},
   "source": [
    "**Строки – неизменяемый тип данных**, поэтому присвоение символа по индексу не сработает.\n",
    "\n",
    "Еще одна операция, которая работает со всеми последовательностями – проверка на наличие элемента in и not in. Возвращает True или False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e476f96",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = [7, 22, 8, 5]\n",
    "x = 22\n",
    "x in n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50b5bbc3",
   "metadata": {},
   "source": [
    "Способ расширить список – метод `.append()`, который добавляет аргумент в список в качестве последнего элемента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07d76f15",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [7, 22, 8, 5]\n",
    "\n",
    "lst.append(10)\n",
    "print(lst)\n",
    "\n",
    "lst += [6]  # Эквивалентное append выражение\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22573606",
   "metadata": {},
   "source": [
    "Удалить элемент из списка можно с помощью метода `.remove()` (без возвращения удаленного элемента) или `.pop` (с возвращением удаленного элемента)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d7cc629",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.remove(7)  # Аргумент – объект, который ходим удалить\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2403ebf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = lst.pop(0)  # Аргумент – индекс объекта. Результат операции можно сохранить в переменную\n",
    "print(lst)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffdfbc44",
   "metadata": {},
   "source": [
    "Поиском в списках занимается метод `.index()`, который вернет индекс объекта, переданного в качестве аргумента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "782659d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73190a3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a92db70b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lst.index(6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1548bd2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Находим индекс объекта 6\n",
    "\n",
    "print(lst[lst.index(6)])  # Используем метод, возвращающий индекс, для обращения к объекту"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b14f9f54",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lst.count(6))  # Метод .count() подсчитывает количество элементов в списке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2d03490",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [1,2,3,4,5]\n",
    "b.reverse()  # .reverse() разворачивает список. Осторожно – метод меняет список!\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "856eea24",
   "metadata": {},
   "source": [
    "##### Все методы списков [здесь](https://docs.python.org/3/tutorial/datastructures.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ba5ed68",
   "metadata": {},
   "source": [
    "### Сортировки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "148247ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list = [9, 3, 2, 1, 4, 8, 5]\n",
    "print(test_list)  # Элементы списка расположены в хаотичном порядке\n",
    "test_list.sort()\n",
    "print(test_list)  # Теперь элементы списка теперь расположены по возрастанию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec6e4e91",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list.sort(reverse = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ded56fde",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38ff2e78",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list.sort(reverse = True)  # Параметр reverse указывает на то, что нужно отсортировать список в обратном порядке\n",
    "print(test_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80dc71a0",
   "metadata": {},
   "source": [
    "Следует обратить внимание, что метод `list.sort()` изменяет сам список, на котором его вызвали.\n",
    "\n",
    "Таким образом, при каждом вызове метода `sort()`, наш список \"test_list\" изменяется.\n",
    "\n",
    "Это может быть удобно, если нам не нужно держать в памяти исходный список.\n",
    "\n",
    "Однако, в противном случае, или же – в случае неизменяемого типа данных (например, кортежа или строки) – этот метод не сработает. В таком случае, на помощь приходит встроенная в питон функция `sorted()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f866884",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list = [9, 3, 2, 1, 4, 8, 5]\n",
    "print(sorted(test_list))  # Сам список при сортировке не изменяется"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7051f21",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78d599d2",
   "metadata": {},
   "source": [
    "Так как `sorted()` – это функция, а не метод, то будет работать и с другими типами данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01e24805",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(\"привет\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "114f7d9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(sorted('привет')) отсортирует буквы в строке, но выведет список\n",
    "print(''.join(sorted('привет')))  # С помощью метода join можно собрать отсортированную строку, ниже подробнее про него"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ced0291",
   "metadata": {},
   "source": [
    "У функции sorted(), как и у метода list.sort() есть параметр key, с помощью которого можно указать функцию, которая будет применена к каждому элементу последовательности при сортировке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a840980f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_string = 'Строка С заглавными И строчными буквами'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0658a5d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(test_string.split()))  # Заглавные буквы получили приоритет над строчными"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5475ba0",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Привет мир!!!\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33466d53",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(test_string.split(), key = str.upper))  # Все буквы были приведены к верхнему регистру и отсортированы по алфавиту"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f855eb9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [-50, 10, 8, 50, 25, 0, -10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4fb3ec2",
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(lst, key = abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0da340b8",
   "metadata": {},
   "source": [
    "## Кортежи (tuple)\n",
    "\n",
    "`Кортежи` очень похожи на списки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64261c63",
   "metadata": {},
   "outputs": [],
   "source": [
    "student = (\"Иван Иванов\", 1988, 7.5, True)\n",
    "print(student)\n",
    "print(type(student))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa34045a",
   "metadata": {},
   "source": [
    "Пустой кортеж можно создать с помощью оператора `()` либо функции `tuple()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fef7d37",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(())\n",
    "print(tuple())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1eccc564",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tuple()\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f8a7384",
   "metadata": {},
   "outputs": [],
   "source": [
    "student"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8723d3d5",
   "metadata": {},
   "source": [
    "**Основное отличие кортежей от списков состоит в том, что кортежи нельзя изменять.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f9c69d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "student[1] = 1987"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddc6685b",
   "metadata": {},
   "source": [
    "Списки и кортежи могут быть вложены друг в друга. Например, пусть в информации о студенте у нас будет храниться не его средний балл, а список всех его оценок."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edac0d4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "student = ('Иван Иванов', 1988, [8, 7, 7, 9, 6], True)\n",
    "print(student)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3b1f0fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "student = ('Ivan Ivanov', 2001, (8, 7, 7, 9, 6), True)\n",
    "print(student)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b73cf8d",
   "metadata": {},
   "source": [
    "Мы можем обратиться к элементу вложенного списка или кортежа с помощью двойной индексации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "251ef5f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(student[2][1])  # Получили вторую оценку"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9561cc41",
   "metadata": {},
   "source": [
    "### Опасность работы с изменяемыми типами данных\n",
    "\n",
    "В работе со списками есть важный момент, на который нужно обращать внимание. Давайте рассмотрим такой код:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f298e2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e49ae2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7307538",
   "metadata": {},
   "outputs": [],
   "source": [
    "b[0] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d0a274b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6536276",
   "metadata": {},
   "source": [
    "Переменная a ссылается на место в памяти, где хранится список [1, 2, 3]. И когда мы пишем, что b = a, b начинает указывать на то же самое место. То есть образуется два имени для одного и того же кусочка данных. И после изменения этого кусочка через переменную b, значение переменной a тоже меняется!\n",
    "\n",
    "Чтобы этого избежать необходимо использовать метод `.copy()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fd116e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a.copy()  # Теперь переменная b указывает на другой список, который хранится в другом кусочке памяти\n",
    "b[0] = 4\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20a50317",
   "metadata": {},
   "source": [
    "Копию можно создавать и с помощью пустого среза."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6d84454",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a[:]  # По умолчанию берется срез от первого элемента до последнего, то есть копируется весь список a\n",
    "b[0] = 4\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a5da197",
   "metadata": {},
   "source": [
    "Не нужно путать присваивание с изменением."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abad4d2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "a = [4,5,6]\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a50b239b",
   "metadata": {},
   "source": [
    "В примере выше переменная a была не изменена, а перезаписана, она начала указывать на другой список, хранящийся в другом месте памяти, поэтому переменная b осталась нетронута."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f800f34",
   "metadata": {},
   "source": [
    "### Конкатенация списков и кортежей\n",
    "\n",
    "На списках и кортежах определен оператор `+`. По аналогии со строками, он будет склеивать две части выражения.\n",
    "\n",
    "Но складывать можно только данные одного типа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cea51375",
   "metadata": {},
   "outputs": [],
   "source": [
    "print([1, 2] + [3, 4])\n",
    "print((1, 2) + (3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c02e37b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print((1, 2) + [3, 4])  # А так нельзя"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b8a9288",
   "metadata": {},
   "source": [
    "Но можно превратить список в кортеж, а потом сложить (или наоборот)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28cf96b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(list((1, 2)) + [3, 4])\n",
    "print((1, 2) + tuple([3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed0bc965",
   "metadata": {},
   "source": [
    "# Методы .split(), .join(),  функция map(), вывод и ввод списков\n",
    "\n",
    "При работе со списками довольно часто нам придется вводить их и выводить в отформатированном виде.\n",
    "\n",
    "`Метод .split()` получает на вход строку-разделитель и возвращает список строк, разбитый по этому разделителю.\n",
    "\n",
    "По умолчанию метод разбивает строку по пробелу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8c495dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, world!!!         Привет мир!!!\".split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "206486a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Ночь. Улица. Фонарь. Аптека'.split('. '))  # Разделитель можно задать самому"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94f66292",
   "metadata": {},
   "source": [
    "`Метод .join()` ведет себя с точностью до наоборот – он склеивает список в строку, вставляя между элементами строку-разделитель."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3638d0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('-'.join(['8', '888', '777', '11', '15']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bf79bcc",
   "metadata": {},
   "source": [
    "`Функция map()` берет функцию и последовательность и применяет эту функцию ко всем ее элементам (map() всегда будет ожидать два аргумента)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3407d74e",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [\"5\", \"4\", \"3\", \"2\", \"1\"]\n",
    "print(lst)\n",
    "\n",
    "lst2 = list(map(int, [\"5\", \"4\", \"3\", \"2\", \"1\"]))\n",
    "print(lst2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa809d85",
   "metadata": {},
   "source": [
    "## Ввод и вывод списков\n",
    "\n",
    "Теперь можно быстро вводить и выводить списки, содержащие разные данные через разные разделители."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "835a2eed",
   "metadata": {},
   "outputs": [],
   "source": [
    "num = list(map(int, input().split()))  # Получаем строку, разбиваем по пробелу, сразу преобразуем все элементы в числа\n",
    "print(num)\n",
    "print('-> '.join(list(map(str, num))))  # Преобразуем массив чисел в массив строк и склеиваем через ->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90b88352",
   "metadata": {},
   "source": [
    "Также, если нет задачи сохранить результат в переменную в виде строки, вместо join() можно использовать распаковку. Мы ставим оператор * перед списком, и, например, функция print() будет воспринимать его не как список, а как последовательность объектов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c21a28e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(num, sep = '-> ')  # Не работает, получили список\n",
    "print(*num, sep = '-> ')  # Теперь сработало. По сути, распакованный список питон видит как в примере ниже. * распаковка списка\n",
    "print(num[0], num[1], num[2], num[3], num[4], sep = '-> ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6f2befa",
   "metadata": {},
   "source": [
    "## Строки: срезы и методы\n",
    "Строки (strings) в питоне предназначаются для хранения и отображения текстовой информации.\n",
    "\n",
    "Строки представляют собой последовательность символов, которые имеют свой порядок, что значит, что питон отслеживает положение каждого элемента строки. Это позволит, например, удобно индексировать строки. Для создания строки нужно использовать одинарные или двойные кавычки.\n",
    "\n",
    "Попробуем создать строку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d9192b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Привет мир!'  # Одинарные кавычки\n",
    "print(s)\n",
    "\n",
    "s = \"Привет мир!\"  # Двойные кавычки\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2f90da5",
   "metadata": {},
   "source": [
    "Если есть необходимость в строке использовать кавычки, например, для какого-то названия, то следует использовать разные кавычки для текста внутри строки и для самой страны."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da788622",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Добро пожаловать на курс \"Python для начинающих\"'  # Можно и наоборот – двойные снаружи и одинарные внтури)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21084084",
   "metadata": {},
   "source": [
    "Также можно посчитать количество символов в строке (ее длину) с помощью функции len()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a32ee315",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = \"Привет мир!     \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e2fc337",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44ea6540",
   "metadata": {},
   "source": [
    "Строка представляет собой последовательность, а это значит, что можно обратиться к любому ее элементу по индексу. Для выполнения такой операции в питоне используются квадратные скобки [] после объекта. В квадратных скобках указывается желаемый индекс. Индексирование начинается с 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e96f6b50",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s[0])  # Первый элемент\n",
    "print(s[1])  # Второй\n",
    "print(s[2])  # Третий\n",
    "print(s[-1])  # Последний\n",
    "print(s[-2])  # Второй с конца\n",
    "\n",
    "# Предыдущие действия никак не изменили строку\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe635fe",
   "metadata": {},
   "source": [
    "Кроме выбора одного элемента с помощью индексирования можно получить подстроку. Для этого надо указать индексы границ подстроки через двоеточие. \n",
    "\n",
    "**Первое число** – от какого индекса начинаем, если ничего не написать, то начнем сначала. Этот индекс включается в отрезок. **Второе число** (после первого двоеточия) – каким индексом заканчивается срез, если ничего не написать, то питон возьмет последний символ. Здесь уже не включительно – если указать срез [0:2], то питон вернет только два символа под индексами 0 и 1. **Третье число** (необязательное, после второго двоеточия) – шаг, по умолчанию там стоит параметр 1 (выводится каждая буква).\n",
    "\n",
    "Таким образом, использовав одно число без двоеточий получим один символ. Использовав два числа через двоеточие – срез строки, включая первый индекс и не включая второй (первое число обязательно меньше второго). Использовав три числа через два двоеточия – срез строки с определенным шагом, заданным третьим числом."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7f7da9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Добро пожаловать на курс \"Python для начинающих\"'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b51c73c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s[1:])    # Вся строка, начиная с первого элемента\n",
    "print(s[:4])    # Четыре первых символа до порядкового номера 4\n",
    "print(s[:])     # Копия строки (срез от первого до последнего символа)\n",
    "print(s[:-1])   # Вся строка, кроме последнего символа\n",
    "print(s[::2])   # Также можно выбирать символы из строки с определённым шагом\n",
    "print(s[::-1])  # Например, с помощью шага -1 можно получить строку наоборот"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2efa30f4",
   "metadata": {},
   "source": [
    "## Методы строк\n",
    "Теперь перейдем к задачам поинтереснее. Пусть нам нужно найти в строке какое-нибудь слово. Мы можем проверять наличие подстроки в строке с помощью специального слова in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aee6e957",
   "metadata": {},
   "outputs": [],
   "source": [
    "poem = '''Это утро, радость эта, \n",
    "Эта мощь и дня и света, \n",
    "Этот синий свод, \n",
    "Этот крик и вереницы, \n",
    "Эти стаи, эти птицы, \n",
    "Этот говор вод, \n",
    "\n",
    "Эти ивы и березы, \n",
    "Эти капли – эти слезы, \n",
    "Этот пух – не лист, \n",
    "Эти горы, эти долы, \n",
    "Эти мошки, эти пчелы, \n",
    "Этот зык и свист, \n",
    "\n",
    "Эти зори без затменья, \n",
    "Этот вздох ночной селенья, \n",
    "Эта ночь без сна, \n",
    "Эта мгла и жар постели, \n",
    "Эта дробь и эти трели, \n",
    "Это все – весна.\n",
    "(А. Фет)'''\n",
    "\n",
    "print('Эта' in poem)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10fcc409",
   "metadata": {},
   "source": [
    "Возьмем пять строк стиха и посчитаем сколько в них встречается определенное слов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "306a1126",
   "metadata": {},
   "outputs": [],
   "source": [
    "mentions = 0  # Переменная, в которой будем считать упоминания\n",
    "poem_number = 1  # Счетчик строк, начинаем работать с первой\n",
    "\n",
    "while poem_number <= 5:\n",
    "    poem_num = input()\n",
    "    if 'Эта' in poem_num:\n",
    "        mentions += 1\n",
    "    poem_number += 1\n",
    "    \n",
    "print(mentions)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d27b83a",
   "metadata": {},
   "source": [
    "Если слово \"Эта\" введено с маленькой буквы, то оно учитываться не будет.\n",
    "\n",
    "Работая со строками, мы будем использовать очень много методов. Методы отличаются от функций тем, что вызываются от имени переменной через точку. Например poem_num.upper() – метод `upper()` вызывается от строковой переменной poem_num. По сути методы, это функции, которые применимы только к особому типу данных. Так, например, функция print() напечатает все, что бы мы ей не передали, а перевод к верхнему регистру (а именно это делает метод upper()) ни с одним типом данных кроме строки уже не сработает."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e999af47",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(poem.upper())  # Приводит строку к верхнему регистру\n",
    "print()\n",
    "print(poem.lower())  # Приводит строку к нижнему регистру"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "857fa317",
   "metadata": {},
   "source": [
    "Обратите внимание, что метод, как правило, не изменяет объект и наша строка осталась такой как была."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "728b32a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(poem)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f0ba42b",
   "metadata": {},
   "source": [
    "Рассмотрим самые основные методы работы со строками\n",
    "\n",
    "Метод `find()` – возвращает индекс вхождения символа в строку (или индекс первого символа подстроки в строке, если идет поиск подстроки). Зная индекс первого элемента, можем достать интересующую нас информацию."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb1acdae",
   "metadata": {},
   "outputs": [],
   "source": [
    "uaz = \"Patriot Цена: 1 480 000 ₽ присутствуют скидки\"\n",
    "\n",
    "print(uaz.find('Цена'))  # Нашли индекс Ц – начала подстроки \"Цена:\"\n",
    "print(uaz.find('₽'))  # Нашли индекс ₽\n",
    "price = uaz[uaz.find('Цена:')+6:uaz.find('₽')-1]  # Вывели срез от от начала до конца цены (с помощью значений 6 и -1\n",
    "                                                  # указали индексы до начала и конца цены)\n",
    "print(price)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bac6702e",
   "metadata": {},
   "source": [
    "Если в строке нет искомой подстроки, то выведется -1. Это не значит, что первый символ находится на последнем месте, это значит, что такой подстроки в строке не встречается."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7801611",
   "metadata": {},
   "outputs": [],
   "source": [
    "uaz.find(\"Lada\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fcb8796",
   "metadata": {},
   "source": [
    "А если подстрока входит в строку несколько раз, то find() вернет индекс только для первого вхождения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd0045ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "uaz.find(\"и\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fce241c",
   "metadata": {},
   "source": [
    "Есть модификация метода find(): rfind(substring) – возвращает позицию самого правого вхождения подстроки substring в строку string или -1, если подстрока не найдена.\n",
    "\n",
    "Метод `replace()` может заменить символ или подстроку в строке. Метод принимает два аргумента – что меняем и на что меняем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fe4782b",
   "metadata": {},
   "outputs": [],
   "source": [
    "price = price.replace(\" \", \"\")  # Убираем пробелы\n",
    "price = price.replace(\"0\", \"9\", 3)  # Третий параметр означает то, сколько вхождений хотим изменить. Иначе, заменяет все\n",
    "int(price)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09ce2810",
   "metadata": {},
   "source": [
    "Рассмотрим следующую задачу: у нас есть строка, в которой собраны данные ответа на вопрос о качестве оказанной услуги. Каждый ответ отделен точкой с запятой от следующего. Требуется напечатать каждый ответ на новой строке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37818413",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Отлично;Хорошо;Удовлетворительно;Не удовлетворительно\"\n",
    "\n",
    "while len(s) > 0:  # Будем отрезать от нашей строки элементы, пока она не станет равна нулю\n",
    "    idx = s.find(';')  # Ищем индекс первого вхождения ;\n",
    "    if idx == -1:  # Если ; нет, то печатаем строку\n",
    "        print(s)\n",
    "        s = ''  # Заменяем строку на пустую строку длины 0, чтобы цикл не запустился на следующую итерацию\n",
    "    else:\n",
    "        print(s[:idx])  # Если нашли ;, то печатаем строку от начала и до ;\n",
    "        s = s[idx+1:]  # А теперь отрезаем тот кусок, который только что напечатали и сам ; (для этого +1). Это делаем для того,\n",
    "                       # чтобы на вход в цикл пришла строка уже без этого куска"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fa11f9d",
   "metadata": {},
   "source": [
    "Методы `startswith()` и `endswith()` проверяют, стоит ли искомая построка в начале или в конце строки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "860964b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Отлично;Хорошо;Удовлетворительно;Не удовлетворительно'\n",
    "\n",
    "print(s)\n",
    "print(s.startswith(\"Отл\"))  # Данный метод проверяет, начинается ли исходная строка на данную подстроку\n",
    "print(s.endswith(\"удовлетворительно\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56477837",
   "metadata": {},
   "source": [
    "Метод `strip()`, а также `lstrip()` и `rstrip()`, работающие только с одной стороны строки, удаляет незначимые символы (пробелы, табуляцию и т.д.) с краев строк. Очень полезный метод, когда мы собираем информацию из интернета. Если этим методам передать аргумент, то они удалят подстроку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6de4ea33",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(' russia.ru   '.strip())  # Удалили пробельные символы слева и справа\n",
    "print('russia.ru'.strip('ru'))  # Удалили ru с обеих сторон\n",
    "print('russia.ru'.lstrip('ru'))  # Удалили ru слева\n",
    "print('russia.ru'.rstrip('ru'))  # Удалили ru справа"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a176478c",
   "metadata": {},
   "source": [
    "В реальности strip() часто используется для нормализации email'ов или других идентификторов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9955cfa2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print('      pileyan@gmail.com       '.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dcd0912",
   "metadata": {},
   "source": [
    "Применение метода `count()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac5ea6f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "uaz = \"Patriot Цена: 1 480 000 ₽ присутствуют скидки\"  # Исходная строка\n",
    "print(uaz.count(\"и\"))  # Ищем строчную букву и\n",
    "print(uaz.count(\"0\"))  # Ищем 0\n",
    "print(uaz.count(\"00\"))  # Ищем два 00\n",
    "print(uaz.count(\"скидка\"))  # Ищем подстроку 'скидки', не находим\n",
    "print(uaz.count(\"и\", 25, 38))  # Ищем букву и в s[25:38]\n",
    "print(uaz.count(\"и\", 39))  # Ищем букву и в s[39:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "652cc116",
   "metadata": {},
   "source": [
    "Отдельное семейство методов строк отвечает за проверку на соответствие условиям."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc7f6ee4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# isalpha – проверяет, что все символы строки являются буквами.\n",
    "print(uaz.isalpha())\n",
    "print(\"Patriot\".isalpha())\n",
    "\n",
    "# isdigit – проверяет, что все символы строки являются цифрами.\n",
    "print(\"13242\".isdigit())\n",
    "\n",
    "# isalnum – проверяет, что все символы строки являются буквами или цифрами.\n",
    "print(\"Patriot 1 480 000 ₽\".isalnum())\n",
    "print(\"Patriot1480000₽\".isalnum())\n",
    "print(\"Patriot1480000\".isalnum())\n",
    "\n",
    "# islower – проверяет, что все символы строки являются маленькими (строчными) буквами.\n",
    "print('Patriot'.islower())\n",
    "print('patriot1480000'.islower())\n",
    "\n",
    "# isupper – проверяет, что все символы строки являются большими (заглавными, прописными) буквами.\n",
    "print('PATRIOT1480000'.isupper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35252ccc",
   "metadata": {},
   "outputs": [],
   "source": [
    "uaz = \"Patriot Цена: 1 480 000 ₽ присутствуют скидки\"\n",
    "\n",
    "# title – переводит первую букву всех слов к верхнему регистру\n",
    "print(uaz.title())\n",
    "\n",
    "# swapcase – меняет регистр на противоположный\n",
    "print(uaz.swapcase())\n",
    "\n",
    "# capitalize – переводит первую букву строки в верхний регистра, а остальные – в нижний\n",
    "uaz = \"patriot Цена: 1 480 000 ₽ присутствуют скидки\"\n",
    "uaz.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf2d5d34",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Пользователь должен придумать пароль для своей учетной записи. Пароль должен состоять только из цифр и букв."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33a3e990",
   "metadata": {},
   "outputs": [],
   "source": [
    "password = input(\"Введите пароль: \")\n",
    "\n",
    "if password.isalnum() == False:\n",
    "    print(\"Пароль должен состоять только из букв и цифр!\")\n",
    "else:\n",
    "     print(\"Пароль сохранен\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18d2bba8",
   "metadata": {},
   "source": [
    "А теперь давайте усложним и добавим проверку на то, что хотя бы одна буква должна быть заглавная."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cabd1c5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "password = input(\"Введите пароль: \")\n",
    "\n",
    "if password.isalnum() == False:\n",
    "    print(\"Пароль должен состоять только из букв и цифр!\")\n",
    "else:     \n",
    "    if password.islower() == True:\n",
    "        print(\"Пароль должен содержать как минимум одну заглавную букву!\")\n",
    "    else:\n",
    "        print(\"Пароль сохранен\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13b866ca",
   "metadata": {},
   "source": [
    "# Цикл For, функция range()\n",
    "\n",
    "* range(стоп) берет один аргумент\n",
    "* range(старт, стоп) берет два аргумента\n",
    "* range(старт, стоп, шаг) берет три аргумента\n",
    "\n",
    "Примеры:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3881b25b",
   "metadata": {},
   "outputs": [],
   "source": [
    "range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93a6608c",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0f19142",
   "metadata": {},
   "outputs": [],
   "source": [
    "range(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49779f9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(1,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be08d545",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(1,17,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3df5e89",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(10,1,-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a0f670d",
   "metadata": {},
   "source": [
    "В цикле `for` действие выполняется для всех элементов какой-то последовательности: они перебираются по очереди, и с каждым производится действие.\n",
    "\n",
    "Пример 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1b12505",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [10, 20, 30, 40, 50]\n",
    "for i in my_list:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1a4ea5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [10, 20, 30, 40, 50]\n",
    "for i in my_list:\n",
    "    if i > 30:\n",
    "        print(i)\n",
    "    elif i == 30:\n",
    "        print(0)\n",
    "    else:\n",
    "        print(i/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ec86fea",
   "metadata": {},
   "source": [
    "Пример 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f001f7fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "slovo = 'Привет мир!'\n",
    "\n",
    "for l in slovo:\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0d5bbe2",
   "metadata": {},
   "source": [
    "Пример 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea749bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [10, 20, 30, 40, 50]\n",
    "for i in range(len(my_list)):\n",
    "    my_list[i] *= 2\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6be6744f",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Даны два целых числа A и B (при этом A ≤ B). Выведите все числа от A до B включительно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16b8b742",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "\n",
    "for i in range(a, b + 1):\n",
    "    print(i, end = \" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afb6eb16",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Дано несколько целых чисел. Вычислите их сумму и количество."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "658ee67a",
   "metadata": {},
   "outputs": [],
   "source": [
    "spisok = list(map(int,input().split()))\n",
    "s = 0\n",
    "c = 0\n",
    "for i in spisok:\n",
    "    s += i\n",
    "    c += 1\n",
    "print(s, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76c398d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Можно конечно и так, но всё таки, мы тут изучаем for\n",
    "\n",
    "spisok = list(map(int,input().split()))\n",
    "s = sum(spisok)\n",
    "c = len(spisok)\n",
    "\n",
    "print(s, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f66a8a51",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Дан список lst = [11, 5, 8, 32, 15, 3, 20, 132, 21, 4, 555, 9, 20]. Необходимо вывести элементы, которые одновременно:\n",
    "1. меньше 30\n",
    "2. делятся на 3 без остатка\n",
    "\n",
    "Все остальные элементы списка необходимо просуммировать и вывести конечный результат."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dd3eea7",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [11, 5, 8, 32, 15, 3, 20, 132, 21, 4, 555, 9, 20]\n",
    "\n",
    "summ = 0\n",
    "for i in lst:\n",
    "    if (i < 30) and (i % 3 == 0):\n",
    "        print(i, end = \" \")\n",
    "    else:\n",
    "        summ += i\n",
    "print()\n",
    "print(summ)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc528004",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Согласно политике безопасности банка, пароль не может содержать год рождения клиента – иначе вероятность подобрать пароль увеличивается. Напишите программу, которая будет проводить такую проверку.\n",
    "\n",
    "**Ввод**\n",
    "\n",
    "На первой строке – полный год рождения клиента (то есть 4 символа, например, «1968»). На второй строке – три варианта пароля, придуманных клиентом, записанных через пробел.\n",
    "\n",
    "**Вывод**\n",
    "\n",
    "True, если в пароле есть подстрока с годом рождения, и False, если нет. Ответ по каждому варианту пароля нужно выводить с новой строки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "856007fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "year = input()\n",
    "pas = input().split()\n",
    "for i in pas:\n",
    "    if year in i:\n",
    "        print(True)\n",
    "    else:\n",
    "        print(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c36d1cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Более короткий вариант написания кода\n",
    "\n",
    "year = input()\n",
    "pas = input().split()\n",
    "for i in pas:\n",
    "    print(year in i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abc47f0d",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Игра \"Угадай число\"\n",
    "\n",
    "Напишем игру, в которой компьютер загадывает число, а пользователь пытается его угадать.\n",
    "\n",
    "    1. Импоритуем библиотеку random и с помощью метода randint() загадываем случайное число от 1 до 100. Затем предлагаем пользователю его угадать.\n",
    "    2. Если пользователь вводит число больше или меньше загаданного, выводим соответствующее сообщение и продолжаем игру.\n",
    "    3. Игра заканчивается, когда пользователь угадывает число, и выводится сообщение о победе."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bce72132",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "number = random.randint(1, 100)  # Генерируется значение в диапазоне от 1 до 100\n",
    "print('Я загадал число от 1 до 100. Попробуй его угадать')\n",
    "\n",
    "while True:\n",
    "    guess = int(input(\"Введите ваше предположение\"))\n",
    "    if guess < number:\n",
    "        print(\"Загаданное число больше\")\n",
    "    elif guess > number:\n",
    "        print(\"Загаданное число меньше\")\n",
    "    else:\n",
    "        print('Поздравляю!')\n",
    "        break"
   ]
  },
  {
   "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": [
    "Здесь мы вывели все уникальные гласные, которые встретились в строке."
   ]
  }
 ],
 "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
}