demos/revisit_bads_stuff/Python-Primer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Humboldt-WI/adams/blob/master/exercises/Ex01-Python-Primer.ipynb) \n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Python primer #1: basics\n",
    "Here is the outline of our first tutorial introducing Python and Jupyter notebooks.\n",
    "\n",
    "1. Jupyter notebook\n",
    "2. Python basics\n",
    "3. Packages and installation\n",
    "3. numpy\n",
    "4. pandas\n",
    "5. loading data\n",
    "6. matpotlib\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Working with a Jupyter notebook\n",
    "### Managing cells\n",
    "Jupyter has two modes. When the cell marker is blue, you can select cells with the keyboard arrows and handle them by creating new cells, moving, copying or deleting them. When you press Enter while selecting a cell, you jump into editing mode and can change the content of a cell, e.g. by writing code.\n",
    "\n",
    "The types of actions you can perform are listed under Help > Keyboard shortcuts \n",
    "\n",
    "- New cells are inserted with *a* (above) or *b* (below).\n",
    "- Cells can be *c* copied, *x* cut and *v* pasted\n",
    "- Cells are deleted by pressing *d* two times.\n",
    "- To run a cell and select the next cell: Shift + Enter\n",
    "- While typing, use Tab to finish the object name for you and Shift + Tab to see the documentation\n",
    "\n",
    "It is worth remembering the shortcuts to work efficiently. Also check out notebook *magic* commands starting with % when things get more interesting."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Cell types ###\n",
    "A Jupyter notebook usually consists of text describing the context of the problem and describing the code as well as the actual code. Text is written in markup cells, which allow nice formatting similar to LaTeX, while code should be written in code cells. There, the code can be run interactively and the output will be visualized in the notebook.\n",
    "\n",
    "You can change the cell content with 'm' for markup and 'y' for code. Remember that you need to be in selection (or command) mode. "
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "##functionality demo"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Python  ## "
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Object types\n",
    "\n",
    "1. _Numbers_: 1234, 3.1415, 999L, 3+4j, Decimal\n",
    "\n",
    "2. _Strings_: 'ourstring', \"text or comment\"\n",
    "\n",
    "3. _Lists_: [1, [2, 'three'], 4]\n",
    "\n",
    "4. _Dictionaries_: {'employment': 'fulltime', 'gender': 'male'}\n",
    "\n",
    "5. _Tuples_: (1,'spam', 4, 'U')\n",
    "\n",
    "6. _Files_: myfile = open('goodcode', 'python')\n",
    "\n",
    "also booleans, functions, classes, etc\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Lists and assignment rules\n",
    "Unlike R, Python is primarily a programming language, so its standard object classes behave a little different. When indexing lists and similar objects, always remember that python starts counting indices at 0. When slicing x[start:end], the end value is *not* included in the output. You can index from the end using the minus like x[0:-2].\n",
    "\n",
    "The biggest difference is that many objects can be modified in-place, i.e. without reassignment common in R like x <- x[1:2]. This increases speed and memory efficiency, but be careful when running code multiple times or in a different order. Also be aware that objects are not copied when reassigned, but instead linked to the original content, which may change. If you'd like to copy a list, use a complete index [:].\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Lists\n",
    "x = [1, 2, 3, 4]\n",
    "print(x)\n",
    "\n",
    "print(x[1:3])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Delete an element of x in-place\n",
    "# Also note that you can index from the end by using -\n",
    "del x[-2]\n",
    "print(x)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "y = x\n",
    "z = x[:]\n",
    "print(y)\n",
    "print(z)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "del y[0]\n",
    "y"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# See that x has changed when we deleted y[0]\n",
    "print(x); print(z)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Methods "
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Python is an object-oriented programming language, so in addition to functions, it has *methods*. Methods are associated with objects. That means they are called for a specific object instead of passing the object as an explicit argument and have access to information saved within the object.\n",
    "\n",
    "Objects, in turn, are an instanciation of a class. Think of classes as templates, which define all the data and behavior (i.e., methods) of an entity. For example, a class _student_ could provide a programmer with means to store data such as _name_, _email_, and _student id_. In addition, the class could define some behavior that students exhibit, such as _enrollForCourse_, _registerForExam_, etc. The way to implement behavior is to write a corresponding method. Using the __class__ _student_, that is our template, we could then create __objects__ that represent individual students, such as a student with _name_ Eve and _student id_ 12345, and a different student with _name_ Paul and _student id_ 67890. "
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# A method for class string\n",
    "a = \"hello world\"\n",
    "print(type(a))\n",
    "\n",
    "a.upper()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "a.split()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Find all methods for an object\n",
    "dir(a)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# As for lists, one of the most frequent methods would be append (when we want to add smth to the list)\n",
    "out = [1,2,3,4,5]\n",
    "out.append(100)\n",
    "print(out)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We will look more into methods when we are talking about packages"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Dictionaries\n",
    "Dictionaries are similar to named lists in R, in that they save a value filed under a name (=key). When creating object classes, python makes use of different brackets. You will need it for data management."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Dictionary\n",
    "d = {\"a\":2, \"b\":\"cheese\", \"c\":[1,2,3]}\n",
    "print(d)\n",
    "print(d[\"c\"])\n",
    "print(d[\"b\"])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "d[3] = 'NEW'\n",
    "d"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Mind the difference!"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "You can get the keys, items or both (as a list of tuples) at any time from the dictionary. Note that the 'functions' are methods that are part of each dictionary, so we use d.keys() instead of keys(d). We will talk more about the difference later."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print(d.keys())\n",
    "print(d.values())\n",
    "print(d.items())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Conditions and Loops\n",
    "Conditional structures are very important in order to create efficient programms. The logic resembles R, however, there is a bunch of notions you should be aware of. For example, __indentation__ (4 spaces per indentation level). Unlike R, Python is sensitive to it."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "language=\"Python\"\n",
    "if language == 'Python':\n",
    " print('Mind the dents!')\n",
    "else:\n",
    " print(\"Ah, do whatever you want\")\n",
    "#just a space will also work in most cases, however, the Python community has developed a Style Guide for Python Code (PEP8) where the agreement is on 4 spaces"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Sometimes we need a certain logical flow to be executed, that is where _else_ and _elif_ would be useful:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "if 1 == 2:\n",
    "    print('first')\n",
    "elif 3 == 3:\n",
    "    print('middle')\n",
    "else:\n",
    "    print('Last')"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Let's try to apply a certain action to every component of a list with a use of looping command __for__:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "ourstring=[5,8,9,7]\n",
    "for thingy in ourstring:\n",
    "    print(thingy)\n",
    "#You won't be able to do much with the list - that is why we will need Numpy or a function"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Some other actions are also possible\n",
    "for dingy in ourstring:\n",
    "    print(dingy+dingy)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "__While__ and __for__ are other examples of looping command:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "j = -1\n",
    "while j < 8:\n",
    "    print('i is: {}'.format(j))\n",
    "    j = j+1"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "for z in range(7):\n",
    "    print(z)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "It is often useful to loop over several values at the same time, for example over each key and value pair in a dictionary. "
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "for key, value in d.items():\n",
    "    print(f\"This is one of the keys: {key}\")\n",
    "    print(f\"And this is its value: {value}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Very often, we can use comprehensions that return an object with the results directly."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "v=[1,5,9,19]\n",
    "[x*2 for x in v] #"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "d.items()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "{key:value==\"cheese\" for key,value in d.items()}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Functions\n",
    "Functions work as in R. You create new function by *defining* them. You see that much of structural programming is indicated by the structure of the code, i.e. a tab or four spaces.\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def ourFunction (arg1, arg2, arg3 ...):\n",
    "    program statement1\n",
    "    program statement3\n",
    "    program statement3\n",
    "    ....\n",
    "    return;"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def happyBirthdayAlisa(): #program does nothing as written\n",
    "    print(\"Happy Birthday to you!\")\n",
    "    print(\"Happy Birthday to you!\")\n",
    "    print(\"Happy Birthday, dear Alisa.\")\n",
    "    print(\"Happy Birthday to you!\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "happyBirthdayAlisa # what happened thata"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "happyBirthdayAlisa()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def happyBirthday(person):\n",
    "    print(\"Happy Birthday to you!\")\n",
    "    print(\"Happy Birthday to you!\")\n",
    "    print(\"Happy Birthday, dear \" + person + \".\")\n",
    "    print(\"Happy Birthday to you!\")\n",
    "happyBirthday(\"Christian\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def multpl(x, y):\n",
    "    return x ** y\n",
    "\n",
    "multpl(5,3)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# In simple cases like the one above we can use an anonymous function like the ones we know from R:\n",
    "\n",
    "r = lambda x, y: x * y\n",
    "r(120, 5) "
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Let's look more into the structure\n",
    "def example_function(x, y = 2):\n",
    "    x += y # This is short for add and reassign x = x + y\n",
    "    return x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "example_function(1)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#You can build your whole code as execution of certain functions\n",
    "def main():\n",
    "    happyBirthday('Bobby')\n",
    "    happyBirthday('Anna')\n",
    "main()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Methods as functions attached to a class"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "class person():\n",
    "    \"\"\"Class person for human interaction\"\"\"\n",
    "    def __init__(self, name, age=None):\n",
    "        \"\"\"\n",
    "        Cool, we can write help text like this starting and ending \n",
    "        with three quotations.\n",
    "        \n",
    "        name : str\n",
    "          The name of the person\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def happy_birthday(self):\n",
    "        \"\"\"Wish a happy birtday\"\"\"\n",
    "        print(f\"Happy Birthday, dear {self.name}.\")\n",
    "        if self.age is not None:\n",
    "            self.age += 1\n",
    "            print(f\"{self.age} years, eh?\")\n",
    "        return None\n",
    "    \n",
    "    def greeting(self):\n",
    "        \"\"\"Greet the person\"\"\"\n",
    "        print(f\"Hi {self.name}! How are you doing?\")\n",
    "        return None"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "example = person(\"Johannes\", 20)\n",
    "example.greeting()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "example.happy_birthday()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "example.age"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Loading libraries aka packages\n",
    "Most of the functionality that we need is provided by additional libraries to the core python. You can do it in several ways:\n",
    " 1. Install manually via Anaconda Netvigator (Environments)\n",
    " 2. Install via Anaconda terminal (advised at set-up stage) **- recommended**\n",
    " 3. Install in Jupyter notebook (!{sys.executable} -m pip install numpy __OR__ !conda install --yes --prefix {sys.prefix} numpy)\n",
    " 4. Install in Jupyter notebook via !pip install  - not recommended"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import sys\n",
    "!conda install  --prefix {sys.prefix} numpy"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "At the beginning of the code, we need to load these packages. Python is stricter than R when it comes to namespaces. When loading a function from a package, the package is usually included in the function call. For convenience, package names are therefore often abbreviated using import [...] as [...]. It is also possible to import only specific function from a library using from 'package' import 'function'.\n",
    "\n",
    "The top 5 packages to remember for now are:\n",
    " - numpy (numeric manipulation)\n",
    " - pandas (data management)\n",
    " - matplotlib (plots)\n",
    " - seaborn (advanced plots, stat visualizations)\n",
    " - scikit-learn (standard package for machine learning in python)\n",
    " \n",
    "When loading packages, you can give them a nickname in order to save some typing time. There usually is a convention for each package's nickname, but you can choose a different one."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Math functionality\n",
    "import numpy as np\n",
    "# Data frame capabilities similar to data.table in R\n",
    "import pandas as pd\n",
    "# Plotting functionality\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "# Statistical data visualization\n",
    "import seaborn as sns\n",
    "# scikit-learn (sklearn) is *the* standard package for machine learning in python"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Numpy\n",
    "\n",
    "Numpy will do most of the linear algebra operations on the way. We will look into:\n",
    "- arrays\n",
    "- indexing\n",
    "- operations"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# numpy array is one of the most basic object types, we can get it by converting a basic list"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "ourlist = [1,2,3,4,5]\n",
    "ourlist"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Note how we specify the package by its nickname before calling a function from the package"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "np.array(ourlist)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Some basic operations\n",
    "print(np.sqrt(ourlist),np.exp(ourlist))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "listoflists=[[1,2,3],[4,5,6],[7,8,9]]\n",
    "listoflists"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "np.array(listoflists) # for our neural networks it will be the most basic type"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Learning to operate them would be important\n",
    "np.arange(0,10)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "np.arange(0,12,3)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "np.ones((3,4)) # generating a matrix of 1, could be 0"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "np.linspace(0,5,10) # evenly spaced numbers in specified interval"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#identity matrix\n",
    "np.eye(6)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Setting a value with index range (Broadcasting)\n",
    "ar = np.arange(0,20)\n",
    "ar[0:5]=0\n",
    "ar"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Important note!\n",
    "slice_of_ar = ar[0:4]\n",
    "slice_of_ar"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "slice_of_ar[:]=999\n",
    "slice_of_ar"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Note that change occurs in initial array!"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "ar"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can copy objects actively to avoid this"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "slice_of_ar=ar[0:4].copy()\n",
    "slice_of_ar"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "slice_of_ar[:]=0\n",
    "ar"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Indexing is similar to R and works by integer index or logical index"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "x = 10\n",
    "ar[ar>x]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Randomization will matter a lot for us\n",
    "np.random.randn(2,4)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Return random integers from `low` (inclusive) to `high` (exclusive).\n",
    "np.random.randint(1,100,5) "
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr = np.arange(25)\n",
    "arr #arr.TAB will show you which methods you can use"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr.max()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr.reshape(5,5) # another important method "
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr.shape"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr.reshape(25,1)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr.shape # mind that the shape wasn't reassigned in-place"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr.reshape(25,1).shape"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "arr.dtype # for neural networks a specific type of float would be necessary, we will get back to  it later"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "w =np.array([12,11,10])\n",
    "v = np.array([1,2,3])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Inner product of vectors;\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Matrix/vector multiplication\n",
    "import numpy as np\n",
    "A = np.array([[ 5, 1 ,3], [ 1, 1 ,1], [ 1, 2 ,1]])\n",
    "b = np.array([1, 2, 3])\n",
    "print (A.dot(b))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Just a quick reminder about the element selection\n",
    "print(A[0,0])\n",
    "A"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "#Let's say we have A x = b, we need to find x\n",
    "\n",
    "A = np.array([[2,1,-2],[3,0,1],[1,1,-1]])\n",
    "b = np.transpose(np.array([[-3,5,-2]]))\n",
    "                 \n",
    "#To solve the system we do\n",
    "x=np.linalg.solve(A,b)\n",
    "x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "That was it for our first session. See you soon for another round of programming.\n"
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [deeplearning]",
   "language": "python",
   "name": "Python [deeplearning]"
  },
  "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.6.7"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "source": [],
    "metadata": {
     "collapsed": false
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}