Lecture1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Lecture 1**\n",
    "### **Introduction: jypiter, variables, types, lists, control flow, functions**\n",
    "\n",
    "#### **Jupyter**\n",
    "\n",
    "\n",
    "This is jupyter notebook (install jupyter-lab). Jupyter is good for  testing commands, playing around, creating plots and creating code with notes, it can handle basic latex for formulas, eg:\n",
    "\n",
    "$F_i(a,b,c) = \\int dx f_i(a x) f_i(b x) f_i(c x)$\n",
    "\n",
    "and it can export the notebook as .tex, .html and .pdf for sharing or using in papers and talks. \n",
    "\n",
    "For serious projects, you want to have `.py` files, which you can also create from the notebook if you don't want to create them in editor. If I were checking homework, I would ask for a `.py` file.\n",
    "\n",
    "Some navigation commands: (please google whatever else you think you need)\n",
    "\n",
    " - to execute a cell, type `shift+enter` (if it doesn't work, try a different browser)\n",
    " - to get \"markdown cell\", press `esc` (to get into command mode) , then `m` \n",
    " - to insert a cell above the current one, press `esc`, then `a`\n",
    " - to insert a cell below the current one, press `esc`, then `b`\n",
    " - to delete a cell, type `esc`, then`dd`\n",
    " - to hide the side bar, press `ctr+b`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Data Types**\n",
    "\n",
    "the first thing we need to know is what kind of types exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 7          # Integer\n",
    "b = 7.3        # Floating point number\n",
    "c = 4e0        # Again a float, but in enginering notation\n",
    "d = 8.0 + 2.1j # Complex numbers (enginering notation)\n",
    "e = True       # Boolean (True or False)\n",
    "f = 'Hello World'    # Strings\n",
    "g = None       # None type, a special type which just means no type or 'null'\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))\n",
    "print(type(d))\n",
    "print(type(e))\n",
    "print(type(f))\n",
    "print(type(g))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is dynamically typed, meaning we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=34\n",
    "a='hi'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no limit on the size of the integer (but don't get happy about that, it's slow if you need a lot of those numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=123456789012345678901234567890\n",
    "j=1234567890129874897238748234799848932749827\n",
    "i*j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "floats do have limits: for double precision (which is used by default) you get and exponent (of 2) between -1022 and +1023 (-307 to 308 base 10) and ~16 decimal places."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(12.3456789**250)\n",
    "print(12.3456789**350)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Arythmetic operations:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 34\n",
    "y = 21\n",
    "print(x + y)  # Addition\n",
    "print(x - y)  # Subtraction\n",
    "print(x * y)  # Multiplication\n",
    "print(x / y)  # Division\n",
    "print(x // y) # Floor function\n",
    "print(x % y)  # Modulus\n",
    "print(x ** y) # Exponentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be careful with integer division:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(4/2))\n",
    "print(type(4//2))\n",
    "print(type(int(4/2)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and be careful with floats, operations are not exact, just like in c++:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0.1 + 0.2 == 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attention: exponent is NOT `^` which is bitwise XOR instead. Bitwise operators {&,|,^,<<,>>,~} operate on integer's binary parts directly and you probably don't need them in data science. \n",
    "\n",
    "All the operations have a short version for self assignment. We can use x += y.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operations on strings work as you would logically expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('string1'+'string2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can say that variables in python are \"labels\", while the data is \"boxes\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa = 3\n",
    "bb = aa\n",
    "print(aa is bb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa=3\n",
    "print(bb)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bb=34\n",
    "print(aa)\n",
    "print(aa is bb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Getting HELP**:\n",
    "\n",
    "`help()` command usually tells you everything you need to know about the object\n",
    "you can also use NAME? to get information about the variables\n",
    "if you need to know which fucntions are available, you can use tab after a `.` (type `a.TAB`_\n",
    "The `dir()` function returns all properties and methods of the specified object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help('string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir('string')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Control Flow: if**\n",
    "\n",
    "Now we come to the two basic building blocks of all code: commands that perform a test and commands that perform a loop.\n",
    "\n",
    "First the control structure for performing a test is `if`. The format is:\n",
    "\n",
    "`if` 'condition' `:`\n",
    "\n",
    "`*obligatory spaces*` 'commands'\n",
    "\n",
    "`elif` 'condition' `:`\n",
    "\n",
    "`*obligatory spaces*` 'commands'\n",
    "\n",
    "`else` 'condition' `:`\n",
    "\n",
    "`*obligatory spaces*` 'commands'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 32\n",
    "\n",
    "if x==0:\n",
    "    print('x is zero')\n",
    "elif x>0:\n",
    "    print('x is greater then zero')\n",
    "elif x<0:\n",
    "    print('x is smaller than zero')\n",
    "else:\n",
    "    print('something strange happened')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditions can be `==`, `!=`, `<`, `>`, `<=`, `>=`, `and`, `not`, `or`. You can use multiple and you can chain comparisons (like when writing on paper):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = 7\n",
    "# check if a in range [5,9)\n",
    "\n",
    "if 5 <= var and var < 9:\n",
    "    print(\"a is in range\")\n",
    "\n",
    "if 5 <= var < 9:\n",
    "    print(\"a is in range\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Control flow: loops**\n",
    "\n",
    "```\n",
    "for VAR in SET_OF_VALUES: \n",
    "    do something\n",
    "    if CONDITION:\n",
    "        continue\n",
    "    <something_that_runs_if_condition_IS_NOT_True>\n",
    "while <true_condition>:\n",
    "    do something\n",
    "    if ANOTHER_CONDITION:\n",
    "        break\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in 3, 4, 5, 11:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0, 17, 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i +=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Basic containers: lists, sets, tuples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[1,2,'meow']\n",
    "print(type(l))\n",
    "t=(1,2,3)\n",
    "print(type(t))\n",
    "s={1,2,2,3,1,3}\n",
    "print(s)\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in l:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in t:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in s:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### **Lists**:\n",
    "\n",
    "Lists are mutable (can change), resizable, can store objects of different types "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#simplest list creation\n",
    "l=[]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#otherwise, you can use\n",
    "l=list()\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can add elemets like this:\n",
    "l.append(2)\n",
    "l.append(\"hi\")\n",
    "l.append(4.9)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can use negative numbers to count from the end:\n",
    "print(l[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can slice the list\n",
    "lr = list(range(20))\n",
    "print(lr[2:7:2])  # general case: print elements from 2 to 7 with step 2\n",
    "print(lr[:7]) #print the first 7 elements \n",
    "print(lr[::5])  # print the whole list with step 5\n",
    "print(lr[::-1]) #print reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#useful function to get the length :\n",
    "len(lr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#careful with this * if you use lists of lists \n",
    "print(l * 3)\n",
    "ll=[[1]*3]*3\n",
    "ll[1][1]=0\n",
    "print(ll)\n",
    "#we can see what happens at https://pythontutor.com/visualize.html#mode=edit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **List Comprehensions**\n",
    "\n",
    "You can create a new list by using \"list comprehensions\". This way allows you creating a list from a rule rather than listing the objects directly.\n",
    "\n",
    "The format is the following:\n",
    "\n",
    "`[`'object to go in list' `for` 'input' `in` 'list/generator' `if` 'condition'  `]`\n",
    "\n",
    "Here are some examples to show you what is looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( [x**2 for x in range(10)]                            ) # Squares\n",
    "print( [x for x in range(10) if x%2==0]                     ) # Evens\n",
    "print( [x if not x%2 else -x for x in range(10)]            ) # Alternate sign for evens and odds\n",
    "print( [x**3 for x in [1,2,3,4]]                            ) # Cubes from a list\n",
    "print( [(x,y) for x in range(5) for y in range(5) if x+y<4] ) # Create pairs with sum<4\n",
    "print( [x**2 for x in [x**2 for x in range(10)]]            ) # 4th power (don't do this...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can list the types of our variables easier:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_things=[a,b,c,d,e,f,g]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [type(item) for item in list_of_things]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can sort the lists\n",
    "l=[2,3,99,-9]\n",
    "l.sort()\n",
    "print(\"l after l.sort()\", l)\n",
    "m=[4,-9,0,212]\n",
    "print(\"sorted m\", sorted(m))\n",
    "print(\"m after sorted\", m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#deleting items\n",
    "l=[1,2,3,4,5]\n",
    "del l[1] #delete by index\n",
    "print(l)\n",
    "l.remove(4) #4 is a value, not an index\n",
    "print(l)\n",
    "el=l.pop(0)\n",
    "print(el)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Sets** (optimized for math. operations on sets like union, intersect)\n",
    "\n",
    "we don't have indexing on sets, i.e. `s[0]` will give an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=set() #can't use {}, as it's a dictionary by default\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evn = {0, 4, 2, 6,6, 8, 10,2}  \n",
    "print(evn)\n",
    "#as you see it becomes ordered and avoids repetitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can check if something is here:\n",
    "4 in evn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#union\n",
    "oddn={1,3,5,7,9}\n",
    "alln= oddn.union(evn)\n",
    "print(alln)\n",
    "alln = oddn | evn\n",
    "print(alln)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#intersect\n",
    "empty = oddn.intersection(evn)\n",
    "print(empty)\n",
    "empty = oddn & evn\n",
    "print(empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#difference\n",
    "set1 = {1, 2, 3, 4, 5, 7}\n",
    "set2 = {1, 3}\n",
    "print(\"set1 - set2 -->\", set1 - set2)\n",
    "print(\"set2 - set1 -->\", set2 - set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can iterate\n",
    "for i in set2:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Tuples**\n",
    "\n",
    "they are immutable, you cannot change them once created (but they are faster than lists because of that)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ()  # or t = tuple(), this is empty tuple\n",
    "t = tuple(range(10)) #create tuple from a list\n",
    "print(t[4::2]) #can use indexing and and slicing\n",
    "t = tuple(\"string\") #can create from the string\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can't change them\n",
    "t[0]=5 #an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can \"pack\" tuples\n",
    "a = \"meow\"\n",
    "b = \"baw\"\n",
    "c=77\n",
    "t = a, b,c\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#and \"unpack\" them\n",
    "a,b,c=t\n",
    "print(a,b,c)\n",
    "v,_,z=t #allows to ignore elements\n",
    "print(v,z)\n",
    "e,*g=t #how to get the \"rest\"\n",
    "print(e,g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can swap like this:\n",
    "a = 1\n",
    "b = 2\n",
    "a, b = b, a\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Magic**\n",
    "\n",
    "Jupyter embeds special commands (called magics):\n",
    "\n",
    " - magic multiple line commands start with \"%%\"\n",
    " - you can list magic commands running %lsmagic\n",
    " - you can pop-up the magic command documentation (if any) adding \"?\" after the command with no space\n",
    " - few magics you might find useful:\n",
    "    - ! runs inline shell commands\n",
    "    - %%bash to run bash program\n",
    "    - %%latex to render a latex block\n",
    "    - %%timeit to time a block\n",
    "    - %timeit to time a line\n",
    "    - %whos # list of all assigned variables\n",
    "    - %run filename.py # runs the python script filename.py\n",
    "    - %reset # delete all varible and definitions\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%lsmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit pow(((0.78)*12321312),0.123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!jupyter --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "%timeit t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Functions**\n",
    "\n",
    "```python\n",
    "def function_name(arg1, arg2, arg3):\n",
    "    '''Documentation\n",
    "    can be \n",
    "    on multiple\n",
    "    lines\n",
    "    '''\n",
    "    what the function does\n",
    "```\n",
    "* `return` statement is optional\n",
    "* `return` you can return multiple elements returning a `tuple`\n",
    "```python\n",
    "    return a,b,c\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    \"\"\"prints 'hello' followed by the arg name\"\"\"\n",
    "    print(\"hello,\", name)\n",
    "\n",
    "\n",
    "hello(\"cat\")\n",
    "hello(name=\"cat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interactive_hello():\n",
    "    \"\"\"prompt the user for a name, then prints \"hello\" followed by the name\"\"\"\n",
    "    name = str(input(\"write your name:\"))\n",
    "    print(\"hello, \", name)\n",
    "\n",
    "\n",
    "interactive_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#unknown number of arguments\n",
    "def multi_hello(*names):\n",
    "    \"\"\"for each name in names print \"hello\" name\"\"\"\n",
    "    for i in names:\n",
    "        print(\"hello,\", i)\n",
    "\n",
    "\n",
    "multi_hello(\"cat1\", \"cat2\", \"cat3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#return multiple arguments\n",
    "def funct():\n",
    "    \"\"\"super complicated algorithm which returns value and error estimation\"\"\"\n",
    "    value = 41\n",
    "    error = 1e-7\n",
    "    return value, error\n",
    "\n",
    "\n",
    "v, e = funct()\n",
    "print(v, e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#recursive fucntions:\n",
    "def factorial(n):\n",
    "    if n < 2:\n",
    "        return 1\n",
    "    return n * factorial(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "factorial(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Keyword arguments**\n",
    "\n",
    "A keyword argument is an argument passed to a function or method which is preceded by a keyword and an equals sign. The general form is: \n",
    "\n",
    "```\n",
    "function(keyword=value)\n",
    "```\n",
    "\n",
    "This way you don't have to remember the order of the arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a,b):\n",
    "    print(a+1)\n",
    "    print(b+2)\n",
    "f(a=3,b=4)\n",
    "f(b=5,a=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you are used to \"thinking in c/c++/fortran\", you might be confused as to how parameters are passed. It's called \"by association\" and behaves like \"by value\" or \"by reference\" depending on what you pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=1\n",
    "def f(a):\n",
    "    a=a+32\n",
    "    return a\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#so you have to do\n",
    "a=f(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#it's different with lists though:\n",
    "def lf(x):\n",
    "    x[0]=999\n",
    "x=[1,2,3,4,5]\n",
    "lf(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**lambda functions**\n",
    "(usually used inside other complicated functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = lambda a : a + 10\n",
    "print(x(5)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(n):\n",
    "  return lambda a : a * n "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mypower2=myfunc(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mypower2(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}