Introduction to Programming in Python (II).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Planning and Conducting a Psychology Experiment (Session 6, Dec. 3 2020): Introduction to Programming in Python (II)\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. In this second session, our focus is on understanding fundamental concepts in order to be able to use Python for scientific purposes such as, for example, stimulus presentation. In Session 7 and 8, we wil lthen be using PsychoPy to set up an actual experiment to see Python in action.\n",
    "\n",
    "This second session covers:\n",
    "- Conditions and Loops\n",
    "- Functions\n",
    "- Basics of PsychoPy\n",
    "- Homework: Downloading and Installing PsychoPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditions and Loops\n",
    "\n",
    "We already know about the basics of Python syntax and data types from the session last week, however, a key element of every programming language has been missing so far: Conditions and loops. These are vital because they allow us to only execute certain bits of code if a specific condition or conditions apply. On the other hand, loops make it possible for us to re-run a bit of code until a specific condition is satisfied.\n",
    "\n",
    "### Conditions\n",
    "\n",
    "Conditions are invoked in Python using pre-defined keywords such as `if`, `elif`, and `else`. This follows the following logic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The world is not flat!\n"
     ]
    }
   ],
   "source": [
    "world_is_flat = False\n",
    "\n",
    "if world_is_flat is True:\n",
    "    print(\"The world is flat!\")\n",
    "else:\n",
    "    print(\"The world is not flat!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we defined a boolean and named it `world_is_flat`. Then, we check the value of `world_is_flat` using an `if` statement. The code following the statement will only be exectued if the condition is satisfied. That is, if `world_is_flat` is `True` then Python will print the string `\"The world is flat!\"`. If `world_is_flat` is not true it will print the string `\"The world is not flat!\"`.\n",
    "\n",
    "We have already encountered the `is` operator last week. It does not only check whether two values are identical, but checks also whether they are the same object.\n",
    "\n",
    "We can always use `not` to reverse the logic of our statement (i.e. instead of `world_is_flat is True` we could also use `world_is_flat is not False`.\n",
    "\n",
    "Notice that in this case using `elif` and `else` will usually have the same effect: If `world_is_flat`is not `True` then the string `\"The world is not flat!\"` will be printed. This works here because `world_is_flat` is a boolean and may either be `True` or `False`. Yet keep in mind that we are not expliclty checking this here: That is, we only implicitly check whether `world_is_flat` is `False`. Therefore, it is generally adviseable to explicitly check a statement as the code for `else` will be run in every other case where the `if` statement is not satisifed.\n",
    "\n",
    "Now, let's look at a more complex example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number 65 is larger than 25 but smaller than 75.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "random.seed(5)\n",
    "rand_number = random.randint(0, 150)\n",
    "\n",
    "if rand_number <= 25:\n",
    "    message = f\"The number {rand_number} is smaller than 26.\"\n",
    "elif rand_number > 25 and rand_number < 75:\n",
    "    message = f\"The number {rand_number} is larger than 25 but smaller than 75.\"\n",
    "elif rand_number >= 75 and rand_number <= 100:\n",
    "    message = f\"The number {rand_number} is larger than 74.\"\n",
    "else:\n",
    "    message = f\"The number {rand_number} is not in the range of 0 to 100.\"\n",
    "\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we first randomly generate a number between `0` and `100`. Then, we use `if`, `elif`, and `else` statements to check whether the generated number is smaller than 26, in the range from 26 to 74, larger than 74, or not in the defined range at all. Notice that the code of a block is executed as soon as a statement is `True`. No further comparisions will be performed for the same statement.\n",
    "\n",
    "We can use a variety of logical operators to make comparisions:\n",
    "- equal: `==`\n",
    "- not equal: `!=`\n",
    "- greater than: `>`\n",
    "- less than: `<`\n",
    "- greater than or equal to: `>=`\n",
    "- less than or equal to: `<=`\n",
    "\n",
    "Different logical operators can be combined using `and` and `or`.\n",
    "\n",
    "Also: The example above uses so-called `f`-strings. Notice that these require Python 3.6 or newer. In older versions you can instead use the following syntax: `message = \"The number %d is smaller than 26.\" % (rand_number)`. With this method, we'll have to use `%d` for inserting numbers and `%s` for inserting a string.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions\n",
    "\n",
    "1. In its current form, the code in `else` will never be run. How would we have to change the code so that there may be `else` cases? (Hint: We may also have to change at least one of our statements.)\n",
    "\n",
    "2. Are the numbers in the example truly random? If not, what can we do to all get the same result? (Hint: We can use `seed()` to control the random number generator.) And: Why would we even want to do this?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "\n",
    "Sometimes we may want to perform the same action multiple times. One way of doing this would be as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "Hello world!\n",
      "Hello world!\n",
      "Hello world!\n",
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world!\")\n",
    "print(\"Hello world!\")\n",
    "print(\"Hello world!\")\n",
    "print(\"Hello world!\")\n",
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is easy to see that while this works, it is not practical. That is especially true for more complex examples. So, what can we do instead? We can use a `for` loop to run the same code a specified number of times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "Hello world!\n",
      "Hello world!\n",
      "Hello world!\n",
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "for n in range(5):\n",
    "    print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we tell Python to run the same code as many times as there is numbers in the range we have defined using the `range()` function. As we would expect in Python, this function starts counting at `0` and then generates the numbers `1`, `2`, `3`, and `4`.\n",
    "\n",
    "Notice that `n` here is just a random name that we use as part of the `for` loop to access the current value. (In principle, this could be any name yet `i` is frequently used here, presuambly as a shorthand for *iteration*.) Hence, if we replace the string `\"Hello World!\"` with the variable `n` we can see that it is true that Python started couting at `0`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for n in range(5):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to alter this behavior, we can tell Python to start counting at `1` using `range(1, 6)` which will generate the numbers `1`, `2`, `3`, `4`, and `5`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for n in range(1, 6):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `for` loop will always iteratre through all the items of an object. For example, if we use it for a list, then it will iterature through the elements of this list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WE\n",
      "ABSOLUTELY\n",
      "LOVE\n",
      "PYTHON!\n"
     ]
    }
   ],
   "source": [
    "our_statement = [\"We\", \"absolutely\", \"love\", \"Python!\"]\n",
    "\n",
    "for s in our_statement:\n",
    "    print(s.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Within loops the statements `break` and `continue` can be used to either quit iterating through the loop immedately or skip the remaining code and proceed to the next iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is an even number.\n",
      "9 is not an even number.\n",
      "18 is an even number.\n",
      "27 is not an even number.\n",
      "36 is an even number.\n",
      "45 is not an even number.\n",
      "54 is an even number.\n",
      "63 is not an even number.\n",
      "72 is an even number.\n",
      "81 is not an even number.\n",
      "90 is an even number.\n",
      "99 is not an even number.\n"
     ]
    }
   ],
   "source": [
    "for number in range(0, 100, 9):\n",
    "    if number % 2 == 0:\n",
    "        print(f\"{number} is an even number.\")\n",
    "        continue\n",
    "    print(f\"{number} is not an even number.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions\n",
    "\n",
    "1. Instead of using `continue`, how else could we make sure that the appropriate string \"x is an even number.\" or \"is not an even number.\" would be returned?\n",
    "\n",
    "2. How would we have to change the code to make the loop stop when it encounters the first uneven number?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another type of loop is the `while` loop. These loops are particuarly useful in situations where you do not know in advance how many iterations a loop will require.\n",
    "\n",
    "For example, we can use a `while` loop in order to continuously run some code until a particular condition is met. In order to do that we create what is called an infinite loop using `while True` (we can use the `input()` function to wait for an input from the user:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please type 'I give up.'' to quit: No.\n",
      "Please type 'I give up.'' to quit: s\n",
      "Please type 'I give up.'' to quit: s\n",
      "Please type 'I give up.'' to quit: s\n",
      "Please type 'I give up.'' to quit: I give up.\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    given_input = input(\"Please type 'I give up.'' to quit: \")\n",
    "    if given_input == \"I give up.\":\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions are another important means for structuring the code of a program. We have already encountered a number of functions so far, for example the `input()` function in the example above. This function will create an input prompt for the user and display the given string passed as a paramter to the function before the prompt.\n",
    "\n",
    "Accordingly, when you used the below code you actually called a the function `print` and passed the string you wanted the function to print as an argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Print this.\n"
     ]
    }
   ],
   "source": [
    "print(\"Print this.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are defined using the keyword `def` and can have no or several paramters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_numbers(number1, number2):\n",
    "    result = number1 + number2\n",
    "    return result\n",
    "\n",
    "add_numbers(1, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `return` is used to define what the function should return to the user when it has been called. In the case above, we want the function to return the result of the computation. However, this could also be the result of an evaluation (e.g., a boolean) or any other object. By default, if `return` is not defined in a function, then the function will return `None`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Questions\n",
    "\n",
    "1. What happens when we only pass one parameter to `add_numbers()` and why?\n",
    "\n",
    "2. If a function has many paramters then so-called positional arguments become hard to read. How can we enhance the readability of our code?\n",
    "\n",
    "3. What happens if we want to direclty print the value of the name `result` and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "\n",
    "1. Write a function called `is_even` which returns `True` if a given number is even and `False` when it is not. The function should have one paramter (i.e. the number that should be checked).\n",
    "2. Once your function has it's basic functionality, what happens if you pass the value `1.57` to the function?\n",
    "3. What happens if we try to pass `\"Hello world!\"` to the function? (Remember from last week that Python has different data types.) How could this be avoided from happening?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def is_even(number):\n",
    "    input_type = type(number)\n",
    "    if input_type == int or input_type == float:\n",
    "        if (number % 2) == 0:\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "    else:\n",
    "        return None\n",
    "    \n",
    "print(is_even(\"abc\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "\n",
    "1. Write a function called `conv_length` which converts a given number from meters into feet or the other way around. The function should have two paramters: One for passing the value (numerical) that is to be convereted and another one for specifying the unit of the input (e.g., either `feet` or `meter`). By default, the function should assume that the input is in feet.\n",
    "2. What happens when you pass the value `\"test\"` to your function and why? And how can you prevent this from happening?\n",
    "3. How can you restrict the return value of your function to only include 4 digits after the decimal point? (Hint: Look up `round()`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.2808"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def conv_length(value, conv_type = \"feet\"):\n",
    "    if isinstance(value, (int, float)):\n",
    "        if conv_type == \"feet\":\n",
    "            conv_result = value / 3.2808\n",
    "        elif conv_type == \"meter\":\n",
    "            conv_result = value * 3.2808\n",
    "    return round(conv_result, 4)\n",
    "\n",
    "conv_length(1, \"meter\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics of PsychoPy\n",
    "\n",
    "Next week you will be introduced to PsychoPy proper. Here, I just want to show you that while PsychoPy is a stand-alone application that brings its own version of Python with it, it is actually developed as a Python module and can be used as such. That is, as seen in the session before, we can install the PsychoPy module using either `conda` or `pip`.\n",
    "\n",
    "PsychoPy itself is organised into different modules so that we can flexibly load those and use them:\n",
    "\n",
    "```python\n",
    "from psychopy import core, visual\n",
    "window = visual.Window(size=[500, 500])\n",
    "fixation = visual.TextStim(window, \"+\")\n",
    "fixation.draw()\n",
    "window.flip()\n",
    "core.wait(10)\n",
    "window.close()\n",
    "core.quit()\n",
    "```\n",
    "\n",
    "This code first imports two modules from PsychoPy, `core` and `visual` and then uses them to draw a window of the size `500 x 500` pixels. Next, a fixation cross is created (in the form of a visual text stimulus) and drawn before the window is updated. Then, the program waits for 10 seconds, before it closes the window and quits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the Builder\n",
    "\n",
    "Easy enough? Still, for beginners it is usually more convenient to install a standalone version of PsychoPy and use the Builder to create simple experiments, instead of writing everything from scratch. The builder will help you with creating the basic logic of an experiment.\n",
    "\n",
    "**The important thing is that the builder will actually create PsychoPy code like in the example above in the backgorund.**\n",
    "\n",
    "So why do you have to know Python or how to code at all? Well, , most use cases will require that you add so-called \"code components\" containing actual Python code in order to customize what you want PsychoPy to do.\n",
    "\n",
    "By default, a current version of PschoPy will show you three default windows upon launch: Builder, Coder, and Experiment Runner:\n",
    "\n",
    "<img src=\"images/PsychoPy_builder.png\" />\n",
    "<img src=\"images/PsychoPy_coder.png\" width=\"75%\" />\n",
    "<img src=\"images/PsychoPy_exp_runner.png\" width=\"75%\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework\n",
    "\n",
    "For next week, everyone please install a current version (v2020.1.2 or newer) of [PsychoPy]() on your system. You'll find current versions for your operating system on the PsychoPy web site:\n",
    "\n",
    "<img src=\"images/PsychoPy_download.png\" />\n",
    "\n",
    "Once installed, please make sure that the program starts up fine! Also, familiarise yourself with the setting of PsychoPy and see how you can change between different PsychoPy versions. To do this, click on the gear icon to access the settings of the (currently loaded) experiment:\n",
    "\n",
    "<img src=\"images/PsychoPy_access_settings.png\" />\n",
    "\n",
    "This will show you a popup window looking like this:\n",
    "\n",
    "<img src=\"images/PschoPy_settings.png\" width=\"75%\" />\n",
    "\n",
    "In the dropdown menu next to \"Use PsychoPy version\" you can then select the version of PsychoPy you want to use to run your code:\n",
    "\n",
    "<img src=\"images/PsychoPy_dropdown.png\" width=\"50%\" />\n",
    "\n",
    "This way, we can ensure that next week, everyone will be using the same version of PsychoPy to actually run the code, regardless of which version you have installed. Giorgio will explain to you next week why this option can sometimes quite important."
   ]
  }
 ],
 "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": 4
}