{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "864255d1-0a87-4d23-947f-895766366ac8",
   "metadata": {},
   "source": [
    "# Обработка данных. Часть 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46646599-e18f-4a8a-b516-53e4a5c338cc",
   "metadata": {},
   "source": [
    "## Работа со строками\n",
    "\n",
    "Строки в Python хранятся в Unicode.\n",
    "\n",
    "В Python нет отдельного типа для одного символа. Символ это `str` длинной 1.\n",
    "\n",
    "### Индексация\n",
    "\n",
    "`str` индексируются как перечисляемые типы. К ним можно применять срезы и перечислять по символам. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e6989071-2fd8-4d6e-a59a-942a59dff9a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "п\n",
      "р\n",
      "и\n",
      "в\n",
      "е\n",
      "т\n"
     ]
    }
   ],
   "source": [
    "s = \"привет\"\n",
    "s[1] == \"p\" # True\n",
    "for ss in s:\n",
    "    print(ss)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8edd0af7-7786-4683-8815-90d6a06b977b",
   "metadata": {},
   "source": [
    "### Изменение\n",
    "\n",
    "`str` нельзя изменить. "
   ]
  },
  {
   "cell_type": "raw",
   "id": "89067635-df62-4593-92b8-3c5cdfe567ae",
   "metadata": {},
   "source": [
    "s = \"привет\"\n",
    "s[1] = \"Ф\" # Ошибка"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcb07b79-39c8-4485-b83b-14c31622407d",
   "metadata": {},
   "source": [
    "Чтобы изменить строку надо создать новую из старой или превратить ее в список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0560c885-036e-4429-8bf7-f13efee423fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"привет\"\n",
    "s = s[0:1] + \"Ф\" + s[2:] # Успешно\n",
    "\n",
    "s = \"привет\"\n",
    "vs = list(s)\n",
    "vs[1] = \"Ф\"\n",
    "s = ''.join(vs) # Успешно"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b181263-9515-4b87-9789-3edb1756a355",
   "metadata": {},
   "source": [
    "### Некоторые методы\n",
    "\n",
    "#### find\n",
    "\n",
    "Поиск подстроки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "221948c3-7add-4e6d-bf04-8aab21b3ce8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"hello world\"\n",
    "x = s.find(\"world\") # x == 6\n",
    "x = s.find(\"code\") # x == -1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbe1126d-a9d7-466f-b27d-222179019eb2",
   "metadata": {},
   "source": [
    "#### startswith и endswith\n",
    "\n",
    "Проверка, что строка начинается или заканчивается на подстроку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9988347f-fd9d-4661-ae57-5c6ce0526af9",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"hello world\"\n",
    "x = s.startswith(\"hello\") # x == True\n",
    "x = s.endswith(\"code\") # x == False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd29e554-d0af-42fc-b7c7-1027b10eb7e9",
   "metadata": {},
   "source": [
    "#### Конкатенация строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6e1a2431-4eaa-4450-ad15-921c56d9059e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hello\"\n",
    "b = \"world\"\n",
    "c = a + \" \" + b #c == \"hello world\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3656fc1-7bda-4dc0-b00f-1f2a36906215",
   "metadata": {},
   "source": [
    "#### split\n",
    "\n",
    "Разбивает строку на список строк с использованием разделителя (по умолчанию пробел)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "da9f6b13-a0d8-4fb8-a5de-bebff0254725",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"goodbye|blue|sky\"\n",
    "d = s.split(\"|\") # d == ['goodbye', 'blue', 'sky']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8a163d1-8ee7-4871-b489-e26b3b8a5c50",
   "metadata": {},
   "source": [
    "#### join\n",
    "\n",
    "Собирает строку из списка строк с использованием разделителя."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "267b73f6-ba52-4027-8626-d64e334a1a2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "jp = [\"goodbye\", \"blue\", \"sky\"]\n",
    "sep = \"_\"\n",
    "s = sep.join(jp) # s == \"goodbye_blue_sky\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8707728b-5efb-408d-a606-eeb0f57edf8c",
   "metadata": {},
   "source": [
    "#### strip\n",
    "\n",
    "Удаляет из начала и конца строки пробельные символы "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "94a8c9b2-23e6-4f62-8691-79a189766902",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"\\t  goodbye blue  sky  \\n \\n\"\n",
    "d = s.strip() # d == \"goodbye blue  sky\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "771ff556-e86c-44e3-902b-89c7229fc0bd",
   "metadata": {},
   "source": [
    "#### replace\n",
    "\n",
    "Выполняет замену в строке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e5d1efe3-52fd-49bf-9624-2915e4140444",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"goodbye blue sky\"\n",
    "d = s.replace(\"blue\", \"red\") # d == \"goodbye red sky\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fe2c855-b6a5-4ce1-9f58-8201d9c09be9",
   "metadata": {},
   "source": [
    "#### encode и decode\n",
    "\n",
    "Превращают `str` в `bytes` и обратно в заданной кодировке (по умолчанию `utf8`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6fe1b67d-e7ab-424d-b2ca-cf644c9dced0",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"привет мир\"\n",
    "d = s.encode(\"cp866\")\n",
    "# d == b'\\xaf\\xe0\\xa8\\xa2\\xa5\\xe2 \\xac\\xa8\\xe0'\n",
    "q = d.decode(\"cp866\")\n",
    "# q == \"привет мир\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a24124-b3c9-4e55-8f21-878461740a94",
   "metadata": {},
   "source": [
    "#### ljust и rjust\n",
    "\n",
    "Догоняет строку заданным символом до нужной длинны. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "085059ce-84e3-44a0-952d-0670bbc73582",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"привет мир\"\n",
    "w = s.ljust(15,\"_\")\n",
    "# w == 'привет мир_____'\n",
    "q = s.rjust(15,\"_\")\n",
    "# q == '_____привет мир'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96177f10-41ce-442d-9bf8-7b6f1b74af77",
   "metadata": {},
   "source": [
    "## Подстановка в строки\n",
    "\n",
    "Методы подстановки в Python:\n",
    "* В стиле printf: `\"Привет %s!\" % (\"мир\",)`\n",
    "* В стиле format: `\"Привет {}!\".format(\"мир\")`\n",
    "* В стиле f-строк: `m = \"мир\"; f\"Привет {m}!\"`\n",
    "\n",
    "### Формирование строк в стиле printf\n",
    "\n",
    "У типа `str` предусмотрен оператор `%` который принимает вторым аргументом кортеж и подставляет его элементы на указанные в шаблоне места. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "98577c86-64f5-4fbb-a655-c121d0684272",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = \"%s = %.2f\"\n",
    "s = t % (\"A\", 42)\n",
    "# s == 'A = 42.00'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06526aee-6e47-4637-8ef6-00c4d9816ff9",
   "metadata": {},
   "source": [
    "#### Популярные форматы\n",
    "\n",
    "| Формат | Ожидаемый тип | Эффект | Варианты с модификаторами |\n",
    "| ------ | ------ | ------ | ------ |\n",
    "| `%s` | `str` | Подстановка строки | |\n",
    "| `%d` | `int` | Подстановка целого числа | `%06d`, `%#4d`, `%+02d` |\n",
    "| `%x` | `int` | Подстановка числа в шестнадцатеричной системе | `%04x`, `%#x`, `%+06x` |\n",
    "| `%f` | `float` | Подстановка числа с плавающей точкой | `%0.4f`, `%8.4f`, `%+8.2f`, `%+08.2f` |\n",
    "| `%e` | `float` | Экспоненциальный формат | `%1.6e` |\n",
    "\n",
    "#### Примеры с использованием модификаторов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "417cef19-0a8d-4a12-a2b7-d1d5840fdfd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    42\n",
      "000042\n",
      "3.14\n",
      "003.14\n",
      "  3.14\n",
      "+3.142\n",
      "+3.1416e+00\n"
     ]
    }
   ],
   "source": [
    "print(\"%6d\" % 42)\n",
    "print(\"%06d\" % 42)\n",
    "print(\"%.2f\" % 3.14159)\n",
    "print(\"%06.2f\" % 3.14159)\n",
    "print(\"%#6.2f\" % 3.14159)\n",
    "print(\"%+6.3f\" % 3.14159)\n",
    "print(\"%+1.4e\" % 3.14159)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d74567c-3973-4cad-a9e4-0265ec95e5c6",
   "metadata": {},
   "source": [
    "### Формирование строк в стиле format\n",
    "\n",
    "У типа `str` есть специальный метод `format`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ad4213d8-e6d9-4212-82a4-3bfb34783a17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Привет, мир!\n"
     ]
    }
   ],
   "source": [
    "s = 'Привет, {}!'\n",
    "w = s.format('мир')\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71a1790a-ac2c-4fe4-8a4d-9c7f84572806",
   "metadata": {},
   "source": [
    "Преимущества:\n",
    "* Автоматическое приведение типов\n",
    "* Возможность передачи параметров по имени и по номеру (в том числе повторение)\n",
    "\n",
    "Форматы аналогичны `%` но указываются после символа `:` перед которым может стоять имя аргумента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "eeb9d5ec-097e-48ce-ad93-bc9bbeca39f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Power 3.14 State Ready\n"
     ]
    }
   ],
   "source": [
    "s = 'Power {power:.2f} State {state}'\n",
    "w = s.format(state = \"Ready\", power = 3.14159)\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a7e2d43-d921-4632-b85b-f9b4bd6eb37d",
   "metadata": {},
   "source": [
    "### Формирование строк в стиле f-строк\n",
    "\n",
    "Строки могут быть созданы со специальным модификатором f который позволяет напрямую вставлять переменные в строку: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "245c2c40-2c7c-4b78-af6c-e43a261c47be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Привет, мир!\n"
     ]
    }
   ],
   "source": [
    "q = 'мир'\n",
    "w = f'Привет, {q}!'\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0739e7cd-4e81-4055-960e-209149d237d4",
   "metadata": {},
   "source": [
    "Преимущества:\n",
    "* Автоматическое приведение типов\n",
    "* Отсутствие дублирования имен переменных в шаблоне и в программе\n",
    "\n",
    "Форматы аналогичны `%` но указываются после символа `:`, как и в подстановках через `format`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1691199f-6208-416a-a186-a2b5e25de410",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Power 3.14 State Ready\n"
     ]
    }
   ],
   "source": [
    "power = 3.14159\n",
    "state = \"Ready\"\n",
    "w = f'Power {power:.2f} State {state}'\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bf86725-4a2b-44b0-a0c4-951939b0f254",
   "metadata": {},
   "source": [
    "Модификатор `f` можно сочетать с модификатором `r`, чтобы не обрабатывать спецсимволы. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "da254571-b2bd-41de-a38f-418b32d82f67",
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'test'\n",
    "fullpath = fr'c:\\test\\{filename}.txt'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2bc960-954f-4b16-a2fe-2096843dabb7",
   "metadata": {},
   "source": [
    "## Разбор строк\n",
    "\n",
    "Базовые разбор строк часто можно выполнить комбинацией методов `split`, `strip` и приведением полученных элементов строки к нужным типам. Но иногда этого бывает мало или получаемый код выходит слишком громоздким.\n",
    "\n",
    "### scanf\n",
    "\n",
    "Пакет `scanf` предоставляет метод разбора строк аналогичный C функции `scanf`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7612169d-03ce-4e7a-af63-ab6f141b302c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.0, 'Cool', 23.73)\n"
     ]
    }
   ],
   "source": [
    "from scanf import scanf\n",
    "\n",
    "template = 'Power: %f [%], %s, Stemp: %f'\n",
    "text = 'Power:   0.0 [%], Cool, Stemp: 23.73'\n",
    "s = scanf(template, text)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d3eb826-1ba2-425c-a35d-7d28782dc47f",
   "metadata": {},
   "source": [
    "| Шаблон | Значение |\n",
    "| ------ | -------- |\n",
    "| `%c` | Один символ |\n",
    "| `%5c` | Пять символов |\n",
    "| `%d`, `%i` | Целое число |\n",
    "| `%7d`, `%7i` | Целое число в 7 символов |\n",
    "| `%f` | Число с плавающей запятой |\n",
    "| `%X`, `%x` | Целое число в шестнадцатеричной системе |\n",
    "| `%s` | Строка до первого пробела |\n",
    "\n",
    "Поддерживаемые модификаторы: ширина поля `%12d` и пропуск поля `%*d`.\n",
    "\n",
    "Дополнительно имеется тип `%c` — один или нескольких символов, например `%12c`, а `%s` работает до первого пробела.\n",
    "\n",
    "Подробное описание форматов [scanf](https://github.com/joshburnett/scanf)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4ea5c26-8694-409c-93d0-2bda679e1fdc",
   "metadata": {},
   "source": [
    "### Регулярные выражения\n",
    "\n",
    "Регулярные выражения — специальный язык программирования. В стандартной библиотеке Python есть модуль для работы с ними — `re`. Перед использованием регулярные выражения следует компилировать методом `re.compile`, это повышает производительность.\n",
    "\n",
    "Основные применения:\n",
    "* Проверка формальной корректности строки\n",
    "* Поиск/замена по шаблону\n",
    "* Разделение строки по правилам\n",
    "\n",
    "Проверить свои регулярные выражения можно, например, на сайте [http://www.pyregex.com/](http://www.pyregex.com/).\n",
    "\n",
    "Использование длинных и сложных регулярных выражений считается плохим стилем. Для разбора сложного синтаксиса следует использовать другие инструменты.\n",
    "\n",
    "Некоторые компоненты регулярных выражений:\n",
    "\n",
    "| Выражение | Значение |\n",
    "| --------- | -------- |\n",
    "| `^` | Начало строки |\n",
    "| `$` | Конец строки |\n",
    "| `.` | Один любой символ |\n",
    "| `[abcd]` | Один из символов abcd |\n",
    "| `[a-z0-9A-Z]` | Один из алфовитноцифровых символов |\n",
    "| `\\w` | Один символ из набора [a-zA-Z0-9_] + Unicode letters |\n",
    "| `\\s` | Один пробельный символ |\n",
    "| `( )` | Группа из одного или нескольких шаблонов к которой можно обращаться |\n",
    "| `+` | Модификатор «один или несколько» |\n",
    "| `*` | Модификатор «ноль или несколько» |\n",
    "\n",
    "Чтобы избежать проблем с экранированием регулярные выражения записываются, как строки без экранирования, например `r'\\w+'`.\n",
    "\n",
    "#### Метод match\n",
    "\n",
    "Метод предназначен для проверки соответствие строки регулярному выражению."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0cdcca56-d484-4599-927c-da6efd673f9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 12), match='Привет = мир'>\n",
      "None\n",
      "<re.Match object; span=(0, 12), match='Привет = мир'>\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "r = re.compile(r\"\\w+ = \\w+\")\n",
    "print(r.match(\"Привет = мир\"))\n",
    "print(r.match(\"Привет =\"))\n",
    "print(r.match(\"Привет = мир проверка\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "74861185-39b6-4f35-a036-7beab39ab994",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "<re.Match object; span=(0, 12), match='Привет = мир'>\n"
     ]
    }
   ],
   "source": [
    "r = re.compile(r\"^\\w+\\s+=\\s+\\w+$\")\n",
    "print(r.match(\"Привет = мир проверка\"))\n",
    "print(r.match(\"Привет = мир\\n\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "f1bd3e3b-a6d8-4a6c-a63c-19ce2e6564c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Привет = мир\n",
      "Привет\n",
      "мир\n"
     ]
    }
   ],
   "source": [
    "r = re.compile(r\"^(\\w+)\\s+=\\s+(\\w+)$\")\n",
    "wd = r.match(\"Привет = мир\")\n",
    "\n",
    "print(wd.group(0))\n",
    "print(wd.group(1))\n",
    "print(wd.group(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de894119-1f49-405d-aa57-2e9b4289f657",
   "metadata": {},
   "source": [
    "#### Методы search и findall\n",
    "\n",
    "Поиск в строке подстрок(-и) удовлетворяющей выражению."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3eca01c0-affb-444e-9aa7-bcfa69e247c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['сли', 'я', 'чешу', 'в', 'затылке', 'не', 'беда']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "r = re.compile(r\"[а-я]+\")\n",
    "wd = r.search(\"Если я чешу в затылке не беда!\")\n",
    "s = wd.group(0) # s == 'сли'\n",
    "\n",
    "t = r.findall(\"Если я чешу в затылке не беда!\")\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00893f20-7cbc-4e2d-95c7-ab286e9cdb97",
   "metadata": {},
   "source": [
    "#### Метод sub\n",
    "\n",
    "Замена подстрок(-и) удовлетворяющей выражению."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5e9e3754-408b-41cf-a780-0fdd6c46d788",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "begin-begin-begin-end-end-end\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "r = re.compile(r\"\\s+\")\n",
    "s = r.sub(\"-\",\"begin      begin       begin   end    end   end\")\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ef3e1ac-fc55-483c-af95-d309a1504d78",
   "metadata": {},
   "source": [
    "#### Метод split\n",
    "\n",
    "Разбиение строки по разделителю в виде регулярного выражения. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "bcec56ad-3784-4398-832c-574ba951cba5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Если', 'я', 'чешу', 'в', 'затылке', 'не', 'беда!']\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "r = re.compile(r\"\\s+\")\n",
    "s = r.split(\"Если   я    чешу  в   затылке   не беда!\")\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "925c5815-91cc-40aa-af51-b7d8af8c9a01",
   "metadata": {},
   "source": [
    "## Дата и время\n",
    "\n",
    "В Python дата и время обычно используется в следующих формах:\n",
    "\n",
    "* Модуль `datetime`:\n",
    "  * `datatime` — основной класс объектов времени. Объект `datatime` может быть по отношению к часовому поясу «naive» или «aware».\n",
    "  * `timedelta` — класс интервала времени.\n",
    "* Модуль `time` — работа с временем в стиле Unix `time_t` (время выражается числом секунд с определенного момента, но имеет тип `float` — целая часть — число секунд, дробная — доли секунды).\n",
    "* Модуль `calendar` — функции календаря.\n",
    "* Модуль `zoneinfo` — данные по часовым поясам.\n",
    "\n",
    "### Дата и время (TZ naive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "dd0f6475-07e8-417f-8c1b-cacfaa1d709e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta\n",
    "from time import time\n",
    "\n",
    "t1 = time() # t1 == 1509532912.9569173\n",
    "\n",
    "t2 = datetime.now()\n",
    "# t2 == datetime.datetime(2017, 11, 1, 13, 42, 55, 774096)\n",
    "\n",
    "t3 = datetime.fromtimestamp(t1)\n",
    "# t3 == datetime.datetime(2017, 11, 1, 13, 44, 26, 259667)\n",
    "\n",
    "t4 = datetime(year=2011,month=2,day=3,hour=12,minute=22,second=34)\n",
    "# t4 == datetime.datetime(2011, 2, 3, 12, 22, 34)\n",
    "\n",
    "t5 = t4.timestamp() # t5 == 1296724954.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a568cda3-6fe4-4bce-ad82-0aaaac003f9f",
   "metadata": {},
   "source": [
    "### Дата и время (UTC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "d56f727a-723a-4c54-9a96-cb38cf746ba0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-11-14 05:16:39.643502\n",
      "1731550599.643502\n",
      "1731539799.6435983\n",
      "2024-11-14 02:16:39.643598\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "import time\n",
    "\n",
    "t7 = datetime.datetime.now()\n",
    "print(t7)\n",
    "\n",
    "print(t7.timestamp())\n",
    "\n",
    "t8 = time.time() + time.timezone\n",
    "print(t8)\n",
    "\n",
    "t9 = datetime.datetime.fromtimestamp(t8)\n",
    "print(t9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "680f0524-f9fa-4383-a0a5-736da8913201",
   "metadata": {},
   "source": [
    "### Дата и время (TZ aware)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "90756386-4830-4499-aa4b-c3ef0ba49937",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2024, 11, 14, 5, 16, 41, 85084, tzinfo=zoneinfo.ZoneInfo(key='Europe/Berlin'))"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime, timedelta\n",
    "from zoneinfo import ZoneInfo\n",
    "\n",
    "t_msk = datetime.now(ZoneInfo('Europe/Moscow'))\n",
    "# t_msk == datetime.datetime(2017, 11, 1, 14, 52, 39, 297530, tzinfo=<DstTzInfo 'Europe/Moscow' MSK+3:00:00 STD>)\n",
    "t_ber = datetime.now(ZoneInfo('Europe/Berlin'))\n",
    "# t_ber == datetime.datetime(2017, 11, 1, 12, 52, 50, 681447, tzinfo=<DstTzInfo 'Europe/Berlin' CET+1:00:00 STD>)\n",
    "\n",
    "(t_msk - t_ber).total_seconds() < 0.001 # True\n",
    "\n",
    "t_msk.astimezone(ZoneInfo('Europe/Berlin'))\n",
    "# datetime.datetime(2017, 11, 1, 12, 55, 21, 842909, tzinfo=<DstTzInfo 'Europe/Berlin' CET+1:00:00 STD>)\n",
    "\n",
    "datetime.now().replace(tzinfo=ZoneInfo('Europe/Berlin'))\n",
    "# datetime.datetime(2017, 11, 1, 15, 0, 59, 63396, tzinfo=<DstTzInfo 'Europe/Berlin' LMT+0:53:00 STD>)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a86cceb9-c61d-4cfc-b883-d363893ae593",
   "metadata": {},
   "source": [
    "### Работа с интервалами\n",
    "\n",
    "Разность двух объектов `datetime` дает объект `timedelta`. Также его можно сконструировать через конструктор `timedelta`. `timedelta` можно складывать и вычитать, а также умножать на число. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "c60e71a2-daf2-4b01-957c-f4ac8ae3ec0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.timedelta(days=30)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime, timedelta\n",
    "from time import time\n",
    "\n",
    "t1 = datetime(year=2013,month=7,day=15,hour=12,minute=22,second=34)\n",
    "t2 = datetime.now()\n",
    "\n",
    "td = t2 - t1\n",
    "#td == datetime.timedelta(1570, 6567, 748425)\n",
    "\n",
    "td.total_seconds() # 135654567.748425\n",
    "\n",
    "t1 + timedelta(days=15)\n",
    "# datetime.datetime(2013, 7, 30, 12, 22, 34)\n",
    "\n",
    "timedelta(days=15) *2 \n",
    "# datetime.timedelta(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56ab351b-bd7b-4396-aa36-68b713be9449",
   "metadata": {},
   "source": [
    "Для модификации `datetime` к нему нужно или прибавить/отнять соответствующий `timedelta` или обновить конкретные поля методом `replace`.\n",
    "\n",
    "### Даты и время и строки\n",
    "\n",
    "Для приведения `datetime` к строке и разбора строки в `datetime` имеются функции `strftime` и `strptime` соответственно. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "9d51525d-4503-44e7-aaf3-0303958905ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2013-07-15 12:22:34\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "t1 = datetime(year=2013,month=7,day=15,hour=12,minute=22,second=34)\n",
    "t1.strftime(\"%d.%m.%Y %H:%M:%S\")\n",
    "print(t1)\n",
    "\n",
    "t2 = datetime.strptime('15.07.2013 12:22:34', \"%d.%m.%Y %H:%M:%S\")\n",
    "print(t2 == t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b6469b9-3489-444e-926e-37a6de136368",
   "metadata": {},
   "source": [
    "### Некоторые популярные форматы\n",
    "\n",
    "| Формат  | Описание | `format` | Пример |\n",
    "| ------- | ------- | ------- | ------- |\n",
    "| `%d` | День месяца | `%02d` | `01` |\n",
    "| `%m` | Месяц числом | `%02d` | `08` |\n",
    "| `%y` | Год (2 знака) | `%02d` | `05` |\n",
    "| `%Y` | Год (4 знака) | `%04d` | `2005` |\n",
    "| `%H` | Час | `%02d` | `08` |\n",
    "| `%M` | Минута | `%02d` | `05` |\n",
    "| `%S` | Секунда | `%02d` | `03` |\n",
    "| `%j` | День года | `%d` | `25` |\n",
    "\n",
    "Подробное описание форматов даты и времени."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c08fd7ad-cd5b-47c9-a921-afd712f7d1d4",
   "metadata": {},
   "source": [
    "### Метод sleep\n",
    "\n",
    "Метод `time.sleep` выполняет приостановку выполнения скрипта на заданное время в секундах и их долях. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1a5d2127-84c9-430d-bb27-98e564fbd568",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "time.sleep(3)\n",
    "time.sleep(0.23)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "014c4b22-f7b1-4312-8de9-e74375a72770",
   "metadata": {},
   "source": [
    "## Работа с аргументами командной строки\n",
    "\n",
    "* Аргументы командной строки — основной способ передачи параметров консольным приложениям\n",
    "* Интерпретатор Python рассматривает все аргументы переданные после имени скрипта, как аргументы скрипта\n",
    "* По традиции 0-вой аргумент — имя скрипта\n",
    "* Доступ к аргументам напрямую — список `argv` модуля `sys`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "42710ff2-140f-49b6-9338-da52e541df4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['/usr/lib/python3.12/site-packages/ipykernel_launcher.py', '-f', '/home/f0ma/.local/share/jupyter/runtime/kernel-298147dc-e767-4a18-8d8a-0ea7f962266c.json']\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "print(sys.argv)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66ed6f57-97a1-4f3e-819f-b474b9c6568e",
   "metadata": {},
   "source": [
    "### Пара слов о традициях обработки аргументов\n",
    "\n",
    "* По традиции аргументы делятся на ключи/флаги и собственно аргументы. По традиции ключи/флаги начинаются с символа `-`\n",
    "* По традиции ключи имеют собственные аргументы (`-x 258`), а флаги — нет (`-x`).\n",
    "* По традиции любой ключ/флаги программы может быть передан в короткой и длинной форме:\n",
    "\n",
    "```\n",
    "-o file.txt\n",
    "--output-file file.txt\n",
    "-v\n",
    "--verbose\n",
    "```\n",
    "\n",
    "По традиции собственно аргументы передаются после ключей/флагов по порядку\n",
    "\n",
    "```\n",
    "python3 script.py -v -o file.txt Arg1 Arg2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75f242cf-1ef6-4856-9037-8a0484561c86",
   "metadata": {},
   "source": [
    "### Работа с модулем argparse\n",
    "\n",
    "Для разбора аргументов командной строки в стандартной библиотеке есть модуль argparse:\n",
    "* Создать объект — парсер\n",
    "* Описать возможные аргументы с помощью вызовов функций парсера\n",
    "* Запустить паресер\n",
    "* Парсер сконструирует объект в полях которого будут значения соответствующих аргументов\n",
    "\n",
    "#### Описание аргументов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "b1d10410-7969-4d6e-a786-43daaef7bdfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "\n",
    "parser = argparse.ArgumentParser()\n",
    "\n",
    "parser.add_argument(\"-v\", \"--verbose\", action=\"store_true\",\n",
    "                    default=False, help=\"Подробный вывод\")\n",
    "\n",
    "parser.add_argument(\"-i\", \"--input\", action=\"store\", required=True,\n",
    "                    help=\"Входной файл (обязательный аргумент)\")\n",
    "\n",
    "parser.add_argument(\"-o\", \"--output\", action=\"store\", default=\"out.dat\",\n",
    "                    help=\"Выходной файл (по умолчанию out.dat)\")\n",
    "\n",
    "parser.add_argument('var', type=int,\n",
    "                    help='Первый обязательный аргумент')\n",
    "\n",
    "parser.add_argument('livar', nargs='+',\n",
    "                    help='Один или более обязательных аргументов');"
   ]
  },
  {
   "cell_type": "raw",
   "id": "dd85aaad-4fda-4882-ab09-95e11c6f4891",
   "metadata": {},
   "source": [
    "args = parser.parse_args()\n",
    "\n",
    "print(args)\n",
    "print(args.verbose)\n",
    "print(args.input)\n",
    "print(args.output)\n",
    "print(args.var)\n",
    "print(args.livar)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e382b9ad-3736-464e-bc20-6141b18176be",
   "metadata": {},
   "source": [
    "#### Автоматическая генерация справки\n",
    "```\n",
    "> python3 test.py \n",
    "usage: test.py [-h] [-v] -i INPUT [-o OUTPUT] var livar [livar ...]\n",
    "test.py: error: the following arguments are required: -i/--input, var, livar\n",
    "```\n",
    "\n",
    "```\n",
    "> python3 test.py -h\n",
    "usage: test.py [-h] [-v] -i INPUT [-o OUTPUT] var livar [livar ...]\n",
    "\n",
    "positional arguments:\n",
    "  var                   Первый обязательный аргумент\n",
    "  livar                 Один или более обязательных аргументов\n",
    "\n",
    "optional arguments:\n",
    "  -h, --help            show this help message and exit\n",
    "  -v, --verbose         Подробный вывод\n",
    "  -i INPUT, --input INPUT\n",
    "                        Входной файл (обязательный аргумент)\n",
    "  -o OUTPUT, --output OUTPUT\n",
    "                        Выходной файл (по умолчанию out.dat)\n",
    "```"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}