notebooks/getting_started_with_jupyter_notebooks.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Familiarize Yourself with Jupyter\n",
    "The Jupyter Notebook is a web application that allows you to create and share documents that contain live code, equations, visualizations and explanatory text. The following links may be useful in gaining a basic understanding of Jupyter and how to work in Jupyter notebook: \n",
    "1. http://jupyter.org/about.html: general information about Jupyter \n",
    "2. https://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/execute.html: starting guide \n",
    "3. http://nbviewer.jupyter.org/github/jupyter/notebook/blob/master/docs/source/examples/Notebook/Notebook%20Basics.ipynb: notebook basics\n",
    "\n",
    "If this is your first time using Jupyter, start with taking a tour of the user interface: \n",
    "* Click on the menu Help -> User Interface Tour\n",
    "* Scroll over each of the tabs in the menu to see the options. They should be fairly straightforward. \n",
    "\n",
    "Here are some other helpful tips and shortcuts: \n",
    "* You can run the notebook document step-by-step (one cell a time) by pressing shift + enter.\n",
    "* You can run the whole notebook in a single step by clicking on the menu Cell -> Run All.\n",
    "* To restart the kernel (i.e. the computational engine), click on the menu Kernel -> Restart. This can be useful to start a computation over from scratch (e.g. variables are deleted, open files are closed, etc...).\n",
    "\n",
    "## Cell Types\n",
    "Cells are designated as Code, Markdown, or Raw NBConvert (Notebook Conversion). To switch from one type to another, click on Cell -> Cell Type. \n",
    "\n",
    "Throughout our tutorials, we will mainly be working in code cells to learn how to use Python. However, each of the tutorials include Markdown cells to provide introductions and learning objectives for each tutorial, background information, and instructions throughout. We encourage you to open these markdown cells to become familiar with the syntax, and add markdown notes as you see fit. Learning to use Markdown and Notebook Conversion cells will become a useful skill for Python scripts and notebooks you will use in your future research. Throughout this data institute, you will learn to use the full set of Jupyter Notebook tools for conducting reproducible (and publishable) research. \n",
    "\n",
    "### Code\n",
    "Code cells are where we will write and execute our Python scripts and functions. \n",
    "\n",
    "### Markdown\n",
    "Markdown cells are mainly used to neatly document the code that is written in Jupyter notebooks. While this course does not focus on Markdown, we encourage you to explore the Markdown capabilities, and add Markdown cells to your notebooks as you see fit. Some useful resources for learning Markdown Syntax include: \n",
    "1. Markdown Cheatsheet: http://nestacms.com/docs/creating-content/markdown-cheat-sheet\n",
    "2. https://ipython.org/ipython-doc/3/notebook/notebook.html#markdown-cells\n",
    "3. Example Markdown Notebook: http://nbviewer.jupyter.org/github/ipython/ipython/blob/1.x/examples/notebooks/Part%204%20-%20Markdown%20Cells.ipynb\n",
    "\n",
    "### NBConvert - Notebook Conversion\n",
    "The NBConvert tool allows you to convert a Jupyter .ipynb noteook document file into another format. The nbconvert documentation contains a complete description of this tool's capabilities:\n",
    "https://media.readthedocs.org/pdf/nbconvert/latest/nbconvert.pdf. The description below, copied from the document, gives a brief overview of the tool: \n",
    "\n",
    "Using nbconvert enables: \n",
    "* presentation of information in familiar formats, such as PDF.\n",
    "* publishing of research using LaTeX and opens the door for embedding notebooks in papers.\n",
    "* collaboration with others who may not use the notebook in their work.\n",
    "* sharing contents with many people via the web using HTML.\n",
    "\n",
    "Overall, notebook conversion and the nbconvert tool give scientists and researchers the flexibility to deliver information\n",
    "in a timely way across different formats.\n",
    "\n",
    "Primarily, the nbconvert tool allows you to convert a Jupyter .ipynb notebook document file into another static\n",
    "format including HTML, LaTeX, PDF, Markdown, reStructuredText, and more. nbconvert can also add productivity\n",
    "to your workflow when used to execute notebooks programmatically.\n",
    "\n",
    "If used as a Python library (import nbconvert), nbconvert adds notebook conversion within a project. For\n",
    "example, nbconvert is used to implement the “Download as” feature within the Jupyter Notebook web application.\n",
    "When used as a command line tool (invoked as jupyter nbconvert ...), users can conveniently convert just\n",
    "one or a batch of notebook files to another format.\n",
    "\n",
    "## Objectives\n",
    "In this tutorial, we will learn some useful Python commands and tips, including how to:\n",
    "\n",
    "1. Use the print statement\n",
    "2. Execute bash commands (eg. pwd, ls)\n",
    "3. Use magic commands (eg %who, %who_ls, %whos)\n",
    "4. Determine the data type of a variable and convert to a different type (integers, strings, floats)\n",
    "5. Import and execute commands from a python package \n",
    "6. Use the numpy (Numerical Python) package to manipulate arrays and explore indexing\n",
    "\n",
    "This link has some useful tips that may come in handy in your research:\n",
    "https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Zen of Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic commands: print, !pwd, !ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Working Directory:\n",
      "/cygdrive/y/users/bhass/RemoteSensingDataInstitute/DataInstitute2017/PythonWorkflows\n",
      "\n",
      "Files in Working Directory:\n",
      "getting_started_with_jupyter_notebooks.ipynb\n",
      "hyperspectral_hdf5\n",
      "Jupyter_Markdown_Cells.ipynb\n"
     ]
    }
   ],
   "source": [
    "#Basic commands: print, !pwd, !ls\n",
    "\n",
    "#Python does not automatically display results unless you use a print statement\n",
    "#You can also use a print statement as a debugging tool:\n",
    "\n",
    "#Print working directory - the ! executes bash commands from the Python platform\n",
    "print('Current Working Directory:')\n",
    "!pwd  \n",
    "\n",
    "print('\\nFiles in Working Directory:') #\\n enters to a new line\n",
    "!ls ./"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Types - integers, floats, & strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x type: <class 'int'>\n",
      "x_float type: <class 'float'>\n",
      "example_string type: <class 'str'>\n",
      "x_string type: <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#Integers\n",
    "x = 1;\n",
    "print('x type:',type(x))\n",
    "\n",
    "#Floating Point Numbers\n",
    "x_float = float(x) #use the command float to change a number to type float\n",
    "print('x_float type:',type(x_float))\n",
    "\n",
    "#Strings\n",
    "example_string = 'This is a string'\n",
    "print('example_string type:',type(example_string))\n",
    "#To change a variable to type string use the command str(argument), for example:\n",
    "x_string = str(x)\n",
    "print('x_string type:',type(x_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing packages: numpy\n",
    "numpy (or Numerical Python) is a useful package for manipulating numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_array:\n",
      " [[1 2 3]\n",
      " [4 5 6]]\n",
      "example_array type: <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "#Import Numpy and make an example array\n",
    "import numpy as np \n",
    "#to run a numpy command, use the syntax np.command_name\n",
    "example_array = np.array([[1,2,3],[4,5,6]]) \n",
    "print('example_array:\\n',example_array)\n",
    "print('example_array type:',type(example_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing\n",
    "Key Points: \n",
    "* The index (i,j) refers to the i<sup>th</sup> row and j<sup>th</sup> column\n",
    "* Python indices start at 0, so to select to the i<sup>th</sup> column, you need to use the index (i-1) \n",
    "* Negative indices will count backwards from the end of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "#extract a single value from the array:\n",
    "#indexing starts at 0, so [0,0] extracts the 1st row and 1st column\n",
    "#negative indices will count backwards from the end\n",
    "print(example_array[0,0]) \n",
    "print(example_array[-1,-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display variables with %whos\n",
    "Since the Jupyter notebook doesn't have a separate window to display the variables that have been generated, we can use the commands %who, %who_ls, or %whos to show a complete list of imported modules, functions, variables, and other outputs (eg. figures). The command %who lists the variable names in row format, %who_ls lists the variable names in column format, and %whos is the most comprehensive, displaying variable name, type, and data/info. Remember this tool throughout the following tutorials if you need to check whether a module or function was already imported, a variable created, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable         Type       Data/Info\n",
      "-------------------------------------\n",
      "example_array    ndarray    2x3: 6 elems, type `int32`, 24 bytes\n",
      "example_string   str        This is a string\n",
      "np               module     <module 'numpy' from 'C:\\<...>ges\\\\numpy\\\\__init__.py'>\n",
      "this             module     <module 'this' from 'C:\\\\<...>Anaconda3\\\\lib\\\\this.py'>\n",
      "x                int        1\n",
      "x_float          float      1.0\n",
      "x_string         str        1\n"
     ]
    }
   ],
   "source": [
    "#Display variables & imported modules \n",
    "%whos"
   ]
  }
 ],
 "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.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}