demo_string_formatting.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "colab": {
      "name": "String Formatting in Python.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-yVHIDlHSwfL"
      },
      "source": [
        "<table border=\"0\" align=\"left\" width=\"700\" height=\"144\">\n",
        "<tbody>\n",
        "<tr>\n",
        "<td width=\"120\"><img width=\"100\" src=\"https://static1.squarespace.com/static/5992c2c7a803bb8283297efe/t/59c803110abd04d34ca9a1f0/1530629279239/\" /></td>\n",
        "<td style=\"width: 600px; height: 67px;\">\n",
        "<h1 style=\"text-align: left;\">String Formatting in Python</h1>\n",
        "<p><a href=\"https://colab.research.google.com/github/KenzieAcademy/python-notebooks/blob/master/demo_string_formatting.ipynb\"> <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\" align=\"left\" width=\"188\" height=\"32\" /> </a></p>\n",
        "</td>\n",
        "</tr>\n",
        "</tbody>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HwWYcHTaSwfQ"
      },
      "source": [
        "There are four major ways to format strings in Python. In this notebook we will explore each of the four string formatting techniques."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lAAMuOGXSwfQ"
      },
      "source": [
        "# For example purposes, we'll declare a couple of variables that will be printed and formatted.\n",
        "errno = 50159747054\n",
        "name = 'Mr. Python'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Io_-g8VZSwfT"
      },
      "source": [
        "## Formatting Option 1 &mdash; Old Style\n",
        "The `%` character is used in Python strings to trigger some built-in behavior called \"placeholder substitution\".  This technique is borrowed from early days of C-language programming and its `printf()` library function.  You use the `%` character (with some extra alpha characters) directly in your format string to perform substitution."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nrl5gp6USwfT"
      },
      "source": [
        "# Use `%s` to perform a string variable substitution\n",
        "'Hello, %s' % name"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4tzMyvWtSwfW"
      },
      "source": [
        "There are many different format specifiers that let you control the look of the output string.  You can convert integers to hexadecimal notation, add whitespace, left-justify, pad with zeroes, and so forth.  Have a look at this mini-language within Python:\n",
        "```\n",
        "Flag   Meaning\n",
        "'#'\tThe value conversion will use the “alternate form” (where defined below).\n",
        "'0'\tThe conversion will be zero padded for numeric values.\n",
        "'-'\tThe converted value is left adjusted (overrides the '0' conversion if both are given).\n",
        "' '\t(a space) A blank should be left before a positive number (or empty string) produced by a signed conversion.\n",
        "'+'\tA sign character ('+' or '-') will precede the conversion (overrides a “space” flag).\n",
        "\n",
        "\n",
        "Conversion\tMeaning\tNotes\n",
        "'d'\tSigned integer decimal.\t \n",
        "'i'\tSigned integer decimal.\t \n",
        "'o'\tSigned octal value.\t(1)\n",
        "'u'\tObsolete type – it is identical to 'd'.\t(7)\n",
        "'x'\tSigned hexadecimal (lowercase).\t(2)\n",
        "'X'\tSigned hexadecimal (uppercase).\t(2)\n",
        "'e'\tFloating point exponential format (lowercase).\t(3)\n",
        "'E'\tFloating point exponential format (uppercase).\t(3)\n",
        "'f'\tFloating point decimal format.\t(3)\n",
        "'F'\tFloating point decimal format.\t(3)\n",
        "'g'\tFloating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.\t(4)\n",
        "'G'\tFloating point format. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.\t(4)\n",
        "'c'\tSingle character (accepts integer or single character string).\t \n",
        "'r'\tString (converts any Python object using repr()).\t(5)\n",
        "'s'\tString (converts any Python object using str()).\t(6)\n",
        "'%'\tNo argument is converted, results in a '%' character in the result.\t \n",
        "```\n",
        "\n",
        "The main formatting argument specifiers that you should know are:\n",
        "\n",
        "```\n",
        "%s - String (or any object with a string representation, like numbers)\n",
        "%d - Integers\n",
        "%f - Floating point numbers\n",
        "%.<number of digits>f - Floating point numbers with a fixed amount of digits to the right of the dot.\n",
        "%x/%X - Integers in hex representation (lowercase/uppercase)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hpxijxQtSwfW"
      },
      "source": [
        "# Let's try out the `x` formatter to convert errno into hexadecimal.\n",
        "# Hexadecimal is another word for `base 16`\n",
        "print('Errno is %x' % errno)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sXu3S8EwSwfZ"
      },
      "source": [
        "# If we are printing multiple arguments in the Old-Style way, \n",
        "# we need to enclose all variables as a tuple\n",
        "print('Hey, %s, there is a %x error!!' % (name, errno))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7SrpHZcASwfb"
      },
      "source": [
        "# But we don't HAVE to use a tuple ... we could also pass a keyword dict:\n",
        "print('Hey, %(name)s, there is a %(errno)x error!!' % {'errno': errno, 'name': name})\n",
        "print('Hey, %(name)s, there is a %(errno)x error!!' % dict(name=name, errno=errno))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TaKPIwVpSwfe"
      },
      "source": [
        "Using keyword argument mappings is good form in Python, because you don't need to worry whether the order of the arguments matches up with the order of the values in the format string.\n",
        "\n",
        "Any object which is not a string can be formatted using the `%s` operator as well. The string which returns from the `__repr__` method of that object is formatted as the string.\n",
        "\n",
        "Why is this style of formatting called \"Old Style\"? Because it has been replaced with \"New Style\" formatting (LOL!). Actually replaced is too harsh...let's just say it has been _de-emphasized_. Old Style formatting is still available in all latest versions of Python.\n",
        "\n",
        "**PRACTICE**: In the next cell, write an old-style format string which prints out the data using the following syntax:\n",
        "\n",
        "```console\n",
        "Hello, John Doe. Your current balance is $53.44.\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SoEinzLBSwfe"
      },
      "source": [
        "# Modify the format string\n",
        "data = (\"John\", \"Doe\", 53.44)\n",
        "format_string = \"Hello, %s %s. Your current balance is $%.2f.\"\n",
        "\n",
        "print(format_string % data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qJGJy2FISwfh"
      },
      "source": [
        "## Formatting Option 2 &mdash; New Style\n",
        "New-style formatting became available in Python 3, then was back-ported to Python 2.  It was introduced for syntactic improvement over the `%` operator.  Formatting is now done by calling a built-in `.format()` method on string objects."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kt21y5EoSwfh"
      },
      "source": [
        "# The format() function can do simple positional formatting\n",
        "print('Hello there {}'.format(name))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "73R1WaYLSwfj"
      },
      "source": [
        "# You can also refer to your variable substitutions by name and use them in any order\n",
        "print('By the way {name}, you made a {errno} error.'.format(errno=errno, name=name))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_xezWYmgSwfl"
      },
      "source": [
        "That's not a cool error, however &mdash; it looks better in hexadecimal. The syntax to format an int variable as a hexadecimal string has changed. To display in hex, we use the `:x` suffix after the variable name."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kv3ZnsPYSwfm"
      },
      "source": [
        "print('By the way {name}, you made a 0x{errno:X} error.'.format(errno=errno, name=name))\n",
        "print('By the way {name}, you made a {errno:#x} error.'.format(errno=errno, name=name))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D04ucUUZSwfr"
      },
      "source": [
        "The `format()` style of string formatting has its own [format specification mini-language](https://docs.python.org/3/library/string.html#format-specification-mini-language). In Python, you will constantly be formatting some kind of string &mdash; you should familiarize yourself with this."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "27HL63RQSwfs"
      },
      "source": [
        "# What will be printed?\n",
        "'{0}, {1}, {2}'.format('a', 'b', 'c')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RC0DudzFSwfu"
      },
      "source": [
        "'{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NRMaINtqSwfw"
      },
      "source": [
        "'{2}, {1}, {0}'.format('a', 'b', 'c')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p9JjgK51Swfy"
      },
      "source": [
        "'{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yXeJ6lB3Swf0"
      },
      "source": [
        "'{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kxTnLdJHSwf2"
      },
      "source": [
        "# Here we are accessing arguments by name\n",
        "'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WjFGhPa4Swf5"
      },
      "source": [
        "coord = {'latitude': '37.24N', 'longitude': '-115.81W'}\n",
        "'Coordinates: {latitude}, {longitude}'.format(**coord)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RpPqmrzKSwf7"
      },
      "source": [
        "# We can access attributes of an object\n",
        "from collections import namedtuple\n",
        "Point = namedtuple('Point', 'x y')\n",
        "pt1 = Point(1.0, 5.0)\n",
        "pt2 = Point(2.5, 1.5)\n",
        "\n",
        "'Start from point {0.x}, {0.y} and end at point {1.x}, {1.y}'.format(pt1, pt2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SBG9qpFqSwf8"
      },
      "source": [
        "## Formatting Option 3 &mdash; String Interpolation (Python 3.6+)\n",
        "In Python 3.6, we encounter yet _another_ way to format strings, called _Formatted String Literals_ (Recall that a *string literal* is any string with \"quotes\" around it). With this syntax, we can insert small Python expressions directly into string constants!\n",
        "\n",
        "These are called **f-strings**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NYm6vukjSwf9"
      },
      "source": [
        "# Let's try an f-string\n",
        "errno = 50159747054\n",
        "name = 'Mrs. Python'\n",
        "# You denote an f-string by prefixing a f or F in front of a string literal:\n",
        "print(f'Hello there, {name}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rHt2_6YlSwf_"
      },
      "source": [
        "# What about inserting a Python expression?\n",
        "# This IS string interpolation!\n",
        "a = 12\n",
        "b = 30\n",
        "f'If a = {a} and b = {b}, then their sum is {a + b}'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HuWUpYcFSwgA"
      },
      "source": [
        "This trivial-seeming feature of being able to insert (interpolate) any Python expression into a string literal is **super powerful**. Plus, it **looks great**. Which is more readable?\n",
        "\n",
        "```python\n",
        "# This?\n",
        "logging.warn(\"Disk space for drive {} is low, only {} bytes remaining\".format(driveid, space_left))\n",
        "\n",
        "# Or this?\n",
        "logging.warn(f\"Disk space for drive {driveid} is low, only {space_left} bytes remaining\")\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5D2_gatmSwgL"
      },
      "source": [
        "# Let's try out some formatting exercises\n",
        "import math\n",
        "f\"Pi to 2 digits: {math.pi:.2f}\"  # prints \"Pi to 2 digits: 3.14\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f_DDfQx2SwgM"
      },
      "source": [
        "# Aligning the text and specifying a width:\n",
        "f\"{'left aligned':<20} asdf\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VRQVvaOZSwgO"
      },
      "source": [
        "# Right aligned:\n",
        "print(f\"{'Language':>10}: Python\")\n",
        "print(f\"{'Level':>10}: Expert\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J7Q_o0E3SwgS"
      },
      "source": [
        "# Embed commas in large numbers\n",
        "num = 1234567890\n",
        "f\"{num:,}\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "67FaVnitSwgV"
      },
      "source": [
        "# support all the different numeric bases\n",
        "x = 42\n",
        "print(f\"dec: {x:d}; hex: {x:x}; oct: {x:o}; bin: {x:b}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QggtpAUPSwgX"
      },
      "source": [
        "# Numbers from 5 to 11, expressed in different bases\n",
        "width = 5\n",
        "bases = 'dXob'\n",
        "for num in range(5, 12):\n",
        "  for base in bases:\n",
        "    print(f\"{num:{width}{base}}\", end=\" \")\n",
        "  print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T90hYx9ySwgZ"
      },
      "source": [
        "\n",
        "## Formatting Option 4 - Template Strings\n",
        "It's simpler than `format()`, but less powerful. Template strings are not a core feature of Python. For this reason we must import the Template class from the standard library `string` module."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "96FjnVbySwgZ"
      },
      "source": [
        "from string import Template\n",
        "t = Template('Hey. Aren\\'t you $name?')\n",
        "t.substitute(name=name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OkbscCd1Swgb"
      },
      "source": [
        "One major drawback of template strings is that they don't support format specifiers.  We have to do all our own formatting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-A4D7HtBSwgc"
      },
      "source": [
        "t_string = 'Ahem $name, you have not cleaned up that $errno error!'\n",
        "Template(t_string).substitute(name=name, errno=hex(errno))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AiwQpPW-Swge"
      },
      "source": [
        "Template strings are best suited in cases where the formatting string itself is being supplied through user input.  If users are allow to supply their own formatting strings in an application by design, then template strings are a way to close this security vulnerability.\n",
        "\n",
        "In general, template strings are used when you need a simple templating engine that substitutes values into some boilerplate text to produce an output."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7NYq30MmSwgf"
      },
      "source": [
        "# Template Strings use `$` instead of `%`\n",
        "s = Template('$when, $who $action $what.')\n",
        "output1 = s.substitute(when='In the summer', who='John', action='drinks', what='iced tea')\n",
        "output2 = s.substitute(when='At night', who='Jean', action='eats', what='popcorn')\n",
        "print(output1)\n",
        "print(output2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j18-1Hu_Swgg"
      },
      "source": [
        "## Conclusions &mdash; what to use when?\n",
        "\n",
        " - If users are providing their own format strings, use template strings\n",
        " - If you are on Python 3.6+, use f-strings\n",
        " - Otherwise, use the `format()` method"
      ]
    }
  ]
}