fstrings_EN.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {
                "collapsed": true,
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "# F-strings: A format system to rule them all\n",
                "\n",
                "#### Juan Diego Godoy Robles, PyConES 2019, Alicante"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "[Wikipedia](https://en.wikipedia.org/wiki/String_interpolation): Process of evaluating a string literal containing one or more *placeholders*, yielding a result in which the placeholders are replaced with their corresponding values."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "outputs": [],
            "source": [
                "from datetime import date, datetime, timedelta\n",
                "talk = 'f-strings'\n",
                "talk_date = date(2019, 10 , 5)\n",
                "me = 'juan diego'\n",
                "minutes_left = 20\n",
                "\n",
                "print (\n",
                "  f'Ey Pythonists folks!, today is {talk_date:%A %d %B of %Y}.\\n'\n",
                "  f'I\\'m {me.title()}, wellcome to this awesome {talk!r} talk.\\nYou\\'ll be free '\n",
                "  f'at {datetime.now() + timedelta(minutes=minutes_left):%H:%M} \\U0001f44d'\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "This feature was proposed in [**PEP-0498**](https://www.python.org/dev/peps/pep-0498/) which is the main source for this talk."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "## How was this solved before?\n",
                "\n",
                "We have *three methods*, all of them are still valid, `F-strings` does not deprecate any previous mechanism."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### Printf style formatting\n",
                "\n",
                "String objects have the [*interpolation*](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting) operator, quite similar to **C** `sprintf` behaviour.\n",
                "\n",
                "If *format* requires more than one argument, the value must be a *tuple* and it's length should match the formatting mask or a mapping object."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "'%s %s' % ('Old Fashioned', 'formatting')"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "'%(style)s %(action)s' % {'style': 'Old Fashioned', 'action': 'formatting'}"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "One of the downsides is that the **conversion type** should be included."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "'%' % 'hello'"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "Only `ints`, `strs`, and `doubles` can be formatted.\n",
                "\n",
                "And, when a single value is passed in a tuple ..."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "'%s' % ('%-formatting sucks',  'much')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "We can avoid the issue by ussing a *defensive tatic*."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "'%s' % (('%-formatting sucks',  'much'),)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "Or knowing beforehand the *number of elements to format*. **Not flexible** at all."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "'%s %s' % ('%-formatting sucks',  'much')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### Format String Syntax\n",
                "\n",
                "My favorite [*method*](https://docs.python.org/3/library/string.html#formatstrings) until the arriving of the `F-strings`. In fact, they *share* part of the the syntax / mechanisms, but `format` is clearly more verbose."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "awesome_conf = 'PyConES'\n",
                "\n",
                "'This {awesome_conf} is really awesome.'.format(awesome_conf=awesome_conf)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "Even if we try to simplify it as far as we possibly can, the variable hangs a **little disconnected from the context**. This is quite more evident in a *side-to-side* comparision with `F-strings`."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "awesome_conf = 'PyConES'\n",
                "\n",
                "print('This {} is really awesome.'.format(awesome_conf))\n",
                "\n",
                "print(f'This {awesome_conf} is really awesome.')\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### Template strings\n",
                "\n",
                "The [*template strings*](https://docs.python.org/3/library/string.html#template-strings) was created as an alternative to the interpolation operator (very error-prone), with one [*target in mind*](https://www.python.org/dev/peps/pep-0292/): a simpler syntax to format strings (substitution could be a more appropriate term)."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "from string import Template\n",
                "Template('Hello from $this').substitute(this='Template')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "*format* protocol is not supported, conversions are not possible.\n",
                "\n",
                "More of its downsides: poor performance and low flexibility."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "## F-strings"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### Definition\n",
                "\n",
                "A way to **embed expressions**, evaluated at run time inside, in string literals."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "type(f'{type}')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### What changes implies?\n",
                "\n",
                "**None**, all the previous methods are still avaliable."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### Which are their advantages?\n",
                "\n",
                "1. **Clarity**: They improve *code readability*, that's a fact."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "ways_2_formatx2 = 6\n",
                "awesome_lang = 'Python'\n",
                "\n",
                "print(\n",
                "    'In %s we have %d ways to do our formatting'\n",
                "    % (awesome_lang, int(ways_2_formatx2/2))\n",
                ")\n",
                "print(\n",
                "    'In {awesome_lang:s} we have {ways_2_format:d} ways to do our formatting'.format(\n",
                "        awesome_lang=awesome_lang, ways_2_format=(int(ways_2_formatx2/2))\n",
                "    )\n",
                ")\n",
                "print (f'In {awesome_lang} we have {int(ways_2_formatx2/2)} ways to do our formatting')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "2. **Performance**: the expression is evaluated in execution time and then combined with the literal part to return the final string, nothing else is required."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "import dis\n",
                "\n",
                "def foo():\n",
                "    x = 42\n",
                "    y = 99\n",
                "    return '{} + {} = {}'.format(x, y, x + y)\n",
                "\n",
                "dis.dis(foo)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "With `LOAD_METHOD` *Python* references the function `format` which will be called later by `CALL_METHOD`. `F-strings` is free from this *overhead*."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "import dis\n",
                "\n",
                "def foo():\n",
                "    x = 42\n",
                "    y = 99\n",
                "    return f'{x} + {y} = {x + y}'\n",
                "\n",
                "dis.dis(foo)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "We can test this in practice in a *real world example*."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "import timeit\n",
                "\n",
                "timeit_times = 10000000\n",
                "\n",
                "print(timeit.timeit(\"\"\"name='PyConES';year=2019;f'{name} - {year}'\"\"\", number=timeit_times))\n",
                "print(timeit.timeit(\"\"\"name='PyConES';year=2019;'%s - %d' % (name, year)\"\"\", number=timeit_times))\n",
                "print(timeit.timeit(\"\"\"name='PyConES';year=2019;'{} - {}'.format(name, year)\"\"\", number=timeit_times))"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### How does it work?\n",
                "\n",
                "Only syntax errors can be caught at **compile time**, example: an orphan curly brace (`{` o `}`).\n",
                "\n",
                "At **execution time** the expression will be evaluated in the context where the `F-string` appears with full access to *local* and *global variables*.\n",
                "\n",
                "In the following example both `print` statements are **completely equivalent**."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "def hi():\n",
                "    return 'Hello'\n",
                "\n",
                "print(f'{hi()} world!')\n",
                "print(str(hi())+ ' world!')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "### How do we use it?"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "\n",
                "`F-strings` are string literals that are prefixed by the letter `f` or `F`.\n",
                "\n",
                "Otherwise, *same rules as normal strings are applied*. That is, the string must end with the same character that it started with: if it starts with a single quote it must end with a single quote, etc.\n",
                "\n",
                "Once *tokenized*, a `F-string` is parsed into **literal strings** and **expressions**, the code should appear within **curly braces**: `{expr}`.\n",
                "\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "\n",
                "To *escape* a curly brace we should double it:  `{{` or `}}`.\n",
                "\n",
                "Comment (`#`) or escape chars (`\\`) are not allowed inside an expression, this last inconvenient can be bypassed by *alternate the quoting char* or using *triple quoting*"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "\n",
                "An optional **type conversion** may be specified as the last part of the expression. These are treated the same as in `str.format()`: `!s`  calls `str()`, `!r` to `repr()` and `!a` to `ascii()`.\n",
                "\n",
                "Optional **format specifiers** maybe be included, separated from the expression (or the type conversion, if specified) by a colon."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "from datetime import datetime\n",
                "import decimal\n",
                "\n",
                "width = 6\n",
                "precision = 4\n",
                "hour = decimal.Decimal('13.29999999999999999999')\n",
                "\n",
                "f'''Playing with {{ {\" f-strings '-) \".upper()!s:-^20} }} {datetime.now():%Y}{hour:{width}.{precision}}'''"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "`F-strings` can be use in *raw mode*, by adding de prefix `r` or `R` . The escape char `\\` will not be interpreted. No escape processing will be done."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "import re\n",
                "\n",
                "re.search(fr'=\\s*{20 * 2}', 'sum=  40')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "## Fun with F-strings"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Objects "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "import datetime\n",
                "\n",
                "class Talk:\n",
                "    def __init__(self, title, conference, date):\n",
                "        self.title = title\n",
                "        self.conference = conference\n",
                "        self.date = date\n",
                "\n",
                "    def __str__(self):\n",
                "        return f'{self.title} ({self.conference} {self.date:%Y})'\n",
                "\n",
                "    def __repr__(self):\n",
                "        return f'{self.conference}: Today is {self.date:%A %d %B} Wellcome to {self.title!r}'\n",
                "\n",
                "\n",
                "my_talk = Talk('f-strings', 'PyConES', datetime.date(2019, 10, 5))\n",
                "print(f'''{Talk('f-strings', 'PyConES', datetime.date(2019, 10 , 5))!r}''')\n",
                "print(f'{my_talk}')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Exceptions"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "try:\n",
                "    print(non_existent)\n",
                "except Exception as err:\n",
                "    print(f'an error hapenned: {err}')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Multiline"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "print (\n",
                "    f'F-strings provide a way to embed \\'{\"expressions\"}\\' inside string literals, '\n",
                "    f'using a minimal syntax. '\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Ternary operator"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "foo = None\n",
                "\n",
                "f'{foo if foo is not None else \"foo\"}'"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Lambda functions"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "f'{(lambda x: x**2)(3)}'"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### List comprehensions"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "celsius = [0, 20, 40]\n",
                "\n",
                "[f'{c} Celsius => {1.8 * c + 32:.2f} Fahrenheit' for c in celsius]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Handy formatting\n",
                "\n",
                "**Note**: `format` like."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "left = 'left'\n",
                "center = 'center'\n",
                "right = 'right'\n",
                "\n",
                "f'{left:><15}{center:-^10}{right:<>15}'"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "from math import pi\n",
                "\n",
                "f'Pi: {pi} - {pi:.4f}'"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Bonus track: DEBUG  >= 3.8\n",
                "\n",
                "```python\n",
                ">>>foo = 30\n",
                ">>> print(f'{foo=}  {cos(radians(foo))=:.3f}')\n",
                "foo=30  cos(radians(foo))=0.866\n",
                "```"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "foo = 30\n",
                "\n",
                "print(f'{foo=}  {cos(radians(foo))=:.3f}')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "## Pitfalls"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Modern Python >= 3.6\n",
                "\n",
                "IMO This should be considered an advantage rather than a problem, let's avoid the \"*Legacy Python*\",  but **bear it in mind**."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Docstrings\n",
                "\n",
                "**Runtime evaluation** prevents `F-strings` from being used for code documentation."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Quoting \n",
                "\n",
                "`F-strings` quoting syntax could be *kind of tricky*. Actually the [PEP536](https://www.python.org/dev/peps/pep-0536/) proposes a formal grammar lifting restrictions. In a (*near?*) future this expression will be valid:\n",
                "`f'Magic wand: {bag['wand']:^10}'`.\n",
                "\n",
                "This `PEP` is in *Deferred* state."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Dicts\n",
                "\n",
                "`format` could be more handy to use when handling `dicts`."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "nerd = {'name': 'Juan Diego', 'from': 'Almería'}\n",
                "\n",
                "print('This nerd is {name} from {from}'.format(**nerd))\n",
                "\n",
                "print(f'This nerd is {nerd[\"name\"]} from {nerd[\"from\"]}')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Logging\n",
                "\n",
                "`F-strings` **calls automatically `__str__`** object method, you can run into a performance problem because of this."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "import logging\n",
                "logging.basicConfig(level=logging.INFO)\n",
                "logger = logging.getLogger('fail')\n",
                "\n",
                "class Dummy:\n",
                "    def __init__(self, name):\n",
                "        self._name = name\n",
                "    def __str__(self):\n",
                "        print('logging should be >= INFO')\n",
                "        return self._name\n",
                "    \n",
                "c = Dummy('fstring')\n",
                "\n",
                "logger.debug(f'Created: {c}')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "In this case traditional interpolation may result *more convenient*."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "outputs": [],
            "source": [
                "logger.debug('Created: %s', c)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "subslide"
                }
            },
            "source": [
                "### Last but not least\n",
                "\n",
                "> There should be one-- and preferably only one --obvious way to do it.\n",
                "\n",
                "Is it worth it? ..."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "outputs": [],
            "source": [
                "from datetime import date, datetime, timedelta\n",
                "talk = 'f-strings'\n",
                "talk_date = date(2019, 10 , 5)\n",
                "me = 'juan diego'\n",
                "minutes_left = 0\n",
                "\n",
                "print (\n",
                "  f'Ey Pythonists folks!, today is {talk_date:%A %d %B of %Y}.\\n'\n",
                "  f'I\\'m {me.title()}, wellcome to this awesome {talk!r} talk.\\nYou\\'ll be free '\n",
                "  f'at {datetime.now() + timedelta(minutes=minutes_left):%H:%M} \\U0001f44d'\n",
                ")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "slideshow": {
                    "slide_type": "slide"
                }
            },
            "source": [
                "# Thanks !!\n",
                "### Contact: https://klashxx.github.io/about"
            ]
        }
    ],
    "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.7.3"
        },
        "livereveal": {
            "autolaunch": true
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}