1 - Lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Authors:**\n",
    "* Yilber Fabian Bautista\n",
    "* Keiwan Jamaly\n",
    "\n",
    "**Last date of modification:**\n",
    " November 27th 2021"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hello there, \n",
    "\n",
    "Welcome to Lecture 1 of this mini-lecture series on programing with Python. In this series, you will learn  basic and intermediate python tools that will be of great use in your scientific carer\n",
    "\n",
    "**Objectives:** \n",
    "\n",
    "By the end of this lecture you will be able to:\n",
    "* Define **variables** and  differentiate between global and local variables. \n",
    "* Identify and use different object **types** in python.\n",
    "* Use some of the python's default functions and define your own **functions**.\n",
    "* Manipulate **lists**\n",
    "* Use function within the  **numpy** library\n",
    "* Creates and manipulate plots using  **Matplot** library "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When programming,  generally one wants to implement algorithms that simplify cumbersome  calculations. \n",
    "Let us consider the following analytic expression:\n",
    "\n",
    "\\begin{equation*}\n",
    "x^2 + 1\n",
    "\\end{equation*}\n",
    "\n",
    "\n",
    "In this expression, $x$ corresponds to a variable, whereas $1$ is a fix number. To define a variable in a python program we use the following syntax:\n",
    "\n",
    "```py\n",
    "x = 5\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this simply means that every time in the code we use <code> x </code>, \n",
    "the code automatically replaces it by its numerical value. For instance, going back to our example analytic example, if we evaluate \n",
    "```py\n",
    "x**2 + 1\n",
    "```\n",
    "we will get as output <code> 26 </code>. Try this out by yourself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#type here the analytic exampe\n",
    "x**2 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code> x </code> as defined before corresponds to a **global variable**  \n",
    "since every time we use <code> x </code> in the code, python automatically  assigns its numeric value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Use x in different cells  and convince yourself that it corresponds to a global variable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In mathematics  a variable `a`,  can  take values in scalar (Natural Numbers, Real Numbers, etc. ), vector,  matrix etc. It is the same in programing and there, the objects have defined **types**. There are many types in programing, and you can even define your own, but the most important ones you need to know for the moment are (without any particular order)\n",
    "\n",
    "* Boolean point number ` (bool) ` :  a binary value; True, False <- spelling is important\n",
    "* Integer ` (int) `:  a number; 1, 4, 6, 23, also -34\n",
    "* Floating Point Number ` (float) `: a decimal number; 2.4, 34.2325, -54.234967\n",
    "* String ` (str) `: a sequence of characters; \"hello\", \"I learn python!\", \"I am a string\"\n",
    "\n",
    "Python is a dynamically typed language, so you can change the type of a variable at any time. This means also, that python tries to guess the type of a variable when you assign it a value.\n",
    "\n",
    "Let us explore these examples in practice\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boolean variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of a: <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "print('type of a:',type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**integer and float variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of x: <class 'int'>\n",
      "type of y: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "print(\"type of x:\", type(x))\n",
    "y = 5.0\n",
    "print(\"type of y:\", type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**string variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " type of r:   <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "r = 'hello world'\n",
    "print(\" type of r:  \", type(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Different variable types have different kinds of operations, for example:\n",
    "* Integers and floats can be added:  `1 + 2` ,  or multiplided  `1 * 2` in the usual form.\n",
    "\n",
    "* Strings  can be concatenated using the + operator `\"hello\" + \"world\"`, you can also do string comparison using  `\"hello\" == \"hello\"`.\n",
    "\n",
    "\n",
    "You can read more about them [here](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not), [here](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex) and [here](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str). But let us see an specific example of how to concatenate two strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "helloworld\n"
     ]
    }
   ],
   "source": [
    "string1 = \"hello\"\n",
    "string2 = 'world'\n",
    "string3 = string1 + string2\n",
    "print(string3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are just sequences of characters, and you can extract a specific element, or a slice,  by indexing and slicing. For instance, if we want to extract only the `h` element from the <code>string1</code> variable,  we use syntax `string1[0]` Notice that the to get the first element we use the index <code> [0] </code>. \n",
    "\n",
    "I we want to extract the slice `lowor` from `string3`, we can simply take the slice of elements  `string3[1:8]`, here, the first entry specify the first element of the interval we want to take, and the second entry, the previous to last element of the slice.  Let's see it in practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "lowor\n",
      "hlool\n"
     ]
    }
   ],
   "source": [
    "print(string1[0])\n",
    "print(string3[3:8:1])\n",
    "print(string3[::2]) #printing all the elements of a string in steps of 2 using an additional argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variable of a given type  can be turn into a variable of a different type. For instance, a float can be turn into an integer using the python's default function `int()`. An integer can be turn into an string using the function `str()`. In a similar way, you can ask for the integer value of the division of two numbers in two ways, for instance doing the usual division and the using the `int()` function on the final result. You can also use the command  `a//b`. Let see"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type of x: <class 'float'>\n",
      "9\n",
      "<class 'str'>\n",
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 5 # this is an integer\n",
    "x = float(x) # this is a float using float() function\n",
    "print(\"type of x:\", type(x))\n",
    "print(int(9.1)) #use int() function\n",
    "print(type(str(1))) #use str() function\n",
    "print(int(9/2))\n",
    "print(9//2) #ask for the integer part of a division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operations can also change the type of a variable, for instance, the division of two integers numbers  give in general float numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 5 is of type : <class 'int'>\n",
      "y = x/3 is of type : <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "print(\"x = 5 is of type :\", type(x))\n",
    "y = x/3\n",
    "print(\"y = x/3 is of type :\", type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are is a set of mathematical operations which are applicable to the different variable **types**, \"+, -, *, /, **, //, %, <, >, <=, >=, ==, !=\". The order of operations can be seen [here](https://docs.python.org/3/reference/expressions.html#operator-precedence). But you can always override the priority with round brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "48\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "print(3 + 3)\n",
    "print(3 + 3 * 15)\n",
    "print((3 + 3) * 15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To finalize this section, let us point that all of the variables that we have defined above are Global variables, that means that we can use them in different cells in the notebook without having to define them again. For instance we can ` print ` the value of ` x ` defined above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "get yourself convinced by using some of the previous defined variables in the following cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Going back to our mathematical expression\n",
    "```py\n",
    "x**2 + 1\n",
    "```\n",
    " we now want to evaluate it at an specific value, for instance   ` x  = 3`. The result of this evaluation will  be   `10` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "x**2 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We  could do this also for another input number, for example `x = 7`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7\n",
    "x**2 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or `x = 50`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2501"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 50\n",
    "x**2 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You get the idea.. You can save your time by abstracting \n",
    "\n",
    "```py\n",
    "x**2 + 1\n",
    "```\n",
    "\n",
    "into a function which can be reused any time we desire to. The syntax for defining a function in python is the following: \n",
    "\n",
    "```py\n",
    "def function_name(x1):\n",
    "    # ...\n",
    "```\n",
    " Here\n",
    "\n",
    "`x1` is a function parameter (independent variable). \n",
    "\n",
    "It is  recommended that you use functions names that accurately describe the function purpose.\n",
    "\n",
    "You can have multiple function parameters.\n",
    "```py\n",
    "def f(x1, x2):\n",
    "    # ...\n",
    "```\n",
    "\n",
    "The function parameters ` x ` can be of any type (including functions themselves).\n",
    "\n",
    "A Function generally takes an input and returns an output. As an example: Let us imagine, we want to write a function that adds two parameters and squares them afterwards. You could write a code of the following form"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_and_square(x1, x2):\n",
    "    power = 2\n",
    "    sum_ = x1 + x2\n",
    "    sum_sq = sum_**power\n",
    "    return sum_sq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now use this function with specific input variables as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = sum_and_square(2, 3)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us take  this example function to discuss local variables. As you can see, inside the function we have defined the variable  ` power = 2 `, that means that  inside the function, anywhere you encounter the variable ` power `, the program automatically replace its value `2`. However, outside the function the variable ` power ` is not defined, and if you try to call it, you will get an error message, namely,   ` power ` was written as a **local** variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'power' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-d6a407a2c881>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpower\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'power' is not defined"
     ]
    }
   ],
   "source": [
    "power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "python syntax for error printed is very informative, as we can see, it tells that the variable <code>power </code> has not been defined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returning to our  function. As you can see, the job of `return`  is to store the result of the operation in the function,  in the variable `x`. A function doesn't need to have a `return` statement, for example, when you work with **classes** (you will learn about classes later). \n",
    "\n",
    "Keep in mind, that the argument's types are carried into the function, so you get an error, when you try use undefined operations  between different type objects. For example, the  sum of a  string and a number is not defined, and the error would be the following "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-518941e76f79>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msum_and_square\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"hello\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-16-456b09cfdb2c>\u001b[0m in \u001b[0;36msum_and_square\u001b[1;34m(x1, x2)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0msum_and_square\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mx2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[0mpower\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[0msum_\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx1\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mx2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[0msum_sq\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msum_\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mpower\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0msum_sq\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "sum_and_square(\"hello\", 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us finally comment on a useful feature when defining functions. You can pre-assign a default value for the independent variables. For instance, let us imagine we want to  define a function of two parameters ` a, b `, but we want to specify a default value for ` b = 1. `, so that when using the function, it assumes that ` b =1. ` , but we could change the value of ` b ` if desired.  The syntax for this will be \n",
    "```py\n",
    "def fun( a, b = 1):\n",
    "    # ...\n",
    "```\n",
    "here we refer to ` b ` as a named variable. Let us see how this works in the following example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(a,b =1.):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(fun(3)) # use the default value for variable b\n",
    "print(fun(3,b=2)) # Change the input value for b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the order of the arguments matters, no named variables always go first, and named variables go afterwards. For instance, if you want to invert the order, you will get an error message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "positional argument follows keyword argument (<ipython-input-22-9f63f40b7e1a>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-22-9f63f40b7e1a>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    fun(b=1,3)\u001b[0m\n\u001b[1;37m            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m positional argument follows keyword argument\n"
     ]
    }
   ],
   "source": [
    "fun(b=1,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining function with default key-values for different parameters  is useful when dealing functions with a big number of  arguments, since it allows us to input the arguments without an specific order. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func2(a=1,b=3,c=19):\n",
    "    return (a-b)/c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func2(b=3, a=13,c=19) == func2(b=3,c=19, a=13) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "To get some practice with functions, let us imagine a freely falling particle whose coordinate position (x, y) is described by the relations  $y(t) = -9.81*t^2 + 0.23*t + 100.34$ and $x(t) = 0.5 * t$. Write two functions, the first (second) one should give you the x(y)-Position for a given t. \n",
    "\n",
    "Being a good programmer means also to verify the functionality of your code, so run some tests. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your solution in this cell\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions have additional features like optional parameters, default parameters, typing, etc., some of them are self explanatory, some of them are not. We encourage you to learn more about functions [here](https://www.w3schools.com/python/python_functions.asp). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists and Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists and tuples are data structures, which as the name explicitly suggests, they are utilized to collect data in one single variable.  Let's define a List, to make it more clear.\n",
    "\n",
    "### List\n",
    "\n",
    "To define a list, we use the following syntax\n",
    "\n",
    "```py\n",
    "my_list = [3, 4, 8, 2, 5, 3, 7]\n",
    "```\n",
    "\n",
    "Likewise for strings, we can:\n",
    "* Acces  a list element by defining the specific index\n",
    "```py\n",
    "my_list[2]\n",
    "```\n",
    "this will give you `8`. Keep in mind, that in python, the first element is referenced as the 0th element. So \n",
    "```py\n",
    "my_list[5]\n",
    "```\n",
    "will result into  `3`  **rather than** 5. You can also access the last (second to last) element by using the index `-1`(`-2`). \n",
    "\n",
    "```py\n",
    "my_list[-1]\n",
    "```\n",
    "* Slice the list by defining the range of interest in the list \n",
    "\n",
    "```py\n",
    "slice = my_list[1:4]\n",
    "```\n",
    "this will give as output  ` [4, 8, 2] `\n",
    "\n",
    "* Lists are **mutable** objects, this means that we can change one or more elements of the list \n",
    "\n",
    "```py\n",
    "my_list[3] = \"string\"\n",
    "```\n",
    "in this example, we would have added a string as the fourth element. This is just to show that the elements of a list do not have to be of the same type.\n",
    "\n",
    "* Append to a list by using\n",
    "```py\n",
    "my_list.append(10)\n",
    "```\n",
    "or you can simply do \n",
    "```\n",
    "my_list+=[10]\n",
    "```\n",
    "* Concatenate two lists \n",
    "\n",
    "```\n",
    "my_list2 = [1,4,'r',(3,4)]\n",
    "my_list3 = [5.6,4,'c',[1,2,3]]\n",
    "my_list4 = my_list2 + my_list3\n",
    "```\n",
    "\n",
    "* Determine the lenght of your list\n",
    "```\n",
    "len(my_list4)\n",
    "```\n",
    "producing as output ` 8 `\n",
    "\n",
    "### Exercise 2 \n",
    "Go ahead and try all these things out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here you have space to play with lists. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "Tuples are in general similar objects  as Lists, but they are defined with round brackets instead of squared ones.\n",
    "```py\n",
    "my_list = [3, 4, 8, 2, 5, 3, 7] # This is a list\n",
    "my_tuple = (3, 4, 8, 2, 5, 3, 7) # This is a tuple\n",
    "```\n",
    "accessing different  elements of a tuple  can be done in the same way than for lists. However,  tuples are **not mutable** which means that one cannot change or add more elements to the tuple. \n",
    "\n",
    "### Exercise 3\n",
    "Go ahead and try to use the operations for list in tuples and convince yourself of their main differences "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here you have space to play with tuples\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists and tuples can be change one into another, and as usual,  python has already default functions for doing that, for instance to go from a list into a tuple we use the function <code> tuple(my_list) </code>, and viceversa, <code> list(my_tuple) </code>.\n",
    "    \n",
    "Convince yourself of this with the following two objects\n",
    "    \n",
    "```py\n",
    "my_list = [3, 4, 8, 2, 5, 3, 7] # This is a list\n",
    "my_tuple = (3, 4, 8, 2, 5, 3, 7) # This is a tuple\n",
    "```    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us finally  point out some useful differences between lists and tuples in the following image, they will be useful on your  future programing \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"Figures/image_1.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you have to beef up your List experience because the build in functionality is not sufficient for your problems or it is just slow. Here we introduce the **numpy** library,  which create a whole universe of functions which are fast and efficient. Without further due, let's import numpy to make it usable in our code \n",
    "\n",
    "```py\n",
    "import numpy as np\n",
    "```\n",
    "\n",
    "A module import has to happen before the libarie's code execution. \n",
    "\n",
    "you may have noticed, that the import statement ends with `as np`, this is called aliasing.  This enables to every time we call the library to call it as `np` instead of `numpy`. For instance to call <code>numpy</code> functions we will always use  `np.fun()` instead of `numpy.fun()` which is just more convenient but doesn't change the nature of the execution. \n",
    "\n",
    "As an example, let us use numpy's <code> sqrt() </code> function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = 2\n",
    "y = np.sqrt(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additional **numpy** functions include \n",
    "1. exponential function: np.exp(x)\n",
    "2. logarithmic function: np.log(x)\n",
    "3. cosine function: np.cos(x)\n",
    "\n",
    "constants like pi and the Euler number  are also accessible by using the syntax `np.pi` and `np.e` respectively. \n",
    "\n",
    "A full documentation can be seen [here](https://numpy.org/devdocs/index.html)\n",
    "\n",
    "### Exercise 4\n",
    "As an exercise and using numpy functions,  write a function which takes as arguments the coordinates `x` and `y` and returns the polar coordinates `r` and `phi`. Recall the change of variables from Euclidean to polar coordinates is \n",
    " $$\n",
    " r = \\sqrt(x^2+y^2)\\\\\n",
    " \\theta = \\arctan{y/x}.\n",
    " $$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your function here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Withing the many useful tools in <code> numpy </code>, we have  <code> numpy-arrays</code>, which replaces  python <code> lists </code> and works hand in hand with other libraries like <code> matplotlib </code> (for plotting) and <code>scipy </code>(for scientific calculations as for instance  solving differential equations which we will learn in Lecture 4). Numpy arrays are fast for evaluation as compared lists (see  [here](https://numpy.org/doc/stable/user/whatisnumpy.html) )\n",
    "\n",
    "To convert a list into a <code>numpy</code> array we use the following syntax:\n",
    "```py\n",
    "a_numpy_array = np.array([2, 3, 4])\n",
    "```\n",
    "### Exercise 5\n",
    "Convert the previous generated List into <code> numpy </code> arrays and calculate the sum of it using [this](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.sum.html?highlight=sum) function. \n",
    "\n",
    "In addition, convince yourself that the indexing, slicing, computing the length of the array, etc, works in a similar way that for lists.\n",
    "However, if you want to add append an element to an array, you do not use the command ` list.append([3]) `, but rather the command ` np.append(array, value)`. Add the element ` 10 ` to the array `a_numpy_array ` above. \n",
    "Note: changing the size of an numpy array is generally not recommended, since this is a very expensive operation. If you often need to append or remove elements, consider using a list instead.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here goes your result. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let us create  a new numpy array named `t`, that looks like this  \n",
    "```py\n",
    "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2,\n",
    "       1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. , 2.1, 2.2, 2.3, 2.4, 2.5,\n",
    "       2.6, 2.7, 2.8, 2.9, 3. , 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8,\n",
    "       3.9, 4. , 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5. , 5.1,\n",
    "       5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6. , 6.1, 6.2, 6.3, 6.4,\n",
    "       6.5, 6.6, 6.7, 6.8, 6.9, 7. , 7.1, 7.2, 7.3, 7.4, 7.5, 7.6, 7.7,\n",
    "       7.8, 7.9, 8. , 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9, 9. ,\n",
    "       9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 9.9])\n",
    "```\n",
    "\n",
    "We have two options for this task:\n",
    "1. Use [np.linspace](https://numpy.org/doc/stable/reference/generated/numpy.linspace.html) to create a numpy array from **start** to **stop** with **steps**. An example of this is:\n",
    "```py\n",
    "t = np.linspace(0, 10, 101)\n",
    "```\n",
    "2. Use [np.arange](https://numpy.org/doc/stable/reference/generated/numpy.arange.html) to create a numpy array with a fixed step size. An example of this is:\n",
    "```py\n",
    "t = np.arange(0, 10.1, 0.1)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write them explicitly here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 6\n",
    "Recall Exercise 1? We created the functions ` x(t), y(t) `. In this exercise  we want to compute the values for the coordinates positions at every single elements of the array ` t ` above, we can simply   insert the array into the function. The function will be applied element wise onto that array.\n",
    "For example, your functions on exercise 1 have the structure: \n",
    "\n",
    "```py\n",
    "def x(t):\n",
    "    #....\n",
    "x_t = x(t)\n",
    "```\n",
    "the resulting evaluation  `x_t ` will be \n",
    "    \n",
    "```py\n",
    "array([ 1.003400e+02,  1.002649e+02,  9.999360e+01,  9.952610e+01,\n",
    "        9.886240e+01,  9.800250e+01,  9.694640e+01,  9.569410e+01,\n",
    "        9.424560e+01,  9.260090e+01,  9.076000e+01,  8.872290e+01,\n",
    "        8.648960e+01,  8.406010e+01,  8.143440e+01,  7.861250e+01,\n",
    "        7.559440e+01,  7.238010e+01,  6.896960e+01,  6.536290e+01,\n",
    "        6.156000e+01,  5.756090e+01,  5.336560e+01,  4.897410e+01,\n",
    "        4.438640e+01,  3.960250e+01,  3.462240e+01,  2.944610e+01,\n",
    "        2.407360e+01,  1.850490e+01,  1.274000e+01,  6.778900e+00,\n",
    "        6.216000e-01, -5.731900e+00, -1.228160e+01, -1.902750e+01,\n",
    "       -2.596960e+01, -3.310790e+01, -4.044240e+01, -4.797310e+01,\n",
    "       -5.570000e+01, -6.362310e+01, -7.174240e+01, -8.005790e+01,\n",
    "       -8.856960e+01, -9.727750e+01, -1.061816e+02, -1.152819e+02,\n",
    "       -1.245784e+02, -1.340711e+02, -1.437600e+02, -1.536451e+02,\n",
    "       -1.637264e+02, -1.740039e+02, -1.844776e+02, -1.951475e+02,\n",
    "       -2.060136e+02, -2.170759e+02, -2.283344e+02, -2.397891e+02,\n",
    "       -2.514400e+02, -2.632871e+02, -2.753304e+02, -2.875699e+02,\n",
    "       -3.000056e+02, -3.126375e+02, -3.254656e+02, -3.384899e+02,\n",
    "       -3.517104e+02, -3.651271e+02, -3.787400e+02, -3.925491e+02,\n",
    "       -4.065544e+02, -4.207559e+02, -4.351536e+02, -4.497475e+02,\n",
    "       -4.645376e+02, -4.795239e+02, -4.947064e+02, -5.100851e+02,\n",
    "       -5.256600e+02, -5.414311e+02, -5.573984e+02, -5.735619e+02,\n",
    "       -5.899216e+02, -6.064775e+02, -6.232296e+02, -6.401779e+02,\n",
    "       -6.573224e+02, -6.746631e+02, -6.922000e+02, -7.099331e+02,\n",
    "       -7.278624e+02, -7.459879e+02, -7.643096e+02, -7.828275e+02,\n",
    "       -8.015416e+02, -8.204519e+02, -8.395584e+02, -8.588611e+02,\n",
    "       -8.783600e+02])\n",
    "```\n",
    "and similar for ` y(t) ` . Write a code that evaluates ` x(t) ` and ` y(t) ` for the <code> t</code> array and store them into the variables `x_t`, `y_t`. \n",
    "In addition, try to do the same evaluation but using <code> t</code> as a list rather than a <code>numpy </code>array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Write your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy also allows you to easily do elementwise operations, if the arrays are of equal length. This feature is called [broadcasting](https://numpy.org/doc/stable/user/basics.broadcasting.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adding two arrays of the same size: [0.         0.33333333 0.66666667 1.         1.33333333 1.66666667\n",
      " 2.         2.33333333 2.66666667 3.        ]\n",
      "\n",
      "adding two list [0.0, 0.2222222222222222, 0.4444444444444444, 0.6666666666666666, 0.8888888888888888, 1.1111111111111112, 1.3333333333333333, 1.5555555555555554, 1.7777777777777777, 2.0, 0.0, 0.1111111111111111, 0.2222222222222222, 0.3333333333333333, 0.4444444444444444, 0.5555555555555556, 0.6666666666666666, 0.7777777777777777, 0.8888888888888888, 1.0]\n"
     ]
    }
   ],
   "source": [
    "y = np.linspace(0, 1, 10)\n",
    "x = np.linspace(0, 2, 10)\n",
    "print(\"adding two arrays of the same size:\", x+y)\n",
    "\n",
    "# let's compare this operation with list\n",
    "x_list = list(x)\n",
    "y_list = list(y)\n",
    "print()\n",
    "print(\"adding two list\", x_list+y_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, python list do not add elementwise, instead they just concatenate. So you need to be careful, you can't just replace python lists with numpy arrays. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 7\n",
    "\n",
    "Use the function defined in **Exercise 4** to convert the arrays `x_t` and `y_t` to polar coordinates. Store your results into `x_p` and `y_p`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert the coordinates here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To end this lecture we will lear how to plot functions using the **matplotlib**\n",
    "\n",
    "First we need to import the library using \n",
    "\n",
    "```py\n",
    "import matplotlib.pyplot as plt\n",
    "```\n",
    "\n",
    "just by looking at the import statement, you already know, that every function of this library will be executed with\n",
    "\n",
    "```py\n",
    "plt.function()\n",
    "```\n",
    "\n",
    "This is in particular useful, if you have a large codebase and you don't want to mix up functions while coding. \n",
    "\n",
    "Back to plotting. You can simply plot two numpy arrays or Lists against each other (they must have the same dimensionality, or in other words: length), by using\n",
    "\n",
    "```py\n",
    "plt.plot(x_axis_array, y_axis_array)\n",
    "``` \n",
    "\n",
    "In the next codeblock, you see an example of a plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x28d6c1a1af0>]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = [1, 2, 3, 4, 5]\n",
    "y = [1, 4, 9, 16, 25]\n",
    "\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see, that the graph is kind of edgy. This is due to the fact, that matplotlib is drawing a straight line between every two points. If you add more points, the line will get smoother. If you want to plot only the points, you can use the scatter plot function as follows\n",
    "```\n",
    "plt.scatter(x,y)\n",
    "```\n",
    "### Exercise 8\n",
    "Convince yourself that this give you a scatter plot. \n",
    "\n",
    "You can include the points and the line in the same plot by using \n",
    "```\n",
    "plt.plot(x,y)\n",
    "plt.scatter(x,y)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convincing is done here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 9\n",
    "* Make also a plot of the polar coordinates using results from Exercise 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# do the radial plot here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, plot the angular component!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Do the plot in angular coordinates here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are also required to look up in the internet how to adjust the the axis-label, title and legend of your plots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example\n",
    "\n",
    "Let us finish the lecture with the following example.\n",
    "We want to plot the function $f(x) = 1/x$ against the values of $x$ from $10^-7$ to $100$.\n",
    "\n",
    "First, we want to create a numpy array, which contains the values of $x$ from $10^-7$ to $100$. For this, I use [np.logspace](https://numpy.org/doc/stable/reference/generated/numpy.logspace.html) which is a function, which creates a numpy array with logarithmic steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.logspace(-7, 3, 1000) # going from 10^-7 to 10^3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we create a function which returns the value of $f(x) = 1/x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return 1/x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last step of the calculation is to calculate the values of $f(x)$ for every value of $x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_x = f(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we plot the values of $f(x)$ against the values of $x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x28d6c20a460>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(x, f_x, label=r'$f(x)=1/x$') # LaTeX support for graph labels :)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"f(x)\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As  can be seen, the graph looks horrible. This is due to the fact that we use a linear scale for plotting. A better scale would be a logarithmic scale. Logarithmic plots can be created using the <code> plt.loglog() <code> function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x28d6c2c34c0>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.loglog(x, f_x, label=r'$f(x)=x^{-1}$', color=\"green\") # LaTeX support for graph labels :)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"f(x)\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "one could have alternative use the <code>plt.xscale()</code> function to change the x-axis scales, and similar for the y-axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x28d6c3f7c10>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, f_x, label=r'$f(x)=x^{-1}$', color=\"green\") # LaTeX support for graph labels :)\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"f(x)\")\n",
    "plt.xscale('log')\n",
    "#plt.yscale('log')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}