00_Python_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Style\n",
    "\n",
    "The style of programming that we will be undertaking in this subject is a `notebook` framework. This contrasts with the original style of python, which is more of a `file-based` (or synonymously, `module-based`) framework. \n",
    "\n",
    "The ways these differ is that the `notebook` style:\n",
    "\n",
    "1. Uses cells and evaluates them one at a time.\n",
    "2. Produces output below the cell that called for it.\n",
    "3. Is (arguably) more common in scientific computing and data science.\n",
    "\n",
    "In contrast, the `file-based/module-based` style:\n",
    "\n",
    "1. Can keep code in multiple files that can then be accessed from one another.\n",
    "2. Produces all outputs to one location.\n",
    "3. Is very common in software engineering environments -- e.g. building apps and running websites. \n",
    "\n",
    "The intent for teaching you some `python` is to:\n",
    "\n",
    "1. Allow you to validate your calculations, both as a student and practising engineer/scientist/mathematician.\n",
    "2. Create visualisations to aid exploration, communication and solutions.\n",
    "3. Solve simple problems numerically -- note, numerical methods is a whole (large) field of research.\n",
    "4. Get a taste for a highly useful transferable skill: *programming*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nomenclature\n",
    "\n",
    "There are a few words that are intended to do more work when mentioned in a programming context than in their conversational meaning.\n",
    "\n",
    "* `syntax`: The structure of valid statements with respect to the `python` programming language.\n",
    "* `keyword`: a word reserved by `python` for use in the language. These words **cannot** be assigned as variable or functions names. It will cause a syntax error.\n",
    "* `sequences`: An ordered set, i.e. a collection of elements that has a logical order to those elements that it contains.\n",
    "* `brackets`: Refer to square brackets `[` and `]`.\n",
    "* `parantheses`: Refer to parantheses `(` and `)`.\n",
    "* `braces`: Refer to braces `{` and `}`.\n",
    "* `variable`: A name that is assigned a value(s)/object(s). **Cannot** be a keyword.\n",
    "* `function`: A repeatable set of instructions that have been formally written so that they are self contained. Can take multiple inputs and (in python, at least) produce multiple outputs. Best thought of as a 'black box' that when provided with the appropriate inputs it causes an action or returns value(s)/object(s).\n",
    "* `object`: A programming abstraction that groups together 'variables' and 'functions', which are then termed 'attributes' and 'methods', respectively.\n",
    "* `class:` Synonymous with object.\n",
    "* `method`: A function that is tied to an object/class. e.g. `my_object.my_method()`. \n",
    "* `attribute`: A variable that is tied to an object/class. e.g. `my_object.my_attribute`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types\n",
    "\n",
    "Those with a star/asterisk (`*`) next to their name will be explored in this subject, `classes` will be touched upon too.\n",
    "\n",
    "The basics types in python are:\n",
    "\n",
    "**Numerics:**\n",
    "\n",
    "* `int`* -- An integer. \n",
    "\n",
    ">    *i.e.* a whole number, a number with no fractional part. \n",
    ">    *e.g.* `1, 8, 99, 1000`\n",
    "\n",
    "\n",
    "* `float`* -- A floating point number. \n",
    "\n",
    ">    *i.e.* a number with values (even zero values) after the decimal place.\n",
    ">    *e.g.* `2.0, 3.14, 2.71`\n",
    "\n",
    "\n",
    "* `complex`* -- Numbers with an imaginary component, indicated by j.\n",
    "\n",
    ">    *e.g.* `2+3j, b+cj, 0.5+0.5j`\n",
    ">   *Note:* The `j` must **follow** the number directly with no other character or operator between them.\n",
    "\n",
    "* `boolean`* and `None`* -- statements that result from logical comparisons and are termed `boolean` after George Boole, who did work on Mathematical Logic.\n",
    "\n",
    ">    *e.g.* `True`, `False` and `None` -- Sometimes `False` just isn't quite right and so a `None` can be used (e.g. in a search, in a matching process or in a set).\n",
    "\n",
    "\n",
    "**Sequences:**\n",
    "\n",
    "* `list`* -- A changeable set of values of any type, enclosed within brackets, separated by commas.\n",
    "\n",
    ">    *e.g.* `[1, 2, 3]`, `['a', 'b', 'c']`, `[1, 3.14, 'Euler', 9j]`\n",
    "\n",
    "\n",
    "\n",
    "* `tuple`* --  An immutable (unchangeable) set of values of any type, enclosed within parantheses, separated by commas.\n",
    "\n",
    ">    *e.g.* `(4, 5, 6)`, `('d', 'e', 'f')`, `(9, 2.71, 'Gauss', 1j)`\n",
    "\n",
    "\n",
    "\n",
    "* `str`* -- A text string of one or more characters.\n",
    "\n",
    ">    *e.g.* `\"Gauss\", \"Euler\", 'Fourier', 'Laplace', \"e\", 'pi'`\n",
    ">    *Note*: That you can use singe-quotes (`'`) or double-quotes (`\"`) to start and end your string.\n",
    ">    *Aside*: You can also make a multi-line string with tripe double-quotes `\"\"\"\"` or triple single-quotes `'''`.\n",
    "\n",
    "\n",
    "\n",
    "* `range` -- Used to yield elements of a sequence piecewise. Useful in loops.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "**Classes:**\n",
    "\n",
    "* `class` -- A way to create and specify the `methods` (class-associated functions) and `attributes` (class-associated variables) of 'objects'.\n",
    "\n",
    "**Others:**\n",
    "\n",
    "* `instances`\n",
    "* `exceptions`\n",
    "\n",
    "\n",
    "Futher reading on this can be done [here](https://docs.python.org/3/library/stdtypes.html).\n",
    "\n",
    "If you are ever in doubt about what the type of a variable is, you can pass it to the `type()` function that is built-in to python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"Hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparisons & Assigning\n",
    "\n",
    "### Assigning\n",
    "\n",
    "To assign is to simply say that _this_ variable should have _that_ value. We do that with the `=` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, `x` is assigned 5.\n",
    "\n",
    "\n",
    "\n",
    "A comparison is a logical statement. \n",
    "\n",
    "_'Is 3 > 5?'_\n",
    "\n",
    "_'Is __this__ equal to 2.71?'_\n",
    "\n",
    "### Comparisons\n",
    "\n",
    "Comparisons after they are evaluated become a `boolean` variable or `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Equals vs Assignment\n",
    "\n",
    "In colloquial terms the `=` is synonymous with equals, but in Python it is reserved solely for assigning.\n",
    "\n",
    "For comparing if things are equal, we inventively use the `==` (double equals sign)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5 # An assignment\n",
    "\n",
    "\n",
    "if x == 5:   # A comparison\n",
    "    display(\"It's true!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Not Equals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "\n",
    "if x != 6:   # A comparison\n",
    "    display(\"It's true that x does not equal 6!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inequalities  `<  >  <=  >=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "\n",
    "if x < 6:\n",
    "    display('x is < 6')\n",
    "    \n",
    "if x > 4:\n",
    "    display('x is > 4')\n",
    "    \n",
    "if x >= 5: # Greater than or equal to\n",
    "    display('x is greater than or equal to 5')   \n",
    "    \n",
    "if x <= 5: # Less than or equal to\n",
    "    display('x is less than or equal to 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing with `print()` and `display()`\n",
    "\n",
    "Generally, if you want text to appear below a cell, the print() function will work both when run in a notebook and as a file. But display is most useful for ensuring that output goes below the cell.\n",
    "\n",
    "Printing will happen by default if there is a variable listed at the bottom of a cell, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 3\n",
    "\n",
    "\n",
    "y = 2\n",
    "\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But it will not appear if we just do assignments to variables, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "y = x + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But placing a variable at the bottom of the cell can be improper and make your cell appear confusing to people who might use your code (or even you if you return to it after a long time). \n",
    "\n",
    "A more clear way would be to use the `display()` function, e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sid = 12345678   # Your student ID here.\n",
    "\n",
    "if (sid < 31415926):\n",
    "    display(\"Less!\")\n",
    "elif (sid > 31415926):\n",
    "    display(\"More!\")\n",
    "else:\n",
    "    display(\"Same!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If-Statements, If-Else-Statements\n",
    "\n",
    "There are two _boolean_ values used in Python to do boolean logic.\n",
    "\n",
    "`True` and `False`. Note that the capitalisation of the first letter is required, or else Python will think you are looking for a variable.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (True):\n",
    "    display(True)\n",
    "else:\n",
    "    display(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the cell above and its output, we can see a few things about the syntax of `if` statements.\n",
    "\n",
    "If the statement evaluates to `True`, then what is indented below it is evaluated.\n",
    "\n",
    "But the example is pretty useless, as all we are doing is checking if something is equal to itself -- an obvious tautology. \n",
    "\n",
    "Let's instead use a variable to explore the `if-else` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check = \"\"    # Change the variable! See what happens!\n",
    "\n",
    "if (check):\n",
    "    display(\"'check' evaluates to 'True'\")\n",
    "else:\n",
    "    display(\"'check' evaluates to 'False'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It would be instructive to change the value of check and see what is and is not considered `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing\n",
    "\n",
    "Importing is where you bring in the functions of a library/module.\n",
    "\n",
    "For us, the most important libraries will be the following (roughly in order of importance):\n",
    "\n",
    "1. `sympy` -- for symbolic mathematics; recall that computers inherently prefer numeric information.\n",
    "2. `matplotlib` -- a plotting library.\n",
    "3. `numpy` -- a numerical package for doing fast, accurate calculations on computers w/ python\n",
    "4. `math` -- a standard library that always comes with python for mathematical functions.\n",
    "\n",
    "You can import a library so that you can access at via the library's name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the sympy library, making its functions available to us.\n",
    "import sympy          \n",
    "\n",
    "# Prettify the output of sympy, using the library's init_printing() function.\n",
    "sympy.init_printing()     \n",
    "\n",
    "# Create a variable called 'x'\n",
    "x = sympy.Symbol('x')     \n",
    "\n",
    "# 'y' is the symbolic function, x squared.\n",
    "y = x**2                  \n",
    "\n",
    "# Use the sympy function, 'diff' to differentiate y.\n",
    "y_prime = sympy.diff(y)   \n",
    "\n",
    "# Make the result echo out below the cell.\n",
    "y_prime                   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But we can also import the library and call it whatever we want, using the `as` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " # Import the sympy library as 'sp', making its functions available to us.\n",
    "import sympy as sp       \n",
    "\n",
    "sp.init_printing()        \n",
    "x = sp.Symbol('x')        \n",
    "y = x**2                  \n",
    "y_prime = sp.diff(y)      \n",
    "y_prime                   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `from` keyword, we can import only certain functions that we need, separated by commas.\n",
    "\n",
    "This kind of style would be considered **best practice**, as it prevents names from clashing with other variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import init_printing, Symbol, diff\n",
    "\n",
    "init_printing()        \n",
    "x = Symbol('x')        \n",
    "y = x**2                  \n",
    "y_prime = diff(y)      \n",
    "y_prime    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As long as the name of all the `sympy` components does not conflict, we can also import all the functions using `*` to be a placeholder or 'wildcard' for all functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *     # From the sympy library, import everything.\n",
    "\n",
    "init_printing()        \n",
    "x = Symbol('x')        \n",
    "y = x**2                  \n",
    "y_prime = diff(y)      \n",
    "y_prime  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Functions\n",
    "\n",
    "A function will usually be denoted in these notebooks in the following format: `function()`\n",
    "\n",
    "The point of using a function can be multiple:\n",
    "\n",
    "* Reusability\n",
    "* Readability\n",
    "* Abstraction\n",
    "\n",
    "Our main use of functions will be so that others can understand our processes, you can reuse the same instruction sets and that functions can be called by yourself without needing to worry what is happening under the hood.\n",
    "\n",
    "### Arguments\n",
    "\n",
    "Arguments are the variables/objects/parameters that are passed into the function. A function can have many arguments or it can have none."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(arg1, arg2, arg3): # 3 arguments\n",
    "    stuff = arg1 + arg2 + arg3 # Calculation/instructions\n",
    "    return stuff\n",
    "\n",
    "def my_other_function(): # No arguments \n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making Functions\n",
    "\n",
    "Let's make a very simple function to see how they work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    result = a + b\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add(4,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### There are a few things to note. \n",
    "\n",
    "* The `def` keyword is used to create a function, it is short for _define_.\n",
    "* You have to have the general structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(argument): # Note that the colon is important.\n",
    "    # Some code to carry out the function\n",
    "    return stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Indentation is key and should be 4 or 2 spaces, **consistently**. The interpreter will consider everything one indent level and further a part of that function until you break the indent level again. e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(argument):  # <-- After colon, interpreter expects indent.\n",
    "    # <--- Indent\n",
    "    display(\"Hello, world.\") # <-- Part of the function!\n",
    "    display(\"Function things!\") # <-- Also part of the function\n",
    "display(\"Where am I?\") # <-- NOT part of the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You do not have to return anything, a function without `return` is still valid. But, a function with nothing in it is not valid.\n",
    "* It's kind of a useless function, because we can insead have said `3+4` in the cell and gotten the same output. But, it is for demonstration purposes!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Capturing the value of functions\n",
    "\n",
    "If you want to save the output of a function, like for our add function, you must _assign_ it to a variable.\n",
    "\n",
    "E.g. Say we want to save the value of `add(8, 10)` to the variable `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = add(8,10)\n",
    "display(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `python` programming interpreter reads a line with the assignment operator (`=`) from right to left -- a significant change if your only language is english! -- and evaluates the function `add(8, 10)` before following our instructions and assigning it to `x`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Useful Functions\n",
    "\n",
    "`min()` will return the minimum element in a list/tuple or sometimes, an object.\n",
    "\n",
    "`max()` will return the maximum value in a list/tuple or sometimes, an object.\n",
    "\n",
    "`len()` will return the length of an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objects, Classes, Functions, Methods, Variables, Attributes\n",
    "\n",
    "### Objects\n",
    "\n",
    "Objects are synonymous with classes. They are a programming abstraction that are used to represent real, fictional or new objects. The human mind is very equipped to understand objects and it is quite a comfortable paradigm to write in for most people. Classes and objects are beyond the scope of a rapid introduction to python, but their effects nonetheless trickle down into the things we will do and so they must be examined from a distance.\n",
    "\n",
    "Examples of objects/classes are:\n",
    "\n",
    "* `list`: Python lists.\n",
    "* `str`: Python strings.\n",
    "* `tuple`: Python tuples.\n",
    "* `symbol`: from `sympy`, used to represent variables, constants, etc.\n",
    "\n",
    "### Classes\n",
    "\n",
    "Classes are synonymous with objects. See objects for details.\n",
    "\n",
    "### Functions\n",
    "\n",
    "Are standalone procedures that turn instructions into a 'black box'. A function is a set of actions that can be called upon at any time. A set of actions may require you to have some materials and it may produce output -- it also may be beholden to neither of these.\n",
    "\n",
    "A `function` and a `method` can often be confused, but when `function` is mentioned appropriately, it means a set of procedures **not** tied to an object/class.\n",
    "\n",
    "A function is, generally, written as so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(arguments):\n",
    "    stuff = 0\n",
    "    # Actions go here\n",
    "    return stuff # Return it, only if you need to."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the functions section of this notebook for more information.\n",
    "\n",
    "### Methods\n",
    "\n",
    "A method is a function that **is tied to** an object/class. It is accessed as so:\n",
    "\n",
    "```py\n",
    "my_object.my_method()\n",
    "#|------------------|  <-- Can be thought of as a big function call.\n",
    "```\n",
    "\n",
    "We will often make use of methods when dealing with libraries.\n",
    "\n",
    "\n",
    "### Variables\n",
    "\n",
    "Variables are names that are assigned a value(s)/object(s). \n",
    "\n",
    "e.g.\n",
    "```py\n",
    "x = 5\n",
    "y = \"G'day\" \n",
    "z = some_object\n",
    "```\n",
    "etc.\n",
    "\n",
    "### Attributes \n",
    "Attributes are variables tied to an object/class.\n",
    "\n",
    "Say we have a complex number, `x = 8+5j`. You can grab the real and imaginary parts of this number with the `real` and `imag` attributes, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 8+5j\n",
    "display(x.real)\n",
    "display(x.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to emphasise how these variables are accessed. You cannot access `real` and `imag` without first stating which object you want them for first, i.e. you have to specify `x`. This is how the variables are tied to the object (which confusingly enough, is also another variable)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metadata about libraries\n",
    "\n",
    "Often times, you need to know which version of a library you are using, or what functions it contains.\n",
    "\n",
    "### Version Numbers\n",
    "\n",
    "Version numbers of libraries are stored in the library in the `__version__`.\n",
    "\n",
    "```py\n",
    "from sympy import __version__\n",
    "```\n",
    "\n",
    "If you wanted to use this version number, it would best to import it with an alias.\n",
    "\n",
    "```py\n",
    "from sympy import __version__ as sp_version\n",
    "```\n",
    "\n",
    "This way you can display the version number to yourself to obtain accurate documentation, or make decisions based on what version of the library that you are using (though this would mean you're building something more complex than we will do here).\n",
    "\n",
    "### The `dir()` and `help()` functions\n",
    "\n",
    "Say you're offline, with no access to documentation. How are you to figure out how to use a certain function in a library? Or know what functions are even contained in that library?\n",
    "\n",
    "The `help()` function is passed in a function name and prints out some documentation for its argument.\n",
    "\n",
    "e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function tan in module math:\n",
      "\n",
      "tan(x, /)\n",
      "    Return the tangent of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from math import tan\n",
    "help(tan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use this to figure out more about the `dir()` function in question.\n",
    "\n",
    "e.g."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function dir in module builtins:\n",
      "\n",
      "dir(...)\n",
      "    dir([object]) -> list of strings\n",
      "    \n",
      "    If called without an argument, return the names in the current scope.\n",
      "    Else, return an alphabetized list of names comprising (some of) the attributes\n",
      "    of the given object, and of attributes reachable from it.\n",
      "    If the object supplies a method named __dir__, it will be used; otherwise\n",
      "    the default dir() logic is used and returns:\n",
      "      for a module object: the module's attributes.\n",
      "      for a class object:  its attributes, and recursively the attributes\n",
      "        of its bases.\n",
      "      for any other object: its attributes, its class's attributes, and\n",
      "        recursively the attributes of its class's base classes.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a bit of jargon in there, but essentially:\n",
    "* The `dir()` function is used to list all the functions/attributes in a library if you pass it as an argument, e.g. `dir(math)` or,\n",
    "* It can list the functions/attributes that you currently have available to you if you don't pass an argument, e.g. `dir()`. \n",
    "\n",
    "e.g. We can have a look at all the functions in the math library. Should you want to know more about any of the names in the list, you can use the `help()` function on them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# -------- Questions --------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 1:\n",
    "\n",
    "Display the string `\"Hello world\"`.\n",
    "\n",
    "## Answer 1:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 2:\n",
    "\n",
    "Display the types of the following values:\n",
    "\n",
    "`3.14`\n",
    "\n",
    "`1+j`\n",
    "\n",
    "`88`\n",
    "\n",
    "`\"Mathemagical\"`\n",
    "\n",
    "## Answer 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 3:\n",
    "\n",
    "Make a function called `subtract` that returns the difference between two numbers. \n",
    "\n",
    "## Answer 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 4:\n",
    "\n",
    "### (i)\n",
    "Find and display the version numbers of the following modules:\n",
    "\n",
    "`sympy`\n",
    "\n",
    "`matplotlib`\n",
    "\n",
    "`numpy`\n",
    "\n",
    "### (ii)\n",
    "Why might it be important to know the version numbers?\n",
    "\n",
    "## Answer 4:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 5:\n",
    "\n",
    "Create a complex number `b = c+dj` such that:\n",
    "\n",
    "`c` = The third number of your student ID\n",
    "\n",
    "`d` = The fourth number of your student ID\n",
    "\n",
    "Display `b`.\n",
    "\n",
    "Note:\n",
    "\n",
    "If you use variables to store these numbers\n",
    "\n",
    "e.g.\n",
    "```py\n",
    "c = 8\n",
    "d = 9\n",
    "```\n",
    "\n",
    "Then you will need to times `d` by `1j`.\n",
    "\n",
    "If you use plain numbers, you can put `j` next to the number to make it imaginary.\n",
    "\n",
    "## Answer 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 6:\n",
    "\n",
    "Create a function called `length` that takes in one complex number and returns its modulus (length).\n",
    "\n",
    "Pass `b` to your `length` function and display the result.\n",
    "\n",
    "## Answer 6:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 7:\n",
    "\n",
    "You can, from the `math` library, obtain the `atan` function to calculate values of: $\\tan^{-1}(x)$ (also called $\\arctan(x)$).\n",
    "\n",
    "Import `atan` and make your own function called `argument`. Inside of your function, calculate the angle formed by the real and imaginary parts (with respect to the $x$-axis) and return it.\n",
    "\n",
    "_Note:_\n",
    "\n",
    "For the wary, recall that $\\arctan(x)$ has a domain of all real $x$. Meaning it can take in a some $x = \\tan\\theta$ where a $\\theta$ angle is from any of the four quadrants. The output (range) is however constrained to $[\\frac{-\\pi}{2}, \\frac{\\pi}{2}]$. What will this mean for $\\theta$ angles given to $x$ in the second and third quadrant? \n",
    "\n",
    "## Answer 7:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 8:\n",
    "\n",
    "From your software library version numbers obtain links to their documentation and edit the cell below to place it next to their name.\n",
    "\n",
    "## Answer 8:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sympy`, version \\_\\_, docs: [link](yourlinkhere.com)\n",
    "\n",
    "`numpy`, version \\_\\_, docs: [link](yourlinkhere.com)\n",
    "\n",
    "`matplotlib`, version \\_\\_, docs: [link](yourlinkhere.com)\n",
    "\n",
    "_Note:_\n",
    "\n",
    "In the past, students have been asked to get the version number of the `math` library, but this is a standard library that always comes with `python`. This is also true for all standard libraries. \n",
    "\n",
    "_Follow up question:_\n",
    "\n",
    "How might you find out what are the standard and non-standard libraries in `python`?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 9:\n",
    "\n",
    "Create a function called `pi_check` that evaluates whether a value passed to it is greater than, equal to or less than an approximate value of $\\pi$.\n",
    "\n",
    "\n",
    "Display the output of the following values:\n",
    "\n",
    "(i) `2.71`\n",
    "\n",
    "(ii) `6.626`\n",
    "\n",
    "(iii) `8.854`\n",
    "\n",
    "(iv) `1.0101`\n",
    "\n",
    "## Answer 9:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}