Notebooks/Python_DataScience/01_Intro_Jupyter_Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## Introduction to Jupyter Notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install -U -q install ipympl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import time\n",
    "\n",
    "from IPython.display import HTML\n",
    "from IPython.display import Image\n",
    "from IPython.display import Audio\n",
    "from IPython.display import clear_output\n",
    "from IPython.display import display\n",
    "from IPython.lib.display import YouTubeVideo\n",
    "from ipywidgets import widgets\n",
    "\n",
    "#%matplotlib notebook\n",
    "#%matplotlib widget\n",
    "%matplotlib inline\n",
    "\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create markdown cells\n",
    "\n",
    "Produce well formatted [markdown](https://www.markdownguide.org/cheat-sheet/) cells with [Markdown sintax](https://guides.github.com/features/mastering-markdown/), or also use [$ \\LaTeX{} $](http://www.utc.fr/~jlaforet/Suppl/latex-cheatsheet.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keyboard Shortcuts\n",
    "\n",
    "As any power user knows, keyboard shortcuts will save you lots of time. Jupyter stores a list of keybord shortcuts under the menu at the top: Help > Keyboard Shortcuts, or by pressing H in command mode (more on that later). It's worth checking this each time you update Jupyter, as more shortcuts are added all the time.\n",
    "\n",
    "Another way to access keyboard shortcuts, and a handy way to learn them is to use the command palette: Cmd + Shift + P (or Ctrl + Shift + P on Linux and Windows). This dialog box helps you run any command by name - useful if you don't know the keyboard shortcut for an action or if what you want to do does not have a keyboard shortcut. The functionality is similar to Spotlight search on a Mac, and once you start using it you'll wonder how you lived without it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ Some of my favorites:\n",
    "\n",
    "    Esc will take you into command mode where you can navigate around your notebook with arrow keys.\n",
    "    While in command mode:\n",
    "        A to insert a new cell above the current cell, B to insert a new cell below.\n",
    "        M to change the current cell to Markdown, Y to change it back to code\n",
    "        D + D (press the key twice) to delete the current cell\n",
    "    Enter will take you from command mode back into edit mode for the given cell.  \n",
    "    Shift + Tab will show you the Docstring (documentation) for the the object you have just typed in a code cell   - you can keep pressing this short cut to cycle through a few modes of documentation.  \n",
    "    Ctrl + Shift + - will split the current cell into two from where your cursor is.  \n",
    "    Esc + F Find and replace on your code but not the outputs.  \n",
    "    Esc + O Toggle cell output.  \n",
    "    Select Multiple Cells:  \n",
    "        Shift + J or Shift + Down selects the next sell in a downwards direction. You can also select sells in an upwards direction by using Shift + K or Shift + Up.  \n",
    "        Once cells are selected, you can then delete / copy / cut / paste / run them as a batch. This is helpful when you need to move parts of a notebook.  \n",
    "        You can also use Shift + M to merge multiple cells.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython Magic Commands\n",
    "\n",
    "The %matplotlib inline you saw above was an example of a IPython Magic command. Being based on the IPython kernel, Jupyter has access to all the Magics from the IPython kernel, and they can make your life a lot easier!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "is_executing": false
    }
   },
   "outputs": [
    {
     "data": {
      "application/json": {
       "cell": {
        "!": "OSMagics",
        "HTML": "Other",
        "SVG": "Other",
        "bash": "Other",
        "capture": "ExecutionMagics",
        "cmd": "Other",
        "debug": "ExecutionMagics",
        "file": "Other",
        "html": "DisplayMagics",
        "javascript": "DisplayMagics",
        "js": "DisplayMagics",
        "latex": "DisplayMagics",
        "markdown": "DisplayMagics",
        "perl": "Other",
        "prun": "ExecutionMagics",
        "pypy": "Other",
        "python": "Other",
        "python2": "Other",
        "python3": "Other",
        "ruby": "Other",
        "script": "ScriptMagics",
        "sh": "Other",
        "svg": "DisplayMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "writefile": "OSMagics"
       },
       "line": {
        "alias": "OSMagics",
        "alias_magic": "BasicMagics",
        "autoawait": "AsyncMagics",
        "autocall": "AutoMagics",
        "automagic": "AutoMagics",
        "autosave": "KernelMagics",
        "bookmark": "OSMagics",
        "cd": "OSMagics",
        "clear": "KernelMagics",
        "cls": "KernelMagics",
        "colors": "BasicMagics",
        "conda": "PackagingMagics",
        "config": "ConfigMagics",
        "connect_info": "KernelMagics",
        "copy": "Other",
        "ddir": "Other",
        "debug": "ExecutionMagics",
        "dhist": "OSMagics",
        "dirs": "OSMagics",
        "doctest_mode": "BasicMagics",
        "echo": "Other",
        "ed": "Other",
        "edit": "KernelMagics",
        "env": "OSMagics",
        "gui": "BasicMagics",
        "hist": "Other",
        "history": "HistoryMagics",
        "killbgscripts": "ScriptMagics",
        "ldir": "Other",
        "less": "KernelMagics",
        "load": "CodeMagics",
        "load_ext": "ExtensionMagics",
        "loadpy": "CodeMagics",
        "logoff": "LoggingMagics",
        "logon": "LoggingMagics",
        "logstart": "LoggingMagics",
        "logstate": "LoggingMagics",
        "logstop": "LoggingMagics",
        "ls": "Other",
        "lsmagic": "BasicMagics",
        "macro": "ExecutionMagics",
        "magic": "BasicMagics",
        "matplotlib": "PylabMagics",
        "mkdir": "Other",
        "more": "KernelMagics",
        "notebook": "BasicMagics",
        "page": "BasicMagics",
        "pastebin": "CodeMagics",
        "pdb": "ExecutionMagics",
        "pdef": "NamespaceMagics",
        "pdoc": "NamespaceMagics",
        "pfile": "NamespaceMagics",
        "pinfo": "NamespaceMagics",
        "pinfo2": "NamespaceMagics",
        "pip": "PackagingMagics",
        "popd": "OSMagics",
        "pprint": "BasicMagics",
        "precision": "BasicMagics",
        "prun": "ExecutionMagics",
        "psearch": "NamespaceMagics",
        "psource": "NamespaceMagics",
        "pushd": "OSMagics",
        "pwd": "OSMagics",
        "pycat": "OSMagics",
        "pylab": "PylabMagics",
        "qtconsole": "KernelMagics",
        "quickref": "BasicMagics",
        "recall": "HistoryMagics",
        "rehashx": "OSMagics",
        "reload_ext": "ExtensionMagics",
        "ren": "Other",
        "rep": "Other",
        "rerun": "HistoryMagics",
        "reset": "NamespaceMagics",
        "reset_selective": "NamespaceMagics",
        "rmdir": "Other",
        "run": "ExecutionMagics",
        "save": "CodeMagics",
        "sc": "OSMagics",
        "set_env": "OSMagics",
        "store": "StoreMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "tb": "ExecutionMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "unalias": "OSMagics",
        "unload_ext": "ExtensionMagics",
        "who": "NamespaceMagics",
        "who_ls": "NamespaceMagics",
        "whos": "NamespaceMagics",
        "xdel": "NamespaceMagics",
        "xmode": "BasicMagics"
       }
      },
      "text/plain": [
       "Available line magics:\n",
       "%alias  %alias_magic  %autoawait  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %cls  %colors  %conda  %config  %connect_info  %copy  %ddir  %debug  %dhist  %dirs  %doctest_mode  %echo  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %macro  %magic  %matplotlib  %mkdir  %more  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %pip  %popd  %pprint  %precision  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %ren  %rep  %rerun  %reset  %reset_selective  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode\n",
       "\n",
       "Available cell magics:\n",
       "%%!  %%HTML  %%SVG  %%bash  %%capture  %%cmd  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile\n",
       "\n",
       "Automagic is ON, % prefix IS NOT needed for line magics."
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This will list all magic commands\n",
    "%lsmagic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython Magic - %env: Set Environment Variables\n",
    "\n",
    "You can manage environment variables of your notebook without restarting the jupyter server process. Some libraries (like theano) use environment variables to control behavior, %env is the most convenient way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: OMP_NUM_THREADS=4\n"
     ]
    }
   ],
   "source": [
    "# Running %env without any arguments\n",
    "# lists all environment variables\n",
    "\n",
    "# The line below sets the environment\n",
    "# variable OMP_NUM_THREADS\n",
    "%env OMP_NUM_THREADS=4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython Magic - %run: Execute python code\n",
    "\n",
    "%run can execute python code from .py files - this is well-documented behavior. Lesser known is the fact that it can also execute other jupyter notebooks, which can quite useful.\n",
    "\n",
    "Note that using %run is not the same as importing a python module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# this will execute and show the output from\n",
    "# all code cells of the specified notebook\n",
    "%run ./histogram_multihist.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython Magic - %load: Insert the code from an external script\n",
    "\n",
    "This will replace the contents of the cell with an external script. You can either use a file on your computer as a source, or alternatively a URL."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# Before Running\n",
    "%load ./hello_world.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# %load ./hello_world.py\n",
    "# After Running\n",
    "# %load ./hello_world.py\n",
    "if __name__ == \"__main__\":\n",
    "\tprint(\"Hello World!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# After Running\n",
    "# %load ./hello_world.py\n",
    "if __name__ == \"__main__\":\n",
    "    print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython Magic - %who: List all variables of global scope.\n",
    "\n",
    "The %who command without any arguments will list all variables that existing in the global scope. Passing a parameter like str will list only variables of that type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Audio\t HTML\t Image\t YouTubeVideo\t ax0\t ax1\t ax2\t ax3\t clear_output\t \n",
      "colors\t display\t fig\t n_bins\t np\t os\t pd\t plt\t sys\t \n",
      "time\t widgets\t x\t x_multi\t \n"
     ]
    }
   ],
   "source": [
    "%who"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython Magic - Timing\n",
    "\n",
    "There are two IPython Magic commands that are useful for timing - %%time and %timeit. These are especially handy when you have some slow code and you're trying to indentify where the issue is.  \n",
    "\n",
    "%%time will give you information about a single run of the code in your cell.  \n",
    "\n",
    "%%timeit uses the Python timeit module which runs a statement 100,000 times (by default) and then provides the mean of the fastest three times.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 0 ns\n",
      "Wall time: 15.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "for _ in range(1000):\n",
    "    time.sleep(0.01)# sleep for 0.01 seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.57 µs ± 108 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit np.random.normal(size=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Profiling: %prun, %mprun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "9\n",
      "9\n",
      "4\n",
      "8\n",
      "7\n",
      "0\n",
      "6\n",
      "2\n",
      "5\n",
      " "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         258 function calls in 50.100 seconds\n",
      "\n",
      "   Ordered by: internal time\n",
      "\n",
      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
      "       10   50.093    5.009   50.093    5.009 {built-in method time.sleep}\n",
      "        8    0.005    0.001    0.005    0.001 socket.py:545(send)\n",
      "       10    0.001    0.000    0.001    0.000 {method 'randint' of 'numpy.random.mtrand.RandomState' objects}\n",
      "       20    0.000    0.000    0.006    0.000 iostream.py:526(write)\n",
      "        1    0.000    0.000   50.100   50.100 591463035.py:1(funcao_lenta)\n",
      "        8    0.000    0.000    0.005    0.001 iostream.py:202(schedule)\n",
      "       10    0.000    0.000    0.006    0.001 {built-in method builtins.print}\n",
      "       20    0.000    0.000    0.000    0.000 iostream.py:437(_is_master_process)\n",
      "       20    0.000    0.000    0.005    0.000 iostream.py:456(_schedule_flush)\n",
      "        8    0.000    0.000    0.000    0.000 threading.py:1169(is_alive)\n",
      "        8    0.000    0.000    0.000    0.000 iostream.py:90(_event_pipe)\n",
      "       20    0.000    0.000    0.000    0.000 {built-in method nt.getpid}\n",
      "        8    0.000    0.000    0.000    0.000 threading.py:1102(_wait_for_tstate_lock)\n",
      "        1    0.000    0.000   50.100   50.100 {built-in method builtins.exec}\n",
      "       20    0.000    0.000    0.000    0.000 {method 'write' of '_io.StringIO' objects}\n",
      "        8    0.000    0.000    0.000    0.000 {method 'acquire' of '_thread.lock' objects}\n",
      "       20    0.000    0.000    0.000    0.000 {method '__exit__' of '_thread.RLock' objects}\n",
      "       20    0.000    0.000    0.000    0.000 {built-in method builtins.len}\n",
      "       20    0.000    0.000    0.000    0.000 {built-in method builtins.isinstance}\n",
      "        8    0.000    0.000    0.000    0.000 threading.py:553(is_set)\n",
      "        8    0.000    0.000    0.000    0.000 {method 'append' of 'collections.deque' objects}\n",
      "        1    0.000    0.000   50.100   50.100 <string>:1(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}"
     ]
    }
   ],
   "source": [
    "def funcao_lenta():\n",
    "    for i in range(10):\n",
    "        x = np.random.randint(10)\n",
    "        print(x)\n",
    "        time.sleep(x)\n",
    "    \n",
    "%prun funcao_lenta()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext memory_profiler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "0\n",
      "3\n",
      "1\n",
      "4\n",
      "0\n",
      "9\n",
      "3\n",
      "1\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "%mprun -f funcao_lenta()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### IPython Magic - Debugging with %pdb\n",
    "\n",
    "Jupyter has its own interface for The Python Debugger (pdb). This makes it possible to go inside the function and investigate what happens there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Automatic pdb calling has been turned ON\n"
     ]
    },
    {
     "ename": "NotImplementedError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [18], line 6\u001b[0m\n\u001b[0;32m      4\u001b[0m     picked \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39mrandint(\u001b[39m0\u001b[39m, \u001b[39m1000\u001b[39m)\n\u001b[0;32m      5\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m()\n\u001b[1;32m----> 6\u001b[0m pick_and_take()\n",
      "Cell \u001b[1;32mIn [18], line 5\u001b[0m, in \u001b[0;36mpick_and_take\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mpick_and_take\u001b[39m():\n\u001b[0;32m      4\u001b[0m     picked \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39mrandint(\u001b[39m0\u001b[39m, \u001b[39m1000\u001b[39m)\n\u001b[1;32m----> 5\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m()\n",
      "\u001b[1;31mNotImplementedError\u001b[0m: "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> \u001b[1;32mc:\\users\\wzhrero\\appdata\\local\\temp\\1\\ipykernel_19852\\480616966.py\u001b[0m(5)\u001b[0;36mpick_and_take\u001b[1;34m()\u001b[0m\n",
      "\n",
      "--KeyboardInterrupt--\n",
      "\n",
      "KeyboardInterrupt: Interrupted by user\n"
     ]
    }
   ],
   "source": [
    "%pdb\n",
    "\n",
    "def pick_and_take():\n",
    "    picked = np.random.randint(0, 1000)\n",
    "    raise NotImplementedError()\n",
    "pick_and_take()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can view a list of accepted commands for pdb [here](https://docs.python.org/3.5/library/pdb.html#debugger-commands)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ IPython Magic - High-resolution plot outputs for Retina notebooks\n",
    "\n",
    "One line of IPython magic will give you double resolution plot output for Retina screens, such as the more recent Macbooks. Note: the example below won't render on non-retina screens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = range(1000)\n",
    "y = [i ** 2 for i in x]\n",
    "plt.plot(x,y)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%config InlineBackend.figure_format = 'retina'\n",
    "plt.plot(x,y)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Suppress the output of a final function.\n",
    "\n",
    "Sometimes it's handy to suppress the output of the function on a final line, for instance when plotting. To do this, you just add a semicolon at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 1, 1000)**1.5\n",
    "# Here you get the output of the function\n",
    "plt.hist(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# By adding a semicolon at the end, the output is suppressed.\n",
    "plt.hist(x);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using R and Python in the Notebook:\n",
    "\n",
    "As described in the [rmagics documentation](https://ipython.org/ipython-doc/2/config/extensions/rmagic.html), you can use %Rpush and %Rpull to move values back and forth between R and Python: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Executing Shell Commands\n",
    "\n",
    "It's easy to execute a shell command from inside your notebook. You can use this to check what datasets are in available in your working folder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!ls -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip3 list | grep pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using $\\LaTeX$ no markdown for formulas:\n",
    "\n",
    "When you write LaTeX in a Markdown cell, it will be rendered as a formula using MathJax.\n",
    "\n",
    "This:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\\\( P(A \\mid B) = \\frac{P(B \\mid A) \\, P(A)}{P(B)} \\\\)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\\\( P(A \\mid B) = \\frac{P(B \\mid A) \\, P(A)}{P(B)} \\\\)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run code from a different kernel in a notebook\n",
    "\n",
    "If you want to, you can combine code from multiple kernels into one notebook.\n",
    "\n",
    "Just use IPython Magics with the name of your kernel at the start of each cell that you want to use that Kernel for:\n",
    "\n",
    "    %%bash\n",
    "    %%HTML\n",
    "    %%python2\n",
    "    %%python3\n",
    "    %%ruby\n",
    "    %%perl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "for i in {1..5}\n",
    "do\n",
    "   echo \"i is $i\"\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jupyter-contrib extensions\n",
    "\n",
    "[Jupyter-contrib](https://github.com/ipython-contrib/jupyter_contrib_nbextensions) extensions is a family of extensions which give Jupyter a lot more functionality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a presentation from a Jupyter notebook.\n",
    "\n",
    "Damian Avila's RISE allows you to create a powerpoint style presentation from an existing notebook.  \n",
    "You can install RISE using conda:  \n",
    "\n",
    "  $ conda install -c damianavila82 rise  \n",
    "  \n",
    "Or alternatively pip:  \n",
    "\n",
    "  $ pip install RISE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Embbeding Images, Audio and Videos in the Notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Image(url=\"https://www.dataquest.io/blog/content/images/interface-screenshot.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(Image('https://i.ytimg.com/vi/j22DmsZEv30/maxresdefault.jpg', width=900, unconfined=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/Rc4JQWowG5I\" frameborder=\"0\" allow=\"autoplay; encrypted-media\" allowfullscreen></iframe>')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "YouTubeVideo('Rc4JQWowG5I')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Audio(\"../datasets/Miscellaneous/Como_nossos_pais.m4a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting in notebooks\n",
    "\n",
    "There are many options for generating plots in your notebooks.\n",
    "\n",
    "[matplotlib](http://matplotlib.org/) (the de-facto standard), activated with %matplotlib inline.\n",
    "    %matplotlib notebook provides interactivity but can be a little slow, since rendering is done server-side.\n",
    "    \n",
    "[Seaborn](http://seaborn.pydata.org/) is built over Matplotlib and makes building more attractive plots easier. Just by importing Seaborn, your matplotlib plots are made 'prettier' without any code modification.\n",
    "\n",
    "[mpld3](https://github.com/mpld3/mpld3) provides alternative renderer (using d3) for matplotlib code. Quite nice, though incomplete.\n",
    "\n",
    "[bokeh](http://bokeh.pydata.org/en/latest/) is a better option for building interactive plots.\n",
    "\n",
    "[plot.ly](https://plot.ly/) can generate nice plots - this used to be a paid service only but was recently open sourced.\n",
    "\n",
    "[Altair](https://github.com/altair-viz/altair) is a relatively new declarative visualization library for Python. It's easy to use and makes great looking plots, however the ability to customize those plots is not nearly as powerful as in Matplotlib.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pretty Display of Variables\n",
    "\n",
    "By finishing a Jupyter cell with the name of a variable or unassigned output of a statement, Jupyter will display that variable without the need for a print statement. This is especially useful when dealing with Pandas DataFrames, as the output is neatly formatted into a table.  \n",
    "\n",
    "What is known less, is that you can alter a modify the ast_note_interactivity kernel option to make jupyter do this for any variable or statement on it's own line, so you can see the value of multiple statements at once.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydataset import data\n",
    "quakes = data('quakes')\n",
    "quakes.head()\n",
    "quakes.tail()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "If you want to set this behaviour for all instances of Jupyter (Notebook and Console), simply create a file ~/.ipython/profile_default/ipython_config.py with the lines below:\n",
    "\n",
    "\n",
    "c = get_config()\n",
    "# Run all nodes interactively\n",
    "c.InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cleaning cell output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(100):\n",
    "    print(i)\n",
    "    time.sleep(0.1)\n",
    "    clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = widgets.Text()\n",
    "display(text)\n",
    "\n",
    "def handle_submit(sender):\n",
    "    print()\n",
    "    \n",
    "text.on_submit(handle_submit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "button = widgets.Button(description = \"Click Me\")\n",
    "display(button)\n",
    "\n",
    "def on_button_clicked(b):\n",
    "    print(\"Button Clicked\")\n",
    "\n",
    "button.on_click(on_button_clicked)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    print(x)\n",
    "    \n",
    "widgets.interact(f, x=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "widgets.interact(f, x=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "outputText = widgets.Text()\n",
    "outputText"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputText = widgets.Text()\n",
    "\n",
    "def uppercase(sender):\n",
    "    outputText.value = inputText.value.upper()\n",
    "    \n",
    "inputText.on_submit(uppercase)\n",
    "inputText"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0.0, 1.0, 0.01)\n",
    "\n",
    "def pltsin(f):\n",
    "    plt.plot(t, np.sin(2*np.pi*t*f))\n",
    "    plt.show()\n",
    "    \n",
    "widgets.interact(pltsin, f=(1,10,0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Easy links to documentation\n",
    "\n",
    "Inside the Help menu you'll find handy links to the online documentation for common libraries including NumPy, Pandas, SciPy and Matplotlib.\n",
    "\n",
    "Don't forget also that by prepending a library, method or variable with ?, you can access the Docstring for quick reference on syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?str.replace()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sharing notebooks\n",
    "\n",
    "The easiest way to share your notebook is simply using the notebook file (.ipynb), but for those who don't use Jupyter, you have a few options:\n",
    "\n",
    "   + Convert notebooks to html file using the File > Download as > HTML Menu option.\n",
    "   + Share your notebook file with [gists](https://gist.github.com/) or on github, both of which render the notebooks. See [this example](https://github.com/dataquestio/solutions/blob/master/Mission202Solution.ipynb).\n",
    "   + If you upload your notebook to a github repository, you can use the handy [mybinder](http://mybinder.org/) service to allow someone half an hour of interactive Jupyter access to your repository.\n",
    "   + Setup your own system with [jupyterhub](https://github.com/jupyterhub/jupyterhub), this is very handy when you organize mini-course or workshop and don't have time to care about students machines.\n",
    "   + Store your notebook e.g. in dropbox and put the link to [nbviewer](http://nbviewer.jupyter.org/). nbviewer will render the notebook from whichever source you host it.\n",
    "   + Use the File > Download as > PDF menu to save your notebook as a PDF. If you're going this route, I highly recommend reading Julius Schulz's excellent article [Making publication ready Python notebooks](http://blog.juliusschulz.de/blog/ultimate-ipython-notebook).\n",
    "   + [Create a blog using Pelican from your Jupyter notebooks](https://www.dataquest.io/blog/how-to-setup-a-data-science-blog/).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful links\n",
    "\n",
    "+ [IPython built-in magics](https://ipython.org/ipython-doc/3/interactive/magics.html)\n",
    "+ [Nice interactive presentation about jupyter by Ben Zaitlen](http://quasiben.github.io/dfwmeetup_2014/#/)\n",
    "+ Advanced notebooks [part 1: magics](https://blog.dominodatalab.com/lesser-known-ways-of-using-notebooks/) and [part 2: widgets](https://blog.dominodatalab.com/interactive-dashboards-in-jupyter/)\n",
    "+ [Profiling in python with jupyter](http://pynash.org/2013/03/06/timing-and-profiling/)\n",
    "+ [4 ways to extend notebooks](http://mindtrove.info/4-ways-to-extend-jupyter-notebook/)\n",
    "+ [IPython notebook tricks](https://www.quora.com/What-are-your-favorite-tricks-for-IPython-Notebook)\n",
    "+ [Jupyter vs Zeppelin for big data](https://www.linkedin.com/pulse/comprehensive-comparison-jupyter-vs-zeppelin-hoc-q-phan-mba-)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.8 64-bit (microsoft store)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "a3a5d4f9651fa550758ade4a473ec6b18daeb3d63067db8abd62b64f4493ea9c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}