LessonM32_BasicObjectTypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PyGIS222/Fall2019/blob/master/LessonM32_BasicObjectTypes.ipynb)\n",
    "\n",
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/PyGIS222/Fall2019/master?filepath=LessonM32_BasicObjectTypes.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notebook Lesson 3.2\n",
    "\n",
    "# Basic Object Types: Numbers, Booleans and Strings\n",
    "\n",
    "This Jupyter Notebook is part of Module 3 of the course GIS222 (Fall2019).\n",
    "\n",
    "This lesson discusses more details of the basic Python object types **Numbers**, **Booleans** and **Strings**. In the aftermath, strings will be further deepened by the subsequent reading material *String Fundamentals* (Lutz, 2013), available in the course's reading list on canvas.\n",
    "\n",
    "Carefully study the content of this Notebook and use the chance to reflect the material through the interactive examples.\n",
    "\n",
    "### Sources\n",
    "Some elements of this notebook source from Chapter 5 and Chapter 7 of Lutz (2013).\n",
    "\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part A: Numeric Object Types in Python\n",
    "\n",
    "Effective data-driven science and computation requires understanding how data is stored and manipulated (VanderPlas, 2016).\n",
    "\n",
    "Most of Python's number types are typical and will seem familiar if you have used other programming languages before. However, numbers are not really a single object type but rather a category. Python supports the usual numeric types (integers and floating point) as well as literals for creating numbers, expressions for processing them and some built-in functions and modules. \n",
    "Python also allows to write integers using hexadecimal, octal and binary literals; offers complex number types Python and allows integers to have unlimited precision - they can grow to have as many ditigs as your memory space allows. Lutz (2013) gives the following overview for numeric object types in Python:\n",
    "\n",
    "Table 1: *Numeric literals and constructors (Lutz, 2013, Table 5.1).*\n",
    "\n",
    "<img src=\"M32_Table_NumericObjects.jpg\" alt=\"Numeric literals and constructors.\" title=\"Lutz (2013), Figure 5-1\" width=\"400\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Built-in numbers are enough to represent most numeric quantities - from your age to your bank balance - but more types are available from external (third-party) Python packages.\n",
    "Below we briefly introduce the most important ones for this course. These are integer and floating numbers as well as Boolean types. The latter allows for logic operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integers\n",
    "\n",
    "Integers are written as strings of decimal digits. These numbers have no fractional component. The size of integer numbers is only limited by your computer's memory. \n",
    "\n",
    "Python's basic number types support the normal mathematical operations, like addition and substraction with the plus and minus signs ```+/-```, multiplication with the star sign ```*```, and two stars are used for exponentiation ```**```. Try to edit and execute the following example performing substractions, multiplications and divisions. What happens? Are the results of all of these operations also of type integer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "345"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "123 + 222"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(123 + 222)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, most mathematical operations involving two integer numbers, will also return an integer number. However, divisions do not return an integer number. This is holds even for divisions without remainder. Instead, thanks to the dynamic typing in Python, we get a floating point number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(4/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python 3 (which we are using here, as you can see from the Kernel type at the top right), if you want to specifically perform an integer division, you have to mark this by using a double division symbol: ```//```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4//2         # integer division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(4//2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just as a side note: The integer division ```//``` in Python 3 is actually a floor division, provided by the Python module math. We will discuss Python modules, at a later point in the course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.floor(123/222)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Floating-point Numbers\n",
    "\n",
    "Floating-point numbers have a fractional component. A decimal point and/or an optional signed exponent introduced by an ```e``` or ```E``` and followed by an optional sign are used to write floating-point numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3.14)    # literal for a floating-point number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "314e-2        # literal for a floating-point number in scientific notation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Floating-point numbers are implemented as C \"doubles\", therefore they get as much precision as the C compiler used to build the Python interpreter gives to doubles (usually that is 15 decimal digits of precision). For more precision, external Python packages have to be used. \n",
    "In addition, Python 3 automatically handles a user-friendly output of floating-point numbers. For example, if we define the mathematical constant π to a numeric object, the unformatted output on screen will have the same length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n",
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "pi_approximate = 3.14\n",
    "pi_accurate = 3.141592653589793\n",
    "print(pi_approximate)\n",
    "print(pi_accurate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, when printing the variable to the screen, you can also change the precision of the output, by using the modulus operator ```%```. If you want to print out 4 digits after the comma, indicate this with ```%.4f``` in the following way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1416\n"
     ]
    }
   ],
   "source": [
    "print('%.4f'%pi_accurate)   # formated screen output using print() for floating-point numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternatively, the output can be formatted in scientific notation or as ingeter number, thought the indicators ```e``` and ```i```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1416e+00\n"
     ]
    }
   ],
   "source": [
    "print('%.4e'%pi_accurate)   # formated screen output using print() for numbers in scientific notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print('%i'%pi_accurate)     # formated screen output using print() for integer numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will discuss further details of formatted output using the print function, further below in the section about strings. \n",
    "\n",
    "Furthermore, since variables are strongly typed in Python, you cannot change their type, but you can change the output to the screen or assign a changed output to another variable.\n",
    "For example, the function ```int()``` truncates a floating-point number into an integer number:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(3.141)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the function ```float()``` does the opposite:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Take notice what happens, if an operation is performed that involves both number types floating-point and integer. In that case, before the Python intepreter performs the operation, it converts the elements of the operation up to the most complicated type. Hence, the output object type of a mathematical operation that includes integer and floating-point numbers will be of floating-point type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(40 + 3.141)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Numeric Tools\n",
    "\n",
    "We have already mentioned some basic mathematic operations. Now let's discuss more expressions available for processing numeric object types and some built-in functions and modules. We will meet many of these as we go along.\n",
    "\n",
    "### *Expression operators:*\n",
    "```+```, ```-```, ```/```, ```*```, ```**```, ```%```, etc.\n",
    "\n",
    "Expressions operators are used for mathematical operations between two numbers. Above listed are the operands of an addition, substraction, division, multiplication, exponent, and modulus. Go to this website to find a comprehensive list of expression operators: https://www.tutorialspoint.com/python/python_basic_operators.htm\n",
    "\n",
    "It is important to keep in mind that:\n",
    "* Mixed operators follow operator precedence (similar to mathematical operations: multiplications precede additions, hence, ```5+1*10=50```. For a full list of precedence orders see table 6.16 in the Python documentation: https://docs.python.org/3/reference/expressions.html)\n",
    "* Parantheses group subexpressions (exactly like in mathematics: ```(5+1)*10=60``` but ```5+(1*10)=50```)\n",
    "* Mixed types are converted up (as already discussed for the last example in the section about floating-point numbers)\n",
    "\n",
    "### *Built-in functions:*\n",
    "Python has some built-in functions and some of them are useful for basic numeric processing. Examples are:\n",
    "```pow()```, ```abs()```, ```round()```, ```int()```, ```hex()```, ```bin()```, etc. The documentation pages of the Python language provides a comprehensive list: https://docs.python.org/3/library/functions.html\n",
    "\n",
    "### *Utility modules:*\n",
    "The packages (modules) ```random``` and ```math``` provide further functions useful for mathematical operations. The documentation pages of the Python language provides a comprehenisve overview of functions coming with the math module: https://docs.python.org/3/library/math.html \n",
    "\n",
    "Such modules have to be imported before first, and then functions in that module can be accessed by combining their names with a literal ```.``` (similar to the example above using the ```math``` function ```floor()``` ):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.floor(3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ```math``` module contains more advanced numeric tools as functions. Conveniently, the math module comes also with some mathematical constants and trigonometric functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.9498743710662"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.141592653589793, 2.718281828459045)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi, math.e    # returns the mathematical constants pi and euler's number e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(math.pi/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After importing the ```random``` module, you can perform random-number generation ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9873197330890641"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.random()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and random selections (here, from a Python *list* coded in square brackets - an object type to be indroduced later in this course module):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choice([1,2,3,4]) # choice([L]) chooses a random element from L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go ahead and use the following code cell to try some of the functions and modules in the examples and/or links above (but be aware that some in the links listed functions request more advanced object types, that we haven't discussed yet)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(3.14)      # ceil(x) returns the smallest integer >= x."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And of course, you can do all of discussed and listed numerical operations with variables that have been assigned with a numerical values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.7071067811865475\n"
     ]
    }
   ],
   "source": [
    "a = math.pi\n",
    "b = math.sin(math.pi*5/4)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using variable of numeric object type with expressions, the following has to be kept in mind for Python:\n",
    "\n",
    "* Variables are created when they are first assigned values.\n",
    "* Variables are replaced with their values when used in expressions.\n",
    "* Variables must be assigned before they can be used in expressions.\n",
    "* Variables refer to objects and are never declared ahead of time.\n",
    "\n",
    "Now, you have gained the most important knowledge to use and process variables of numeric object type in Python. For even more complex numerical operations, especially involving data tables, one has to refer to separate, external Python packages. We will discuss modules in general and external Python packages in specific during a later course module. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python HELP???!!!\n",
    "\n",
    "If you ever wonder what a function's function is without starting any literature or internet search, you may always consult the very useful built-in function ```help()```, through which you can request the manual entry for any function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function abs in module builtins:\n",
      "\n",
      "abs(x, /)\n",
      "    Return the absolute value of the argument.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The returned text delivers information about syntax and semantics of the function. This work also for functions of imported modules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function ceil in module math:\n",
      "\n",
      "ceil(...)\n",
      "    ceil(x)\n",
      "    \n",
      "    Return the ceiling of x as an Integral.\n",
      "    This is the smallest integer >= x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.ceil)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part B: Boolean Types: Truth Values, Comparisons & Tests\n",
    "\n",
    "Python's Boolean type and its operators are a bit different from their counterparts in languages like C. In Python, the Boolean type, ```bool```, is numeric in nature because its two values, ```True``` and ```False```, are basically custom versions of 1 and 0. Also Boolean values ```True``` or ```False``` are treated as numeric *constants* in Python (see the Table 1) and their Boolean object type (```bool```) is actually a subtype (subclass) of integers (```int```). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at some examples to understand how Boolean types and their operators function in Python.\n",
    "\n",
    "### Boolean Truth Values\n",
    "In Python all objects have an inherent *Boolean* true or false value. \n",
    "We can define:\n",
    "\n",
    "* Any nonzero number or nonempty object is true.\n",
    "* Zero numbers, empty objects, and a special object ```None``` are considered false.\n",
    "\n",
    "The built-in function ```bool()```, which tests the Boolean value of an argument, is available to request this inherent value for any variable. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False, True)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 0\n",
    "b = None\n",
    "c = 10.0\n",
    "bool(a), bool(b), bool(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of Python's customization of the Boolean type, the output of Boolean expressions typed at the interactive prompt prints as the words ```True``` and ```False``` instead of the older and less obvious ```1``` and ```0```. Most programmers had been assigning ```True``` and ```False``` to ```1``` and ```0``` anyway. The ```bool``` type simply makes this standard. It's implementation can lead to curious results, though. Because ```True``` is just the integer ```1``` with a custom display format, ```True + 4``` yields integer ```5``` in Python!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By the way, very much like the Boolean values ```True``` and ```False```, also the value ```None``` is a built-in constant. However the  ```None``` value is special, as it basically sets a variable to an empty value (much like a ```NULL``` pointer in C) and it has it's very separate and unique object type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(NoneType, bool)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(None), type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the top of this Python documentation page for explanations of the built-in constants: https://docs.python.org/3/library/constants.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparisons & Equality tests\n",
    "Also comparisons and equality tests return ```True``` or ```False```. Range comparisons can be performed using the expression operators ```<```, ```>```, ```>=```, ```<=```; and equality tests using the expression operators ```==```, ```!=```. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False, True)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < c, a==c, b!=c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how mixed types are allowed in numeric expressions (only). In the first test above, Python compares an integer and a floating-point number with each other as well as a number with the NoneType. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Tests\n",
    "Boolean tests use the logical operators ```and``` and ```or``` and they return a true or false operand object. Such Boolean operators combine the results of other tests in richer ways to produce new truth values. For that, revise also the operator precedence ([Table 6.16 of the Python documentation](https://docs.python.org/3/reference/expressions.html)).\n",
    "More formally, there are three Boolean expression operators in Python, which are typed out as workds in Python (in contrast to other languages):\n",
    "\n",
    "* ```X and Y``` Is true if both ```X``` and ```Y``` are true\n",
    "* ```X or Y``` Is true if either ```X``` or ```Y``` is true\n",
    "* ```not X``` Is true if ```X``` is false (the expression returns ```True``` or ```False```)\n",
    "\n",
    "Here, ```X``` and ```Y``` may be any truth value, or any expression that returns a truth value (e.g., an equality test, range comparison, and so on).\n",
    "\n",
    "Keep in mind, that the Boolean ```and``` and ```or``` operators return a true or false object, not the values ```True``` or ```False```. Let's look at a few examples to see how this works. Compare the following comparison:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2, 3 < 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... with the output of the following Boolean tests:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 or 2, 3 or 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "None or 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 and 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see, that ```and``` and ```or``` operators always return an object. Either the object on the *left* side of the operator or the object on the *right*. If we test their results, using the built-in function ```bool()``` they will be as expected (remember, every object is inherently true or false), but we won't get back a simple ```True``` or ```False```.\n",
    "\n",
    "Furthermore, Boolean ```or``` tests are done in a so called *short-circuit evaluations*. This means the interpreter evaluates the operand objects from left to right. Once it finds the first true operand, it terminates (short-circuits) the evaluation of the rest of the expression. After the first true operand was found, the values of further operands in the expression won't be able to change the outcome of an ```or``` test: ```true``` or anything is always true.\n",
    "\n",
    "Similarily, the Python ```and``` operands stop as soon as the result is known. However, in this case Python evaluates the operands from left to right and stops if the left operand is a ```false``` object because it determines the result: false ```and``` anything is always false.\n",
    "\n",
    "The concept of *short-circuit evaluations* has to be known, to predict the exact output of a Boolean test. Below some examples to study:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or 20  # Evaluation stops after first True object: result is True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 or 20    # Evaluation stops after first non-zero object: result is 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False and 20 # Evaluation stops after first False: result is False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 and False # Evaluation stops after first False: result is False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 and 20   # Evaluation continues until last object: results is 20\n",
    "            # (no zero or false object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 and 20 and 30  # Evaluation continues until last object: results is 30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    "\n",
    "### Chained Comparisons\n",
    "\n",
    "In addition to that, Python allows us to chain multiple comparisons together. Chained compariosns are sort of shorthand for larger Boolean expressions. This allows to perform range tests. For instance, the expression ```(a < b < c)``` tests wheter ```b``` is between ```a``` and ```c```; it is equivalent to the Boolean test ```(a < b and b < c)```. But the former is easier on the eyes (and the keyboard).\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 20\n",
    "b = 40\n",
    "c = 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < b < c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < b and b < c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can build even longer chains or add comparisons into the chained tests. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 < 2 < 3 < 4.0 < 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But the resulting expressions can become nonintuitive, unless you evaluate them the way Python does. The following, for example, is false just because 1 is not equal to 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 2 < 3    # Same as 1 == 2 and 2 < 3 (not same as False < 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, Python does not compare the ```1 == 2``` expression's ```False``` result to 3. This would technically mean the same as ```0 < 3```, which would be ```True```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identity Operators\n",
    "\n",
    "Lastly, identity operators compare the memory locations of two objects. There are two identity operators: ```is``` and ```is not```.\n",
    "\n",
    "* ```is``` evaluates to true if the variables on either side of the operator point to the same object and false otherwise.\n",
    "* ```is not``` evaluates to false if the variables on either side of the operator point to the same object and true otherwise.\n",
    "\n",
    "For example, remember from the last notebook what we have learned about how Variable names are referenced to objects in Python? From that, it becomes obvious the following identity test has to be true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3\n",
    "b = a\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And with identity tests, we can also show, that the Boolean \"number\" ```True``` and the integer number ```1``` are of the same value (both are basically an integer number ```1```), but not of the same object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True == 1    # Same value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True is 1    # But a different object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Types: Summary\n",
    "So let's summarize briefly, what we have discussed about Boolean types and operators:\n",
    "\n",
    "* Any nonzero number or nonempty object is true.\n",
    "* Zero numbers, empty objects, and a special object ```None``` are considered false.\n",
    "* Comparisons and equality tests are applied recursively to data structures.\n",
    "* Comparisons, equality tests and identity operators return ```True``` or ```False``` (which are custom versions of 1 and 0)\n",
    "* Boolean ```and``` and ```or``` operators return a true or false operand object.\n",
    "* Boolean operators stop evaluating (\"short circuit\") as soon as a result is known.\n",
    "\n",
    "Refer back to this website to find a comprehensive list of expression operators, including those for comparisons and equality test as well as logical operators and identity operators: https://www.tutorialspoint.com/python/python_basic_operators.htm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part C: Strings in Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are used to record both, textual information (your name, for instance) as well as arbritrary collection of bytes (such as image file's contents). They are our first example, of what in Python we call a ***sequence*** - **a positionally ordered collection of other objects**. Sequences maintain a **left-to-right order** among the items they contain: their items are stored and fetched by their relative positions. Strictly speaking, strings are sequences of one-character strings; other, more general sequence types include *lists* and *tuples*, coverd later (Lutz, 2013). But let's first begin with the syntax for generating strings.\n",
    "\n",
    "### String Literals\n",
    "\n",
    "Python strings are easy to use and several syntax forms can be used to generate them. For example, we can assign the a string \"```knight's```\" to a variable ```S``` in different ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "knight\"s knight's knights \n",
      "knight's\n"
     ]
    }
   ],
   "source": [
    "S1 = 'knight\"s'       # single quotes\n",
    "S2 = \"knight's\"       # double quotes\n",
    "S3 = '''knights'''    # triple quotes\n",
    "S4 = '\\nknight\\'s'    # escape sequence\n",
    "print(S1 , S2 , S3 , S4, )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single and double-quote characters are interchangeable and they can be enclosed in either. You can also embed one in the other and vice versa, as seen in the examples above. Triple quotes are an alternative to code entire *block strings*. That is a syntactic convenience for coding mulitiline text data.\n",
    "\n",
    "Escape sequences allow embedding of special characters in string cannot easily be typed on a keyborad. In the string literal, one Backslash ```\\``` precedes a character. The character pair is then replaced by a single character to be stored in the string:\n",
    "\n",
    "* ```\\n``` stores a newline\n",
    "* ```\\t``` stores a horizontal tab\n",
    "* ```\\v``` stores a vertical tab\n",
    "* ```\\\\```,```\\'```,```\\''``` for special caracters like Backslash, single quotes or double quotes \n",
    "\n",
    "The ```\\\\``` stores one ```\\``` in the string. While the function print replaces the escape characters (see code cell above). However, the interactive echo of the interpreter keeps showing the special characters as escapes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nknight's\""
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Properties\n",
    "Because strings are sequences, they support operations that assume a positional ordering among its items. For example, one can request the length of a string with the built-in function ```len()```.  And one can select and print out certain items of a string, or in other words, fetch its components with *indexing* expressions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(S1)   # len returns ength of a string sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'k'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S1[0]     # returns the first item from the left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S1[1]     # returns the second item from the left"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, indexing is coded as offsets from the front. The first item is at index 0, the second at index 1 and so on. In addition to that, strings allow the following typcial sequence operations.\n",
    "\n",
    "* slicing: general form of indexing - extract an entire section (slice) of a string in a single step\n",
    "* concatenating: joining two strings into a new string\n",
    "* repeating: making a new string by repeating another\n",
    "\n",
    "Here some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nig'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S1[1:4]    # slicing an index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"knight'sknights\""
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S2 + S3    # concatenating an index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'knightsknightsknights'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S3*3       # Repetition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index operations will be discussed in more detail in the upcoming reading material.\n",
    "\n",
    "Another property of strings in Python is *immutability*. In the previous notebook you have learned about the concepts of mutability and immutability. Now, strings being immutable means they cannot be changed in place after they are created: any operations performed on strings cannot overwrite the values of a string object. But you can always build a new one and assign it to the same name. \n",
    "\n",
    "To illustrate that, let's look at two examples. Immutabilitity means, that you cannot change a single item of a string like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-54-d76515d46702>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mS1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'y'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "S1[1]='y'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, we get a ```TypeError```, stating that string objects do not support item assignment! But we can run expressions to make new objects and reference them to the same name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "S1 = 'y' + S1\n",
    "print(S1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the old object and its reference are then deleted. In fact, Python cleans up old objects as you go. You will learn more about that in the upcoming reading material."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formatted output of strings using ```print()```\n",
    "\n",
    "You have already used ```print()``` to quickly print variable to the screen. The function, however, can be fed with syntax that formats the output of strings and numbers. For that, two different flavors are possible. \n",
    "\n",
    "The original technique available since Python's beginning, which is based on the C language and is used widely:\n",
    "\n",
    "* String formatting expressions: ```'...%s...' % (values)```\n",
    "\n",
    "A newer technique added since Python 2.6:\n",
    "\n",
    "* String formatting method calls: ```'...{}...'.format(values)```\n",
    "\n",
    "The second method is syntactically a bit more complex, expecially since it uses object oriented syntax, which we will discuss at a later point in the course. However, it has a clear advantage, as type codes are optional and different object types handled automatically. \n",
    "\n",
    "Both flavors can be used without (as interactive echo of the interpreter) and with the ```print()``` function. Below you can find a list of type codes useful for the second option (string formatting expressions). The list is not complete, but contains all codes relevant for this course.\n",
    "\n",
    "Table 2: *Selected string Formatting Type Codes.*\n",
    "\n",
    "| Code           | Meaning / Object Type      \n",
    "| :-: | :- |\n",
    "| ```%s```          | String   \n",
    "| ```%c```          | Character (int or str)   \n",
    "| ```%d```          | Decimal (base-10 integer)\n",
    "| ```%i```          | Integer\n",
    "| ```%e```          | Floating-point with exponent, lower case\n",
    "| ```%E```          | Same as ```e``` but uses upper case ```E```\n",
    "| ```%f```          | Floating-point decimal   \n",
    "| ```%```           | Literal % (coded as %%) \n",
    "\n",
    "In the following examples, both formatting techniques are adapted. Try to alter them and learn how they work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The %s robe is green!\" % S2)          # formatting expression\n",
    "print('The {} robe is green!'.format(S2))    # formatting method calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "knifes = 2\n",
    "print(\"The %s has %i knifes in his hand.\" % (S2,knifes))\n",
    "print(\"The {} has {} knifes in his hand.\".format(S2,knifes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Precision of floating points can be controlled for the second formatting method by entering parameter into the curvy brackets, for example in the following way if you want to print two digits after the comma. Also the positions of the variable replacements can be switched: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 2.222 cents in the knight's pockets were stolen.\n",
      "The kni cents in the 2.22 pockets were stolen.\n"
     ]
    }
   ],
   "source": [
    "money = 2.222222\n",
    "print(\"The {1:.3f} cents in the {0} pockets were stolen.\".format(S2,money))\n",
    "print(\"The {0:.3} cents in the {1:0.3} pockets were stolen.\".format(S2,money))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you like to get into the details of the very flexible string formatting using method calls, check the following pages:\n",
    "* https://www.digitalocean.com/community/tutorials/how-to-use-string-formatters-in-python-3 \n",
    "* https://pyformat.info/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Specific Operations and Methods\n",
    "\n",
    "Lastly, I would like to provide an overview of type specific operations for strings in Python.\n",
    "\n",
    "Table 3: *String Type Specific Operations (after Lutz, 2013, Table 7-1).*\n",
    "\n",
    "| Operation                                     | Interpretation      \n",
    "| :-----------                                   | :----------- |\n",
    "| ```S1 + S2```                                 | Concatenate   \n",
    "| ```S1 * 3```                                  | Repeat    \n",
    "| ```S[i]```                                    | Indexing   \n",
    "| ```S[i:j]```                                  | Slicing \n",
    "| ```len(S)```                                  | Length \n",
    "| ```\"The sum of 1 + 2 is %i\" % (1+2)```        | String formatting expression \n",
    "| ```\"The sum of 1 + 2 is {0}\".format(1+2)```   | String formatting method calls\n",
    "| ```.find('pa')```                            | String methods: search \n",
    "| ```.strip()```                               | Remove all leading and trailing whitespace\n",
    "| ```.rstrip()```                              | Remove trailing whitespace\n",
    "| ```.replace('pa','xx')```                    | Replacement\n",
    "| ```.split(',')```                            | Split on delimiter\n",
    "| ```.splitlines()```                          | split string at all ‘\\n’ and return a list of the lines\n",
    "| ```.lower()```                               | Case conversion (to lower case)\n",
    "| ```.upper()```                               | Case conversion (to upper case)\n",
    "| ```.endswith(spam')```                       | End test\n",
    "\n",
    "The first seven entries have been addressed in this notebook. All remaining entries are so called methods. Methods are specific functions that are applied with the following syntax: ```stringname.methodname(arguments)```. The methods in the table are specifically designed to handle strings. These methods may appear to alter the content of strings. However, they are actually not changing the original strings but create new strings as results - because strings are immutable.\n",
    "\n",
    "Investigate and practice the functionality of these methods. You can use the examples below, the Python ```help()``` function or search them in the Python documentation: https://docs.python.org/3/library/stdtypes.html (scroll down to  the section \"String Methods\"). Alternatively, study the following external Jupyter Notebook, which discusses the most important string methods: https://www.digitalocean.com/community/tutorials/an-introduction-to-string-functions-in-python-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = 'Hello World ! '# define a string S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S.find('World')    # find the substring 'World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Class ! '"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S.replace('World','Class')        # replace the substring 'World' with 'Class'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Hello World !', 'hello world ! ', 'HELLO WORLD ! ')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S.rstrip(), S.lower(), S.upper()  # check what happened to the spaces and the letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'World', '!', '']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S.split(' ')       # splits the string at a given delimiter (here space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World ! '"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S                  # even after the performed operations, the immutable string S remains unchanged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "find(...)\n",
      "    S.find(sub[, start[, end]]) -> int\n",
      "    \n",
      "    Return the lowest index in S where substring sub is found,\n",
      "    such that sub is contained within S[start:end].  Optional\n",
      "    arguments start and end are interpreted as in slice notation.\n",
      "    \n",
      "    Return -1 on failure.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.find)     # request help for a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can move on to read the book section about \"Strings in Action\" from Lutz (2013), which you can download on Canvas. The material will strengthen you knowledge about strings sequences, most importantly details about **indexing and slicing**. You can use the code cells below, to practice the examples in the book section. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add your code here\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}