2-code/2-1-control-flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### GESIS Fall Seminar in Computational Social Science 2022\n",
    "### Introduction to Computational Social Science with Python\n",
    "# Day 2-1: Understanding Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "* Conditionals\n",
    "* Iteration\n",
    "   * List comprehensions\n",
    "* Functions\n",
    "* Modules and libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FTdve28S58DE",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## So Far, We Learned How to Write Straight-Line Programs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "id": "wm5p4YzM58DE",
    "outputId": "4c0af985-7298-42bf-e638-0844bbe5482a",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 12 words in the sentence.\n"
     ]
    }
   ],
   "source": [
    "s = 'All animals are equal, but some animals are more equal than others.'\n",
    "s = s.rstrip('.').lower()\n",
    "s_tokens = s.split()\n",
    "print('There are', len(s_tokens), 'words in the sentence.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VWoahMq858DE",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In straight-line programs, code is executed line by line, from top to bottom and within a line, from left to right (unless overridden with brackets).\n",
    "\n",
    "Statements can be executed in more complex order, however, and the control flow determines how this is done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vw-ZBUcd58DF",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## [Control Flow](https://www.youtube.com/watch?v=k0xgjUhEG3U)\n",
    "\n",
    "* Control flow is the order in which statements are executed or evaluated\n",
    "* In Python, there are three main categories of control flow:\n",
    "  * **Branches** (conditional statements) – execute only if some condition is met\n",
    "  * **Loops** (iteration) – execute repeatedly \n",
    "  * **Function calls** – execute a set of distant statements and return back to the control flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gqPHo6nj58DF",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "![Three categories of control flow](figs/control_flow.png \"Three categories of control flow\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7UluOUq758DF",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Conditional Statements\n",
    "\n",
    "![Conditional statements](figs/conditional_statements.png \"Conditional statements\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1Z-Dpxie58DF",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditional Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uF_gsfZS58DF",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```\n",
    "if *Boolean expression*:\n",
    "    *block of code*\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZtOjWO-r58DF",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```\n",
    "if *Boolean expression*:\n",
    "    *block of code*\n",
    "else:\n",
    "    *block of code*\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FQFX5uwb58DF",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```\n",
    "if *Boolean expression*:\n",
    "    *block of code*\n",
    "elif *Boolean expression*:\n",
    "    *block of code*\n",
    "else:\n",
    "    *block of code*\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "id": "RirUFRhO58DF",
    "outputId": "e7184a7c-bc2b-42e0-b203-33d5b5e81510",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "\n",
    "if x > 0:\n",
    "    print('Positive')\n",
    "elif x < 0:\n",
    "    print('Negative')\n",
    "else:\n",
    "    print('Zero')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NmcY3jqy58DF",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indentation in Python Code\n",
    "\n",
    "* Indentation is semantically meaningful in Python\n",
    "* You can use [tabs or spaces](https://www.youtube.com/watch?v=SsoOG6ZeyUI)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IYuv5v-y58DF",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Obviously(!), tabs are preferable\n",
    "* However, it does not really matter in Jupyter as Jupyter converts tabs to spaces by default"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3P7tftPv58DF",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## You Can Nest Conditional Statements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "id": "LNdR6_pd58DF",
    "outputId": "8d3336b3-3c69-4cac-a5f8-ac9dbf423471",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a negative number.\n"
     ]
    }
   ],
   "source": [
    "x = -100\n",
    "\n",
    "if type(x) == int or type(x) == float:\n",
    "    if x >= 0:\n",
    "        print('This is a nonnegative number.')\n",
    "    else:\n",
    "        print('This is a negative number.')\n",
    "elif type(x) == str:\n",
    "    print('This is a string.')\n",
    "else:\n",
    "    print(\"I don't know what this is.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9KDtyPxm58DG",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Iteration\n",
    "\n",
    "![Iteration](figs/iteration.png \"Iteration\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9jBuDKvK58DG",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration: `while` vs. `for`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vw6LZ7i_58DG",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```\n",
    "while *Boolean expression*:\n",
    "    *block of code*\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3ekBqgZd58DG",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```\n",
    "for *element* in *sequence*:\n",
    "    *block of code*\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ljRcUW3K58DG",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration: `while` with decrementing function\n",
    "\n",
    "The decrementing function is a function that maps variables to an integer that is initially non-negative but that decreases with every pass through the loop; the loop ends when the integer is 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "id": "xqLRQpSl58DG",
    "outputId": "d3d4d3b6-26d1-416f-b087-1dce3976a6e1",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# decrementing function: 5 - x\n",
    "x = 0\n",
    "while x < 5: \n",
    "    print(x)\n",
    "    x += 1\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iUrs5wry58DG",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration: `while` with conditional statements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "id": "9lOn-Oag58DG",
    "outputId": "51113eb1-abb4-4724-f709-45b55449c866",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess which number from 1 to 100 I'm thinking of? 59\n",
      "You are quite far. Try again.\n",
      "Guess which number from 1 to 100 I'm thinking of? 26\n",
      "You are very close. Try again.\n",
      "Guess which number from 1 to 100 I'm thinking of? 25\n",
      "That's right!\n"
     ]
    }
   ],
   "source": [
    "correct = 25\n",
    "repeat = True\n",
    "\n",
    "while repeat:\n",
    "    guess = int(input(\"Guess which number from 1 to 100 I'm thinking of? \"))\n",
    "    \n",
    "    if guess > correct + 10 or guess < correct - 10:\n",
    "        print(\"You are quite far. Try again.\")\n",
    "    elif guess != correct:\n",
    "        print(\"You are very close. Try again.\")\n",
    "    else:\n",
    "        print(\"That's right!\")\n",
    "        repeat = False\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sUMzU6uJ58DG",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration: `for` with sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "id": "TXHvZGnn58DG",
    "outputId": "f977fa91-1d4d-4186-9284-3878a127188a",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for elem in [1, 2, 3, 4]:\n",
    "    print(elem)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "soxWXk5i58DH",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration: `for` with `range()`\n",
    "\n",
    "* In-built function that produces an immutable ordered non-scalar object of type `range`\n",
    "* Initiate as `range([start], stop, [step])`. If ommitted, `start = 0` and `step = 1`. \n",
    "* Function produces progression of integers `[start, start + step, start + 2*step, ..., start + i*step]` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "id": "ZKfhRFli58DH",
    "outputId": "4a97d557-a5ea-4d7e-99a5-0c6728ecf678",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 3]"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i+1)\n",
    "    \n",
    "list(range(1, 5, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dW_QUTPt58DH",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Indexing Lists with `range(len(L))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "id": "rVQoLPV958DH",
    "outputId": "8a27f62d-7630-4b57-f6aa-c8704759b8bb",
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index 0 - a\n",
      "index 1 - b\n",
      "index 2 - c\n",
      "index 3 - d\n"
     ]
    }
   ],
   "source": [
    "mylist = ['a', 'b', 'c', 'd']\n",
    "for i in range(len(mylist)):\n",
    "     print('index', i, '-', mylist[i])\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H41E5A9O58DH",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* This is especially useful when you need to go simultaneously over two different lists of the same length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "id": "lUbGFpjd58DH",
    "outputId": "d5489dd4-1cb3-4eb9-a0df-a6b3c34c7056",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a1\n",
      "b2\n",
      "c3\n",
      "d4\n"
     ]
    }
   ],
   "source": [
    "mylist1 = ['a', 'b', 'c', 'd']\n",
    "mylist2 = [1, 2, 3, 4]\n",
    "for i in range(len(mylist1)):\n",
    "     print(mylist1[i] + str(mylist2[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HuLhe6qq58DH",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteration: `break` and `continue`\n",
    "\n",
    "* Use `break` to exit a loop \n",
    "* Use `continue` to go directly to next iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "id": "QfwR5PUk58DH",
    "outputId": "132519a3-e813-484a-d4e8-1a58ccd9eda4",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    if i == 2:\n",
    "        break\n",
    "    print(i)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 🏋️‍♀️ PRACTICE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**Q1**: Using loops, write a program to print the following pattern:\n",
    "\n",
    "![Iteration exercise](figs/iteration_exercise.png \"Iteration exercise\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 🏋️‍♀️ PRACTICE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Q2: Sum the even integers from the list below.\n",
    "lst = [1, 3, 2, 4.5, 7, 8, 10, 3, 5, 4, 7, 3.33]\n",
    "\n",
    "# Hint: A number is even if, when we divide it by 2, the remainder is 0.\n",
    "# Use the modulo operator % to get the remainder when dividing by an integer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Q3: Create a list that contains all integers from 1 to 100 (inclusive), \n",
    "# except that it has the string 'boo' for every integer that is divisible by 3 \n",
    "# Your list should look like: [1, 2, 'boo', 4, 5, 'boo', 7, 8, 'boo', 10, ...]\n",
    "# Hint: Use the modulo operator % to check if a number is divisible by 3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oxYuIXWW58DI",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# List Comprehensions\n",
    "\n",
    "```\n",
    "L = [*object, expression, or function* for *element* in *sequence*]\n",
    "L = [*object, expression, or function* for *element* in *sequence* if *Boolean expression*]\n",
    "L = [*object, expression, or function* for *element* in *sequence* for *element2* in *sequence2*]\n",
    "```\n",
    "\n",
    "* Provide a concise way to create lists\n",
    "* Faster because implemented in C\n",
    "* Nested list comprehensions can be somewhat confusing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-ohgvNyl58DI",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "id": "9J9E21Od58DI",
    "outputId": "c6f0215d-4ff7-41af-ca37-faea00733315",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    }
   ],
   "source": [
    "ans = []\n",
    "for x in range(1, 11):\n",
    "    ans.append(x**2)\n",
    "print(ans)\n",
    "\n",
    "ans2 = [x**2 for x in range(1, 11)]\n",
    "print(ans2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "id": "6GhGUEbt58DI",
    "outputId": "710d1a40-9dac-4391-cd27-7c0891116d97",
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'c1', 'c2', 'c3']"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x**2 for x in range(1, 11) if x%2 == 0]\n",
    "[x + str(y) for x in ['a', 'b', 'c'] for y in [1, 2, 3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hIQTYOV658DI",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dictionary and Set Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "id": "WdvV_ZLs58DI",
    "outputId": "9111050d-7c68-4313-9260-098a3109c4b8",
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}\n",
      "{'a': 1, 'b': 2, 'c': 2}\n",
      "{'r', 'e', 'o', 'g', 't', 'i', 'n', 'm', 'a', 's', 'd'}\n"
     ]
    }
   ],
   "source": [
    "print( {x: x**2 for x in range(1, 11)} )\n",
    "\n",
    "print( {x.lower(): y for x, y in [('A', 1), ('b', 2), ('C', 2)]} )\n",
    "\n",
    "print( {x.lower() for x in 'SomeRandomSTRING'} )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 🏋️‍♀️ PRACTICE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "**Q4**: Rewrite the following code using a list comprehension:\n",
    "\n",
    "```\n",
    "sentence = \"the quick brown fox jumps over the lazy dog\"\n",
    "words = sentence.split()\n",
    "word_lengths = []\n",
    "for word in words:\n",
    "      if word != \"the\":\n",
    "          word_lengths.append(len(word))\n",
    "print(word_lengths)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 🏋️‍♀️ PRACTICE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Q5: Using a list comprehension, create a new list containing \n",
    "# the squares of the integers in the list below\n",
    "lst = [1, 3, 2, 4.5, 7, 8, 10, 3, 5, 4, 7, 3.33]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Q6: Consider the lists x and y below. Using a list comprehension,\n",
    "# create a list that contains all combinations of (elem_x, elem_y) \n",
    "# such that elem_x + elem_y = 6\n",
    "# Your answer should look as follows: [(0, 6), (1, 5), (2, 4), (3, 3)]\n",
    "x = [0, 1, 2, 3]\n",
    "y = [3, 4, 5, 6]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gtdq58kF58DJ",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "![Functions](https://drive.google.com/uc?id=16PwluRAedCvTnbFylD8Cy4Fq7NEca1W1 \"Functions\") \n",
    "\n",
    "\n",
    "* Built-in\n",
    "  * `len()`, `max()`, `range()`, `open()`, etc.\n",
    "* User-defined\n",
    "  * By you, collaborators, or the open-source community"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CUBlZwGM58DJ",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defining and Calling Functions\n",
    "\n",
    "**Defining a function**\n",
    "\n",
    "```\n",
    "def *function_name*(*list of parameters*):\n",
    "    *body of function*\n",
    "```\n",
    "\n",
    "**Calling a function**\n",
    "\n",
    "```\n",
    "*function_name*(*arguments*)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MKXU0lXH58DJ",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## When the Function is Used, the Parameters are Bound to the Arguments\n",
    "\n",
    "```\n",
    "def *function_name*(*list of parameters*):\n",
    "    *body of function*\n",
    "\n",
    "*function_name*(*arguments*)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "id": "Zw84vC8758DJ",
    "outputId": "72111f73-f57b-4e5e-d6dd-67bf3478ae7c",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_larger(x, y):\n",
    "    \"\"\"Assumes x and y are of numeric type.\n",
    "    Returns the larger of x and y.\n",
    "    \"\"\"\n",
    "    if x > y:\n",
    "        # The execution of a `return` statement terminates the function call\n",
    "        return x\n",
    "    else:\n",
    "        return y\n",
    "    \n",
    "m = get_larger(3, 4)\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s1KHYCSa58DJ",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A Function Call Always Returns a Value\n",
    "\n",
    "* The execution of a `return` statement terminates the function call\n",
    "* The function call also terminates when there are no more statements to execute\n",
    "* If no expression follows `return` or there is no `return` statement, the function returns `None`       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "id": "vtsQqmS158DJ",
    "outputId": "91d0f15f-0baa-4245-f344-5640bcee1339",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def get_larger(x, y):\n",
    "    if x > y:\n",
    "        return x\n",
    "    if y > x:\n",
    "        return y\n",
    "\n",
    "print(get_larger(7,7))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6_GwDxyu58DJ",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions Can Return Multiple Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "id": "ZJiA04S_58DJ",
    "outputId": "aa74f749-ea75-422c-ae1d-d33dc22917bb",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def double_one(a):\n",
    "    return 2*a\n",
    "\n",
    "def double_two(a, b):\n",
    "    return 2*a, 2*b\n",
    "\n",
    "x, y = double_two(2, 3)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 🏋️‍♀️ PRACTICE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Q7: Write a function that reverses a string, e.g. \"now\" -> \"won\".\n",
    "# Then call the function to reverse each of the strings in the list.\n",
    "\n",
    "to_reverse = ['doc', 'keep', 'lap', 'lever', 'nap', 'nip', 'war']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 🏋️‍♀️ PRACTICE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Q8: Rewrite the code below using a function and a suitable data structure.\n",
    "\n",
    "# Print the name and profession of famous dead scientists:\n",
    "print('Alan Turing was a mathematician.')\n",
    "print('Richard Feynman was a physicist.')\n",
    "print('Marie Curie was a chemist.')\n",
    "print('Charles Darwin was a biologist.')\n",
    "print('Ada Lovelace was a mathematician.')\n",
    "print('Werner Heisenberg was a physicist.')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_hM47ny958DJ",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Positional vs. Keyword Arguments\n",
    "\n",
    "* Keyword arguments cannot come before positional arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gyU2gdH958DK",
    "outputId": "44e70a00-add2-41f0-bf4a-133af9dade70",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def print_reverse(first, second, third):\n",
    "    print(third, second, first)\n",
    "    \n",
    "print_reverse(1, 2, 3)\n",
    "print_reverse(third=3, second=2, first=1)\n",
    "print_reverse(1, second=2, third=3)\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pMLxZeiT58DK",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Default Parameter Values\n",
    "\n",
    "* Default values allow to call a function with fewer arguments than specified\n",
    "* Default arguments cannot come before non-default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "id": "y7tVF8G358DK",
    "outputId": "388fe7cb-f9cb-472c-d748-d1d58aca4abe",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The quick brown fox jumps over the lazy dog.\n",
      "The quick brown fox jumps over the lazy dog.\n",
      "The quick brown fox jumps over the lazy dog\n"
     ]
    }
   ],
   "source": [
    "def pretty_print(lst, sep, fullstop=True, capitalize=True):\n",
    "    toprint = sep.join(lst)\n",
    "    if fullstop:\n",
    "        toprint += '.'\n",
    "    if capitalize:\n",
    "        toprint = toprint.capitalize()\n",
    "    print(toprint)\n",
    "\n",
    "wordlst = ['the', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']  # an English pangram\n",
    "\n",
    "pretty_print(wordlst, ' ', True, True)\n",
    "pretty_print(wordlst, ' ')\n",
    "pretty_print(wordlst, ' ', False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SZzgBkWB58DK",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A Function Defines a New Scope\n",
    "\n",
    "* Scope = name space\n",
    "* This means you can reuse your favorite variable names in different functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "id": "v81oDQfh58DK",
    "outputId": "a1082c20-727a-4913-bc8d-3bac816eca79",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'z' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-161-b29c4e50881d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'z' is not defined"
     ]
    }
   ],
   "source": [
    "def func(x, y):\n",
    "    x += 1\n",
    "    # x is a parameter, z is a local variable\n",
    "    z = x + y   # z, x, and y exist only in the scope of the definition of func\n",
    "    return z\n",
    "\n",
    "x = 1\n",
    "res = func(x, 5)\n",
    "\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gyeoTaBm58DK",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Global Scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "id": "AwmK-XT_58DK",
    "outputId": "69ddcf9a-9d97-4c86-cab7-067c85d70d12",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "GLOBVAR = 3 # It is conventional to use CAPITALS to name global variables\n",
    "\n",
    "def print_global():\n",
    "    # Since GLOBVAR is not defined in the function, it is treated as global\n",
    "    print(GLOBVAR)  \n",
    "\n",
    "print_global()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QCxqbtHn58DL",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Modules\n",
    "\n",
    "* For large programs, store different parts in `.py` files\n",
    "* Get access using `import` statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "9UITqMhZ58DL",
    "outputId": "b9f3e27f-ca5f-4364-8aa4-a1a81614b56b",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "She said: \"Hello!\"\n"
     ]
    }
   ],
   "source": [
    "import module\n",
    "\n",
    "module.my_func('Hello!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "9gwk44AH58DL",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "She said: \"Hello there!\"\n"
     ]
    }
   ],
   "source": [
    "import module as md\n",
    "\n",
    "md.my_func('Hello there!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "5JX5UM2E58DL",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "She said: \"HELLO! DO YOU HEAR ME?\"\n"
     ]
    }
   ],
   "source": [
    "# You should be careful with this one: there will be a conflict if you\n",
    "# import a different module that also has a function called get_tokens()\n",
    "from module import *\n",
    "\n",
    "my_func('HELLO! DO YOU HEAR ME?')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h6Ms4IqZ58DL",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Useful Python Modules\n",
    "\n",
    "https://docs.python.org/3/library/\n",
    "\n",
    "* `re` – Regular expression operations\n",
    "* `datetime` – Basic date and time types\n",
    "* `math` – Mathematical functions\n",
    "* `random` – Generate pseudo-random numbers\n",
    "* `os.path` – Common pathname manipulations\n",
    "* `pickle` — Python object serialization\n",
    "* `csv` — CSV file reading and writing\n",
    "* `json` — JSON encoder and decoder\n",
    "* ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5bXDw2BW58DL",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Useful Python Packages\n",
    "\n",
    "* `numpy` – Scientific computing with multi-dimensional arrays\n",
    "* `pandas` – Data anlysis with table-like structures (R, pretty much)\n",
    "* `statsmodels` – Statistical data analysis with linear models\n",
    "* `scikit-learn` – Data mining and machine learning\n",
    "* `networkx` – Network analysis\n",
    "* `matplotlib` – Plotting\n",
    "* ..."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}