2-basic-operations/formatted-string.ipynb

{
 "metadata": {
  "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.8.5-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python38564bita6c660d366ad41288ccc0d1156e7cceb",
   "display_name": "Python 3.8.5 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formatted String Literal\n",
    "\n",
    "Python 3.6 introduces a new feature that allow you to format string literals in different ways. It is called **formmated string literal** or **f-string**.\n",
    "\n",
    "## f-string\n",
    "\n",
    "An f-string is a string literal prefixed with the letter `f`. For example, `f'Hello World'`. You can think the prefix `f` as a function that formats the string literal according right after it. To make the syntax simple, Python put the `f` as the prefix of its string literal argument.\n",
    "\n",
    "If the f-string only use plain string literal, its result is just the string literal. The result of `f'Hello World'` is `'Hello World'`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Hello World\n"
    }
   ],
   "source": [
    "print(f'Hello World')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You don't use f-string like the above because it is redundant. F-string is useful because it can use a pair of brackets `{}` to embed an expression or a value in the string leteral. Inside the brackets, you can put a literal value (string, number), a variable or an expression that produces a value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Hi Alice, how are you?\nPlease tell Alice that the value of 3 + 5 is 8\n"
    }
   ],
   "source": [
    "name = 'Alice'\n",
    "print(f'Hi {name}, how are you?')\n",
    "\n",
    "print(f'Please tell {name} that the value of 3 + 5 is {3 + 5}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above code allows you to embedded values into a string literal that produce another string. The `{}` works as a placeholder that is replaced by the expression value in it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Embed Values\n",
    "\n",
    "A simple usage of f-string is to embed computation result in a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "The input value of 0.37 is 37.0%\n"
    }
   ],
   "source": [
    "user_input = float(input('Please input a value between 0 and 1: '))\n",
    "print(f'The input value of {user_input} is {user_input * 100}%')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An input of `.37` will print a message `The input value of 0.37 is 37.0%`. You can play it with other numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Format Values\n",
    "\n",
    "The real power of f-string is that it can use **format specifier** after a value to format the value in the resulting string. The syntax is\n",
    "\n",
    "`{placeholder: format-specifier}`\n",
    "\n",
    "The `placeholder` is an expression and `format-specifier` specifies how Python format the expression value. The four common format specifiers are \n",
    "\n",
    "- precision designator\n",
    "- comma separator\n",
    "- minimum width\n",
    "- alignment\n",
    "\n",
    "### Precision Designator\n",
    "\n",
    "The prcision designator specifies the number of decimal places. For example, the format-specifier `.2f` specifies two decimal palces for float.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Pi rounded to two decimal places:  3.14\nPi rounded to four decimal places:  3.1416\n"
    }
   ],
   "source": [
    "PI = 3.1415926\n",
    "print(f'Pi rounded to two decimal places: {PI: .2f}')\n",
    "print(f'Pi rounded to four decimal places: {PI: .4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comma Separators\n",
    "\n",
    "It is better to format large numbers into comma-sperated numbers for easy read."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "You have $ 1,234,567,890.\nThe big number is  1,234,567,890.012345\nThe big number with 2 decimal palces is  1,234,567,890.01235\n"
    }
   ],
   "source": [
    "# d for integer\n",
    "big_money = 1234567890\n",
    "print(f'You have ${big_money: ,d}.')\n",
    "\n",
    "# f for float\n",
    "big_float = 1234567890.012345\n",
    "print(f'The big number is {big_float: ,f}')\n",
    "print(f'The big number with 2 decimal palces is {big_float: ,.5f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `,d` to separate integers by commas. Use `,f` for float without specifing decimal places or `,nf` to specify `n` decimal places."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Minimum Field Width\n",
    "\n",
    "Before a comma or a precision specifier, you can put a number to specify the minimum field width. If the value occupies more spaces, it is ok, otherwise, add space characters to fill the field space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Pi rounded to two decimal places:                 3.14\nA big number with 2 decimal palces is     1,234,567,890.01\nYou have $   1,234,567,890,123\n"
    }
   ],
   "source": [
    "PI = 3.1415926\n",
    "print(f'Pi rounded to two decimal places: {PI: 20.2f}')\n",
    "big_float = 1234567890.012345\n",
    "print(f'A big number with 2 decimal palces is {big_float: 20,.2f}')\n",
    "big_money = 1234567890123\n",
    "print(f'You have ${big_money: 20,d}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above code, the `20` right after the `:` specifies that the value should occupy 20 character spaces.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Field Alignment\n",
    "\n",
    "In the above code, all numberic values are center-aligned and strings are left-aligned. You can use the following alignment designator to change the default behavior:\n",
    "\n",
    "- `<`: Left align\n",
    "- `>`: Rigth align\n",
    "- `^`: Center align\n",
    "\n",
    "Following are some examples: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Welcome **   Alice    **\nWelcome ** Alexander  **\n"
    }
   ],
   "source": [
    "name1 = 'Alice'\n",
    "message1 = f'Welcome ** {name1: ^10} **'\n",
    "name2 = 'Alexander'\n",
    "message2 = f'Welcome ** {name2: ^10} **'\n",
    "print(message1)\n",
    "print(message2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Pi rounded to two decimal places: 3.14                \nPi rounded to for decimal places: 3.1416              \n"
    }
   ],
   "source": [
    "PI = 3.1415926\n",
    "print(f'Pi rounded to two decimal places: {PI: <20.2f}')\n",
    "print(f'Pi rounded to for decimal places: {PI: <20.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Order of Designators\n",
    "\n",
    "As demonstrated in the above examples, the order of designators is\n",
    "\n",
    "`[alignment][width][,][.precision][type]`\n",
    "\n",
    "You have seen types of `f` for float and `d` for integer. There is another type `%` for percentage. It simplifes the format of a value in percentage. For example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "PI in percentage with 3 decimal palces is  314.159%\n"
    }
   ],
   "source": [
    "PI = 3.1415926\n",
    "print(f'PI in percentage with 3 decimal palces is {PI: .3%}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, it automatically convert a number into a percentage value and you can specify the precision.\n",
    "\n",
    "Wow, that's enough for basic formatting tasks. "
   ]
  }
 ]
}