Python/made_easy/ipynb/chapter_8_data_structures_and_sequence.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Глава 8. Структуры данных и последовательности.\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Глава 8. Структуры данных и последовательности\n",
    "\n",
    "## 8.1. Строки\n",
    "\n",
    "### 8.1.1. Строковые операции\n",
    "\n",
    "Основные характеристики:\n",
    "- Строки являются объектами (экземплярами класса str)\n",
    "- Строки неизменяемы\n",
    "- Поддерживают различные методы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Оригинал: python example\n",
      "Заглавные: Python example\n",
      "Верхний регистр: PYTHON EXAMPLE\n",
      "Смена регистра: PYTHON EXAMPLE\n"
     ]
    }
   ],
   "source": [
    "def demonstrate_string_methods(text: str) -> None:\n",
    "    \"\"\"Демонстрация основных строковых методов.\n",
    "\n",
    "    Args:\n",
    "        text: Исходный текст для демонстрации\n",
    "    \"\"\"\n",
    "    print(f\"Оригинал: {text}\")\n",
    "    print(f\"Заглавные: {text.capitalize()}\")\n",
    "    print(f\"Верхний регистр: {text.upper()}\")\n",
    "    print(f\"Смена регистра: {text.swapcase()}\")\n",
    "\n",
    "\n",
    "# Результат:\n",
    "# Оригинал: python example\n",
    "# Заглавные: Python example\n",
    "# Верхний регистр: PYTHON EXAMPLE\n",
    "# Смена регистра: PYTHON EXAMPLE\n",
    "demonstrate_string_methods(\"python example\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.1.2. Форматирование строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Язык Python версии 3.9\n",
      "    Python\n",
      "Python    \n",
      "  Python  \n",
      "3.90\n"
     ]
    }
   ],
   "source": [
    "def show_string_formatting() -> None:\n",
    "    \"\"\"Демонстрация различных способов форматирования строк.\"\"\"\n",
    "    name = \"Python\"\n",
    "    version = 3.9\n",
    "\n",
    "    # Все примеры с f-строками\n",
    "\n",
    "    # Базовое форматирование\n",
    "    print(f\"Язык {name} версии {version}\")\n",
    "\n",
    "    # Выравнивание\n",
    "    print(f\"{name:>10}\")  # выравнивание вправо\n",
    "    print(f\"{name:<10}\")  # выравнивание влево\n",
    "    print(f\"{name:^10}\")  # центрирование\n",
    "\n",
    "    # Форматирование чисел\n",
    "    print(f\"{version:.2f}\")  # два знака после запятой\n",
    "\n",
    "\n",
    "# Результат:\n",
    "# Язык Python версии 3.9\n",
    "#     Python\n",
    "# Python\n",
    "#   Python\n",
    "# 3.90\n",
    "show_string_formatting()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.2. Списки\n",
    "Свойства списков:\n",
    "\n",
    "- Упорядоченность\n",
    "- Изменяемость\n",
    "- Итерируемость"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "После append: [1, 2, 3, 4, 5, 6]\n",
      "После insert: [0, 1, 2, 3, 4, 5, 6]\n",
      "После pop: [0, 1, 2, 3, 4, 5], удален: 6\n"
     ]
    }
   ],
   "source": [
    "def demonstrate_list_operations() -> None:\n",
    "    \"\"\"Демонстрация основных операций со списками.\"\"\"\n",
    "    numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "    # Добавление элементов\n",
    "    numbers.append(6)\n",
    "    print(f\"После append: {numbers}\")\n",
    "\n",
    "    # Вставка элемента\n",
    "    numbers.insert(0, 0)\n",
    "    print(f\"После insert: {numbers}\")\n",
    "\n",
    "    # Удаление элемента\n",
    "    removed_item = numbers.pop()\n",
    "    print(f\"После pop: {numbers}, удален: {removed_item}\")\n",
    "\n",
    "\n",
    "# Результат:\n",
    "# После append: [1, 2, 3, 4, 5, 6]\n",
    "# После insert: [0, 1, 2, 3, 4, 5, 6]\n",
    "# После pop: [0, 1, 2, 3, 4, 5], удален: 6\n",
    "demonstrate_list_operations()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.3. Кортежи\n",
    "Основные характеристики:\n",
    "\n",
    "- Неизменяемость\n",
    "- Упорядоченность\n",
    "- Возможность содержать разные типы данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Точка: (10, 20)\n",
      "Координаты: ((10, 20), (30, 40))\n",
      "X: 10, Y: 20\n"
     ]
    }
   ],
   "source": [
    "def demonstrate_tuple_usage() -> None:\n",
    "    \"\"\"Демонстрация работы с кортежами.\"\"\"\n",
    "    # Создание кортежа\n",
    "    point = (10, 20)\n",
    "    coordinates = point, (30, 40)  # Вложенные кортежи\n",
    "\n",
    "    print(f\"Точка: {point}\")\n",
    "    print(f\"Координаты: {coordinates}\")\n",
    "\n",
    "    # Распаковка кортежа\n",
    "    x_coord, y_coord = point\n",
    "    print(f\"X: {x_coord}, Y: {y_coord}\")\n",
    "\n",
    "\n",
    "# Результат:\n",
    "# Точка: (10, 20)\n",
    "# Координаты: ((10, 20), (30, 40))\n",
    "# X: 10, Y: 20\n",
    "demonstrate_tuple_usage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.4. Множества\n",
    "Характеристики множеств:\n",
    "\n",
    "- Неупорядоченность\n",
    "- Уникальность элементов\n",
    "- Поддержка математических операций"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Объединение: {1, 2, 3, 4, 5, 6, 7, 8}\n",
      "Пересечение: {4, 5}\n",
      "Разность A-B: {1, 2, 3}\n",
      "Симметричная разность: {1, 2, 3, 6, 7, 8}\n"
     ]
    }
   ],
   "source": [
    "def demonstrate_set_operations() -> None:\n",
    "    \"\"\"Демонстрация операций с множествами.\"\"\"\n",
    "    set_a = {1, 2, 3, 4, 5}\n",
    "    set_b = {4, 5, 6, 7, 8}\n",
    "\n",
    "    print(f\"Объединение: {set_a | set_b}\")\n",
    "    print(f\"Пересечение: {set_a & set_b}\")\n",
    "    print(f\"Разность A-B: {set_a - set_b}\")\n",
    "    print(f\"Симметричная разность: {set_a ^ set_b}\")\n",
    "\n",
    "\n",
    "# Результат:\n",
    "# Объединение: {1, 2, 3, 4, 5, 6, 7, 8}\n",
    "# Пересечение: {4, 5}\n",
    "# Разность A-B: {1, 2, 3}\n",
    "# Симметричная разность: {1, 2, 3, 6, 7, 8}\n",
    "demonstrate_set_operations()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.5. Словари\n",
    "Особенности словарей:\n",
    "\n",
    "- Хранение пар ключ-значение\n",
    "- Уникальность ключей\n",
    "- Изменяемость"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "После добавления: {'name': 'Анна', 'age': 20, 'courses': ['Python', 'Data Science'], 'grade': 4.5}\n",
      "Имя: Анна\n",
      "После удаления возраста: {'name': 'Анна', 'courses': ['Python', 'Data Science'], 'grade': 4.5}\n"
     ]
    }
   ],
   "source": [
    "def demonstrate_dict_operations() -> None:\n",
    "    \"\"\"Демонстрация операций со словарями.\"\"\"\n",
    "    stud = {\"name\": \"Анна\", \"age\": 20, \"courses\": [\"Python\", \"Data Science\"]}\n",
    "\n",
    "    # Добавление элемента\n",
    "    stud[\"grade\"] = 4.5\n",
    "    print(f\"После добавления: {stud}\")\n",
    "\n",
    "    # Получение значения\n",
    "    print(f\"Имя: {stud.get('name')}\")\n",
    "\n",
    "    # Удаление элемента\n",
    "    stud.pop(\"age\")\n",
    "    print(f\"После удаления возраста: {stud}\")\n",
    "\n",
    "\n",
    "# Результат:\n",
    "# После добавления: {'name': 'Анна', 'age': 20,\n",
    "#                    'courses': ['Python', 'Data Science'], 'grade': 4.5}\n",
    "# Имя: Анна\n",
    "# После удаления возраста: {'name': 'Анна',\n",
    "#                          'courses': ['Python', 'Data Science'], 'grade': 4.5}\n",
    "demonstrate_dict_operations()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.6. Перебор последовательностей в цикле"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: яблоко\n",
      "1: банан\n",
      "2: апельсин\n",
      "красный = red\n",
      "синий = blue\n",
      "имя: Алиса\n",
      "возраст: 25\n"
     ]
    }
   ],
   "source": [
    "def demonstrate_iterations() -> None:\n",
    "    \"\"\"Демонстрация различных способов перебора последовательностей.\"\"\"\n",
    "    # Перебор с enumerate\n",
    "    fruits = [\"яблоко\", \"банан\", \"апельсин\"]\n",
    "    for index, fruit in enumerate(fruits):\n",
    "        print(f\"{index}: {fruit}\")\n",
    "\n",
    "    # Перебор словаря\n",
    "    colors = {\"красный\": \"red\", \"синий\": \"blue\"}\n",
    "    for russian, english in colors.items():\n",
    "        print(f\"{russian} = {english}\")\n",
    "\n",
    "    # Использование zip\n",
    "    questions = [\"имя\", \"возраст\"]\n",
    "    answers = [\"Алиса\", \"25\"]\n",
    "    for question, answer in zip(questions, answers):\n",
    "        print(f\"{question}: {answer}\")\n",
    "\n",
    "\n",
    "# Результат:\n",
    "# 0: яблоко\n",
    "# 1: банан\n",
    "# 2: апельсин\n",
    "# красный = red\n",
    "# синий = blue\n",
    "# имя: Алиса\n",
    "# возраст: 25\n",
    "demonstrate_iterations()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.7. Резюме\n",
    "В этой главе мы изучили:\n",
    "\n",
    "- Основные структуры данных Python\n",
    "- Операции со строками и их форматирование\n",
    "- Работу со списками и их методы\n",
    "- Особенности кортежей\n",
    "- Операции с множествами\n",
    "- Работу со словарями\n",
    "- Различные способы перебора последовательностей"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.8. Упражнения\n",
    "\n",
    "## 8.8.1. Вопросы и ответы\n",
    "\n",
    "1. **В чем разница между числами и строками в Python? Они взаимозаменяемы?**\n",
    "   - Числа представляют собой числовые значения для математических операций\n",
    "   - Строки - это последовательности символов для текстовых данных\n",
    "   - Они не взаимозаменяемы напрямую, но могут быть преобразованы друг в друга с помощью функций str() и int()/float()\n",
    "\n",
    "2. **Как работает новый метод форматирования строк, представленный в версии Python 3.6?**\n",
    "   - Это f-строки, которые начинаются с буквы f перед кавычками\n",
    "   - Позволяют вставлять значения переменных прямо в строку, используя синтаксис {переменная}\n",
    "   - Поддерживают выражения и вызовы функций внутри фигурных скобок\n",
    "   - Более читаемы и удобны, чем метод .format()\n",
    "\n",
    "3. **Какие типы данных и последовательности могут храниться в списке?**\n",
    "   - Любые типы данных: числа, строки, булевы значения\n",
    "   - Другие последовательности: списки, кортежи, множества\n",
    "   - Словари\n",
    "   - Объекты любых классов\n",
    "   - Различные типы данных могут быть смешаны в одном списке\n",
    "\n",
    "4. **Какой результат даст приведенный оператор? Обоснуйте ответ:**\n",
    "   ```python\n",
    "   print(\"let's get back to work\")\n",
    "   ```\n",
    "   Результат: `let's get back to work`\n",
    "   - Обратный слеш (\\) используется для экранирования одинарной кавычки\n",
    "   - Позволяет включить кавычку в строку, не нарушая её структуру\n",
    "\n",
    "5. **Списки можно изменять, но кортежи неизменяемы. Как это влияет на использование обоих типов данных?**\n",
    "   - Списки подходят для данных, которые могут меняться во время выполнения программы\n",
    "   - Кортежи используются для данных, которые должны оставаться неизменными\n",
    "   - Кортежи более эффективны по памяти и быстрее в обработке\n",
    "   - Кортежи могут использоваться как ключи словарей, а списки - нет\n",
    "\n",
    "6. **Какому оператору эквивалентны списковые включения? Чем они полезнее?**\n",
    "   - Эквивалентны циклу for с условием if\n",
    "   - Более компактны и читаемы\n",
    "   - Обычно работают быстрее, чем эквивалентный цикл\n",
    "   - Пример:\n",
    "     ```python\n",
    "     # Списковое включение\n",
    "     squares = [x**2 for x in range(10)]\n",
    "\n",
    "     # Эквивалентный цикл\n",
    "     squares = []\n",
    "     for x in range(10):\n",
    "         squares.append(x**2)\n",
    "     ```\n",
    "\n",
    "7. **Кортежи представляют собой упорядоченную коллекцию, а множества - неупорядоченную коллекцию. Как это влияет на использование обоих типов?**\n",
    "   - В кортежах важен порядок элементов, они доступны по индексам\n",
    "   - В множествах порядок не гарантируется, нет доступа по индексам\n",
    "   - Кортежи могут содержать дубликаты, множества - только уникальные элементы\n",
    "   - Множества оптимизированы для проверки наличия элементов и операций над множествами\n",
    "\n",
    "8. **Если требуется хранить уникальные элементы любого текста или коллекции, какой тип лучше использовать?**\n",
    "   - Множества (set) идеально подходят для хранения уникальных элементов\n",
    "   - Пример:\n",
    "     ```python\n",
    "     text = \"hello hello world\"\n",
    "     unique_letters = set(text)  # {'h', 'e', 'l', 'o', 'w', 'r', 'd', ' '}\n",
    "     ```\n",
    "   - Полезно для:\n",
    "     - Удаления дубликатов\n",
    "     - Подсчета уникальных элементов\n",
    "     - Быстрой проверки наличия элемента\n",
    "\n",
    "9. **Являются ли словари итерируемыми?**\n",
    "   - Да, словари итерируемы\n",
    "   - По умолчанию итерация идет по ключам\n",
    "   - Можно итерировать по:\n",
    "     - Ключам (dict.keys())\n",
    "     - Значениям (dict.values())\n",
    "     - Парам ключ-значение (dict.items())\n",
    "\n",
    "## 8.8.2. Правда или ложь\n",
    "\n",
    "1. **Одну и ту же строку можно изменять с помощью строковых методов и сохранять её в той же области памяти.**\n",
    "   - Ложь\n",
    "   - Строки неизменяемы, методы создают новые строки\n",
    "\n",
    "2. **Операция умножения строки на число возвращает строку с повторяющимися значениями.**\n",
    "   - Правда\n",
    "   - Пример: \"ha\" * 3 == \"hahaha\"\n",
    "\n",
    "3. **Строки различаются в зависимости от используемых кавычек.**\n",
    "   - Ложь\n",
    "   - 'строка' == \"строка\" == \"\"\"строка\"\"\"\n",
    "\n",
    "4. **Индексирование работает со строками и списками, но не со множествами.**\n",
    "   - Правда\n",
    "   - Множества неупорядочены и не поддерживают индексацию\n",
    "\n",
    "5. **В списках может храниться только один тип данных.**\n",
    "   - Ложь\n",
    "   - Списки могут содержать элементы разных типов\n",
    "\n",
    "6. **Вставлять новое значение в кортеж нельзя.**\n",
    "   - Правда\n",
    "   - Кортежи неизменяемы\n",
    "\n",
    "7. **Списковые включения - это элегантный метод управления списками.**\n",
    "   - Правда\n",
    "   - Они более читаемы и часто эффективнее циклов\n",
    "\n",
    "8. **Кортеж может содержать разные типы данных.**\n",
    "   - Правда\n",
    "   - Как и списки, кортежи могут содержать элементы разных типов\n",
    "\n",
    "9. **Кортежи заключаются в круглые скобки ( ), а списки заключаются в квадратные скобки [ ].**\n",
    "   - Правда\n",
    "   - Это один из способов их различать\n",
    "\n",
    "10. **В словаре количество ключей и значений не обязательно должно быть одинаковым.**\n",
    "    - Ложь\n",
    "    - Каждый ключ должен иметь ровно одно значение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.8.3. Практические задания\n",
    "\n",
    "## Задание 1\n",
    "**Используйте списковые включения для создания следующих списков:**\n",
    "\n",
    "### а) ['C', 'O', 'U', 'N', 'T', 'R', 'Y']\n",
    "```python\n",
    "def create_country_list() -> list[str]:\n",
    "    \"\"\"Создание списка букв из слова 'COUNTRY'.\"\"\"\n",
    "    return [char for char in \"COUNTRY\"]\n",
    "\n",
    "\n",
    "# Результат: ['C', 'O', 'U', 'N', 'T', 'R', 'Y']\n",
    "print(create_country_list())\n",
    "```\n",
    "\n",
    "### б) ['C', 'A', 'T', 'CC', 'AA', 'TT', 'CCC', 'AAA', 'TTT']\n",
    "```python\n",
    "def create_pattern_list() -> list[str]:\n",
    "    \"\"\"Создание списка с повторяющимися буквами.\"\"\"\n",
    "    letters = [\"C\", \"A\", \"T\"]\n",
    "    return [letter * count for letter in letters for count in range(1, 4)]\n",
    "\n",
    "\n",
    "# Результат: ['C', 'A', 'T', 'CC', 'AA', 'TT', 'CCC', 'AAA', 'TTT']\n",
    "print(create_pattern_list())\n",
    "```\n",
    "\n",
    "### в) [[2], [3], [4], [3], [4], [5], [4], [5], [6]]\n",
    "```python\n",
    "def create_nested_lists() -> list[list[int]]:\n",
    "    \"\"\"Создание списка вложенных списков с числами.\"\"\"\n",
    "    return [[j] for i in range(2, 5) for j in range(i, i + 3)]\n",
    "\n",
    "\n",
    "# Результат: [[2], [3], [4], [3], [4], [5], [4], [5], [6]]\n",
    "print(create_nested_lists())\n",
    "```\n",
    "\n",
    "### г) [[2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]\n",
    "```python\n",
    "def create_sequential_lists() -> list[list[int]]:\n",
    "    \"\"\"Создание списка последовательностей чисел.\"\"\"\n",
    "    return [list(range(i, i + 4)) for i in range(2, 6)]\n",
    "\n",
    "\n",
    "# Результат: [[2, 3, 4, 5], [3, 4, 5, 6], [4, 5, 6, 7], [5, 6, 7, 8]]\n",
    "print(create_sequential_lists())\n",
    "```\n",
    "\n",
    "### д) [(1, 1), (2, 1), (3, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3)]\n",
    "```python\n",
    "def create_coordinate_pairs() -> list[tuple[int, int]]:\n",
    "    \"\"\"Создание списка координатных пар.\"\"\"\n",
    "    return [(x, y) for y in range(1, 4) for x in range(1, 4)]\n",
    "\n",
    "\n",
    "# Результат: [(1, 1), (2, 1), (3, 1), (1, 2), (2, 2), (3, 2), (1, 3), (2, 3), (3, 3)]\n",
    "print(create_coordinate_pairs())\n",
    "```\n",
    "\n",
    "### е) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
    "```python\n",
    "def create_squares() -> list[int]:\n",
    "    \"\"\"Создание списка квадратов чисел.\"\"\"\n",
    "    return [i**2 for i in range(10)]\n",
    "\n",
    "\n",
    "# Результат: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
    "print(create_squares())\n",
    "```\n",
    "\n",
    "## Задание 2\n",
    "**Создайте пустой список и заполните его 50 числами от 1 до 25 (числа могут повторяться).**\n",
    "\n",
    "```python\n",
    "from random import randint\n",
    "\n",
    "\n",
    "def create_random_list(size: int = 50, max_value: int = 25) -> list[int]:\n",
    "    \"\"\"\n",
    "    Создание списка случайных чисел.\n",
    "\n",
    "    Args:\n",
    "        size: Размер списка\n",
    "        max_value: Максимальное значение числа\n",
    "\n",
    "    Returns:\n",
    "        Список случайных чисел\n",
    "    \"\"\"\n",
    "    return [randint(1, max_value) for _ in range(size)]\n",
    "\n",
    "\n",
    "# Пример использования:\n",
    "my_list = create_random_list()\n",
    "print(f\"Созданный список: {my_list}\")\n",
    "print(f\"Длина списка: {len(my_list)}\")\n",
    "```\n",
    "\n",
    "## Задание 3\n",
    "**Поиск чисел 11, 18 и 20 в списке и подсчет их количества.**\n",
    "\n",
    "```python\n",
    "def find_and_count_numbers(numbers: list[int]) -> dict[int, int]:\n",
    "    \"\"\"\n",
    "    Поиск и подсчет заданных чисел в списке.\n",
    "\n",
    "    Args:\n",
    "        numbers: Список чисел для анализа\n",
    "\n",
    "    Returns:\n",
    "        Словарь с количеством каждого числа\n",
    "    \"\"\"\n",
    "    search_numbers = {11, 18, 20}\n",
    "    return {num: numbers.count(num) for num in search_numbers}\n",
    "\n",
    "\n",
    "# Пример использования:\n",
    "my_list = create_random_list()\n",
    "results = find_and_count_numbers(my_list)\n",
    "for num, count in results.items():\n",
    "    print(f\"Число {num} встречается {count} раз\")\n",
    "```\n",
    "\n",
    "## Задание 4\n",
    "**Подсчет четных и нечетных чисел в списке.**\n",
    "\n",
    "```python\n",
    "def count_even_odd(numbers: list[int]) -> tuple[int, int]:\n",
    "    \"\"\"\n",
    "    Подсчет четных и нечетных чисел.\n",
    "\n",
    "    Args:\n",
    "        numbers: Список чисел для анализа\n",
    "\n",
    "    Returns:\n",
    "        Кортеж (количество_четных, количество_нечетных)\n",
    "    \"\"\"\n",
    "    even_count = len([num for num in numbers if num % 2 == 0])\n",
    "    odd_count = len(numbers) - even_count\n",
    "    return even_count, odd_count\n",
    "\n",
    "\n",
    "# Пример использования:\n",
    "my_list = create_random_list()\n",
    "even, odd = count_even_odd(my_list)\n",
    "print(f\"Четных чисел: {even}\")\n",
    "print(f\"Нечетных чисел: {odd}\")\n",
    "```\n",
    "\n",
    "## Задание 5\n",
    "**Создание списка квадратов чисел в обратном порядке.**\n",
    "\n",
    "```python\n",
    "def create_reversed_squares(numbers: list[int]) -> list[int]:\n",
    "    \"\"\"\n",
    "    Создание списка квадратов в обратном порядке.\n",
    "\n",
    "    Args:\n",
    "        numbers: Исходный список чисел\n",
    "\n",
    "    Returns:\n",
    "        Список квадратов в обратном порядке\n",
    "    \"\"\"\n",
    "    return [num**2 for num in reversed(numbers)]\n",
    "\n",
    "\n",
    "# Пример использования:\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "squares = create_reversed_squares(my_list)\n",
    "print(f\"Исходный список: {my_list}\")\n",
    "print(f\"Квадраты в обратном порядке: {squares}\")\n",
    "```\n",
    "\n",
    "## Задание 6\n",
    "**Проверка сортировки списка по возрастанию.**\n",
    "\n",
    "```python\n",
    "def sorted_list(numbers: list) -> bool:\n",
    "    \"\"\"\n",
    "    Проверка сортировки списка по возрастанию.\n",
    "\n",
    "    Args:\n",
    "        numbers: Список для проверки\n",
    "\n",
    "    Returns:\n",
    "        True если список отсортирован, иначе False\n",
    "    \"\"\"\n",
    "    return all(numbers[i] <= numbers[i + 1] for i in range(len(numbers) - 1))\n",
    "\n",
    "\n",
    "# Примеры использования:\n",
    "print(sorted_list([1, 2, 3, 4, 5]))  # True\n",
    "print(sorted_list([1, 3, 2, 4, 5]))  # False\n",
    "```\n",
    "\n",
    "## Задание 7\n",
    "**Создание телефонной книги.**\n",
    "\n",
    "```python\n",
    "def create_phone_book() -> dict[str, str]:\n",
    "    \"\"\"\n",
    "    Создание телефонной книги с вводом данных.\n",
    "\n",
    "    Returns:\n",
    "        Словарь с именами и телефонами\n",
    "    \"\"\"\n",
    "    phone_book = {}\n",
    "\n",
    "    for i in range(10):\n",
    "        name = input(f\"Введите имя {i+1}: \")\n",
    "        phone = input(f\"Введите телефон {i+1}: \")\n",
    "        phone_book[name] = phone\n",
    "\n",
    "    return phone_book\n",
    "\n",
    "\n",
    "def find_phone(phone_book: dict[str, str], name: str) -> str:\n",
    "    \"\"\"\n",
    "    Поиск телефона по имени.\n",
    "\n",
    "    Args:\n",
    "        phone_book: Телефонная книга\n",
    "        name: Имя для поиска\n",
    "\n",
    "    Returns:\n",
    "        Номер телефона или сообщение об отсутствии\n",
    "    \"\"\"\n",
    "    return phone_book.get(name, \"Номер не найден\")\n",
    "\n",
    "\n",
    "# Пример использования:\n",
    "# phone_book = create_phone_book()\n",
    "# print(find_phone(phone_book, \"Анна\"))\n",
    "```\n",
    "\n",
    "## Задание 8\n",
    "**Удаление дубликатов из списка.**\n",
    "\n",
    "```python\n",
    "def remove_duplicates(items: list) -> list:\n",
    "    \"\"\"\n",
    "    Создание списка уникальных элементов.\n",
    "\n",
    "    Args:\n",
    "        items: Исходный список\n",
    "\n",
    "    Returns:\n",
    "        Список без дубликатов\n",
    "    \"\"\"\n",
    "    return list(dict.fromkeys(items))\n",
    "\n",
    "\n",
    "# Пример использования:\n",
    "original = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]\n",
    "unique = remove_duplicates(original)\n",
    "print(f\"Исходный список: {original}\")\n",
    "print(f\"Список без дубликатов: {unique}\")\n",
    "```\n",
    "\n",
    "## Задание 9\n",
    "**Вычисление произведения элементов списка.**\n",
    "\n",
    "```python\n",
    "def multiply_list_elements(items: list) -> float:\n",
    "    \"\"\"\n",
    "    Вычисление произведения элементов списка.\n",
    "\n",
    "    Args:\n",
    "        items: Список чисел\n",
    "\n",
    "    Returns:\n",
    "        Произведение элементов\n",
    "\n",
    "    Raises:\n",
    "        TypeError: Если элементы нельзя перемножить\n",
    "    \"\"\"\n",
    "    result = 1\n",
    "    for item in items:\n",
    "        result *= item\n",
    "    return result\n",
    "\n",
    "\n",
    "# Примеры использования:\n",
    "print(multiply_list_elements([1, 2, 3, 4]))  # 24\n",
    "# print(multiply_list_elements(['a', 'b']))  # Вызовет TypeError\n",
    "```\n",
    "\n",
    "Все функции:\n",
    "1. Типизированы\n",
    "2. Имеют docstrings\n",
    "3. Следуют PEP 8\n",
    "4. Включают примеры использования\n",
    "5. Обрабатывают возможные ошибки\n",
    "\n",
    "Хотите, чтобы я добавил больше примеров использования или подробнее объяснил какое-то решение?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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
}