Table of Contents

• 1  Jupyter Notebook - Quick Introduction
  • 1.1  Python code cells
  • 1.2  Notebook managing
    • 1.2.1  Edit Modes and Cell Types
  • 1.3  Help and documentation
    • 1.3.1  Tab-completion of object contents
  • 1.4  IPython Magic Commands
    • 1.4.1  Running External Code: %run
    • 1.4.2  Timing code %timeit
    • 1.4.3  Shell commands
  • 1.5  Python versions
    • 1.5.1  Python3 vs Python2

Jupyter Notebook - Quick Introduction

A very attractive way to use python and work interactively is provided by jupyter notebooks

• Start an interactive python environment in a browser window
• Output and Graphs are shown in the notebook
• you can add your own comments, descriptions, math formulas (Latex style) , ...

Great way to develop and document an interactive analysis and to share with others:

• Nice example provided by Ligo gravitational wave analysis (2017 Nobel prize):
  Detailed notebook to present analysis in detail

Starting:
In shell-window:

jupyter notebook

Sometimes problems on cip nodes, you might need:

jupyter notebook --browser=firefox

More info at https://jupyter.readthedocs.io/en/latest/index.html

Python code cells

• you can enter Python instructions (single line, many lines, ...) in code cells.
• switch from "command mode" (cell highlighted in blue) to "edit mode" (green) with <Enter> and back with <Esc>
  • explained in more detail below
• content of cells will be executed when you press
  • <Control>+<Enter>: executes current cell
  • <Shift>+<Enter>: executes current cell and jumps to next cell
• the return value of the last line in a code cell is printed (unless the line ends in ;)
• there are two relevant types of cells: "markdown" (display text) and "code" (input code to execute)
  • new cells are code cells by default
  • change cell type in command mode to markdown (<m>) or code type (<y>)

5**25

import numpy as np
import pylab as pl

t = np.arange(0.0, 1.0+0.01, 0.01)
s = np.cos(2*2*np.pi*t)
pl.plot(t, s)

pl.xlabel('time (s)')
pl.ylabel('voltage (mV)')
pl.title('About as simple as it gets, folks')
pl.grid(True)

Code cells

• Output of commands is shown, both text and graphics
• Cells are part of interactive python session
  • all variables, definitions, imports, ..., which happen in a cell stay active and can be used in sub-sequent cells
• usually cells are executed one after the other, starting from top
  • just convention, not mandatory, watch out!

type(t)

print(t[0:10])

Notebook managing

Notebooks

• can be stored
• re-used
• shared with other
• exported as html, slides, ...

They can also be executed and stored on remote system and accessed via web-browser.

Edit Modes and Cell Types

There are two modes in which jupyter notebooks are displayed:

• When a cell is marked blue, you are in "command mode" and can navigate around, add / change / remove cells etc.
• When a cell is marked green, you can edit it ("edit mode").

To enter edit mode, press ENTER. To leave it, press ESC or CTRL+ENTER (to execute code or render markdown) or SHIFT+ENTER (to execute / render and move to the next cell).

There are mainly two different types of cells, code and markdown. To switch the type of a cell in navigation mode, press

• y for code type (for cells with code that is to be executed), or
• m for markdown type (for adding documentation).

You can also delete cells in navigation mode by pressing d two times.

(Hint: You can find all keyboard shortcuts under "Help" of the notebook menu.)

Help and documentation

Jupyter/IPython uses the ? character as a shorthand for accessing documentation and other relevant information on any object, function or module:

In [2]: len?
Type:        builtin_function_or_method
String form: <built-in function len>
Namespace:   Python builtin
Docstring:
len(object) -> integer

Return the number of items of a sequence or mapping.

This notation works for just about anything, including object methods:

In [3]: L = [1, 2, 3]
In [4]: L.insert?
Type:        builtin_function_or_method
String form: <built-in method insert of list object at 0x1024b8ea8>
Docstring:   L.insert(index, object) -- insert object before index

or even objects themselves, with the documentation from their type:

In [5]: L?
Type:        list
String form: [1, 2, 3]
Length:      3
Docstring:
list() -> new empty list
list(iterable) -> new list initialized from iterable's items

Tab-completion of object contents

Every Python object has various attributes and methods associated with it. This can be accessed in Python with help or dir. But much more convenient is the tab-completion interface. To see a list of all available attributes of an object, you can type the name of the object followed by a period (".") character and the Tab key:

In [10]: L.<TAB>
L.append   L.copy     L.extend   L.insert   L.remove   L.sort     
L.clear    L.count    L.index    L.pop      L.reverse

IPython Magic Commands

IPython magic commands are prefixed by the % character.

We just discuss two quick examples, but will see more in later chapters.

Running External Code: %run

Rather than writing or loading code in a cell it can be convenient to just run code in an external python file. This can be done with the %run magic.

In [6]: %run myscript.py

The output of the code will be shown and also all declarations (vars, functions, imports, ...) are available, it is equivalent to load and execute the code in a cell.

Timing code %timeit

This will determine the execution time of the single-line Python statement that follows it. For example, we may want to check the performance of a list comprehension:

In [8]: %timeit L = [n ** 2 for n in range(1000)]
1000 loops, best of 3: 325 µs per loop

The benefit of %timeit is that for short commands it will automatically perform multiple runs in order to attain more robust results. For multi line statements, adding a second % sign will turn this into a cell magic that can handle multiple lines of input. For example, here's the equivalent construction with a for-loop:

In [9]: %%timeit
   ...: L = []
   ...: for n in range(1000):
   ...:     L.append(n ** 2)
   ...: 
1000 loops, best of 3: 373 µs per loop

Shell commands

Simple executon of shell commands, just precede with !

!pwd

a=!ls  # ouput can be obtained as list
print (a)

Python versions

We are using for the course the recent Python 3.7 version together with corresponding Numpy, Scipy, Pandas, etc, packages.

The installation is based on the Anaconda and conda tools, which provide scientific and machine learning python packages for many architectures (Linux, WIndows, Mac).

Pandas provides a function to get detailed info on installed package versions:

import pandas as pd
pd.show_versions()

Python3 vs Python2

For most parts differences between Python3 and Python2 are small:

• most notable : print is a function in Python3 and requires () (was statement in Python2)
  • print ('Hi there') # Python3
  • print 'Hi there' # Python2
    • Python2 also accepts print ('Hi there'), but not v.v.
• many detailed differences in Python modules
  • existing Python2 code which relies on Python modules might require larger porting effort

More info e.g. in http://sebastianraschka.com/Articles/2014_python_2_3_key_diff.html

We will use (only) Python 3. Python 2 was discontinued in 2020.