New python features.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Python 3.8 и 3.9 new features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.9.0 | packaged by conda-forge | (default, Oct 14 2020, 22:59:50) \\n[GCC 7.5.0]'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python 3.8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Assignment expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List is too long (12 elements, expected <= 10)\n"
     ]
    }
   ],
   "source": [
    "a = [10] * 12\n",
    "if (n := len(a)) > 10:\n",
    "    print(f\"List is too long ({n} elements, expected <= 10)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Вместо if можно while, вместо len любую функцию"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Позиционные и именнованные аргументы функций"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def my_func(a, b, /, c, d, *, e, f):\n",
    "    return a + b + c + d + e + f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "my_func() takes 4 positional arguments but 6 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-4473ec8e2a85>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: my_func() takes 4 positional arguments but 6 were given"
     ]
    }
   ],
   "source": [
    "my_func(1, 2, 3, 4, 5, 6) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-8-3f5264ec4329>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-8-3f5264ec4329>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    my_func(a=1, b=2, 3, 4, e=5, f=6)\u001b[0m\n\u001b[0m                                    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "my_func(a=1, b=2, 3, 4, e=5, f=6) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-10-be3b071bf2d9>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-10-be3b071bf2d9>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    my_func(1, 2, c=3, 4, e=5, f=6)\u001b[0m\n\u001b[0m                                  ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "my_func(1, 2, c=3, 4, e=5, f=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func(1, 2, 3, d=4, e=5, f=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_func(1, 2, c=3, d=4, e=5, f=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def incr(x, /):\n",
    "    return x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "incr(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "incr() got some positional-only arguments passed as keyword arguments: 'x'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-786104a2d7a8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mincr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: incr() got some positional-only arguments passed as keyword arguments: 'x'"
     ]
    }
   ],
   "source": [
    "incr(x=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### f-string 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=3\n",
      "a=3\n"
     ]
    }
   ],
   "source": [
    "a = 3  \n",
    "print(f'a={a}')\n",
    "print(f'{a=}') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"name.upper()[::-1] = 'DLROW OLLEH'\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = 'Hello World'\n",
    "f\"{name.upper()[::-1] = }\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### More Precise Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from typing import Literal, Union, overload"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Literal - Аннотация с опциональными строками"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# draw_line.py\n",
    "def draw_line(direction: Literal[\"horizontal\", \"vertical\"]) -> None:\n",
    "    if direction == \"horizontal\":\n",
    "        print('horizontal')\n",
    "\n",
    "    elif direction == \"vertical\":\n",
    "        print('vertical')\n",
    "\n",
    "    else:\n",
    "        raise ValueError(f\"invalid direction {direction!r}\")\n",
    "        \n",
    "draw_line(\"up\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "$ mypy draw_line.py \n",
    "draw_line.py:15: error:\n",
    "    Argument 1 to \"draw_line\" has incompatible type \"Literal['up']\";\n",
    "    expected \"Union[Literal['horizontal'], Literal['vertical']]\"\n",
    "Found 1 error in 1 file (checked 1 source file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Union - Аннотация на случай возможности разных типов переменных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "ARABIC_TO_ROMAN = [(1000, \"M\"), (900, \"CM\"), (500, \"D\"), (400, \"CD\"),\n",
    "                   (100, \"C\"), (90, \"XC\"), (50, \"L\"), (40, \"XL\"),\n",
    "                   (10, \"X\"), (9, \"IX\"), (5, \"V\"), (4, \"IV\"), (1, \"I\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# calculator.py\n",
    "\n",
    "def _convert_to_roman_numeral(number: int) -> str:\n",
    "    \"\"\"Convert number to a roman numeral string\"\"\"\n",
    "    result = list()\n",
    "    for arabic, roman in ARABIC_TO_ROMAN:\n",
    "        count, number = divmod(number, arabic)\n",
    "        result.append(roman * count)\n",
    "    return \"\".join(result)\n",
    "\n",
    "def add(num_1: int, num_2: int, to_roman: bool = True) -> Union[str, int]:\n",
    "    \"\"\"Add two numbers\"\"\"\n",
    "    result = num_1 + num_2\n",
    "\n",
    "    if to_roman:\n",
    "        return _convert_to_roman_numeral(result)\n",
    "    else:\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "?add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Signature: add(num_1: int, num_2: int, to_roman: bool = True) -> Union[str, int]\n",
    "Docstring: Add two numbers\n",
    "File:      ~/Severstal/<ipython-input-43-b8c79f08c4cc>\n",
    "Type:      function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### @overload - декоратор предназначен для того, чтобы выдавать выходную аннотацию разных типов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@overload\n",
    "def add(num_1: int, num_2: int, to_roman: Literal[True]) -> str:\n",
    "    result = num_1 + num_2\n",
    "    return _convert_to_roman_numeral(result)\n",
    "    \n",
    "@overload\n",
    "def add(num_1: int, num_2: int, to_roman: Literal[False]) -> int:\n",
    "    result = num_1 + num_2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "?add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Signature: add(*args, **kwds)\n",
    "Docstring: Helper for @overload to raise when called.\n",
    "File:      ~/miniconda3/envs/py39-demo/lib/python3.9/typing.py\n",
    "Type:      function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Final квалификатор - показывает, что переменная больше не должна быть переназначена"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from typing import Final\n",
    "\n",
    "ID: Final = 1\n",
    "ID = 2 # Так делать нельзя"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### @final - декоратор класса покзывающий, что данный класс не может быть наследован в другом классе. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from typing import final\n",
    "\n",
    "@final\n",
    "class Base:\n",
    "    ...\n",
    "\n",
    "class Sub(Base): # Так тоже нельзя делать\n",
    "    ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Подробнее в PEP 591 -- Adding a final qualifier to typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### TypedDict - Как NamedTuple,  только словарь с ключами name, year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from typing import TypedDict\n",
    "\n",
    "class Movie(TypedDict):\n",
    "    name: str\n",
    "    year: int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Protocol - пока не понял в чем фишка, но можно наследоваться не задумываясь о самом объекте"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from typing import Protocol\n",
    "\n",
    "class Named(Protocol):\n",
    "    name: 'name'\n",
    "\n",
    "def greet(obj: Named) -> None:\n",
    "    print(f\"Hi {obj.name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "784\n",
      "784\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.prod((2, 8, 7, 7)))\n",
    "print(2 * 8 * 7 * 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(math.isqrt(9))\n",
    "print(math.isqrt(13))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.25\n",
      "3.013668912157617\n",
      "[9, 2, 1]\n",
      "[1.25, 2.5, 8.5]\n"
     ]
    }
   ],
   "source": [
    "import statistics\n",
    "data = [9, 3, 2, 1, 1, 2, 7, 9]\n",
    "print(statistics.fmean(data))\n",
    "print(statistics.geometric_mean(data))\n",
    "print(statistics.multimode(data))\n",
    "print(statistics.quantiles(data, n=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Полезные ссылки: <br>\n",
    "https://docs.python.org/3/whatsnew/3.8.html <br>\n",
    "https://realpython.com/python38-new-features/ <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python 3.9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Easy dictionary updating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d1 = {2016: \"Portland\", 2018: \"Cleveland\"}\n",
    "d2 = {2017: \"Rimini\", 2018: \"Edinburgh\", 2019: \"Basel\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2016: 'Portland', 2018: 'Edinburgh', 2017: 'Rimini', 2019: 'Basel'}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1.update(d2)\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Union operators to dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}\n"
     ]
    }
   ],
   "source": [
    "a = {1: 'a', 2: 'b', 3: 'c'}\n",
    "b = {4: 'd', 5: 'e'}\n",
    "c = a | b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}\n"
     ]
    }
   ],
   "source": [
    "a = {1: 'a', 2: 'b', 3: 'c'}\n",
    "b = {4: 'd', 5: 'e'}\n",
    "a |= b\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c', 6: 'new', 4: 'd', 5: 'e'}\n"
     ]
    }
   ],
   "source": [
    "a = {1: 'a', 2: 'b', 3: 'c', 6: 'old'}\n",
    "b = {4: 'd', 5: 'e', 6: 'new'}\n",
    "print(a | b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Type Hinting Generics In Standard Collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def greet_all(names: list[str]) -> None:\n",
    "    for name in names:\n",
    "        print(\"Hello\", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Oleg\n",
      "Hello Vasya\n",
      "Hello 1\n",
      "Hello 2\n",
      "Hello 3\n"
     ]
    }
   ],
   "source": [
    "test1 = ['Oleg', 'Vasya']\n",
    "test2 = [1, 2, 3]\n",
    "greet_all(test1)\n",
    "greet_all(test2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"files/1.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Annotated Type Hints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from typing import Annotated\n",
    "\n",
    "def speed(\n",
    "    distance: Annotated[float, \"feet\"], time: Annotated[float, \"seconds\"]\n",
    ") -> Annotated[float, \"miles per hour\"]:\n",
    "    \"\"\"Calculate speed as distance over time\"\"\"\n",
    "    fps2mph = 3600 / 5280  # Feet per second to miles per hour\n",
    "    return distance / time * fps2mph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'distance': typing.Annotated[float, 'feet'],\n",
       " 'time': typing.Annotated[float, 'seconds'],\n",
       " 'return': typing.Annotated[float, 'miles per hour']}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speed.__annotations__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### New String Methods to Remove Prefixes and Suffixes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'llo world'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello world\".removeprefix(\"He\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello wor'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello world\".removesuffix(\"ld\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello world\".removesuffix(\"id\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### New Parser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Новый парсер основанный на PEG вместо LL(1). ОН сохранил производительность, но стал более гибким. Возможно, в работе мы его не заметим, но говорят это очень важное обновление\n",
    "Как это работает подробно написано тут <br>\n",
    "https://medium.com/@gvanrossum_83706/left-recursive-peg-grammars-65dab3c580e1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ZoneInfo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "zoneinfo.ZoneInfo(key='Europe/Moscow')"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from zoneinfo import ZoneInfo\n",
    "from datetime import datetime, timezone\n",
    "ZoneInfo(\"Europe/Moscow\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "dt = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo(\"Europe/Moscow\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(zoneinfo.ZoneInfo(key='Europe/Moscow'), 'MSK')"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.tzinfo, dt.tzname()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2020, 10, 31, 12, 0, tzinfo=zoneinfo.ZoneInfo(key='Europe/Moscow'))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2020, 10, 31, 5, 0, tzinfo=zoneinfo.ZoneInfo(key='America/New_York'))"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.astimezone(ZoneInfo(\"America/New_York\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Australia/Victoria',\n",
       " 'Europe/Tirane',\n",
       " 'America/Barbados',\n",
       " 'GMT-0',\n",
       " 'Arctic/Longyearbyen',\n",
       " 'Turkey',\n",
       " 'America/Curacao',\n",
       " 'America/St_Vincent',\n",
       " 'Etc/Universal',\n",
       " 'America/Atka']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import zoneinfo\n",
    "list(zoneinfo.available_timezones())[10:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.timedelta(seconds=3600)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ZoneInfo(\"Europe/London\").utcoffset(datetime(2020, 7, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.timedelta(0)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ZoneInfo(\"Europe/London\").utcoffset(datetime(2020, 12, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Relaxing Grammar Restrictions On Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Теперь декораторы не обязательно должы вызываться непосредственно классом или функцией"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# story.py\n",
    "import functools\n",
    "\n",
    "def normal(text):\n",
    "    return text\n",
    "\n",
    "def shout(text):\n",
    "    @functools.wraps(text)\n",
    "    def shout_decorator(*args, **kwargs):\n",
    "        return func(*args, **kwargs).upper()\n",
    "\n",
    "    return shout_decorator\n",
    "\n",
    "def whisper(text):\n",
    "    @functools.wraps(text)\n",
    "    def whisper_decorator(*args, **kwargs):\n",
    "        return func(*args, **kwargs).lower()\n",
    "\n",
    "    return whisper_decorator\n",
    "\n",
    "DECORATORS = {\"normal\": normal, \"shout\": shout, \"whisper\": whisper}\n",
    "\n",
    "voice = input(f\"Choose your voice ({', '.join(DECORATORS)}): \")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "@DECORATORS[voice]\n",
    "def get_story():\n",
    "    return \"\"\"\n",
    "        Alice was beginning to get very tired of sitting by her sister on the\n",
    "        bank, and of having nothing to do: once or twice she had peeped into\n",
    "        the book her sister was reading, but it had no pictures or\n",
    "        conversations in it, \"and what is the use of a book,\" thought Alice\n",
    "        \"without pictures or conversations?\"\n",
    "        \"\"\"\n",
    "\n",
    "print(get_story())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<img src=\"files/2.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Полезные ссылки <br>\n",
    "https://realpython.com/python39-new-features/ <br>\n",
    "https://docs.python.org/3/whatsnew/3.9.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}