formatted_strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d3a84106-4609-4f97-a7e4-20c862e8b3d7",
   "metadata": {},
   "source": [
    "# The print function and string formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a643a4b-3d71-4951-bda7-d9e1b9f63b80",
   "metadata": {},
   "source": [
    "## Assigning variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10e24e97-af2c-4400-bb35-89ad621f8a8e",
   "metadata": {},
   "source": [
    "Let's create three basic variables ```a```, ```b```, and ```c``` that are of the data type ```str```, ```int``` and ```float``` respectively. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5937a2a1-33f7-476e-8a4c-a15f608ab5bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "441c92bb-e24d-42a8-aeda-090cb10eb264",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b354765b-aa79-4f6b-b71f-6597ec3d261a",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 1.1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "064cff5c-0753-420d-9329-a8c99c675049",
   "metadata": {},
   "source": [
    "## The print function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ee042f0-743e-4ae2-9f5c-abd3908358b4",
   "metadata": {
    "tags": []
   },
   "source": [
    "The ```print``` function can be used to print the value of an ```object``` as part of the output of a cell. We can look up its docstring using ```?```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9bac3778-7a92-4d26-b009-edb458a97740",
   "metadata": {},
   "outputs": [],
   "source": [
    "? print"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acfbd68d-45f9-4852-854e-51c196d1c82f",
   "metadata": {},
   "source": [
    "The positional input arguments are ```value, ...``` lets assign ```value``` to a ```str```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "876c6d77-e8d0-4773-846c-6830deaa1565",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d82082e0-f1b0-4077-bca1-ac6fcd545626",
   "metadata": {},
   "source": [
    "We can also assign it to an ```object``` ```name```. The ```value``` of the ```object``` will be printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ef3e248b-ba7d-4015-a61b-9fc4b910f3d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "31a09df5-be62-4222-8e6e-f88296bc8dbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "aeff48f6-b058-49d3-b7ec-da564290a7a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1\n"
     ]
    }
   ],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e780b2e-8122-4726-8cfa-e9fc71f85653",
   "metadata": {},
   "source": [
    "The positional input argument ```value, ...``` implies we can print a single value or multiple values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ee95b79d-d77b-4871-b1af-5da7500f61f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9873bac9-22a6-405e-8395-acead05dae93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello hello\n"
     ]
    }
   ],
   "source": [
    "print(a, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c9bb0aa-2a8d-4dd7-8ce1-661e1a4128d6",
   "metadata": {},
   "source": [
    "Notice that the keyword input argument ```sep``` has a default value of ```' '``` meaning a space is inserted between each value. This can be explicitly implied and changed to a new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9f8f6089-1b42-4d55-bda7-efcc6e626dd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello hello\n"
     ]
    }
   ],
   "source": [
    "print(a, a, sep=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4d9779c6-9d6c-4bba-8ed8-2bbc62b94cf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello-hello\n"
     ]
    }
   ],
   "source": [
    "print(a, a, sep=\"-\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325e725e-edd9-42c5-9550-75c0c5f4f5ad",
   "metadata": {},
   "source": [
    "The keyword argument ```end``` has a default value of ```\\n``` (new line) which places a new line after the ```print``` statement. This can be explicitly implied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a2d47a70-c0ba-49e9-8f60-48764cdf48b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello-hello\n",
      "hello+hello\n",
      "helloWilmahello\n",
      "helloCarolinahello\n"
     ]
    }
   ],
   "source": [
    "print(a, a, sep=\"-\", end=\"\\n\")\n",
    "print(a, a, sep=\"+\", end=\"\\n\")\n",
    "print(a, a, sep=\"Wilma\", end='\\n')\n",
    "print(a, a, sep=\"Carolina\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26e11f82-5442-4f8a-8bb4-836addc4f71d",
   "metadata": {},
   "source": [
    "Notice that when ```end``` is changed to a new value, the two print statements continue on the same line as no ```\\n``` (new line) is specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7d714bc9-3fc5-4c31-af0b-e88e120b9890",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello-hello:hello Wilma-Carolina hello\n",
      "hello+hello:hello Javier-Jonnathan hello\n"
     ]
    }
   ],
   "source": [
    "print(a, a, sep=\"-\", end=\":\")\n",
    "print(a, a, sep=\" Wilma-Carolina \", end=\"\\n\")\n",
    "print(a, a, sep=\"+\", end=\":\")\n",
    "print(a, a, sep=\" Javier-Jonnathan \")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "658adab6-463c-42f2-b3c0-b41a023a0317",
   "metadata": {},
   "source": [
    "## The back slash \\"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78082283-d724-4e61-ae4e-16f488e5b726",
   "metadata": {},
   "source": [
    "The back slash can be used within a ```str``` to denote a special character. For example:\n",
    "* ```\\n``` (new line)\n",
    "* ```\\t``` (tab)\n",
    "* ```\\\\``` (back slash)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8bf49397-a0e2-41c7-b513-3f09294c1920",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t hello\n"
     ]
    }
   ],
   "source": [
    "print(\"\\t\",a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e268544c-84df-42b8-8c5b-4e4d339022a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " hello\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n\",a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dbfefa5-13ad-4885-b75a-45dc27db295b",
   "metadata": {},
   "source": [
    "## The rstr (relative str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69a4c558-24cb-486e-ac11-e432bd3600e0",
   "metadata": {},
   "source": [
    "When file paths are copied from the operating system for example ```C:\\Windows\\System32``` they contain a single back slash. To convert them to a ```str``` we must update every back slash to a double back slash (recall the first back slash within a ```str``` denotes we are going to insert a special character and the second back slash denotes that the special character is the back slash)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8f768445-a087-4112-bfea-38a76b57c724",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Windows\\System32\n"
     ]
    }
   ],
   "source": [
    "print(\"C:\\\\Windows\\\\System32\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cc7b7e8-51a6-4bc2-829b-b947ac9a6eb1",
   "metadata": {},
   "source": [
    "A relative str or rstr will automatically convert all instances of ```\\``` in a file path to ```\\\\```. To use a rstr, prepend the ```str``` with ```r```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7289e519-db45-4a82-9be4-8feb544b9493",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C:\\Windows\\System32\n"
     ]
    }
   ],
   "source": [
    "print(r\"C:\\Windows\\System32\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cb98ff6-e2d8-416d-8b35-72f9e0a0e599",
   "metadata": {},
   "source": [
    "## The type function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72536ca4-2eed-44a5-a698-e59d213630fe",
   "metadata": {},
   "source": [
    "The ```type``` function can be used to determine the data type of an object. We can look up its docstring using ```?```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b2a6b58c-01cb-4bb8-8295-da0c428460ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "? type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "adc4f91a-238f-43fa-afaf-27b33d267963",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "319e0e0f-0e68-4ff3-bda0-7bd8cc5596fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "dfd87d22-d63e-4bb9-a152-8dae4525925d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f93d7c98-5b35-46f4-8d68-951727ec43d3",
   "metadata": {},
   "source": [
    "## Inserting variables into a str using str concatenation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70d34817-5db9-4e2c-bd81-a0e4d2ddb749",
   "metadata": {},
   "source": [
    "Sometimes we will want to print the value of a variable incorporated into a ```str```. We can do this using ```str``` concatenation with the ```+``` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b49b8947-76d8-4bab-a7aa-d428fd88a62e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is the wordhello.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is the word\"+a+\".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b03ddb01-4e1f-4407-9ee5-c8ab44910b56",
   "metadata": {},
   "source": [
    "Note that we have to manually specify spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c3abe425-cbf5-4a31-91ed-f6af6e30b083",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is the word hello.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is the word \"+a+\".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f51f45a-8d45-4558-b917-9f0bd96be7e0",
   "metadata": {},
   "source": [
    "When the object is not a ```str```. We have to cast it to a ```str``` using the ```str``` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "9d558cda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 1.\n"
     ]
    }
   ],
   "source": [
    "print(\"b is \"+str(b)+\".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e0edc8b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(\"c is \"+str(c)+\".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ed1306c-44d0-4f8f-b97d-3779d3f36b3d",
   "metadata": {},
   "source": [
    "## The fstr (formatted str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9c70c63-f72a-4929-a23f-f34f365a6a12",
   "metadata": {},
   "source": [
    "object values can be placed within a str using the a formatted ```str``` or ```fstr```. The ```fstr``` must be prepended with an ```f``` and the ```object``` name to be inserted is enclosed with a ```{}```. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ed2db8a7-88cd-42fd-b0d0-75311a0ff8de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello.\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "4d23d2df-fc91-4634-b9dd-0421cc849cfc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 1.\n"
     ]
    }
   ],
   "source": [
    "print(f\"b is {b}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "6d57a91c-9dc0-40d8-9137-dba0bedc95ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(f\"c is {c}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b89669-b3b8-4733-9707-226cc3038898",
   "metadata": {},
   "source": [
    "We can insert multiple objects in each ```fstr```, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "319249ac-1d33-4713-a164-6674b6d4200d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello, b is 1 and c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a}, b is {b} and c is {c}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24422b71-2e99-4133-bdd5-cd0e82b4ff31",
   "metadata": {
    "tags": []
   },
   "source": [
    "Within the placeholder ```{object}``` a format specification can be added by use of a colon ```:```. A letter is used to denote the object data type:\n",
    "\n",
    "* ```s``` for a ```str`` \n",
    "* ```d``` for a decimal ```int```\n",
    "* ```f``` for a ```float```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eec4d680-d961-49d8-93d4-0211f42bb592",
   "metadata": {},
   "source": [
    "### The str placeholder ns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "020fb850-e916-43c4-85ab-0ef153ec1923",
   "metadata": {},
   "source": [
    "Let's have a look at the formatting options for a ```str```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "04650eda-3347-43ba-8938-baa21bc2cdcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello.\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e59724b9-f463-48f7-bdda-4fa9ecab25c1",
   "metadata": {},
   "source": [
    "If we just use ```s``` the ```str``` will ```print``` out using the defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7ff6ef60-3c18-483c-a430-fc04ad40caeb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello.\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a:s}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "171d2ef0-aa17-4a60-a569-0cd52b0da44c",
   "metadata": {},
   "source": [
    "We can prepend an int ```n``` to specify the number of characters the ```str``` should specify. By default the number of characters used will be the length of the ```str```. Let's set ```n``` to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4521e5fd-5c9a-4c7d-b668-861eb95ff693",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello     .\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a:10s}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c8f2676-b788-4d8d-a863-fb5fa77656a3",
   "metadata": {},
   "source": [
    "Note that this can be used to left justify some printed ```str```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4692a843-feb7-4c7b-8bef-a0cc0723eeec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello     .\n",
      "a is hellohello.\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a:10s}.\")\n",
    "print(f\"a is {a+a:10s}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e80f88e-9826-4eaf-90ca-64c5544e7491",
   "metadata": {},
   "source": [
    "Note that ```str``` methods ```capitalize```, ```upper``` and ```lower``` can be used to format the text of the ```str```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "bd4a18df-1db3-45d4-b94c-0dba2a6050cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is Hello     .\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a.capitalize():10s}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "86083ecc-003a-46ed-94fc-a967c48cb0a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is HELLO     .\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a.upper():10s}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "167cf199-95a3-4e0a-9460-a918f1e7994d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello     .\n"
     ]
    }
   ],
   "source": [
    "print(f\"a is {a.lower():10s}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b7cf721-53c8-4eef-8953-d60231a1f96a",
   "metadata": {},
   "source": [
    "### The decimal int placeholder 0nd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0ef9019-fe60-4750-8348-7cb8e31866b7",
   "metadata": {},
   "source": [
    "Let's now have a look at the formatting options for a decimal ```int```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "759c6605-4a5f-4e0d-a163-9b0695f74061",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 1.\n"
     ]
    }
   ],
   "source": [
    "print(f\"b is {b}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7cee8ae-05a9-4b10-a71c-7c00a22b8513",
   "metadata": {},
   "source": [
    "If we just use ```d``` the ```int``` will print out using the defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "fb3d64f1-c19f-46c0-ba00-66996d100000",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 1.\n"
     ]
    }
   ],
   "source": [
    "print(f\"b is {b:d}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41e940d1-854e-4dc9-b641-faf4b9d55679",
   "metadata": {},
   "source": [
    "Once again we can specify the number of characters to be displayed using ```n```. Let's set ```n``` to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "abe3cae0-5c1a-4132-a710-9080648529df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is          1.\n"
     ]
    }
   ],
   "source": [
    "print(f\"b is {b:10d}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f225bc0b-02af-4b59-8969-d5fa39535ee9",
   "metadata": {},
   "source": [
    "If we want to display leading zeros, we can also prepend ```n``` with a ```0```. Let's use 010."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "fde26a38-ea40-48e0-80f7-3facd68fc231",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 0000000001.\n"
     ]
    }
   ],
   "source": [
    "print(f\"b is {b:010d}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c77437b-0d62-47a6-8825-b40974315bf7",
   "metadata": {},
   "source": [
    "This can be quite useful for objects such as time and dates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "c7f0567f-f516-49fc-8f9c-e7f12ddabbc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "day = 4\n",
    "month = 5\n",
    "year = 2021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "4df90dbb-cdf6-4c42-ae96-928d4fb2a4dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The date is 4-5-2021.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The date is {day}-{month}-{year}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "bc67ae74-8217-4474-b23e-bcbd12609609",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The date is 04-05-2021.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The date is {day:02d}-{month:02d}-{year:04d}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "d2ab5dc5-dbcc-4cd8-869e-91d2c816efcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "hour = 8\n",
    "minute = 5\n",
    "second = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "7a8967bb-176b-499c-ab80-bdf312b42991",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The time is 8:5:7.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The time is {hour}:{minute}:{second}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e4a34c89-eda7-444f-8972-4e047fb5173e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The time is 08:05:07.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The time is {hour:02d}:{minute:02d}:{second:02d}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40694c09-c18a-4ba8-9d18-846fe9d3e450",
   "metadata": {},
   "source": [
    "Note there are specific formatting options available for a ```datetime``` object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d044795-d5f6-47a2-810d-553da0738bf6",
   "metadata": {},
   "source": [
    "### The float placeholder 0n.mf"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb7d9549-f825-4d7e-945b-107582e69749",
   "metadata": {},
   "source": [
    "Let's now have a look at the formatting options for a ```float```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "1939fe2e-0fa4-4c10-96f4-1a664f9e19cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(f\"c is {c}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d582ea80-bb9d-4ea1-a992-0aa2d2cd4c70",
   "metadata": {},
   "source": [
    "If we just use ```f``` the ```float``` will print out using a default of 6 decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5c4c5bc6-097c-4ff9-84fb-debef822105b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is 1.100000.\n"
     ]
    }
   ],
   "source": [
    "print(f\"c is {c:f}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63086526-74b8-4f80-96b0-1435490db3da",
   "metadata": {},
   "source": [
    "Once again we can specify the number of characters to be displayed using ```n```. Let's set ```n``` to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "f9850e2c-f227-4932-aea9-e334ce7d053b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is   1.100000.\n"
     ]
    }
   ],
   "source": [
    "print(f\"c is {c:10f}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f6b38a5-0683-40c9-9e70-009002e85f83",
   "metadata": {},
   "source": [
    "Once again if we want to display leading zeros, we can also prepend ```n``` with a ```0```. Let's use 010."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "69363cf1-4d72-4f71-914f-958e33d47213",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is 001.100000.\n"
     ]
    }
   ],
   "source": [
    "print(f\"c is {c:010f}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "296e3fee-fabf-4463-8b0d-fd1167848a54",
   "metadata": {},
   "source": [
    "Notice that there are ten characters in ```001.100000``` and including the character of the decimal point ```.```."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ce5fb31-b6dc-417b-b9dc-342bebb5772b",
   "metadata": {},
   "source": [
    "The ```float``` is automatically specified to 6 decimal places. This may not be desired, particularly when the ```float``` represents a physical value from a measurement. Take for example the ruler below, it has cm markings and divisions for a mm. If a distance measurement of 21 mm is represented as a float in terms of the meter unit. 0.021 m makes much more sense than 0.021000 as the latter implies μm accuracy opposed to the mm accuracy of the measurement."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1e4c26e-37dd-44ba-8fd1-b22dd412686e",
   "metadata": {},
   "source": [
    "Let's create a ```float``` of the distance and now use a ```fstr``` to print it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "89390877-b197-47c5-85ae-8810cf4064c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "distance = 0.021"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "dce7c9fc-3577-45d7-baa1-d1de32d3e1a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The distance is 0.021000 m.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The distance is {distance:f} m.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64b24891-f4bf-482b-a90c-60df252bd5cd",
   "metadata": {},
   "source": [
    "We see the distance is displayed with μm precision. We can update the placeholder to specify the number of decimal places using the form ```0n.mf``` where ```n``` is the number of characters to display including the decimal point ```.``` and ```m``` is the precision i.e. the number of characters displayed after the decimal point. Let's set ```n``` to 6 and ```m``` to 3. This means we will have 6 characters in total, 3 after the decimal point, the decimal point itself and 6-3-1=2 before the decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "dbff3e0a-6d86-460a-92eb-2467e9a7022d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The distance is 00.021 m.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The distance is {distance:06.3f} m.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19aba219-3d12-4b0c-9898-6a6e5aa2608b",
   "metadata": {},
   "source": [
    "Note that it is far more common to specify ```.mf``` opposed to ```0n.mf```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "49d607b0-5f4b-4684-99fd-d695e5dd8256",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The distance is 0.021 m.\n"
     ]
    }
   ],
   "source": [
    "print(f\"The distance is {distance:.3f} m.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "269469c5-2d8f-4f4a-8d94-d91a1693e6eb",
   "metadata": {},
   "source": [
    "Note that an object of the datatype ```int``` can be printed as a ```float```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "52c0b585-7fb7-4312-81a1-97c8721f3fb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 1.000.\n"
     ]
    }
   ],
   "source": [
    "print(f\"b is {b:.3f}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00805b94-3069-4cb0-b2b0-20b317d35225",
   "metadata": {},
   "source": [
    "### The datetime placeholder "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "dad7f199-9148-491a-a7b1-6c72e54cb42a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "now = datetime.datetime.now()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8110de98-8de3-4742-806f-8055b2fd0f5f",
   "metadata": {},
   "source": [
    "For a ```datetime``` object, the current format specifiers can be used:\n",
    "* ```%Y``` year\n",
    "* ```%m``` month\n",
    "* ```%d``` day\n",
    "* ```%H``` Hour\n",
    "* ```%M``` Minute\n",
    "* ```%S``` Second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "d5686ed4-e441-483e-8c13-6a7693323c52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The time is  12:14:01 and the date is  28-05-2021.\n"
     ]
    }
   ],
   "source": [
    "print(f'The time is {now: %H:%M:%S} and the date is {now: %d-%m-%Y}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fff02995-29a0-40e3-947e-8400f1e71699",
   "metadata": {},
   "source": [
    "## The str format method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a509e9a1-696a-4de1-b61c-13fee105df68",
   "metadata": {},
   "source": [
    "```object``` values can also be placed within a str using the ```str``` ```format``` method. The ```str``` ```format``` method can take a variable number of keyword input arguments. Each keyword input argument ```kw``` must also be placed within the ```str``` using a ```{kw}``` placeholder. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "033dedc5-71d6-4386-9215-34de95d565cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is {kw1}.\".format(kw1=\"hello\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "4e623890-9092-4f09-801c-d2f0552b9bf4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 1.\n"
     ]
    }
   ],
   "source": [
    "print(\"b is {kw2}.\".format(kw2=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "2c4af945-57da-4a9e-b503-625417088d65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(\"c is {kw3}.\".format(kw3=1.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f50c056e-60d0-44f2-887c-d744ba57b882",
   "metadata": {},
   "source": [
    "Let's insert the objects ```a```, ```b``` and ```c``` into a ```str``` using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "e94efdbb-94cb-44b2-93c8-e23e326257f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello, b is 1 and c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is {kw1}, b is {kw2} and c is {kw3}.\".format(kw1=a, kw2=b, kw3=c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54b8938c-13f3-4180-96b7-0ffa167a4474",
   "metadata": {},
   "source": [
    "We can name the ```format``` method keyword input arguments ```a```, ```b```, and ```c```. Recall that these will be local to the function and therefore we can assign the values of these to ```a```, ```b``` and ```c``` which come from the main workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b299a8d2-fde8-4a9c-b63f-7691e080bcea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello, b is 1 and c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is {a}, b is {b} and c is {c}.\".format(a=a, b=b, c=c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d600ab7-d852-44ae-bf46-58c111331607",
   "metadata": {},
   "source": [
    "It is also possible to use the ```format``` method with an optional number of positional input arguments instead. When using positional input arguments, no keyword argument is specified in the placeholder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "655d7070-7084-4756-bdc2-61095e553cdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello, b is 1 and c is 1.1.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is {}, b is {} and c is {}.\".format(a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58f5a265-1967-417d-8d5e-074b0e92bcb3",
   "metadata": {},
   "source": [
    "The ```str``` ```format``` method uses the same ```str``` formatting options as the ```fstr```. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "3fff8bb5-2fed-416a-bb22-f75fa54a41d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello     , b is 0000000001 and c is 000001.100.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is {kw1:10s}, b is {kw2:010d} and c is {kw3:010.3f}.\".format(kw1=a, kw2=b, kw3=c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "db27fac3-cf13-4cb4-92f8-c2e2de04ef51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello     , b is 0000000001 and c is 000001.100.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is {:10s}, b is {:010d} and c is {:010.3f}.\".format(a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb744693-a75b-4109-b06a-87bc1697cc32",
   "metadata": {},
   "source": [
    "## str formatting using the % operator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d0d2eae-c9f4-4e08-aee8-c76f1222b785",
   "metadata": {},
   "source": [
    "object values can be placed within a ```str``` using C-style syntax. This type of syntax was commonly used for Python 2. In Python 3 the ```fstr``` and the ```str``` ```format``` method are more commonly used as they are more intuitive.\n",
    "\n",
    "With the C-style syntax a placeholder must be specified within the ```str``` for each object (```%s``` for a ```str```, ```%d``` for a decimal ```int``` and ```%f``` for a ```float```). The ```str``` is preceded by the ```%``` operator which acts on a tuple of the object names to be inserted within the ```str```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "e2c87e34-b5ff-42db-ab47-5e51b09609a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is %s.\"%(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "ca37fd1a-4a8e-4c68-abe3-7822dbc10bb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b is 1.\n"
     ]
    }
   ],
   "source": [
    "print(\"b is %d.\"%(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "ab596b7b-b4f8-4493-ada6-cec6e671cc78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c is 1.100000.\n"
     ]
    }
   ],
   "source": [
    "print(\"c is %f.\"%(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcedecbd-2bcc-4cb9-b87e-12724d960a7e",
   "metadata": {},
   "source": [
    "Incorporating these three objects into a ```str``` gives:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "849fb568-d79f-4e1a-8fa4-f4b7580acffb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is hello, b is 1, c is 1.100000.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is %s, b is %d, c is %f.\"%(a,b,c))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df31da2-5365-4645-8f35-cef9e4f67bb0",
   "metadata": {},
   "source": [
    "With exception to the use of ```%``` opposed to ```:```the format specification in the placeholders is identical to ```fstr``` and the ```str``` ```format``` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "87277b71-f374-42bf-88f3-4fe73e92a729",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is      hello, b is 0000000001, c is 000001.100.\n"
     ]
    }
   ],
   "source": [
    "print(\"a is %10s, b is %010d, c is %010.3f.\"%(a,b,c))"
   ]
  }
 ],
 "metadata": {
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}