fstrings.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": [
    "La interpolación de cadenas permite embeber código en cadenas de texto usando una sintaxis mínima y limitando al máximo los posibles errores.\n",
    "\n",
    "[Wikipedia](https://en.wikipedia.org/wiki/String_interpolation): es el proceso de evaluación de una cadena de texto literal que contiene al menos un placeholder y que devuelve un resultado en el que estos tokens son reemplazados con los valores resultantes."
   ]
  },
  {
   "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": [
    "Esta feature (presente previamente en numerosos lenguajes), fue propuesta en la [PEP-0498](https://www.python.org/dev/peps/pep-0498/), aprobada no sin su buena dosis de [polémica](https://www.reddit.com/r/Python/comments/3k6qi8/pep_498_approved/) y constituye la base para esta charla."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Cómo se había resuelto esto antes?\n",
    "\n",
    "Existen tres métodos, que siguen absolutamente vigentes ya que las `F-strings` no suponen la  *deprecación* de ninguno de los anteriores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Printf style formatting\n",
    "\n",
    "Los objetos tipo String disponen de un operador de [interpolación](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting) similar al `sprintf` en **C**.\n",
    "\n",
    "Si el proceso de _format_ requiere más de un argumento, el valor deberá ser una *tupla* cuyo número de elementos deberá coincidir con los especificados en la cadena a formatear, o un objeto que mapee _key-value_ (por ejemplo un diccionario)."
   ]
  },
  {
   "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": [
    "Una de sus desventajas es que necesita especificar el *tipo de conversión*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "'%' % 'hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Solo permite el formateo de *enteros*, *dobles* o *cadenas*.\n",
    "\n",
    "Cualquier otro tipo debe ser convertido a los anteriores antes de aplicar el formato (quizás esto no suponga un problema serio ya que casi cualquier objeto suele implementar los métodos __str__ y/o __repr__).\n",
    "\n",
    "Por otro lado existe un *known problem* al pasarle una tupla con más de un elemento."
   ]
  },
  {
   "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": [
    "Podemos evitarlo programando de forma *defensiva*."
   ]
  },
  {
   "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": [
    "O conociendo de antemano el número de elementos lo cual es muy **poco flexible**."
   ]
  },
  {
   "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",
    "Mi [método](https://docs.python.org/3/library/string.html#formatstrings) favorito hasta la llegada de las `F-strings`, de hecho  estas ultimas reutilizan gran parte de la sintaxis y los mecanismos de format pero también son mucho más *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": [
    "Incluso si lo simplificamos al máximo, podemos ver como la variable queda un poco desconectada del contexto lo cual se hace mucho más evidente al compararlo con el mismo ejemplo usando `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",
    "Las [templates ](https://docs.python.org/3/library/string.html#template-strings) se crearon como alternativa al operador de interpolación, que como hemos visto es muy propenso a errores, con el único [objetivo en mente](https://www.python.org/dev/peps/pep-0292/) de simplificar los modos de formatear (en este caso el termino más apropiado sería sustituir) cadenas, con el *trade-off* de sacrificar la *expresividad*."
   ]
  },
  {
   "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": [
    "No soportan el protocolo *format*, no es posible realizar conversiones.\n",
    "\n",
    "El bajo rendimiento y su poca flexibilidad son otros de sus puntos débiles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## F-strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¿Qué son?\n",
    "\n",
    "Una forma de *embeber* en objetos tipo *String* expresiones que se evalúan en tiempo de ejecución."
   ]
  },
  {
   "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": [
    "### ¿Qué cambios suponen? \n",
    "\n",
    "**Ninguno**, los métodos anteriores no han sido *deprecados*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### ¿Qué ventajas nos aportan?\n",
    "\n",
    "Dos fundamentalmente: \n",
    "\n",
    "1. Claridad: Sin duda el principal aporte de las `F-strings` es la mejora de la legibilidad  de nuestro código."
   ]
  },
  {
   "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. Rendimiento: una `F-string` en primer lugar se evalúa la expresión en tiempo de ejecución y después se combina con la porción literal para devolver la cadena final. No existe ningún otro requerimiento, esto las hace muy rápidas y eficientes, al mismo nivel que la interpolación y superiores a `format`."
   ]
  },
  {
   "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": [
    "Con `LOAD_METHOD` *Python* referencia a la función `format` a la que posteriormente llama en `CALL_METHOD` lo cual resulta más pesado que el tratamiento con `F-strings` libre de este *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": [
    "Podemos comprobarlo en la práctica con una sencilla prueba."
   ]
  },
  {
   "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": [
    "### ¿Cómo funciona?\n",
    "\n",
    "En la  **compilación** solo se podrá detectar errores de sintaxis, por ejemplo si nos dejamos alguna llave (`{` o `}`)  _coja_.\n",
    "\n",
    "Al **ejecutar**, la expresión se evaluará en el contexto en el que aparezca la `F-string`, por lo que tendrá pleno acceso a las *variables locales y globales*.\n",
    "\n",
    "En el siguiente ejemplo los `print` son totalmente equivalentes."
   ]
  },
  {
   "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": [
    "### ¿Cómo se usan?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "Debemos formar una cadena literal a la que se le antepone el prefijo `f` o `F`.\n",
    "\n",
    "Por lo demás, su tratamiento es equivalente al de cualquier otra cadena, por ejemplo el carácter que inicia el entrecomillado debe ser igual al que lo finaliza.\n",
    "\n",
    "Una vez *tokenizada*, una `F-string` se descompone en cadenas literales y expresiones, estas últimas deben de contenerse entre llaves: `{expr}`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "Para escapar una llave, necesitaremos doblarla `{{` o `}}`.\n",
    "\n",
    "Dentro de una expresión no están permitidos los carácteres de comentario `#` y escape `\\` , este último inconveniente puede ser solventado alternando el carácter de entrecomillado o usando el *triple quoting*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "Opcionalmente y como última parte de una expresión se puede especificar un tipo de conversión, con un funcionamiento análogo a `format`: `!s`  llama a `str()`, `!r` a `repr()` y `!a` a `ascii()`.\n",
    "\n",
    "Añadir que se pueden usar *especificadores de formato*, en cuyo caso una vez evaluada la expresión se *parsean* al método `__format__` del objeto resultante para que sean interpretados."
   ]
  },
  {
   "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",
    "hora = decimal.Decimal('13.29999999999999999999')\n",
    "\n",
    "f'''Playing with {{ {\" f-strings '-) \".upper()!s:-^20} }} {datetime.now():%Y}{hora:{width}.{precision}}'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "También podemos usar `F-strings` en *modo raw*, añadiendo el prefijo `r` o `R` . De esta forma el carácter de escape `\\` no será interpretado."
   ]
  },
  {
   "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",
    "**Nota**: Equivalente al de `format`."
   ]
  },
  {
   "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",
    "En este caso, IMO esto es más una ventaja que un problema, a estas alturas de la película todos deberíamos estar al menos en esta versión de y evitar el \"*Legacy Python*\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Docstrings\n",
    "\n",
    "La evaluación en *runtime* descarta la posibilidad de que las `F-strings` puedan usarse para documentar código."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Quoting \n",
    "\n",
    "La sintaxis de las `F-strings` pueden resultar un tanto ardua en lo que se refiere al *entrecomillado*, de hecho existe una propuesta, la [PEP536](https://www.python.org/dev/peps/pep-0536/) que aboga por su modificación que, entre otras, cosas permitiría el uso de las comillas dentro de la expresión con independencia de las *exteriores* permitiendo código del tipo: `f'Magic wand: {bag['wand']:^10}'`.\n",
    "\n",
    "Esta `PEP` se encuentra en estado *Deferred*, es decir, no hay ningún desarrollador Core que se haya prestado voluntario a desarrollarla."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Dicts\n",
    "\n",
    "El uso con diccionarios puede resultar mucho mas *cómodo* con `format`."
   ]
  },
  {
   "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",
    "Al usar `F-strings` con logging podemos *toparnos* con problemas de **rendimiento** debido a la llamada automática al método `__str__` del objeto."
   ]
  },
  {
   "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": [
    "En caso de que esto suponga un problema resulta más conveniente usar la *interpolación tradicional*."
   ]
  },
  {
   "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",
    "Las mayores críticas a este nuevo sistema basan su *argumentación* en que rompe, en teoría, este principio. Las nuevas funcionalidades estarían cubiertas por los métodos previos lo cual produce una *sobrecarga* en el lenguaje."
   ]
  },
  {
   "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": [
    "# ¡¡ Gracias !!\n",
    "### Contacto: 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
}