Introduction to Programming in Python (I).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Planning and Conducting a Psychology Experiment (Session 5, Nov. 26 2020): Introduction to Programming in Python (I)\n",
    "\n",
    "This is a notebook with practical examples and exercises for the hands-on part on programming in Python of the seminar **\"Planning and Conducting a Psychology Experiment\"** co-taught by [Tomás Goucha](https://www.cbs.mpg.de/mitarbeiter/goucha), [Matteo Maran](https://www.cbs.mpg.de/employees/59327), [Giorgio Papitto](https://www.cbs.mpg.de/person/papitto/373360), and [Patrick C. Trettenbrein](https://trettenbrein.biolinguistics.eu) at [University of Leipzig](https://www.uni-leipzig.de/en/) in the winter term 2020-21.\n",
    "\n",
    "The goal of our two hands-on sessions is to introduce participants to the basics of programming in Python. Our focus here is on understanding fundamental concepts in order to be able to use Python for scientific purposes such as stimulus presentation or data analysis.\n",
    "\n",
    "In this first hands-on session we'll cover the very basics of programming (in Python):\n",
    "- What is Python? And why use it?\n",
    "- Ways of installing Python\n",
    "- How does the Python environment work (packages, etc.)?\n",
    "- What are names, expressions, statements?\n",
    "- Data formats: Strings, lists, and dictionaries vs. numerical data\n",
    "- Functions, conditions and loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Python? And Why Use it?\n",
    "\n",
    "[Python](https://www.python.org) is:\n",
    "- easy to learn\n",
    "- a general-purpose programming language (as opposed to, e.g., R)\n",
    "- available for all major platforms (Windows, Linux, macOS)\n",
    "- open source\n",
    "- large and very active development community\n",
    "- very flexible due to large of default libraries and additional packages\n",
    "\n",
    "### Popularity\n",
    "\n",
    "Python is increasingly popular (data from [PYPL](https://pypl.github.io/)):\n",
    "\n",
    "<img src=\"images/pypl_plot.png\" width=\"75%\"/>\n",
    "\n",
    "And the popularity of Python continues to grow:\n",
    "\n",
    "<img src=\"images/pypl_table.png\" width=\"40%\"/>\n",
    "\n",
    "### Usage Example: *PsychoPy*\n",
    "\n",
    "Especially amongst psychologists and neuroscientists Python is now frequently used for stimulus presentation and data analysis:\n",
    "\n",
    "<a href=\"https://www.psychopy.org\" target=\"_blank\"><img src=\"images/PsychoPy_logo.png\" width=\"40%\"/></a>\n",
    "\n",
    "*PsychoPy* comes with a GUI, yet can also be used without it to create simple experiments. More complex experimental designs, however, will require at least a bit of coding in Python.\n",
    "\n",
    "<img src=\"images/PsychoPy_builder.png\" width=\"80%\" />\n",
    "\n",
    "We will be focusing on creating experiments in *PsychoPy* in the upcoming Sessions 7 and 8.\n",
    "\n",
    "### Usage Example: *Nipype*\n",
    "\n",
    "Neuroimaging data can be analysed in many different ways using a wide variety of different software packages. The *Nipype* project provides a uniform Python interface to existing neuroimaging software and facilitates interaction between these packages within a single workflow.\n",
    "\n",
    "<a href=\"https://nipype.readthedocs.io/en/latest/\" target=\"_blank\"><img src=\"images/nipype_logo.png\" width=\"40%\"/></a>\n",
    "\n",
    "That is, *Nipype* makes it easy to interact with tools from different software packages and combine processing steps from these different packages into a single workflow:\n",
    "\n",
    "<img src=\"images/nipype_architecture.png\" width=\"40%\" />\n",
    "\n",
    "We will not be covering *Nipype* any further in this class, it just serves as an example to illustrate what Python can and is being used for."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installing Python\n",
    "\n",
    "There is many different ways of installing Python. One way is to obtain the official packages for your respective operating system from the [web site of the Python project](https://www.python.org).\n",
    "\n",
    "If you are using Linux or macOS, chances are that you'll already have a version of Python installed:\n",
    "\n",
    "<img src=\"images/Python_on_macOS.png\" width=\"70%\" />\n",
    "\n",
    "This screenshot shows us that macOS comes with a version of Python 2 already installed. However, in a scientific context we will almost always want to use a more currrent version and be able to update easily and as needed.\n",
    "\n",
    "### *Anaconda*\n",
    "\n",
    "One popular way of using Python in a scientific context is to use a ready-made Python environment such as, for example, [*Anaconda*](https://www.anaconda.com/). *Anaconda* is a collection of different components with a current version of Python at its core. Another advantage is that *Anaconda* can be installed as a regular user (i.e. doesn't require root access).\n",
    "\n",
    "<img src=\"images/Anaconda.png\" width=\"90%\" />\n",
    "\n",
    "An installation of *Anaconda* already includes an integrated development envornment such as, for example, [*Spider*](https://www.spyder-ide.org). Anoter IDE that has become very popular in recent years is [PyCharm](https://www.jetbrains.com/pycharm/).\n",
    "\n",
    "<img src=\"images/Spyder.png\" width=\"90%\" />\n",
    "\n",
    "We will not discuss IDEs any further here. Instead, what we'll be using—respectively already are using right now— is [Jupyter Notebook](https://jupyter.org) to create interactive notebooks for coding in Python. If you are familar with R, think [RMarkdown](). That is, *Jupyter* notebooks can be used to code in an interactive and reproducible manner. The following screenshot shows the editing of this very notebook:\n",
    "\n",
    "<img src=\"images/Jupyter_notebook.png\" width=\"90%\" />\n",
    "\n",
    "Usually, you would run *Jupyter* locally (e.g., from *Anaconda*) to create notebooks in your browser. However, it is also possible to run notebooks on a service such as [*binder*](https://mybinder.org)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What Does Python Code Look Like?\n",
    "\n",
    "Below you will find some examples of Python code to give you a first idea. Notice that in this *Jupyter* notebook lines of code are prefixed with `In [n]:`, whereas `n` here represents the line number (i.e. the number of this particular line of code in context of the entire document you are currently viewing). The output of our commands (if any) is printed underneath and sometimes prefixed `Out[n]`.\n",
    "\n",
    "If you are running this notebook locally, you can actually execute the code examples by pressing **Shift ⇧ + Enter ⏎**. Similarly, if you have accessed this notebook using the link to *binder* that was previded prior to this session, you should be able to run the code in your browser without having to install anything on your system:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I CANNOT FIND CAPSLOCK! HELP, WHAT DO I DO NOW?'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"i cannot find capslock! help, what do i do now?\".upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10, 20, 30, 40, 50, 60, 70, 80, 90, 100, "
     ]
    }
   ],
   "source": [
    "for n in range(10, 101, 10):\n",
    "    print(n, end=\", \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10, 20, 30, 40, 50, 60, 70, 80, 90, 100\n"
     ]
    }
   ],
   "source": [
    "print(\", \".join([str(n) for n in range(10, 101, 10)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How does the Python environment work?\n",
    "\n",
    "If we were not using a *Jupyter* notebook for writing and running our code, we would most likely be wiriting a script in an IDE such as Spyder or PyCharm. In some cases, scripts may get rather long and we may want to split it into different files. Also, we may have implemented some functionality that we want to reuse in other scripts. For this purpose, we can put such defnitions into a file and import them in a script where we want to use them. Such a file is called a **module**. By default, a Python installation will already contain a large number of modules for different purposes that we can use.\n",
    "\n",
    "Consider, for example, that we want to use Python to perform some mathematical calculations. Generally, we can just use Python like a calculator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(10 - 9) / 2 - 1 * 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows us that Python knows how to correctly handle `()`, `*`, `/`, `+`, and `-` in a mathematical context. The output of the above calculation is `-0.5`: **Hence, notice that Python uses the English decimal separator `.`, as opposed to the German `,`!**\n",
    "\n",
    "Now, if we want to perform a somewhat more complex calculation, we may want to rely on already defined functions that are available as part of the `math` module. We import this using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This makes a number of mathematical functions availabe which we can now access using the prefix `math.` For example: `log()` and  `sin()`, or constants such as `pi` and `e` can be used as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use the `math` module in calculations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.447314978843446"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(( 10 * math.pi ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the standard modules that ship with Python, a myriad of additional modules for all purposes is available via packages. An overview of all available packages can be found on the [Python Package Index](https://pypi.org). Additional packages can be installed in the terminal using the commands `pip search name_of_package` to first check if a package with a particular name exists, followed by `pip install name_of_package` to actually install a particular package.\n",
    "\n",
    "If you are using Anaconda, you can also use the [`conda` command](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html) in the command line of your system to install additional packages. Alternatively, you can also use the Anaconda GUI which you already saw above. Notice, however, that the packages available via `conda` may be less current than what is available via `pip`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are names, expressions, statements?\n",
    "\n",
    "Many students of psychology may already be familiar with scripting languages that are used for a specific purpose such as, for example, R. Python is slightly different in some respects and, in essence, follows a simple logic: Everything in Python is and **object**; and objects can have **names**.\n",
    "\n",
    "Unlike many other languages, Python uses names instead of variables. That is, the `=` operator is used to assign a name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "name = 1 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the **expression**, `1 + 1` has been assigned the name `name`. Notice that different conventions for naming in Python exist. These state that `name` is actually not a **good** name for our expression. Why? It is not clear what it really contains. Hence, you should always try to use names that are desripctive, precise, yet not too long. For example, we could have used `calc_result` as a name instead (multiple words in names are usually separated using `_`in Python).\n",
    "\n",
    "Also, there is a number of pre-defined names which we should not use, otherwise we will run into trouble. We can see those names by looking at the keyword module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['False',\n",
       " 'None',\n",
       " 'True',\n",
       " 'and',\n",
       " 'as',\n",
       " 'assert',\n",
       " 'async',\n",
       " 'await',\n",
       " 'break',\n",
       " 'class',\n",
       " 'continue',\n",
       " 'def',\n",
       " 'del',\n",
       " 'elif',\n",
       " 'else',\n",
       " 'except',\n",
       " 'finally',\n",
       " 'for',\n",
       " 'from',\n",
       " 'global',\n",
       " 'if',\n",
       " 'import',\n",
       " 'in',\n",
       " 'is',\n",
       " 'lambda',\n",
       " 'nonlocal',\n",
       " 'not',\n",
       " 'or',\n",
       " 'pass',\n",
       " 'raise',\n",
       " 'return',\n",
       " 'try',\n",
       " 'while',\n",
       " 'with',\n",
       " 'yield']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import keyword\n",
    "keyword.kwlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we should avoid overwriting so-called **builtins**, that is default functions included in Python. If we were to do that we would sooner or later run into serious trouble.\n",
    "\n",
    "A list of these builtins can be viewed as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ArithmeticError',\n",
       " 'AssertionError',\n",
       " 'AttributeError',\n",
       " 'BaseException',\n",
       " 'BlockingIOError',\n",
       " 'BrokenPipeError',\n",
       " 'BufferError',\n",
       " 'BytesWarning',\n",
       " 'ChildProcessError',\n",
       " 'ConnectionAbortedError',\n",
       " 'ConnectionError',\n",
       " 'ConnectionRefusedError',\n",
       " 'ConnectionResetError',\n",
       " 'DeprecationWarning',\n",
       " 'EOFError',\n",
       " 'Ellipsis',\n",
       " 'EnvironmentError',\n",
       " 'Exception',\n",
       " 'False',\n",
       " 'FileExistsError',\n",
       " 'FileNotFoundError',\n",
       " 'FloatingPointError',\n",
       " 'FutureWarning',\n",
       " 'GeneratorExit',\n",
       " 'IOError',\n",
       " 'ImportError',\n",
       " 'ImportWarning',\n",
       " 'IndentationError',\n",
       " 'IndexError',\n",
       " 'InterruptedError',\n",
       " 'IsADirectoryError',\n",
       " 'KeyError',\n",
       " 'KeyboardInterrupt',\n",
       " 'LookupError',\n",
       " 'MemoryError',\n",
       " 'ModuleNotFoundError',\n",
       " 'NameError',\n",
       " 'None',\n",
       " 'NotADirectoryError',\n",
       " 'NotImplemented',\n",
       " 'NotImplementedError',\n",
       " 'OSError',\n",
       " 'OverflowError',\n",
       " 'PendingDeprecationWarning',\n",
       " 'PermissionError',\n",
       " 'ProcessLookupError',\n",
       " 'RecursionError',\n",
       " 'ReferenceError',\n",
       " 'ResourceWarning',\n",
       " 'RuntimeError',\n",
       " 'RuntimeWarning',\n",
       " 'StopAsyncIteration',\n",
       " 'StopIteration',\n",
       " 'SyntaxError',\n",
       " 'SyntaxWarning',\n",
       " 'SystemError',\n",
       " 'SystemExit',\n",
       " 'TabError',\n",
       " 'TimeoutError',\n",
       " 'True',\n",
       " 'TypeError',\n",
       " 'UnboundLocalError',\n",
       " 'UnicodeDecodeError',\n",
       " 'UnicodeEncodeError',\n",
       " 'UnicodeError',\n",
       " 'UnicodeTranslateError',\n",
       " 'UnicodeWarning',\n",
       " 'UserWarning',\n",
       " 'ValueError',\n",
       " 'Warning',\n",
       " 'ZeroDivisionError',\n",
       " '__IPYTHON__',\n",
       " '__build_class__',\n",
       " '__debug__',\n",
       " '__doc__',\n",
       " '__import__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'abs',\n",
       " 'all',\n",
       " 'any',\n",
       " 'ascii',\n",
       " 'bin',\n",
       " 'bool',\n",
       " 'breakpoint',\n",
       " 'bytearray',\n",
       " 'bytes',\n",
       " 'callable',\n",
       " 'chr',\n",
       " 'classmethod',\n",
       " 'compile',\n",
       " 'complex',\n",
       " 'copyright',\n",
       " 'credits',\n",
       " 'delattr',\n",
       " 'dict',\n",
       " 'dir',\n",
       " 'display',\n",
       " 'divmod',\n",
       " 'enumerate',\n",
       " 'eval',\n",
       " 'exec',\n",
       " 'filter',\n",
       " 'float',\n",
       " 'format',\n",
       " 'frozenset',\n",
       " 'get_ipython',\n",
       " 'getattr',\n",
       " 'globals',\n",
       " 'hasattr',\n",
       " 'hash',\n",
       " 'help',\n",
       " 'hex',\n",
       " 'id',\n",
       " 'input',\n",
       " 'int',\n",
       " 'isinstance',\n",
       " 'issubclass',\n",
       " 'iter',\n",
       " 'len',\n",
       " 'license',\n",
       " 'list',\n",
       " 'locals',\n",
       " 'map',\n",
       " 'max',\n",
       " 'memoryview',\n",
       " 'min',\n",
       " 'next',\n",
       " 'object',\n",
       " 'oct',\n",
       " 'open',\n",
       " 'ord',\n",
       " 'pow',\n",
       " 'print',\n",
       " 'property',\n",
       " 'range',\n",
       " 'repr',\n",
       " 'reversed',\n",
       " 'round',\n",
       " 'set',\n",
       " 'setattr',\n",
       " 'slice',\n",
       " 'sorted',\n",
       " 'staticmethod',\n",
       " 'str',\n",
       " 'sum',\n",
       " 'super',\n",
       " 'tuple',\n",
       " 'type',\n",
       " 'vars',\n",
       " 'zip']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(__builtins__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How is naming now different from assigning a variabel? In short, a variable in the traditional sense would, for example, reserve a certain amount of memory for storing a value. However, in Python everything is an object and names are actually only pointers to objects. We see this when we first create a list using the `[]` operator with the values `1`, `2`, and `3` and we give it the name `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/assignment1.png\" width=\"40%\" />\n",
    "\n",
    "Then we assign `a` to `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what happens when we change the third value in the list `b` to `4`. **Important: Notice that Python, unlike R, starts indexing at `0`, not at `1`!** Hence, in order to access the third element of a list, we have to use the the index `[2]` and assign the new value using the `=` operator. After this, we tell Python to print the current value of `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[2] = 4\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Coming from R or other languages, we would maybe expect that by using the `=` operator in the field above, we had created  a copy of `a` called `b`. When we modified an element of `b`, the values in `a` should not have been affected. Yet this is exactly what has happened here in Python because `a` and `b` are just names for the same object:\n",
    "\n",
    "<img src=\"images/assignment2.png\" width=\"40%\" />\n",
    "\n",
    "(You can actually try an see what happens in R using the exact same code. Just be aware that not modifying the index will lead to manipulateing the second element of the list in R [i.e. `2`], whereas here in Python it changed the value of the third element [i.e. `3`].)\n",
    "\n",
    "To make this more clear, we can use the `id()` function to see what actually happened. (Notice that by using `id()` we will create a **statement**, that is an instruction of Python to perform a particular operation. These differ from **expressions** [e.g., `1 + 1`] which we have already seen above.) This function tells us the ID of an object in Python (remember that *everything* is an object):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140592902444352"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140592902444352"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `id()` function shows that both `a` and `b` are indeed names that point to the same object in memory. Hence, if we wanted to create an actual copy of `a`, we would have to first import the `copy` module and then use the `copy()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140592902411072"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import copy\n",
    "b = copy.copy(a)\n",
    "id(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to a visual comparision of the IDs we can also ask Python whether two objects are the same. One way would be to use the `==` operator to compare the *values* returned by the `id()` function along the lines of `id(a) == id(b)` (i.e. comparing the two IDs of `a` and `b`). Alternatively, we can also perform this comparision using the `is` operator which compares two *objects* instead of their values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data formats\n",
    "\n",
    "If you are familiar with any other programming or scripting language, chances are that you are at least aware of the fact that data comes in different types. Python is no exception and comes with a number of useful data types: `bool` for logical statements; `int`, `float`, and `complex` for numbers; `str`, `list`, `tuple`, and `set` for sequences; and `dict` for storing paris of keys and values in the form of dictionaries.\n",
    "\n",
    "### Logical\n",
    "\n",
    "The type `bool` is used for comparisions and has only two possible values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = True\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = False\n",
    "c == d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numerical\n",
    "\n",
    "Python has three differnt data types for numerical objects. We will disregard the type `complex` here which is used to represent complex numbers in mathemical contexts. The two most important types for our purposes are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = 1\n",
    "type(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = 0.29\n",
    "type(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The types `int` and `float` represent either integers or floats. **Notice that due to the way in which computers represent numbers there can be rounding errors when working with floats!** See, for example, what happens when we add two floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.31999999999999995"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f + 0.03"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f + 0.03 == 0.32"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential\n",
    "\n",
    "In Python, sequential data types can consists of more than one element. The simplest is a string of letters `str`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = \"I love Python.\"\n",
    "type (g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string can be defined using either `\"`or `'`. It is recommend that you stick two one of the two in the same script, but Python itself that does not strictly require this. Just make sure to use the same quotations marks for defining the beginning and end of a string.\n",
    "\n",
    "Next, as we have already seen above, elments can also be nested in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = [\"This is our\", \"second\", \"list\"]\n",
    "type (h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List are orderd and have an index for every element (remember: starting at `0`, unlike R). Elements of a list do not have ot be of the same type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This is our', 2, 'list']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h[1] = 2\n",
    "h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A similar data type are tuples. The are also ordered and can contain different types. The key difference to lists is that tuples are unchangeable once created, whereas lists can be changed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = (\"firstname\", \"lastname\", 10, True)\n",
    "type(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next up are sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "j = {\"Python\", \"R\", \"PsychoPy\", \"Jupyter\", \"nypipe\"}\n",
    "type(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set contains a collection of different elements (does not allow duplicates) in no particular order. This makes them an efficient way of removing duplicates from an object. Notice that sets are unordered and that elements in a set cannot be referrred to using an index or key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries\n",
    "\n",
    "Finally, the last common type you will see a lot in Python are dictionaries. They allow the assignement of values to keys which mirror the assignment of definitions to keywords in a dictionary (hence the name):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {\"a\": 15.7, \"b\": 12.9, \"c\": 14.1}\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hands-on exercise\n",
    "\n",
    "Now, try to solve the below exercises in the ramaining time of today's session. Remember that for everyone who is not a programmer, almost half of the time of programming is probably spent looking stuff up on the internet.\n",
    "\n",
    "<a href=\"https://twitter.com/programmersmeme/status/1033293108518313985\"><img src=\"https://pbs.twimg.com/media/Dlb-mxlU0AE9_sA?format=jpg&name=medium\" width=\"50%\" /></a>\n",
    "\n",
    "This is not necessarily a bad thing: You do not have to reinvent the wheel, chances are that someone has run into the same problem you are having before and has asked about it on [Stackoverflow](https://stackoverflow.com) or a similar forum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise 1\n",
    "\n",
    "Check of what type the value `True` is? Next, assign the value to `x`. What happens when you now assign `y = \"True\"` and compare the two—and why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "Assume that we have some data from a study about some worldwide phenomenon of the following structure: `[[\"africa\", 0.2], [\"asia\", 0.4], [\"europe\", 0.1], [\"n_america\", 0.3], [\"s_america\", 0.2]]`. We want to create an object with this data and assign the name `global`. What happens when we assign it the name `global` and why? How can we change the value for Asia to `0.3` in this nested list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "Use Python to compute the volume of a sphere with the a radius (`r`) of `100` cm. (Hint: You may have to import the `math` module to be able to perform this computation.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125663.70614359173"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * math.pi * 100**2"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}