Python/made-easy/chapter_8_structures_and_sequences.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Структуры данных и последовательности.'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Структуры данных и последовательности.\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict, List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Название «структуры данных» говорит само за себя. Это структуры, в которых\n",
    "совместно хранятся определенные данные.\n",
    "В Python есть четыре встроенных структуры данных.\n",
    "♦ списки;\n",
    "♦ кортежи;\n",
    "♦ множества;\n",
    "♦ словари.\n",
    "\n",
    "8.1. Строки\n",
    "Строки являются объектами в Python, а именно экземплярами класса str.\n",
    "В Python все типы данных являются классами. В Python класс - это определение \n",
    "объекта, а объект - это экземШIЯр класса.\n",
    "Строки можно задать несколькими способами. Их можно заключать в одинарные\n",
    "( ' ' ) или двойные кавычки (\"\") - результат будет одинаковый. Их также можно за\n",
    "ключать в три кавычки, одинарные или двойные. Использование трех кавычек дает\n",
    "возможность записывать строки более чем в одну строку. Примеры:\n",
    "'строка ', \"строка \", '''строка''', \"\"\" строка\"\"\"\n",
    "8.1.1. Строковые операции\n",
    "Строки - это объекты, и, как у любых объектов, у них есть методы, которые мож\n",
    "но применять. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nilabh\n"
     ]
    }
   ],
   "source": [
    "x_ = \"nilabh\"\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nilabh\n"
     ]
    }
   ],
   "source": [
    "x_ = \"nilabh\".capitalize()\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NILABH\n"
     ]
    }
   ],
   "source": [
    "x_ = \"nilabh\".upper()\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nILABH\n"
     ]
    }
   ],
   "source": [
    "x_ = \"Nilabh\".swapcase()\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строки - это неизменяемые объекты. При изменении каждая строковая операция\n",
    "создает новый объект."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = \"Nilabh\"\n",
    "s2 = \"Nilabh\"\n",
    "# nроверим, являются ли s1 и s2 одним и тем же объектом\n",
    "s1 is s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2867002884432\n",
      "2867002884432\n"
     ]
    }
   ],
   "source": [
    "# убедимся, проверив идентификаторы\n",
    "print(id(s1))\n",
    "print(id(s2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "2867002736480\n",
      "2867002884432\n"
     ]
    }
   ],
   "source": [
    "s3 = s1.upper()\n",
    "print(s3 is s1)\n",
    "print(id(s3))\n",
    "print(id(s1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.1.2. Форматирование\n",
    "Теперь посмотрим, что делает метод format(). Для использования этого метода \n",
    "в строке должны быть заполнители, в которые помещаются аргументы метода \n",
    "format() при выполнении. Это позиционный метод, если не указано иное. \n",
    "Это означает, что аргументы в результирующей строке появляются на тех же\n",
    "позициях, что и в format(). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seven, 8, 9 and ten\n"
     ]
    }
   ],
   "source": [
    "# 8 , 9 и \"ten\" появятся в указанном порядке\n",
    "x_ = f\"seven, {8}, {9} and {'ten'}\"\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы можем изменить очередность, указав позиции аргументов в заполнителях."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seven, ten, 9 and 8\n"
     ]
    }
   ],
   "source": [
    "x_ = f\"seven, {'ten'}, {9} and {8}\"\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод format ( ) также можно использовать для выравнивания строк и создания\n",
    "строки нужной длины. Если исходная строка короче, она будет дополнена пробе-\n",
    "лами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seven,ten      ,         9 and         8 \n"
     ]
    }
   ],
   "source": [
    "# 8 , 9 и \"ten\" будут дополнены пробелами справа или слева,\n",
    "# в зависимости от знака ' < ' или ' > ' после двоеточия\n",
    "x_ = f\"seven,{'ten':<9}, {9:>9} and {8:9} \"\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cтроки прижимаются к левому или правому краю в направлении символов (<) или\n",
    "(>) соответственно. Так, строка \"ten\" выровнена по левому краю, а правая\n",
    "часть дополнена пробелами.\n",
    "Существует другой способ форматирования строк, этот метод называется f-строками."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seven, 8 , 9 and ten \n"
     ]
    }
   ],
   "source": [
    "# В f-строках можно использовать переменные в заполнителях\n",
    "a_ = \"8\"\n",
    "b_ = \"9\"\n",
    "c_ = \"ten\"\n",
    "x_ = f\"seven, {a_} , {b_} and {c_} \"\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.1.3. Методы split() и join()\n",
    "Разделить строку можно с помощью метода split(). Python находит в строке пробелы\n",
    "и символы переноса и возвращает список всех слов из строки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Put', 'several', 'strings', 'within', 'parentheses']\n"
     ]
    }
   ],
   "source": [
    "text = \"Put several strings within parentheses \"\n",
    "\"to have them joined together.\"\n",
    "print(text.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По умолчанию метод split() делит строку по пробелам. Но мы можем изменить это\n",
    "поведение."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Put several str', 'ngs w', 'th', 'n parentheses ']\n"
     ]
    }
   ],
   "source": [
    "print(text.split(\"i\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Put', 'several', 'strings', 'within', 'parentheses']\n"
     ]
    }
   ],
   "source": [
    "split_text = text.split()\n",
    "print(split_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Put several strings within parentheses\n"
     ]
    }
   ],
   "source": [
    "join_text = \" \".join(split_text)\n",
    "print(join_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Список слов можно объединять с помощью любой строки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Put-several-strings-within-parentheses\n"
     ]
    }
   ],
   "source": [
    "join_text = \"-\".join(split_text)\n",
    "print(join_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.2. Списки\n",
    "У списков в Python есть важные 3 свойства:\n",
    "♦ упорядоченность;\n",
    "♦ последовательность;\n",
    "♦ итерируемость."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Побег из Шоушенка',\n",
       " 'Крестный отец',\n",
       " 'Аватар',\n",
       " 'Терминатор-2: Судный день',\n",
       " '24 часа',\n",
       " '12 разгневанных мужчин',\n",
       " 'Три амигос!',\n",
       " 'Игра престолов']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_movies = [\n",
    "    \"Побег из Шоушенка\",\n",
    "    \"Крестный отец\",\n",
    "    \"Аватар\",\n",
    "    \"Терминатор-2: Судный день\",\n",
    "    \"24 часа\",\n",
    "    \"12 разгневанных мужчин\",\n",
    "    \"Три амигос!\",\n",
    "    \"Игра престолов\",\n",
    "]\n",
    "\n",
    "list_of_movies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После создания в список можно вносить изменения с помощью различных\n",
    "функций и операций над списками. Можно добавлять, удалять и искать элемен-\n",
    "ты в списке. Список является изменяемым типом данных.\n",
    "Список - это просто контейнер. У этого контейнера есть некоторые свойства,\n",
    "которые делают его простым и полезным в использовании."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.2.1. Индексы и срезы\n",
    "Как и строки (и другие встроенные типы последовательностей), списки можно ин-\n",
    "дексировать и делать срезы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even = [2, 4, 6, 8, 10, 12, 14]\n",
    "even[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 6, 8]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "even + [16, 18, 20, 22]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В отличие от неизменяемых строк, списки являются изменяемым типом данных,\n",
    "т.е. их содержимое можно изменять."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 17, 25]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [1, 4, 9, 17, 25]  # квадраты чисел, с ошибкой\n",
    "# 4 в квадрате равно 16, а не 17 !\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares[3] = 16\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Встроенная функция len( ) также применима к спискам."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.2.2. Методы списков\n",
    "\n",
    "list.append(x) - Добавление элемента х в конец списка. Эквивалентно а[len(а):] = [х]\n",
    "list.extend(iterable) - Добавление в список всех элементов из iterable. Эквивалентно\n",
    "a[len(a):] = iterable\n",
    "list.insert(i, х)  - Вставка элемента х на заданную позицию. Первый аргумент - это\n",
    "индекс элемента, перед которым нужно выполнить вставку, поэтому a.insert (О, х)\n",
    "вставляет элемент в начало списка, а а.insert(len(а), х) эквивалентно a.append (х)\n",
    "list.remove(х)  - Удаление из списка первого элемента, значение которого равно х.\n",
    "Если такого элемента нет, возникает ошибка valueError\n",
    "list.pop([i])  - Удаляет элемент в данной позиции в списке и возвращает его. Если\n",
    "индекс не указан, а.рор() удаляет и возвращает последний элемент в списке. \n",
    "(Квадратные скобки вокруг i в сигнатуре метода означают, что этот параметр\n",
    "является необязательным и не нужно печатать эти скобки при вызове метода.\n",
    "Это обозначение часто встречается в справочниках по библиотекам Python.)\n",
    "list.clear() - Удаляет все элементы из списка. Эквивалентно del а [:\n",
    "list.index(x [, start [ , end] ] )Возвращает индекс первого элемента, значение \n",
    "которого равно х. Возвращает ошибку valueError, если такого элемента нет. \n",
    "Необязательные аргументы start и end интерпретируются как срез и используются\n",
    "для ограничения области поиска в списке. Возвращается индекс относительно начала\n",
    "списка, а не от аргумента start\n",
    "list.count(x) - Сколько раз значение х встречается в списке\n",
    "list.sort([key=None, reverse=False]) - Сортирует элементы списка (необязательные аргументы\n",
    "можно использовать для настройки сортировки)\n",
    "list.reverse()  - Меняет порядок элементов списка на обратный\n",
    "list.сору() - Возвращает копию списка. Эквивалентно [:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['orange', 'apple', 'pear', 'banana', 'kiwi ', 'apple', 'banana']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits = [\"orange\", \"apple\", \"pear\", \"banana\", \"kiwi \", \"apple\", \"banana\"]\n",
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.count(\"tangerline\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.index(\"banana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.index(\"banana\", 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banana', 'apple', 'kiwi ', 'banana', 'pear', 'apple', 'orange']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.reverse()\n",
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits.append(\"grape\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi ', 'orange', 'pear']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.sort()\n",
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pear'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.2.3. Списковые включения\n",
    "Списковые включения - это краткий и элегантный способ создания списков. Базо-\n",
    "вая струюура спискового включения выглядит следующим образом:\n",
    "результат = [ вьражение for элемент in список if условие]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 's', 'i', 'a']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# [i_ for i_ in \"asia\"]\n",
    "list(\"asia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mylist = [i_ for i_ in range(10)]\n",
    "my_list = list(range(10))\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evens = [i_ for i_ in range(20) if i_ % 2 == 0]\n",
    "evens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "my_list = [\"x\", \"y\", \"z\"]\n",
    "new_list = [i_ * n_ for i_ in my_list for n_ in range(1, 5)]\n",
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы хотим создать вот такой список: [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)].\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# создание списка с помощью цикла for\n",
    "combs = []\n",
    "for x_ in [1, 2, 3]:\n",
    "    for y_ in [3, 1, 4]:\n",
    "        if x_ != y_:\n",
    "            combs.append((x_, y_))\n",
    "combs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# создание списка с помощью спискового включения\n",
    "[(x_, y_) for x_ in [1, 2, 3] for y_ in [3, 1, 4] if x_ != y_]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.2.4. Оператор del\n",
    "Если нужно удалить элемент из списка, указав его индекс, а не значение, вы можете\n",
    "использовать оператор del. Он отличается от метода рор ( ) , который еще и возвращает\n",
    "значение элемента. Оператор del также можно использовать для удаления фрагмента списка\n",
    "или очистки всего списка. Например:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "x_ = [-2, -4, 5, 8, 2.2, 44]\n",
    "del x_[0]\n",
    "x_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "del x_[2:4]\n",
    "x_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оператор del можно использовать для удаления целых переменных:\n",
    "del х"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.3. Кортежи 1\n",
    "Кортеж состоит из ряда значений, разделенных запятыми, например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1234, 5678, ' xyz ')"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t_ = 1234, 5678, \" xyz \"  # здесь переменная t - это кортеж\n",
    "t_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1234, 5678, ' xyz '), (' a ', ' b ', ' c '))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u_ = t_, (\" a \", \" b \", \" c \")  # кортеж u, состоящий из вложенных кортежей\n",
    "u_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нельзя менять отдельные элементы кортежа, но можно создавать кортежи, которые \n",
    "содержат внутри себя изменяемые объекты, такие как списки. Кортежи похожи на\n",
    "списки, но с двумя отличиями.\n",
    "♦ Кортежи неизменяемы, а списки изменяемы.\n",
    "♦ Кортежи заключаются в круглые скобки, а списки - в квадратные.\n",
    "Разница:\n",
    "♦ Хотя кортежи и похожи на списки, они часто используются в разных ситуациях\n",
    "и для разных целей.\n",
    "♦ Кортежи неизменяемы и обычно содержат неоднородную последовательность\n",
    "элементов, доступ к которым осуществляется посредством распаковки или ин-\n",
    "дексации (или по имени атрибута в случае именованных кортежей).\n",
    "♦ Списки изменяемы, их элементы обычно однородны, а доступ к ним осуществ-\n",
    "ляется путем перебора списка.\n",
    "Где и почему лучше использовать кортежи вместо списков?\n",
    "♦ Когда важна скорость выполнения программы, предпочтительнее использовать\n",
    "кортежи. Программа с кортежами выполняется быстрее по сравнению с такой\n",
    "же программой, но на списках. Но при использовании небольших кортежей и\n",
    "списков разница не ощущается.\n",
    "♦ Когда важна целостность данных и вы не хотите, чтобы ваши данные изменя-\n",
    "лись во время выполнения программы. Использование кортежа вместо списка\n",
    "защищает данные от случайного изменения во время выполнения (помните, что\n",
    "кортежи неизменяемы).\n",
    "♦ Кортежи можно использовать в качестве ключа к словарю, а вот списки - нельзя.\n",
    "Т.к. ключи должны быть неизменяемы.\n",
    "8.3.1. Методы кортежей\n",
    "Почти все методы списков также применимы и к кортежам. Так как кортежи неизменяемы,\n",
    "следовательно, методы и функции, которые изменяют списки, для кортежей использоваться\n",
    "не могут.\n",
    "\n",
    "8.4. Множества\n",
    "Множество - это неупорядоченная коллекция неповторяющихся элементов. Они используются\n",
    "в основном для проверки вхождения элементов во множество и для устранения\n",
    "дубликатов. Множества также поддерживают математические операции, такие как\n",
    "объединение, пересечение, разность и симметричная разность.\n",
    "Множество - это неупорядоченный тип данных, который является итерируемым,\n",
    "изменяемым и не имеет повторяющихся элементов. Класс множества в Python со-\n",
    "ответствует математическим множествам1 •\n",
    "Поскольку множества не упорядочены, к их элементам нельзя получить доступ\n",
    "через индекс.\n",
    "Для создания множеств можно использовать фиrурные скобки {} или функцию\n",
    "set()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{' blue', ' red', 'black', 'orange', 'pink', 'red', 'white'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colours = {\" red\", \"black\", \" blue\", \"orange\", \"red\", \"pink\", \"white\"}\n",
    "colours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# быстрая проверка на вхождение в множество\n",
    "\"red\" in colours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"purple\" in colours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ПРИМЕЧАНИЕ\n",
    "Для создания пустого множества нужно использовать функцию set() , а не {}, т. к. \n",
    "пустые фигурные скобки создают пустой словарь.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.4.1. Операции над множествами\n",
    "Множества поддерживают те же операции, что и в работе с математическими множествами."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "уникальные буквы в словах\n",
    "a_ = set(\"abracadabra\")\n",
    "b_ = set(\"alacazam\")\n",
    "a_  # уникальные буквы\n",
    "{'a', 'b', 'r', 'c', 'd'}\n",
    "\n",
    "b_  # уникальные буквы\n",
    "{'a', 'c', 'l', 'm', 'z'}\n",
    "\n",
    "a_ - b_  # буквы, которые есть в множестве а, но не в b\n",
    "{'b', 'd', 'r'}\n",
    "\n",
    "a_ | b_  # буквы, которые есть в а, или ь, или в обоих множества\n",
    "{'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'}\n",
    "\n",
    "a_ & b_  # буквы, которые есть в множествах а и b одновременно\n",
    "{'a', 'c'}\n",
    "\n",
    "a_ ^ b_  # буквы, которые есть в а или b, но не в обоих сразу\n",
    "{'b', 'd', 'l', 'm', 'r', 'z'}\n",
    "\n",
    "oперации, аналогичные списковым включениям, применимы и для множеств:\n",
    "a_ = {x_ for x_ in \"abracadabra \" if x_ not in \"abc\"}\n",
    "a_\n",
    "{' ', 'd', 'r'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.4.2. Методы множеств\n",
    "Практически все методы списков также применимы и к множествам. Множества не\n",
    "упорядочены, поэтому методы, использующие индексацюо, здесь не используются.\n",
    "add()  -  Добавляет элемент в множество\n",
    "сору()  -  Возвращает копию множества\n",
    "clear()  -  Удаляет все элементы из множества\n",
    "discard()  -   Удаляет указанный элемент из множества\n",
    "рор()  -  Удаляет произвольный элемент из множества\n",
    "remove()  -  Удаляет указанный элемент. Если такого элемента нет в множестве, вернется ошибка\n",
    "symmetric_difference()  -  Возвращает симметричную разность двух множеств\n",
    "syrmnetric_difference_update()  -  Вставляет симметричную разность этого множества и другого\n",
    "union()  -  Возвращает объединение множеств\n",
    "difference()  -  Возвращает разницу между двумя или более множествами\n",
    "difference_update()  -  Удаляет элементы из этого множества, которые также включены в другое\n",
    "множество\n",
    "update()  -  Объединяет множество с другим\n",
    "intersection()  -  Возвращает пересечение двух других множеств\n",
    "intersection_update()  -  Удаляет из множества элементы, которых нет в другом множестве\n",
    "isdisjoint()  -  Проверяет, есть ли у двух множеств пересечение\n",
    "issubset()  -  Проверяет, является ли это множество подмножеством другого\n",
    "issuperset()  -  Проверяет, является ли другое множество подмножеством первого"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.5. Словари\n",
    "Словарь - это еще один встроенный тип данных Python. Это неупорядоченный\n",
    "набор единиц данных. Лучше всего рассматривать словарь как пары ключ : значение с требованием о том,\n",
    "чтобы ключи в пределах одного словаря были уникальными. Пустой словарь создается с помощью пары\n",
    "фигурных скобок {}. Затем через запятую перечисляются пары ключ: значение.\n",
    "Словарь также можно создать с помощью встроенной функции dict()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ключ в словаре - это уникальный и неизменяемый тип данных, такой как строка,\n",
    "число или кортеж. Другими словами, в качестве ключей можно использовать только\n",
    "простые типы данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ramesh': 9893200000, 'surabhi': 9893200311}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# небольшой nример словаря из телефонных номеров друзей\n",
    "household = {\"ramesh\": 9893200000, \"surabhi\": 9893200311}\n",
    "household"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ramesh': 9893200000, 'surabhi': 9893200311, 'sush': 9893200422}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# добавить нового друга\n",
    "household[\"sush\"] = 9893200422\n",
    "household"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9893200311"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# словарь индексируется no ключам, а не по порядку,\n",
    "# как список или строка\n",
    "household[\"surabhi\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Конструктор dict {} строит словарь непосредственно из последовательности пар\n",
    "( ключ, значение):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'sape': 4139, 'guido': 4127, 'jack': 4098}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict([(\"sape\", 4139), (\"guido\", 4127), (\"jack\", 4098)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для создания словарей из произвольных выражений для ключей и значений можно\n",
    "использовать синтаксис, аналогичный списковым включениям."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: 4, 3: 9, 4: 16, 5: 25}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Квадраты чисел\n",
    "{x_: x_**2 for x_ in (2, 3, 4, 5)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.5.1 . Методы словарей\n",
    "\n",
    "сору() -  Возвращает копиию словаря\n",
    "clear() -  Удаляет все элементы из словаря\n",
    "рор() -  Возвращает значение ключа и удаляет эту пару из словаря\n",
    "popitem() -  Удаляет произвольную пару из словаря и возвращает ее как кортеж\n",
    "get() -  Обычный метод доступа к значению ключа\n",
    "values() -  Возвращает список всех значений словаря\n",
    "str() -  Создает строковое представление словаря\n",
    "update() -  Добавляет в словарь или обновляет пары из другого словаря\n",
    "setdefault() -  Возвращает значение ключа, если он есть в словаре, или добавляет его\n",
    "в словарь со значением по умолчанию\n",
    "keys() -  Возвращает список всех ключей словаря\n",
    "items() -  Возвращает список, содержащий кортеж для каждой пары «ключ - значение»\n",
    "has_key() -  Возвращает true, если ключ присутствует в словаре, иначе false\n",
    "fromkeys() -  Создает новый словарь с ключами из указанной последовательности\n",
    "и заданными значениями по умолчанию\n",
    "type() -  Возвращает тип переданной переменной\n",
    "cmp() -  Сравнивает элементы двух словарей"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.6. Перебор последовательностей в цикле\n",
    "При циклическом просмотре словаря ключ и соответствующее значение можно\n",
    "получить одновременно с помощью метода items()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gallahad the pure\n",
      "Robin the brave\n"
     ]
    }
   ],
   "source": [
    "knights = {\"Gallahad\": \"the pure\", \"Robin\": \"the brave\"}\n",
    "for k_, v_ in knights.items():\n",
    "    print(k_, v_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При переборе последовательности индекс позиции и соответствующее значение\n",
    "можно получить одновременно с помощью функции enumerate()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 tic\n",
      "1 tac\n",
      "2 toe\n"
     ]
    }
   ],
   "source": [
    "for i_, v_ in enumerate([\"tic\", \"tac\", \"toe\"]):\n",
    "    print(i_, v_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При совместном переборе двух или более последовательностей можно объединять\n",
    "записи с помощью функции zip()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " What is your name? It is Lancelot.\n",
      " What is your quest? It is the Holy Grail.\n",
      " What is your favorite color? It is blue.\n"
     ]
    }
   ],
   "source": [
    "questions = [\"name\", \"quest\", \"favorite color\"]\n",
    "answers = [\"Lancelot\", \"the Holy Grail\", \"blue\"]\n",
    "for q_, a_ in zip(questions, answers):\n",
    "    print(f\" What is your {q_}? It is {a_}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы перебрать последовательность в обратном порядке, сначала укажите после\n",
    "довательность в прямом порядке, а затем вызовите функцию reversed()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "7\n",
      "5\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for i_ in reversed(range(1, 10, 2)):\n",
    "    print(i_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы перебрать последовательность в отсортированном порядке, используйте\n",
    "функцию sorted(), которая возвращает новый отсортированный список, оставляя\n",
    "исходный список неизменным."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "orange\n",
      "pear\n"
     ]
    }
   ],
   "source": [
    "basket = [\"apple\", \"orange\", \"apple\", \"pear\", \"orange\", \"banana\"]\n",
    "for f_ in sorted(set(basket)):\n",
    "    print(f_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.7. Резюме\n",
    "1. Я изучила строки и их методы, форматирование и операции, как можно изменять строки, \n",
    "хотя они и неизменяемы.\n",
    "2. Узнала, что списки - это один из самых популярных типов данных, в котором можно \n",
    "хранить что угодно, они изменяемы, и ими можно элегантно управлять с помощью списковых\n",
    "включений.\n",
    "3. Изучила такой тп данных, как кортежи, которые очень похожи на списки, но они неизме-\n",
    "няемы, поэтому используются по-другому.\n",
    "4. Изучила множества, узнала,что они не упорядочены, и, следовательно, от них нельзя\n",
    "брать индекс или срез, как от списков. Они содержат только уникальные значения и\n",
    "используются там, где нужна определенная функциональность.\n",
    "5. Изучила словари, данные в которых хранятся в виде пар «ключ - значение». "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.8.1. Ответьте на вопросы\n",
    "1. В чем разница между числами и строками в Python? Они взаимозаменяемы?\n",
    "Ответ:\n",
    "Числа и строки - это два разных класса в Python Int и str. Они не взаимоваменяемые.\n",
    "2. Как работает новый метод форматирования строк, представленный в версии\n",
    "Python 3.6?\n",
    "Ответ: Этот метод называется f -строками f' '\n",
    "3 . Какие типы данных и последовательности могут храниться в списке?\n",
    "Ответ: любые\n",
    "4. Какой результат даст приведенный оператор? Обоснуйте ответ.\n",
    "print ('let\\'s get back to work')\n",
    "Вывод строки на экран.\n",
    "5. Списки можно изменять, но кортежи неизменяемы. Как вы понимаете это ут-\n",
    "верждение? Как это влияет на использование обоих этих типов данных?\n",
    "К спискам могут быть применимы методы, которые вносят изменения, по сути \n",
    "списки - это всего лишь контейнеры для хранения различных типов данных. в \n",
    "то время как к кортежам такие методы пременены быть не могут, следовательно они\n",
    "используются, когда необходимо защитить данные от изменений. Также они занимают\n",
    "меньше места, операции над ними намного быстрее.\n",
    "6. Какому оператору эквивалентны списковые включения? Чем они полезнее?\n",
    "оператору for\n",
    "Списковые включения - элегантнее и быстрее.\n",
    "7. Кортежи представляют собой упорядоченную коллекцию, а множества - не\n",
    "упорядоченную коллекцию. Как вы понимаете это утверждение? Как это влияет\n",
    "на использование обоих этих типов?\n",
    "Упорядоченная коллекция - это такая коллекция, у которой каждый элемент находится\n",
    "на определенном месте и имеет свой индекс.Соответственно к элементам неупорядоченных \n",
    "коллекций нельзя получить доступ через индекс. Часто можества используют для того,\n",
    "чтобы убрать дубликаты.\n",
    "8. Если требуется хранить уникальные элементы любого текста или коллекции, какой\n",
    "тип лучше использовать? Приведите пример, когда это может быть полезно.\n",
    "Уникальные элементы могут хранится в словарях в качестве ключей.\n",
    "9. Являются ли словари итерируемыми? Продумайте ответ.\n",
    "Словари являются итерируемыми"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Одну и ту же строку можно изменять с помощью строковых методов и сохра  -\n",
    "нять ее в той же области памяти. ЛОЖЬ\n",
    "2. Операция умножения строки на число возвращает строку с повторяющимися\n",
    "значениями. ПРАВДА\n",
    "3. Строки различаются в зависимости от используемых кавычек.ЛОЖЬ\n",
    "4. Индексирование работает со строками и списками, но не со множествами. ЛОЖЬ\n",
    "5. В списках может храниться только один тип данных. ЛОЖЬ\n",
    "6. Вставлять новое значение в кортеж нельзя. ПРАВДА\n",
    "7. Списковые включения - это элегантный метод управления списками. ПРАВДА\n",
    "8. Кортеж может содержать разные типы данных. ПРАВДА\n",
    "9. Кортежи заключаются в круглые скобки( ) , а списки заключаются в квадратные\n",
    "скобки[ ]. ПРАВА\n",
    "10. В словаре количество ключей и значений не обязательно должно быть одина\n",
    "ковым. ПРАВДА"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 . Используйте списковые включения для создания следующих списков:\n",
    "а) [ ' С ' , ' О ' , ' U ' , ' N ' , ' Т ' , ' R ' , ' У ' ]\n",
    "б) [ ' С ' , ' А ' , ' Т ' , ' СС ' , ' АА ' , ' ТТ ' , ' ССС ' , ' ААА ' , ' ТТТ ' ]\n",
    "в) [ [ 2 ] , [ 3 ] , [ 4 ] , [ 3 ] , [ 4 ] , [ 5 ] , [ 4 ] , [ 5 ] , [ 6 ] ]\n",
    "г) [ [ 2 , 3 , 4 , 5 ] , [ 3 , 4 , 5 , 6 ] , [ 4 , 5 , 6 , 7 ] , ( 5 , 6 , 7 , 8 ] ]\n",
    "д) [ ( 1 , 1 ) , ( 2 , 1 ) , ( 3 , 1 ) , ( 1 , 2 ) , ( 2 , 2 ) , ( 3 , 2 ) , ( 1 , 3 ) , ( 2 , 3 ) , ( 3 , 3 ) ]\n",
    "е) [ 0 , 1 , 4 , 9 , 1 6 , 2 5 , 3 6, 4 9 , 64 , 8 1 ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C', 'O', 'U', 'N', 'T', 'R', 'Y']\n"
     ]
    }
   ],
   "source": [
    "print(list(\"COUNTRY\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['C', 'A', 'T', 'CC', 'AA', 'TT', 'CCC', 'AAA', 'TTT']\n"
     ]
    }
   ],
   "source": [
    "print([char * i_ for i_ in range(1, 4) for char in \"CAT\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2], [3], [4], [3], [4], [5], [4], [5], [6]]\n"
     ]
    }
   ],
   "source": [
    "print([[j_] for i_ in range(3) for j_ in range(i_ + 2, i_ + 2 + 3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]\n"
     ]
    }
   ],
   "source": [
    "print([list(range(i_ + 2, i_ + 2 + 4)) for i_ in range(4)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 1), (2, 1), (3, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3)]\n"
     ]
    }
   ],
   "source": [
    "print([(j_, i_) for i_ in range(1, 4) for j_ in range(1, 4)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "print([i_**2 for i_ in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Создайте пустой список. Допустим, он называется my_list. Заполните его\n",
    "50 числами от 1 до 25 (числа могут повторяться)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 6, 8, 15, 5, 6, 12, 12, 4, 14, 16, 12, 22, 9, 7, 18, 24, 10, 14, 13, 1, 4, 2, 7, 13, 22, 7, 3, 2, 19, 13, 18, 25, 3, 4, 5, 17, 9, 1, 7, 5, 16, 7, 18, 6, 21, 1, 10, 10, 1]\n"
     ]
    }
   ],
   "source": [
    "my_list = [random.randint(1, 25) for _ in range(50)]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. В списке my_list, созданном в предыдущем пункте, выполните поиск и узнайте, есть ли в нем числа 11, 18 и 20.\n",
    "Напишите код для поиска этих чисел. Кроме того, подсчитайте, сколько раз встречаются эти числа в списке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Число 11 не входит в список my_list\n",
      "Число 18 входит в список my_list 3 раз\n",
      "Число 20 не входит в список my_list\n"
     ]
    }
   ],
   "source": [
    "for num in (11, 18, 20):\n",
    "    if num in my_list:\n",
    "        print(f\"Число {num} входит в список my_list {my_list.count(num)} раз\")\n",
    "    else:\n",
    "        print(f\"Число {num} не входит в список my_list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Напишите код для вывода информации о том, сколько четных и нечетных чисел\n",
    "в списке my_list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_even(lst: List[int]) -> int:\n",
    "    \"\"\"Find quantity of even numbers.\"\"\"\n",
    "    return len(list(x_ for x_ in lst if x_ % 2 == 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Четных чисел в списке my_list: 25\n"
     ]
    }
   ],
   "source": [
    "print(f\"Четных чисел в списке my_list: {get_even(my_list)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def odd(lst: List[int]) -> int:\n",
    "    \"\"\"Find quantity of odd numbers.\"\"\"\n",
    "    return len(list(x_ for x_ in lst if x_ % 2 != 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Нечетных чисел в списке my_list: 25\n"
     ]
    }
   ],
   "source": [
    "print(f\"Нечетных чисел в списке my_list: {odd(my_list)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Напишите код для создания из my_list другого списка, в котором числа равны\n",
    "квадрату чисел в my_list, но в обратном порядке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reversed_sqrts(lst: List[int]) -> List[int]:\n",
    "    \"\"\"Find square of numbers.\"\"\"\n",
    "    sqrts = [x_**2 for x_ in lst]\n",
    "    return list(reversed(sqrts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 100, 100, 1, 441, 36, 324, 49, 256, 25, 49, 1, 81, 289, 25, 16, 9, 625, 324, 169, 361, 4, 9, 49, 484, 169, 49, 4, 16, 1, 169, 196, 100, 576, 324, 49, 81, 484, 144, 256, 196, 16, 144, 144, 36, 25, 225, 64, 36, 49]\n"
     ]
    }
   ],
   "source": [
    "print(reversed_sqrts(my_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.Напишите функцию sorted_list(), которая принимает в качестве параметра спи-\n",
    "сок и возвращает True, если список отсортирован в порядке возрастания, и False\n",
    "в противном случае. В качестве дополнительного условия вы можете считать,\n",
    "что элементы списка можно сравнивать с помощью операторов отношения <, >\n",
    "и т. д."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_sorted(lst: List[int], reverse: bool = False) -> bool:\n",
    "    \"\"\"Define sorted list.\"\"\"\n",
    "    return all(\n",
    "        lst[i_] <= lst[i_ + 1] if not reverse else lst[i_] >= lst[i_ + 1]\n",
    "        for i_ in range(len(lst) - 1)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(is_sorted(my_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(is_sorted(list(sorted(my_list))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Напишите программу Python для вывода имен и номеров телефонов 10 ваших друзей, сохранения их в словаре и вывода номера телефона по заданному имени."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "telephone_book: Dict[str, List[str]] = {}  # Correct type annotation\n",
    "for _ in range(10):\n",
    "    name, number = input(\"Введите имя и номер \").split()\n",
    "    if name in telephone_book:\n",
    "        telephone_book[name].append(number)  # Append number \n",
    "        telephone_book[name] = [number]  # Create a new list with the number\n",
    "\n",
    "print(telephone_book)\n",
    "\n",
    "while True:\n",
    "    searching_name = input(\"Введите имя для поиска (или 'end'): \")\n",
    "    if searching_name == \"end\":\n",
    "        break\n",
    "    if searching_name in telephone_book:\n",
    "        print(f\"Номера для {searching_name}: {telephone_book[searching_name]}\")\n",
    "    else:\n",
    "        print(\"Нет в телефонной книге\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Напишите функцию, remove_duplicates(), которая принимает в качестве параметра список и возвращает новый список, содержащий только уникальные элементы из первого списка. Подсказка: они не обязательно должны сохранять порядок."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[81, 39, 97, 75, 16, 18, 73, 83, 100, 4, 90, 39, 52, 50, 53, 96, 9, 61, 65, 38, 100, 49, 53, 42, 4, 39, 17, 12, 48, 92]\n",
      "[4, 9, 12, 16, 17, 18, 38, 39, 42, 48, 49, 50, 52, 53, 61, 65, 73, 75, 81, 83, 90, 92, 96, 97, 100]\n"
     ]
    }
   ],
   "source": [
    "def remove_duplicates(lst: List[int]) -> list[int]:\n",
    "    \"\"\"Remove_duplicates.\"\"\"\n",
    "    return list(set(lst))\n",
    "\n",
    "\n",
    "my_list = [random.randint(1, 100) for _ in range(30)]\n",
    "print(my_list)\n",
    "print(remove_duplicates(my_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Напишите функцию для вычисления произведения элементов списка. Что произойдет, если в функцию передать список строк?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'random' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[1], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m my_list \u001b[38;5;241m=\u001b[39m [\u001b[43mrandom\u001b[49m\u001b[38;5;241m.\u001b[39mrandint(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m100\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m10\u001b[39m)]\n\u001b[0;32m      2\u001b[0m product \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i_ \u001b[38;5;129;01min\u001b[39;00m my_list:\n",
      "\u001b[1;31mNameError\u001b[0m: name 'random' is not defined"
     ]
    }
   ],
   "source": [
    "my_list = [random.randint(1, 100) for _ in range(10)]\n",
    "product = 1\n",
    "for i_ in my_list:\n",
    "    product *= i_\n",
    "\n",
    "print(f\"Весь список: {my_list}\")\n",
    "print(f\"Произведение элементов списка: {product}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}