07-strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8z5cONg8rUrX",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Strings\n",
    "\n",
    "## Programming Fundamentals (NB07)\n",
    "\n",
    "### MIEIC/2020-21\n",
    "\n",
    "#### João Correia Lopes\n",
    "\n",
    "FEUP/DEI and INESC TEC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MZzE7pYorju5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Goals\n",
    "\n",
    "By the end of this class, the student should be able to:\n",
    "\n",
    "\n",
    "- Describe how to work with strings as single things\n",
    "\n",
    "- Describe how to work with the parts of a string\n",
    "\n",
    "- Enumerate the main methods available to work with strings\n",
    "\n",
    "- Describe how to format strings\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eR5Lh1jNroE2",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bibliography\n",
    "\n",
    "- Peter Wentworth, Jeffrey Elkner, Allen B. Downey, and Chris Meyers, *How to Think Like a Computer Scientist — Learning with Python 3* (Section 5.1)\n",
    "\n",
    "- Brad Miller and David Ranum, Learning with Python: Interactive Edition. Based on material by Jeffrey Elkner, Allen B. Downey, and Chris Meyers (Chapter 9)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5UO7jDY8YN8C",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Data types: Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sKfnoTuAYVQH",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.1 A compound data type\n",
    "\n",
    "- So far we have seen built-in types like `int`, `float`, `bool`,\n",
    "    `str` and we've seen lists and pairs\n",
    "\n",
    "- Strings, lists, and pairs are qualitatively different from the\n",
    "    others because they are made up of smaller pieces\n",
    "\n",
    "- In the case of strings, they're made up of smaller strings each\n",
    "    containing one **character** in a particular order from left to\n",
    "    right\n",
    "\n",
    "- Types that comprise smaller pieces are called **collection or\n",
    "    compound data types**\n",
    "\n",
    "- Depending on what we are doing, we may want to treat a compound data\n",
    "    type as a single thing\n",
    "\n",
    "- A string that contains no characters, often referred to as the **empty string**, is still considered to be a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text Sequence Type — str\n",
    "\n",
    "  - Textual data in Python is handled with str objects, or strings\n",
    "  \n",
    "  - Strings are immutable sequences of Unicode code points. \n",
    "  \n",
    "  - String literals are written in a variety of ways:\n",
    "\n",
    "    - Single quotes: 'allows embedded \"double\" quotes'\n",
    "\n",
    "    - Double quotes: \"allows embedded 'single' quotes\".\n",
    "\n",
    "    - Triple quoted: '''Three single quotes''', \"\"\"Three double quotes\"\"\"\n",
    "\n",
    "  - Triple quoted strings may span multiple lines - all associated whitespace will be included in the string literal.\n",
    "\n",
    "https://docs.python.org/3/library/stdtypes.html#textseq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wTgmwtPbYaW-",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.2 Working with strings as single things\n",
    "\n",
    "- Just like a turtle, a string is also an object\n",
    "\n",
    "- So each string instance has its own attributes and methods (around\n",
    "    70!)\n",
    "\n",
    "- For example:\n",
    "\n",
    "```\n",
    "  >>> our_string = \"Hello, World!\"\n",
    "  >>> all_caps = our_string.upper()\n",
    "  >>> all_caps\n",
    "  'HELLO, WORLD!'\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/smethods.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q5FuQ6ONgaUU",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "our_string = \"Hello, World!\"\n",
    "our_string.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try a \"TAB\" after the colon (\".\") to see the names of the available string methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ba0Tp-xXnKQV",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Operations on Strings\n",
    "\n",
    "In general, you cannot perform mathematical operations on strings, even if the strings look like numbers. \n",
    "\n",
    "The following are illegal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kK8qu9bjnluq",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fruit = \"banana\"\n",
    "fruit - 1\n",
    "fruit * \"Hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qSwQyO5pnpVw",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Interestingly, the + operator does work with strings, but for strings, the + operator represents **concatenation**, not addition. \n",
    "\n",
    "Concatenation means joining the two operands by linking them end-to-end. \n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EPaGgRDAnvUC",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fruit = \"banana\"\n",
    "bakedGood = \" nut bread\"\n",
    "print(fruit + bakedGood)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "npZqA-9vgkuN",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.3 Working with the parts of a string\n",
    "\n",
    "- The **indexing operator** selects a single character substring from\n",
    "    a string:\n",
    "\n",
    "```\n",
    "  >>> fruit = \"banana\"   # a string\n",
    "  >>> letter = fruit[0]  # this is also a string\n",
    "  >>> print(letter)\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/sindex.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aTA6JoWjoT4P",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The characters are accessed by their *position* or *index value* (the expression in brackets). \n",
    "\n",
    "For example, in the string shown below, the 14 characters are indexed left to right from postion 0 to position 13.\n",
    "\n",
    "![string](images/07/s-index.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1zVfL745gpPk",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "mieic = \"Master in Informatics and Computing Engineering\"\n",
    "m = mieic[0]\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "J_fdJ-U_pf6B",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "lastchar = mieic[-1]\n",
    "print(lastchar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O_Fa3Pyyg0zj",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.4 Length\n",
    "\n",
    "- The `len` function, when applied to a string, returns the number of\n",
    "    characters in a string:\n",
    "\n",
    "```\n",
    "  size = len(word)\n",
    "  last = word[size-1]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bjZch9lig51J",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "word = \"Monty\"\n",
    "size = len(word)\n",
    "word[size-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pd9J3Sp7q7bl",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(size)\n",
    "print(word[size-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What do we get here?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7tnO4OR0rNeb",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "last = word[size]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dvZ21ss6jWXc",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.5 Traversal and the `for` loop\n",
    "\n",
    "- A lot of computations involve processing a *string one character at\n",
    "    a time*\n",
    "\n",
    "- Often they start at the beginning, select each character in turn, do\n",
    "    something to it, and continue until the end\n",
    "\n",
    "- This pattern of processing is called a **traversal**\n",
    "\n",
    "```\n",
    "  word = \"Banana\"\n",
    "  for letter in word:\n",
    "      print(letter)\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/straversal.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uhsi-7XqtWxa",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Since a string is simply a sequence of characters, the for loop *iterates* over each character automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8yZzvRjEjc28",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "words = \"Monty Python\"\n",
    "for l in words:\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1l32ckj4tcRf",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Recall that the loop variable takes on each value in the sequence of names. The body is performed once for each name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "u6uh0NxitFvH",
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for aname in [\"Eric\", \"Graham\", \"John\", \"Michael\", \"Terry\"]:\n",
    "    invitation = \"Hi \" + aname + \".  Please come to my party on Saturday!\"\n",
    "    print(invitation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6rgCgl8btufD",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Traversal and looping: By Index\n",
    "\n",
    "- It is also possible to use the range function to systematically generate the indices of the characters. \n",
    "\n",
    "- The for loop can then be used to iterate over these positions. \n",
    "\n",
    "- These positions can be used together with the indexing operator to access the individual characters in the string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Try this (and then see it using [Python tutor](http://www.pythontutor.com/visualize.html#mode=edit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "l2gCoHdst8RT",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fruit = \"apple\"\n",
    "for idx in range(5):\n",
    "    currentChar = fruit[idx]\n",
    "    print(currentChar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "p5qkIQRzupZp",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Likewise:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JM2w2I5Huu5d",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "fruit = \"apple\"\n",
    "\n",
    "position = 0\n",
    "while position < len(fruit):\n",
    "    print(fruit[position])\n",
    "    position = position + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XDtNZt7Djpc8",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.6 Slices\n",
    "\n",
    "- A substring of a string is obtained by taking *a slice*\n",
    "\n",
    "- Similarly, we can slice a list to refer to some sublist of the items\n",
    "    in the list\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/slices.py>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "K8-BAwRGrrtm",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "singers = \"Eric, Graham, John, Michael, Terry\"\n",
    "print(singers[0:4])\n",
    "print(singers[14:18])\n",
    "print(singers[:-22])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nztU9CyxjyIx",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.7 String comparison\n",
    "\n",
    "- The comparison operators work on strings\n",
    "\n",
    "- To see if two strings are equal:\n",
    "\n",
    "```\n",
    "  if word == \"banana\":\n",
    "      print(\"Yes, we have bananas!\")\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/scomparison.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "w2eePpH0s2fp",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "word = \"zebra\"\n",
    "\n",
    "if word < \"banana\":\n",
    "    print(\"Your word, \" + word + \", comes before banana.\")\n",
    "elif word > \"banana\":\n",
    "    print(\"Your word, \" + word + \", comes after banana.\")\n",
    "else:\n",
    "    print(\"Yes, we have no bananas!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xIxSSLala4VJ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Strings are compared lexicographically by comparing corresponding elements, as you can see:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jQECISTvZ7Sj",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"zebra\" < \"banana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1xq6cyc3ac2k",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"Zebra\" < \"banana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Jpkhcy9FaPyW",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(\"zebra\" < \"Banana\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4U1ehZAFj8Kn",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.8 Strings are immutable\n",
    "\n",
    "- Strings are **immutable**, which means you can't change an existing\n",
    "    string\n",
    "\n",
    "- The best you can do is create a new string that is a variation on\n",
    "    the original\n",
    "\n",
    "```\n",
    "  greeting = \"Hello, world!\"\n",
    "  greeting[0] = 'h'            # ERROR!\n",
    "\n",
    "  greeting = \"h\" + greeting[1:]\n",
    "  print(greeting)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "See the difference beteewn the following two examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9b1dimY3kCXH",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "greeting = \"Hello, world!\"\n",
    "greeting[0] = 'h'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "M0trLy9LkNxG",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "greeting = \"Hello, world!\"\n",
    "greeting = \"h\" + greeting[1:]\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8OhBxuARkWXK"
   },
   "source": [
    "## 5.1.9 The `in` and `not in` operators\n",
    "\n",
    "- The `in` operator tests for membership\n",
    "\n",
    "- The `not in` operator returns the logical opposite results of `in`\n",
    "\n",
    "```\n",
    "  >>> \"p\" in \"apple\"\n",
    "  True\n",
    "  >>> \"i\" in \"apple\"\n",
    "  False\n",
    "  >>> \"apple\" in \"apple\"\n",
    "  True\n",
    "  >>> \"\" in \"a\"\n",
    "  True\n",
    "  >>> \"x\" not in \"apple\"\n",
    "  True\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/removeVowels.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Try, analyse the result and change the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hJqc0h1Zu65E",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print('p' in 'apple')\n",
    "print('i' in 'apple')\n",
    "print('ap' in 'apple')\n",
    "print('pa' in 'apple')\n",
    "print('apple' in 'apple')  # a string is a substring of itself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hphoRBqMY1lg",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## 5.1.10 A `find` function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z8vSHA8WwGp4",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `enumerate` function\n",
    "\n",
    "- Enumerate is a built-in function of Python\n",
    "\n",
    "\n",
    "```\n",
    " enumerate(iterable, start=0)\n",
    "```\n",
    "\n",
    "- Return an *enumerate object*\n",
    "\n",
    "- *iterable* must be a sequence, an *iterator*, or some other object which supports iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Try the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qMUKcSQXwMJv",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "some_list = ['apple', 'banana', 'grapes', 'pear']\n",
    "for counter, value in enumerate(some_list):\n",
    "    print(counter, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lbWerFEPw3Qi",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_list = ['apple', 'banana', 'grapes', 'pear']\n",
    "for c, value in enumerate(my_list, 1):\n",
    "    print(c, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OntfCWoueWF9",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "words = \"Eric Idle, Michael Palin\"\n",
    "for i, ch in enumerate(words):\n",
    "    print(i, \":\", ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VwGXgCjJkbtc",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### A `find` function\n",
    "\n",
    "- In a sense, find is the opposite of the indexing operator\n",
    "\n",
    "- What does the following function do?\n",
    "\n",
    "```\n",
    "  def my_find(haystack, needle):\n",
    "  \"\"\"\n",
    "  No clues here!\n",
    "  \"\"\"\n",
    "  for index, letter in enumerate(haystack):\n",
    "      if letter == needle:\n",
    "          return index\n",
    "  return -1\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/sfind.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Compare the output of the code above with what Python does itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def my_find(haystack, needle):\n",
    "  for index, letter in enumerate(haystack):\n",
    "      if letter == needle:\n",
    "          return index     # eureka traversal or short-circuit evaluation\n",
    "  return -1\n",
    "\n",
    "haystack = \"Bananarama!\"\n",
    "print(\"Mine:\", my_find(haystack,'a'))\n",
    "print(\"Python's:\", haystack.find('a'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KMpIprackjc5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.11 Looping and counting\n",
    "\n",
    "- another example of the **counter** pattern (introduced in *Counting\n",
    "    digits*)\n",
    "\n",
    "```\n",
    "  def count_a(text):\n",
    "      count = 0\n",
    "      for letter in text:\n",
    "          if letter == \"a\":\n",
    "              count += 1\n",
    "      return count\n",
    "  \n",
    "  print(count_a(\"banana\") == 3)\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/scount.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Kr3beiNbvfvL",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try this one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nN-s17XvkwqR",
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def count_c(text, char):\n",
    "    count = 0\n",
    "    for c in text:\n",
    "        if c == char:\n",
    "            count = count + 1\n",
    "    return count\n",
    "\n",
    "print(count_c(\"banana\",\"a\"))\n",
    "print(count_c(\"banana\",\"b\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xUW-BpY_k-Bp",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.12 Optional parameters\n",
    "\n",
    "- To find the locations of the occurrence of a character in a string, starting at any position (with 0 as default)\n",
    "\n",
    "- we can modify the `find` function, adding a third parameter for the\n",
    "    starting position in the search string to a `find_2`function\n",
    "\n",
    "- Better still, we can combine `find` and `find2` using an **optional\n",
    "    parameter**:\n",
    "\n",
    "```\n",
    "  def find(haystack, needle, start=0):\n",
    "      for index,letter in enumerate(haystack[start:]):\n",
    "          if letter == needle:\n",
    "              return index + start\n",
    "      return -1\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/optional.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Let's do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def find2(haystack, needle, start):\n",
    "    for index,letter in enumerate(haystack[start:]):\n",
    "        if letter == needle:\n",
    "            return index + start\n",
    "    return -1\n",
    "\n",
    "print(find2(\"banana\", \"a\", 2) == 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "One way of doing it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "PJz4G_swxxTt",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def find(astring, needle, start=0):\n",
    "    \"\"\"\n",
    "    Find and return the index of a char (the needle) in a string (astring).\n",
    "    Return -1 if achar does not occur in astring.\n",
    "    \"\"\"\n",
    "    ix = start\n",
    "    found = False\n",
    "    while ix < len(astring) and not found:\n",
    "        if astring[ix] == needle:\n",
    "            found = True\n",
    "        else:\n",
    "            ix = ix + 1\n",
    "    if found:\n",
    "        return ix\n",
    "    else:\n",
    "        return -1\n",
    "\n",
    "print(find('banana', 'a', 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VnVYV_kGlI_X",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.13 The built-in `find` method\n",
    "\n",
    "- The built-in `find` method is more general\n",
    "\n",
    "- It can find substrings, not just single characters:\n",
    "\n",
    "```\n",
    "  >>> \"banana\".find(\"nan\")\n",
    "  2\n",
    "  >>> \"banana\".find(\"na\", 3)\n",
    "  4\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"banana\".find(\"nan\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The built-in `index` method\n",
    "\n",
    "  - Python string method `index()` is same as `find()`, but raises an exception if the substring is not found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"banana\".index(\"nan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "\"banana\".index(\"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UnuMxMgflOYZ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.14 The `split` method\n",
    "\n",
    "- One of the most useful methods on strings is the `split` method\n",
    "\n",
    "- it splits a single multi-word string into a list of individual\n",
    "    words, removing all the whitespace between them<sup>1</sup>\n",
    "\n",
    "```\n",
    "  >>> phrase = \"Oh, that's jolly good. Well, off you go then\"\n",
    "  >>> words = phrase.split()\n",
    "  >>> words\n",
    "  ['Oh,', \"that's\", 'jolly', 'good.', 'Well,', 'off', 'you', 'go', 'then']\n",
    "```\n",
    "\n",
    "<sup>1</sup> Whitespace means any tabs, newlines, or spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6qEgOJ3tyhm7",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "phrase = \"Oh, that's jolly good. Well, off you go then.\"\n",
    "print(phrase.split())\n",
    "print(type(phrase.split()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "GroRZT7olVz4",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.15 Cleaning up your strings\n",
    "\n",
    "- We'll often work with strings that contain punctuation, or tab and\n",
    "    newline characters\n",
    "\n",
    "- But if we're writing a program, say, to count word frequency, we'd\n",
    "    prefer to strip off these unwanted characters.\n",
    "\n",
    "- We'll show just one example of how to strip punctuation from a\n",
    "    string\n",
    "\n",
    "    - we need to traverse the original string and create a new string,\n",
    "        omitting any punctuation\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/strip.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "c6Hl6S2ZboKR",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s = \"  I'm not  clean.  \"\n",
    "print(s)\n",
    "print(s.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7QkhAR6alciD",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 5.1.16 The string `format` method\n",
    "\n",
    "- The easiest and most powerful way to format a string in Python3 is\n",
    "    to use the `format` method\n",
    "\n",
    "- The template string contains place holders, ... `{0}` ...`{1}`\n",
    "    ...`{2}` ...etc\n",
    "\n",
    "- The format method substitutes its arguments into the place holders\n",
    "\n",
    "- To see how this works, let's start with a few examples:\n",
    "\n",
    "```\n",
    "  phrase = \"His name is {0}!\".format(\"Arthur\")\n",
    "  print(phrase)\n",
    "\n",
    "```\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/format.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Try it here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TW1sKduJyZVJ",
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "name = \"Alice\"\n",
    "age = 10\n",
    "phrase = \"I am {0} and I am {1} years old.\".format(age, name)\n",
    "print(phrase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gyVioFYFlf0x",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Format specification\n",
    "\n",
    "- Each of the replacement fields can also contain a **format\n",
    "    specification**\n",
    "\n",
    "- This modifies how the substitutions are made into the template, and\n",
    "    can control things like:\n",
    "\n",
    "    - whether the field is aligned to the left **`<`**, center\n",
    "        **`^`**, or right **`>`**\n",
    "\n",
    "    - the width allocated to the field within the result string (a\n",
    "        number like 10)\n",
    "\n",
    "    - the type of conversion: we'll initially only force conversion to\n",
    "        float, **`f`** or perhaps we'll ask integer numbers to be\n",
    "        converted to hexadecimal using **`x`**)\n",
    "\n",
    "    - if the type conversion is a float, you can also specify how many\n",
    "        decimal places are wanted: typically, **`.2f`** is useful for\n",
    "        working with currencies to two decimal places\n",
    "\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/tree/master/lectures/07/formatspec.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_1TvY01XbyrU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## f-strings\n",
    "\n",
    "From Python 3.6 onwards there's f-strings:\n",
    "\n",
    "\n",
    "```\n",
    "name = \"Eric\"\n",
    "age = 74\n",
    "f\"Hello, {name}. You are {age}.\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ydRiRiL6cD3z",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Because f-strings are evaluated at runtime, you can put any and all valid Python expressions in them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k_pPbfXVcFXK",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f\"{2 * 37}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WJFjXjXzcIu7",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "But you could also call functions. Here’s an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Tbk_SzszcJh7",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def to_lowercase(input):\n",
    "    return input.lower()\n",
    "\n",
    "name = \"Eric Idle\"\n",
    "f\"{to_lowercase(name)} is funny.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4vVXRqT4cYOT",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "You also have the option of calling a method directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vAPIasPmcY9M",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "f\"{name.lower()} is funny.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lT1FtkSycbPU",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "*f-strings* are faster than both *%-formatting* and `str.format()`. \n",
    "\n",
    "As you already saw, *f-strings* are expressions evaluated at runtime rather than constant values.\n",
    "\n",
    "[PEP 498 -- Literal String Interpolation](https://www.python.org/dev/peps/pep-0498/#abstract)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "To sum up the Python string formatting best practices, see: https://realpython.com/python-string-formatting/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "myRr0idGZV9y",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operations on Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2AjwpghpclZy",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "### Common string operations\n",
    "\n",
    "- See the Python Standard Library for a comprehensive list of\n",
    "    operations on strings:\n",
    "    \n",
    "<https://docs.python.org/3.7/library/string.html>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "See some useful constants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1IBOTwtgyOsB",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import string\n",
    "print(string.ascii_lowercase)\n",
    "print(string.ascii_uppercase)\n",
    "print(string.digits)\n",
    "print(string.punctuation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Zz-UtV8ORH_t",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ticket to leave"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C-hchAExRRVh",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Moodle activity\n",
    "\n",
    "[LE07: Strings](https://moodle.up.pt/course/view.php?id=1738#section-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uV1OP6ahRYne",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "\n",
    "$\\Rightarrow$ \n",
    "[Go back to the Table of Contents](00-contents.ipynb)\n",
    "\n",
    "$\\Rightarrow$ \n",
    "[Read the Preface](00-preface.ipynb)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "8z5cONg8rUrX",
    "Zz-UtV8ORH_t"
   ],
   "name": "07-strings.ipynb",
   "private_outputs": true,
   "provenance": [],
   "toc_visible": true
  },
  "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": 1
}