01_GettingStarted.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started\n",
    "\n",
    "This tutorial is based on [Jupyter Notebooks](http://jupyter.org/). Jupyter Notebook is a web-based Python development environment allowing you to combine documentation (markdown), code, and their results) into a single document. This follows a similar idea as [Mathematica](http://www.wolfram.com/mathematica/).\n",
    "\n",
    "JupyterLab is a web-based interactive development environment for Jupyter notebooks that adds a number of quality of life additions to working with notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First Steps\n",
    "\n",
    "A Juypter Notebook consists of individual cells. There are two major cell types: Code and Markdown. \n",
    "\n",
    "Useful keyboard shortcuts: \n",
    "* **Enter**: enter edit mode of the selected cell\n",
    "* **Shift-Enter**: run cell, select below\n",
    "* **Ctrl-Enter**: run cell\n",
    "* **Alt-Enter**: run cell, insert a new cell below\n",
    "\n",
    "Getting Help: \n",
    "\n",
    "* **Tab** code completion or indent\n",
    "* **Shift-Tab** for a function, e.g., argument list\n",
    "* `function?` query the Python docstring for the given function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Conventions\n",
    "The Python community has adopted some naming conventions for common libraries:\n",
    "```\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pylot as plt\n",
    "import seaborn as sns\n",
    "import statsmodels as sm\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#include some package that we use later on\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0)\n",
       "\n",
       "Create an array.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "object : array_like\n",
       "    An array, any object exposing the array interface, an object whose\n",
       "    __array__ method returns an array, or any (nested) sequence.\n",
       "dtype : data-type, optional\n",
       "    The desired data-type for the array.  If not given, then the type will\n",
       "    be determined as the minimum type required to hold the objects in the\n",
       "    sequence.\n",
       "copy : bool, optional\n",
       "    If true (default), then the object is copied.  Otherwise, a copy will\n",
       "    only be made if __array__ returns a copy, if obj is a nested sequence,\n",
       "    or if a copy is needed to satisfy any of the other requirements\n",
       "    (`dtype`, `order`, etc.).\n",
       "order : {'K', 'A', 'C', 'F'}, optional\n",
       "    Specify the memory layout of the array. If object is not an array, the\n",
       "    newly created array will be in C order (row major) unless 'F' is\n",
       "    specified, in which case it will be in Fortran order (column major).\n",
       "    If object is an array the following holds.\n",
       "\n",
       "    ===== ========= ===================================================\n",
       "    order  no copy                     copy=True\n",
       "    ===== ========= ===================================================\n",
       "    'K'   unchanged F & C order preserved, otherwise most similar order\n",
       "    'A'   unchanged F order if input is F and not C, otherwise C order\n",
       "    'C'   C order   C order\n",
       "    'F'   F order   F order\n",
       "    ===== ========= ===================================================\n",
       "\n",
       "    When ``copy=False`` and a copy is made for other reasons, the result is\n",
       "    the same as if ``copy=True``, with some exceptions for `A`, see the\n",
       "    Notes section. The default order is 'K'.\n",
       "subok : bool, optional\n",
       "    If True, then sub-classes will be passed-through, otherwise\n",
       "    the returned array will be forced to be a base-class array (default).\n",
       "ndmin : int, optional\n",
       "    Specifies the minimum number of dimensions that the resulting\n",
       "    array should have.  Ones will be pre-pended to the shape as\n",
       "    needed to meet this requirement.\n",
       "\n",
       "Returns\n",
       "-------\n",
       "out : ndarray\n",
       "    An array object satisfying the specified requirements.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "empty_like : Return an empty array with shape and type of input.\n",
       "ones_like : Return an array of ones with shape and type of input.\n",
       "zeros_like : Return an array of zeros with shape and type of input.\n",
       "full_like : Return a new array with shape of input filled with value.\n",
       "empty : Return a new uninitialized array.\n",
       "ones : Return a new array setting values to one.\n",
       "zeros : Return a new array setting values to zero.\n",
       "full : Return a new array of given shape filled with value.\n",
       "\n",
       "\n",
       "Notes\n",
       "-----\n",
       "When order is 'A' and `object` is an array in neither 'C' nor 'F' order,\n",
       "and a copy is forced by a change in dtype, then the order of the result is\n",
       "not necessarily 'C' as expected. This is likely a bug.\n",
       "\n",
       "Examples\n",
       "--------\n",
       ">>> np.array([1, 2, 3])\n",
       "array([1, 2, 3])\n",
       "\n",
       "Upcasting:\n",
       "\n",
       ">>> np.array([1, 2, 3.0])\n",
       "array([ 1.,  2.,  3.])\n",
       "\n",
       "More than one dimension:\n",
       "\n",
       ">>> np.array([[1, 2], [3, 4]])\n",
       "array([[1, 2],\n",
       "       [3, 4]])\n",
       "\n",
       "Minimum dimensions 2:\n",
       "\n",
       ">>> np.array([1, 2, 3], ndmin=2)\n",
       "array([[1, 2, 3]])\n",
       "\n",
       "Type provided:\n",
       "\n",
       ">>> np.array([1, 2, 3], dtype=complex)\n",
       "array([ 1.+0.j,  2.+0.j,  3.+0.j])\n",
       "\n",
       "Data-type consisting of more than one element:\n",
       "\n",
       ">>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])\n",
       ">>> x['a']\n",
       "array([1, 3])\n",
       "\n",
       "Creating an array from sub-classes:\n",
       "\n",
       ">>> np.array(np.mat('1 2; 3 4'))\n",
       "array([[1, 2],\n",
       "       [3, 4]])\n",
       "\n",
       ">>> np.array(np.mat('1 2; 3 4'), subok=True)\n",
       "matrix([[1, 2],\n",
       "        [3, 4]])\n",
       "\u001b[0;31mType:\u001b[0m      builtin_function_or_method\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#test np.ar -> tab\n",
    "a = np.array([1,2,3,4])\n",
    "#test np.array -> shift-tab or np.array?\n",
    "np.array?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Python basics\n",
    "\n",
    "Python is an untyped dynamic language. The last output of a cell line will be printed. Individual values can also be printed using the `print(...)` function. Variables are just declared and assigned. Function are first level objects and Python can be used to program in a functional style. Some simple examples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3+4\n",
    "10/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(5+2)\n",
    "3+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7777777777777778"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5+2\n",
    "b = 9\n",
    "a/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum(a,b): #indent is important in Python!\n",
    "    return a+b\n",
    "sum(4,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum  16\n",
      "sub -2\n"
     ]
    }
   ],
   "source": [
    "def sub(arg1,arg2):\n",
    "    return arg1-arg2\n",
    "def calc(f, a, b):\n",
    "    return f(a,b)\n",
    "#functions are first level objects, e.g., can be passed as argument to another function\n",
    "print('sum ', calc(sum, a, b))\n",
    "print('sub', calc(sub, a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n",
      "{'a': 'ALPHA', 'b': 'BETA'}\n"
     ]
    }
   ],
   "source": [
    "#list\n",
    "arr = [1,2,3,4]\n",
    "#maps aka dictionaries/dicts\n",
    "dictionary = { 'a': 'Alpha', 'b': 'Beta'}\n",
    "\n",
    "#list transformation\n",
    "arr2 = [a * 2 for a in arr]\n",
    "dict2 = {k : v.upper() for k,v in dictionary.items()}\n",
    "\n",
    "print(arr2)\n",
    "print(dict2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "large\n"
     ]
    }
   ],
   "source": [
    "if a < 5:\n",
    "    print ('small')\n",
    "else:\n",
    "    print ('large')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'large'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 'small' if a < 5 else 'large'\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#what else: generators, iterators, classes, tuples, ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next\n",
    "\n",
    "[Data Manipulation with Numpy and Pandas](02_DataManipulation.ipynb)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}