f-strings/f-strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# f-Strings\n",
    "\n",
    "There are several ways to format textual data into strings, including [`string.format()` and *%-formatting*](../formatted-printing/README.ipynb). As of python 3.6, the easiest and most performant is *f-strings*.\n",
    "\n",
    "\n",
    "## What Is an f-string?\n",
    "\n",
    "An *f-string* is a format string that includes references to variables in the local context. What this basically means is the string describing the format is able to \"see\" variables and can refer to them directly within the string. A basic example, using three different "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "regular print: 10\n",
      "using string.format(): 10\n",
      "using f-string: 10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "print('regular print:', x)\n",
    "print('using string.format(): {0}'.format(x))\n",
    "print(f'using f-string: {x}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the f-string is just a regular string but preceeded with the letter `f`, so that you get something like:  `formatted_string = f'some  text and {references} {to} {different} {variables}'`.\n",
    "\n",
    "\n",
    "### Basic String Characteristics\n",
    "\n",
    "f-strings enhance basic strings, so most of the rules about basic strings apply. These are all normal strings without variables as f-strings:\n",
    "\n",
    "* `f''`\n",
    "* `f'my string'`\n",
    "* `f'a string with something in the same quotes (\\'...\\') inside'`\n",
    "\n",
    "If you are not including variables within your string, you can still express it as an f-string. This is likely not the most performant approach, but it is fully supported.\n",
    "\n",
    "Within an f-string, any expression inside curly brackets (`{ ... }`) is evaluated as part of the string. So what can you put inside those curly brackets?\n",
    "\n",
    "\n",
    "### Basic Expressions\n",
    "\n",
    "Primitive values and expressions evaluate the same way they would outside a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 + 3 = 5\n"
     ]
    }
   ],
   "source": [
    "my_string = f'2 + 3 = {2 + 3}'\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable References\n",
    "\n",
    "Within the string, variables can be referenced by name. Assuming `x` has some value (string, integer, list, object, whatever), the following will insert `x` into the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "want to see some content? look no further!\n"
     ]
    }
   ],
   "source": [
    "x = 'some content'\n",
    "my_string = f'want to see {x}? look no further!'\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and Lookups\n",
    "\n",
    "You can index lists and look up dictionary values just like you would expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the [2] index of [5, 6, 7, 8, 9] is 7\n"
     ]
    }
   ],
   "source": [
    "x = list(range(5, 10))\n",
    "print(f'the [2] index of {x} is {x[2]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the ['b'] key in {'a': 1, 'b': 2, 'c': 3} points to 2\n"
     ]
    }
   ],
   "source": [
    "x = {'a': 1, 'b': 2, 'c': 3}\n",
    "print(f'the [\\'b\\'] key in {x} points to {x[\"b\"]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note in the last example that there are escaped quotes of the type surrounding the string and also the use of the other quote type (`\"` instead of `'`). Using the other quote type in this way prevents having to have lots of backslashes, but either works.\n",
    "\n",
    "\n",
    "### Function Calls\n",
    "\n",
    "You can also make function calls within f-strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling increment(3) returns: 4\n"
     ]
    }
   ],
   "source": [
    "def increment(x):\n",
    "    return x + 1\n",
    "\n",
    "print(f'calling increment(3) returns: {increment(3)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multi-Line f-strings\n",
    "\n",
    "Sometimes you want to create a string that includes linefeeds. You can do that with regular strings this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the quick brown fox jumps over\n",
      "the lazy dog\n"
     ]
    }
   ],
   "source": [
    "sentence = '''the quick brown fox jumps over\n",
    "the lazy dog'''\n",
    "\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... with f-strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the quick brown fox jumps over\n",
      "the lazy dog\n"
     ]
    }
   ],
   "source": [
    "obstacle = 'lazy dog'\n",
    "sentence = f'''the quick brown fox jumps over\n",
    "the {obstacle}'''\n",
    "\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also break your stirng up over several lines to make it easier to read and maintain:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This paragraph starts normal. Then you realize it is not actually a single string.\n"
     ]
    }
   ],
   "source": [
    "paragraph = (\n",
    "    'This paragraph starts normal. '\n",
    "    'Then you realize it is not actually a single string.'\n",
    ")\n",
    "\n",
    "print(paragraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... with f-strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This paragraph starts normal. Then you realize it isn't actually a single string.\n"
     ]
    }
   ],
   "source": [
    "start_emotion = 'normal'\n",
    "is_not = \"isn't\"\n",
    "\n",
    "paragraph = (\n",
    "    f'This paragraph starts {start_emotion}. '\n",
    "    f'Then you realize it {is_not} actually a single string.'\n",
    ")\n",
    "\n",
    "print(paragraph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "* [Python 3's f-Strings: An Improved String Formatting Syntax (Guide)](https://realpython.com/python-f-strings/)\n",
    "* [PEP 498 -- Literal String Interpolation](https://www.python.org/dev/peps/pep-0498/)\n"
   ]
  }
 ],
 "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}