session-1/first_contact.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Programming with Python\n",
    "\n",
    "*Programming*: the act of instructing computers to perform tasks (Wikipedia)\n",
    "\n",
    "*Python*: a programming language, i.e. a formal language specifying means and rules for programming a computer\n",
    "\n",
    "### quick note about this document\n",
    "\n",
    "This jupyter notebook is one of the course teachers' notes and cheat sheet. The actual lesson in class uses this as its basis, but it will never appear on a screen there. Instead, everything happens live in an interactive terminal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming...\n",
    "\n",
    "You've probably already done it to some extent. If you have ever used a unix terminal console and written things like\n",
    "\n",
    "```sh\n",
    "ls\n",
    "cd myproject\n",
    "echo \"when it's done\" > deadline.txt\n",
    "```\n",
    "\n",
    "(maybe not the third line), then you are already familiar with some computer programming, according to the definition above! In this case, you have programmed with the \"unix shell\" language. You have used the interactive prompt to issue commands, one at a time. You could also have written a sequence of commands in a file, and then run that all at once. That would have been called a \"shell script\", and they are very common. Et voila, programming. You've already been there."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming languages\n",
    "\n",
    "Programming languages must be understood by both humans and computers. Humans must be able to both read and write them, while computers often just have to be able to read them.\n",
    "\n",
    "Like natural \"spoken\" languages, programming languages have grammar and syntax and vocabulary. So there are words that mean something and there are rules how you can combine them in order to express something. But unlike natural languages, programming languages don't have things like \"subjects\" and \"verbs\" and \"objects\", but other things, for example \"statemens\" and \"expressions\" and \"functions\". They are quite different to spoken languages.\n",
    "\n",
    "Yet, the established way we tell a computer what to do is (currently still) programming languages. Especially when we're talking about complex things. One day we might be able to convey complex programs to a computer with natural language, but we aren't there yet. So if you want to program today, you have to learn a programming language.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python\n",
    "\n",
    "Python is a very popular programming language in the science community, and you're here to learn it. A very good way to learn it is to try things out in the interactive Python interpreter, which acts in some ways like the unix shell you already know. You write a line of code, press enter, and the interactive interpreter runs the code immediately.\n",
    "\n",
    "(Note: this concept is called REPL - \"read, evaluate, print loop\", and it's become very popular in programming. It's immensely useful for doodling and learning)\n",
    "\n",
    "Start the interactive interpreter in a unix shell like so:\n",
    "\n",
    "```\n",
    "ipython\n",
    "```\n",
    "\n",
    "and then you can talk python to the computer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First steps in the REPL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple statements: arithmetic expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whenever I write something (let's call it a \"statement\") in the REPL and press enter, then the REPL will print whatever is the result of what I wrote (if there is any). The result of just writing 1 is 1, and this may seem a little weird at first. But look at this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This hopefully begins to makes more sense, intuitively. The REPL **r**eads the statement \"1 + 1\", **e**valuates it (to 2 obviously), and **p**rints the result, 2.\n",
    "\n",
    "Before, in the first line, the REPL read the statement \"1\", evaluated it to 1 (nothing more to evaluate beyond that), and printed the result, 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python code consists of such (and other) statements. So \"1 + 1\" is a-okay Python code. It's a statement that can be evaluated. It even has a result, \"2\". A statement with a result is called an expression. Don't worry, you don't need to accurately remember these terms right now, but I'll use them because these are the correct terms. You'll quickly get used to them.\n",
    "\n",
    "I can write all sorts of statements into the REPL. Easy examples to start with are arithmetic expressions, which work out pretty much like you would expect from intuition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 4 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * (4 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3333333333333335"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 / 2.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, let's look at these expressions and understand intellectually what they are in the eyes of a computer.\n",
    "\n",
    "\"1\" is a trivial expression that evaluates to \"1\".\n",
    "\"1+1\" is a not that trivial an expression, but it's not hard to understand what it is: it is a combination of more expressions. There are two \"1\"s (easy), and there's a \"+\". The Python language defines \"+\" with something to the left and the right of it as an expression that can be evaluated to a result. Python evaluates that, if the stuff left and right is numbers, to the sum of these numbers. As you'd expect from your intuition.\n",
    "\n",
    "The takeaway for now is that you can combine expressions! The result of one expression can be used in another expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * (1 + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use the interactive python interpreter like a basic calculator :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can remember the result of an expression for later by storing it in the computer's memory, into a so-called *variable*. Don't confuse the term with the mathematical term \"variable\" you're probably familiar with. In the context of programming, variable just means \"name that I use to refer to something that I've stored in the computer's memory\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it, now I can use 'a' in statements, and it currently has the value 1.\n",
    "\n",
    "By the way, notice that the REPL didn't print anything back now. That is because the statement \"a = 1\" does not have a result (by the language's definition). It's a-okay Python code, it's just a statement that doesn't have a result.\n",
    "\n",
    "A statement of this form, `<name> = <some expression>` is called an *assignment*.\n",
    "\n",
    "Back to a. Let's use a!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was easy. Or at least trivial. This was just the REPL evaluating my statement \"a\", which it identified as the name of a variable, which it evaluated to its current value, 1, which becomes the result of the statement because there's nothing more to evaluate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here I combined the first expression with another expression, using the \"+\" operator. Python dutifully evaluates that stuff to the best of its ability, coming up with the result, 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here I assign all of that to `b`. What is b's value now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's 1. Sure it is."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now? Is it still 1? Or is it 2 now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Still 1! Why? Didn't we define `b` to be equal to `a`?\n",
    "\n",
    "Answer: we did not define `b` to be equal to `a`. It might look a bit like that if we read Python assignments like mathematical equations, but they are not the same thing at all.\n",
    "\n",
    "What we actually did was that we *assigned* to the variable named `b` the result of the expression `a`. The result of that expression was 1 at the time we asked the python interpreter to evaluate it. That result became the value of b. b knows nothing about how the result was obtained. Python does not keep track of assignments and expressions and re-evaluates them \"when necessary\". Python just executes one statement after another and that's it.\n",
    "\n",
    "So don't think of the `=` sign like you think of it in a mathematical context. Rather, translate it in your head to \"is assigned to the result of the expression ... right now\". So read `b = a` as \"`b` is assigned to the result of the expression `a` (which is 1) right now\".\n",
    "\n",
    "This is quite different behavior than, say, an Excel spreadsheet, which you might be familiar with. This is very normal behavior for a programming language, though. Most behave like this, Python included."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now our basic calculator can remember values. Let's move on to functions!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calling functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll dive right in. Functions that do things to numbers look and behave much like mathematical functions (i.e. without surprises), so they're a good starting point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We called the function named \"abs\" here. \"abs\" takes an argument, -1 here, does something and then *returns* the absolute value of the argument. \"Return\" means that the function at some point says \"my value for the given argument is this!\". So when the python interpreter evaluates the statement with the function call (\"abs(-1)\"), it replaces the whole thing with that value. Which means the whole thing evaluates to that value.\n",
    "\n",
    "Overall, we're looking at an expression here, because abs(-1) has a result. And guess what goes into the function, language-wise... a value. Which can be the result of an expression! Check these things out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(1 - 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = abs(1-a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just expressions and function calls."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can have more than one argument. They are separated by comma. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(1+1, a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Something else than numbers: Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python doesn't deal only with numbers. Numbers are just one (several actually, but never mind now) *data type* among many. Another important data type is so called \"strings\", a programmer's fancy word for \"text\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In an important way, a string and a number are the same thing: they are both data. In programming terms, that means that variables can be assigned to them, they can be used in expressions. So they can be used as arguments to functions, they can be the input or output of computations.\n",
    "\n",
    "But numbers and text are of course not the same thing. You can't subtract a number from text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-bd7b56582fbc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"hello\"\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "\"hello\" - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our first error message! Don't try to decipher it just yet, we'll get to that later. Just note that it says `TypeError`, which means that the Python interpreter wasn't happy with the types you gave it. Types being number and string here... as expected, this didn't work."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what *can* we do with strings? Well, check these things out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world!'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + \" world!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What was that? Add one string to another? Yes... the Python language defines that the *addition operator*, when there are strings on both sides of it, puts the strings together. Putting to strings together is called *concatenation*.\n",
    "\n",
    "It sort of makes sense that addition on two strings means concatenation. This isn't necessaritly true for other arithmetically looking operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-e655d249aea4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;34m\"o\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "a - \"o\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check that error message now... Python says: I don't know what to do with a \"-\" when there are strings to the left and right of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hellohellohello'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok... sort of makes sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'str' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-35-ec8ab00ab28d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'str' and 'int'"
     ]
    }
   ],
   "source": [
    "a / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for /: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-36-cc62050d252c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m3\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for /: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "3 / a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-ca42ed42e993>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "a + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This error message looks a bit different, but means the same: \"+\" on string and number is not defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-38-4a317a22d93c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "1 + a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Beyond numbers and strings: booleans!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The name of this stems from mathematician George Bool, who introduced boolean algebra in the 19th century with his book \"The Mathematical Analysis of Logic\". Although the term \"boolean algebra\" wasn't used before the 20th century.\n",
    "\n",
    "Boolean algebra is basically algebra on logical values *true* and *false* (or 1 and 0). In programming, we often deal with \"yes or no? true or false?\" questions, and data that represents these values are called *booleans*.\n",
    "\n",
    "Here are all boolean values, and some boolean operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As any other data, you can store a boolean into a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = False or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common scenario when we're dealing with boolean values is when we use them as results of some sort of check (for equality for instance) and then do something depending on whether our check was \"true\" or \"false\". More on such *conditional expressions* later. First, checks!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 3 == 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "== checks for equality, and evaluates to true if the things to the left and right of it are equal, false otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 == 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other checks include >, <, <=, >=, !=. Strings can also make use of some of these. Can you figure out what they mean?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"b\" > \"a\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"boo\" > \"aaaa\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every piece of data in Python has a *type*. Like \"number\" (several types for that actually), \"string\", \"boolean\", \"file\" (we'll see that later), whatever.\n",
    "\n",
    "The type of some data determines what values said data can assume. It's \"domain\" in mathy-speak. A whole number (called integer) can only be whole numbers, not 3.5 for instance. A \"real\" number, represented in computer hardware usually as \"floating point number\" (a can of worms!), assumes numbers with something behind the decimal point. A \"string\" can be any text of any length. A boolean is either \"true\" or \"false\".\n",
    "\n",
    "The type of some data also determines what you can do with the data. You may do arithmetic with numbers, for instance. You can concatenate strings. But you can't divide strings by something, or add a number to a string.\n",
    "\n",
    "We can see what type something is using the \"type\" function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a + 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 99999999999999999999999999999999999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a < 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a < 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float pitfalls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that Python (as many other programming languages) has two numerical types, int and float. This is really inconvenient in practice, but there are also very good reasons for this. The main reason we care about is that float numbers are by their nature (nature as in the IEEE 754 representation of them in basically all computers) inexact, while integers are not. A very good writeup can be found in the Python documentation: https://docs.python.org/3/tutorial/floatingpoint.html\n",
    "\n",
    "And here's the jaw dropper taken directly from that documentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.1 + 0.1 == 0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's hard to find a better example to illustrate that computer math and actual math are not the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.1 + 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computer math just approximates actual math, and knowing how to deal with this is a funny computer science topic. But for now, let me throw one final insult at you:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.1 == 0.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should know how to do it right. This can't be done without using some language features you haven't seen yet. Don't worry, you will see them all in due time. So here's how you do it (described [here](https://docs.python.org/3/whatsnew/3.5.html#pep-485-a-function-for-testing-approximate-equality)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.isclose(0.1 + 0.1 + 0.1, 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you're interested to understand what's going on, just read the linked document above - it's not hard to understand at all.\n",
    "\n",
    "The takeaway is: use floats only if you have to, and when you do, be mindful of the rounding errors and inaccuracy that comes with them. Otherwise stick to integers.\n",
    "\n",
    "Oh, and this is not Python's fault. This is just how (virtually all?) computers behave."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mixing floats and ints\n",
    "\n",
    "Python will readily do arithmetic on a mix of integers and floats. Whenever a mix of ints and floats is encountered, the result will be a float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.1"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 4.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar magic happens when dividing to ints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.75"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 / 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Division of two integers always results in a float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want \"integer division\" ([euclidean division](https://en.wikipedia.org/wiki/Euclidean_division)), then you can do it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 // 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 // 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"remainder\" of an integer division can be computed with the modulo operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 % 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \"dotting\" into data... objects"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've talked about \"pieces of data\" and variables. So far, it looked like all that's \"in\" a piece of data is the data's type and its value, as in \"a is an integer with the value 5\", or \"a is a string with the value 'hello'\", or even \"'hello' is a string with the value 'hello'\".\n",
    "\n",
    "But actually, there's more to it than just that. \"Pieces of data\" are, in Python, almost without exception, so-called *objects*. I'll try to explain what that means conceptually later, but show right away what it means in practice: we can \"dot into\" objects. Look at this screenshot from ipython:\n",
    "\n",
    "![Screenshot](screenshot_dotting.png)\n",
    "\n",
    "I got this by typing \"a.\" and then pressing the TAB key. What we see here is functions, lots of functions. It's easy to explore what they do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function str.capitalize>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.capitalize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aha, a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.capitalize?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try this in ipython and you'll get a helptext! (It works in a notebook too, but you'll get the helptext in a separate little box in your browser)\n",
    "\n",
    "```Docstring:\n",
    "S.capitalize() -> str\n",
    "\n",
    "Return a capitalized version of S, i.e. make the first character\n",
    "have upper case and the rest lower case.\n",
    "Type:      builtin_function_or_method\n",
    "```\n",
    "\n",
    "Let's try that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Dotting into\" works on any object (\"piece of data\"), even if it's not stored in a variable. (We call that a \"literal\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\".capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also works on numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.bit_length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...but not on number literals. Can you figure out why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-72-ae568eb235f5>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-72-ae568eb235f5>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    7.bit_length()\u001b[0m\n\u001b[0m               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "7.bit_length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hint: the interpreter is confused about the dot.\n",
    "\n",
    "You'll notice that you find different things when you dot into numbers than when you dot into strings. This makes perfect sense, as <number>.capitalize() should not exist. In general, the type of an object dictates what stuff you find behind the dot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, in general, if you have an object a and a function a.func, then func is a function that does something with a. It might return something, or it might change a (we'll see examples for that later), or both. You can think of a.func as a function whose first argument is the object, a.\n",
    "\n",
    "Of course it could have more arguments as well. Example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\".count(\"l\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"Objects\" as a programming language construct deserve a more thorough explanation, but for starters we can leave it at this: objects are pieces of data you can \"dot into\". You'll find functions (or variables) in there, which tell you something about the object, act on the object, might even change the object.\n",
    "\n",
    "There's a whole paradigm of programming with accompanying languages called \"object-oriented programming\". Python supports writing in an object-oriented style, although it doesn't force you to do so. (This is why Python is often described as a \"multi-paradigm language\"). We won't bother with details here, just know that \"objects\" are an important concept not only in Python.\n",
    "\n",
    "Explained in a less immediately accessible but profound way you often hear programmers say, \"object\" means that a piece of data contains/describes not only its type and value, but its behavior as well. This has upsides and downsides, and many programmers will happily spend lots of time explaining to you why it is a huge mistake with only downsides."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The print() function, with variable number of arguments and keyword arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A super important function is print(). It takes whatever argument you throw at it and prints it to the screen. As soon as you leave the confines of the interactive Python interpreter, this is the only way you can write something to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how there is no \"Out\\[number\\]\" visible on screen. print() doesn't return anything. It just prints to the screen and that's it.\n",
    "\n",
    "A few more examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jibber jabber\n"
     ]
    }
   ],
   "source": [
    "print(\"jibber\", \"jabber\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "print() supports a \"variable number of arguments\". You can throw in one, or two, or as many as you want! In the documentation this is usually denoted by using the following notation: print(\\*objects). This notation is used in the web version of the Python documentation, see here: https://docs.python.org/3/library/functions.html#print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 4 three objects!\n"
     ]
    }
   ],
   "source": [
    "print(3,4,\"three objects!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you check the documentation on print in ipython (by writing \"print?\" in ipython), you'll see the \"variable number of arguments\" denoted in a different, just slightly less common way: \"print(value, ...)\".\n",
    "\n",
    "Anyway, you see that print also supports some so-called \"optional keyword arguments\". Here are some in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jibber-jabber STOP\n"
     ]
    }
   ],
   "source": [
    "print(\"jibber\", \"jabber\", sep=\"-\", end=\" STOP\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sequence in which you give keyword arguments doesn't matter, but all keyword arguments have to be at the end. So no non-keyword arguments after the first keyword argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jibberjabber STOP\n"
     ]
    }
   ],
   "source": [
    "print(\"jibber\", \"jabber\", end=\" STOP\\n\", sep=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String formatting: f-strings\n",
    "\n",
    "We often want to make strings like \"Hi, Alice!\" or \"a is 10 and that is an even number\" - i.e. construct them in code. This is called \"string formatting\".\n",
    "\n",
    "There are many ways to do string formatting. We did it a bit already above, albeit clumsily. Now we'll look at a proper way to di it. The most recently introduced into the language and very warmly welcomed way: f-strings, or, long, [formatted string literals](https://docs.python.org/3/reference/lexical_analysis.html#f-strings).\n",
    "\n",
    "Basically, you write a string literal and put an 'f' in front of it, and then you have the magic of f-strings available to you! Let's dive right in with a simple example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi, Alice!'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = \"Alice\"\n",
    "f\"Hi, {name}!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it for starters! Just to prove to you that this trick really only works with f-strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hi, {name}!'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hi, {name}!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f-strings, once \"made\", can be used just like any other object. Store them into a variable, do stuff with that, print later... whatever."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the swapped string: hI, aLICE! - funny, eh?\n"
     ]
    }
   ],
   "source": [
    "s = f\"Hi, {name}!\"\n",
    "s_swapped = s.swapcase()\n",
    "print(f\"the swapped string: {s_swapped} - funny, eh?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f-strings are a relatively recent addition to the Python language. They were introduced in Python 3.6, which went into production in december 2016. You might encounter an older version of Python somewhere. If you are that unlucky, you might have to stick to one of the older methods of string formatting. These will be shown tomorrow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive input using prompts\n",
    "\n",
    "We will soon leave the interactive Python interpreter and write our first script file. When you run a script, there are many ways to provide data to it: command line arguments, reading stuff from files, downloading something from the internet etc.\n",
    "\n",
    "One way that has gone a little bit out of fashion maybe (at least on the text console) is that the program you run asks you for some information, and you type in that information with your keyboard. This is called a *prompt*. We'll use it here now because it is so easy to do, and thus really good when just getting started with Python. You will learn about all the other methods later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gimme your name: Gaius Julius Caesar\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Gimme your name: \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When that line runs, the program execution pauses and waits for keyboard input. As soon as the enter key is pressed, the program is resumed. The \"input\" function returns whatever was typed in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You typed in: Gaius Julius Caesar\n"
     ]
    }
   ],
   "source": [
    "print(f\"You typed in: {name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First exercises!\n",
    "\n",
    "We've covered some admittedly dry ground so it's time to get your feet wet. Sorry. Time for your first exercises! What you have to do is \"make the scripts work\". Take all script files named ex\\_1\\_*n*.py, one after another. Open your script file in your editor, modify it, save it, and then run it using `python3 ex_1_n.py` on the console. You're done with a script when there are no error messages and the output looks like expected.\n",
    "\n",
    "For each exercise, there is a reference solution in the file ex\\_1\\_*n*\\_solved.py.\n",
    "\n",
    "ex\\_1\\_0.py is a bit different. It's just a test to see whether your installation works correctly. No code modifications are necessary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting more into programming: control flow and functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control flow: if/then/else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, every line of code was executed unconditionally. But obviously we want to be able to do or not do things depending on some object's value. Let's say we want, for a given number n, print whether the number divides by 7. So if the number is a multiple of 7, we want to print \"*value of n* divides by 7\", and if it is not, we want to print \"*value of n* doesn't divide by 7\". This is where if\\then\\else comes in - and `%`, which is the modulo operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 doesn't divide by 7\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "\n",
    "if n % 7 == 0:\n",
    "    print(f\"{n} divides by 7\")\n",
    "else:\n",
    "    print(f\"{n} doesn't divide by 7\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code that should run if the given *conditional expression* (`n % 7 == 0`) evaluates to `True` is *indented*. This is intentional and carries meaning: everything that's indented under the \"if\" is run only if the conditional expression evaluates to true, or with other words, if we \"go into the if branch\". As soon as we \"de-indent\", we're implicitly telling the Python interpreter that we're done with that branch.\n",
    "\n",
    "The same applies to the \"else\". In general, an if-then-else looks like this:\n",
    "```\n",
    "if <conditional expression>:\n",
    "    indented code block that runs if the conditional expression is true\n",
    "else:\n",
    "    indented code block that runs if the conditional expression is false\n",
    "\n",
    "code block that will run after all of that and in any case\n",
    "```\n",
    "\n",
    "With \"code block\" we mean \"one or many lines of code, which may itself contain nested if/then/else and other things\".\n",
    "\n",
    "The \"else\" is optional, it can be left out entirely. In that case no code will be run if the conditional expression evaluates to false. (But the \"run after all of that and in any case\" will run.)\n",
    "\n",
    "In general, whenever we're talking about \"directing\" code, like running something conditionally, we're talking about \"control flow\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control flow: while loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important thing besides conditionally running some code is to run code repeatedly. This can be accomplished for example with \"while\". Let's go through all numbers from 1 and up and print that they don't divide by 7 *until* we have a number that divides by 7:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 doesn't divide by 7\n",
      "2 doesn't divide by 7\n",
      "3 doesn't divide by 7\n",
      "4 doesn't divide by 7\n",
      "5 doesn't divide by 7\n",
      "6 doesn't divide by 7\n",
      "7 divides by 7\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "\n",
    "while True:\n",
    "    n = n + 1\n",
    "    if n % 7 == 0:\n",
    "        print(f\"{n} divides by 7\")\n",
    "        break\n",
    "    else:\n",
    "        print(f\"{n} doesn't divide by 7\")\n",
    "\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basic shape of a \"while\" is like this:\n",
    "```\n",
    "while <conditional expression>:\n",
    "    code block that runs if the conditional expression is true... and then runs again if the conditional expression is true... and then runs again if the conditional expression is true... until the conditional expression is false\n",
    "    trick: use \"break\" at any time to \"break out of the while loop\" immediately \n",
    "```\n",
    "\n",
    "There are many ways to write the above functionality. Some are nicer than others. Look at this for comparison:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 doesn't divide by 7\n",
      "2 doesn't divide by 7\n",
      "3 doesn't divide by 7\n",
      "4 doesn't divide by 7\n",
      "5 doesn't divide by 7\n",
      "6 doesn't divide by 7\n",
      "7 divides by 7\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "\n",
    "while n % 7 != 0:\n",
    "    print(f\"{n} doesn't divide by 7\")\n",
    "    n = n + 1\n",
    "print(f\"{n} divides by 7\")\n",
    "\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You decide what's better and more readable. This was just to illustrate that there are many different \"coding styles\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function definitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The true power of programming is to generalize or factor out things you do often into reusable bits. Functions are arguably the most important programing concept to do this. So far, we've called functions, but now we take our first step into real programming: writing a function.\n",
    "\n",
    "Let's take the numbers example from above. Suppose we want to do that not only with 7, but 5 as well. We could write that like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 doesn't divide by 7\n",
      "2 doesn't divide by 7\n",
      "3 doesn't divide by 7\n",
      "4 doesn't divide by 7\n",
      "5 doesn't divide by 7\n",
      "6 doesn't divide by 7\n",
      "7 divides by 7\n",
      "1 doesn't divide by 5\n",
      "2 doesn't divide by 5\n",
      "3 doesn't divide by 5\n",
      "4 doesn't divide by 5\n",
      "5 divides by 5\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while n % 7 != 0:\n",
    "    print(f\"{n} doesn't divide by 7\")\n",
    "    n = n + 1\n",
    "print(f\"{n} divides by 7\")\n",
    "\n",
    "n = 1\n",
    "while n % 5 != 0:\n",
    "    print(f\"{n} doesn't divide by 5\")\n",
    "    n = n + 1\n",
    "print(f\"{n} divides by 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is wasteful and ugly. Why don't we factor out the code we repeat? Let's say we want a function that we can just give a number, and it does the printing. for a given number x, it would contain the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 doesn't divide by 9\n",
      "2 doesn't divide by 9\n",
      "3 doesn't divide by 9\n",
      "4 doesn't divide by 9\n",
      "5 doesn't divide by 9\n",
      "6 doesn't divide by 9\n",
      "7 doesn't divide by 9\n",
      "8 doesn't divide by 9\n",
      "9 divides by 9\n"
     ]
    }
   ],
   "source": [
    "x = 9\n",
    "n = 1\n",
    "while n % x != 0:\n",
    "    print(f\"{n} doesn't divide by {x}\")\n",
    "    n = n + 1\n",
    "print(f\"{n} divides by {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know the number, we compute and print some stuff. Let's make an actual function out of this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def enumerate_until_it_divides(x):\n",
    "    n = 1\n",
    "    while n % x != 0:\n",
    "        print(f\"{n} doesn't divide by {x}\")\n",
    "        n = n + 1\n",
    "    print(f\"{n} divides by {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it! And here's how we use it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 doesn't divide by 7\n",
      "2 doesn't divide by 7\n",
      "3 doesn't divide by 7\n",
      "4 doesn't divide by 7\n",
      "5 doesn't divide by 7\n",
      "6 doesn't divide by 7\n",
      "7 divides by 7\n",
      "1 doesn't divide by 5\n",
      "2 doesn't divide by 5\n",
      "3 doesn't divide by 5\n",
      "4 doesn't divide by 5\n",
      "5 divides by 5\n"
     ]
    }
   ],
   "source": [
    "enumerate_until_it_divides(7)\n",
    "enumerate_until_it_divides(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I think the use of the function is straightforward. The definition, however, needs some explaining: the \"def\" tells Python that we're going to define a function. We follow with the name of the function (here, enumerate_until_it_divides). Then, in parentheses and separated by comma, the function arguments: the objects we pass into the function.\n",
    "\n",
    "What follows under is the so-called \"body\" of the function. This code is run when the function is called. It is one level indented (relative to the \"def\") so that Python knows what code belongs into the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function has no result, which is fine. It just prints stuff. Let's make a function that has a result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divides_by(num, div):\n",
    "    does_it_divide = (num % div == 0)\n",
    "    return does_it_divide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the function body, we can use \"return\" to specify the result of the function, and \"jump out\". It is common but by no means mandated to have the return statement at the end of the function body.\n",
    "\n",
    "The general form of the return statement is `return <expression>` - the result of the expression is returned. In the above example, that is the value of the variable `does_it_divide`. But we can save some space by doing it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divides_by(num, div):\n",
    "    return (num % div == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how we can use it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divides_by(7,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divides_by(9,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More exercises!\n",
    "\n",
    "Now have a go at the ex\\_2\\_*x*.py exercises.\n",
    "\n",
    "Congrats! These were the basics. Next up: data structures such as lists of things!"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}