In [1]: print("Hello world!")
Hello world!

In [2]: 2+2
Out[2]: 4

In [3]: _ * 3
Out[3]: 12

In [4]: !ls *.ipynb
notebook1.ipynb  ...

In [5]: %lsmagic
Out[5]: Available line magics:
%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %cls  %colors  %config  %connect_info  %copy  %ddir  %debug  %dhist  %dirs  %doctest_mode  %echo  %ed  %edit  %env  %gui  %hist  %history  %install_default_config  %install_ext  %install_profiles  %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  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %ren  %rep  %rerun  %reset  %reset_selective  %rmdir  %run  %save  %sc  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%cmd  %%debug  %%file  %%html  %%javascript  %%latex  %%perl  %%powershell  %%prun  %%pypy  %%python  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

In [6]: %%writefile test.txt
        Hello world!
Writing test.txt
In [7]: # Let's check what this file contains.
        with open('test.txt', 'r') as f:
            print(f.read())
Hello world!

In [9]: %run?
Type:        Magic function
Namespace:   IPython internal
...
Docstring:
Run the named file inside IPython as a program.
[full documentation of the magic command...]

### New paragraph 
This is *rich* **text** with [links](http://ipython.org),
equations:

$$\hat{f}(\xi) = \int_{-\infty}^{+\infty} f(x)\,
                 \mathrm{e}^{-i \xi x}$$

code with syntax highlighting: 
```python
print("Hello world!")
``` 
and images: 
![This is an image](http://ipython.org/_static/IPy_header.png)

In [11]: from IPython.display import HTML, SVG, YouTubeVideo

In [12]: HTML('''
         <table style="border: 2px solid black;">
         ''' + 
         ''.join(['<tr>' + 
                  ''.join(['<td>{row},{col}</td>'.format(
                                 row=row, col=col
                                 ) for col in range(5)]) +
                  '</tr>' for row in range(5)]) +
         '''
         </table>
         ''')

In [13]: SVG('''<svg width="600" height="80">''' + 
         ''.join(['''<circle cx="{x}" cy="{y}" r="{r}"
                             fill="red"
                             stroke-width="2"
                             stroke="black">
                     </circle>'''.format(x=(30+3*i)*(10-i),
                                         y=30,
                                         r=3.*float(i)
                                         ) for i in range(10)]) + 
         '''</svg>''')

In [14]: YouTubeVideo('j9YpkSX7NNM')

In [15]: from collections import OrderedDict
         from IPython.display import (display,
                                      clear_output,
                                      YouTubeVideo)
         from IPython.html.widgets import DropdownWidget
In [16]: # We create a DropdownWidget, with a dictionary
         # containing the keys (video name) and the values
         # (Youtube identifier) of every menu item.
         dw = DropdownWidget(values=OrderedDict([
                           ('SciPy 2012', 'iwVvqwLDsJo'),
                           ('PyCon 2012', '2G5YTlheCbw'),
                           ('SciPy 2013', 'j9YpkSX7NNM')]
                                                )
                             )
         
         # We create a callback function that displays the 
         # requested Youtube video.
         def on_value_change(name, val):
             clear_output()
             display(YouTubeVideo(val))
         
         # Every time the user selects an item, the 
         # function `on_value_change` is called, and the 
         # `val` argument contains the value of the selected 
         # item.
         dw.on_trait_change(on_value_change, 'value')
         
         # We choose a default value.
         dw.value = dw.values['SciPy 2013']
         
         # Finally, we display the widget.
         display(dw)

In [1]: import numpy as np
        import pandas as pd
        import matplotlib.pyplot as plt
        %matplotlib inline

In [2]: url = "http://donnees.ville.montreal.qc.ca/storage/f/2014-01-20T20%3A48%3A50.296Z/2013.csv"

In [3]: df = pd.read_csv(url, index_col='Date',
                         parse_dates=True, dayfirst=True)

In [4]: df.head(2)

In [5]: df.describe()

In [6]: df[['Berri1', 'PierDup']].plot()

In [7]: df.index.weekday
Out[7]: array([1, 2, 3, 4, 5, 6, 0, 1, 2, ..., 0, 1, 2])

In [8]: days = np.array(['Monday', 'Tuesday', 'Wednesday', 
                         'Thursday', 'Friday', 'Saturday', 
                         'Sunday'])
        df['Weekday'] = days[df.index.weekday]

In [9]: df_week = df.groupby('Weekday').sum()
In [10]: df_week

In [11]: df_week.ix[days].plot(lw=3)
         plt.ylim(0);  # Set the bottom axis to 0.

In [12]: from IPython.html.widgets import interact
         @interact
         def plot(n=(1, 30)):
             pd.rolling_mean(df['Berri1'], n).dropna().plot()
             plt.ylim(0, 8000)
             plt.show()

In [1]: import random
        import numpy as np

In [2]: %precision 3
Out[2]: u'%.3f'

In [3]: n = 1000000
        x = [random.random() for _ in range(n)]
        y = [random.random() for _ in range(n)]
In [4]: x[:3], y[:3]
Out[4]: ([0.996, 0.846, 0.202], [0.352, 0.435, 0.531])

In [5]: z = [x[i] + y[i] for i in range(n)]
        z[:3]
Out[5]: [1.349, 1.282, 0.733]

In [6]: %timeit [x[i] + y[i] for i in range(n)]
1 loops, best of 3: 273 ms per loop

In [7]: xa = np.array(x)
        ya = np.array(y)
In [8]: xa[:3]
Out[8]: array([ 0.996,  0.846,  0.202])

In [9]: za = xa + ya
        za[:3]
Out[9]: array([ 1.349,  1.282,  0.733])

In [10]: %timeit xa + ya
100 loops, best of 3: 10.7 ms per loop

In [11]: %timeit sum(x)  # pure Python
         %timeit np.sum(xa)  # NumPy
100 loops, best of 3: 17.1 ms per loop
1000 loops, best of 3: 2.01 ms per loop

In [12]: d = [abs(x[i] - y[j]) 
              for i in range(1000) for j in range(1000)]
In [13]: d[:3]
Out[13]: [0.230, 0.037, 0.549]

In [14]: da = np.abs(xa[:1000,None] - ya[:1000])
In [15]: da
Out[15]: array([[ 0.23 ,  0.037,  ...,  0.542,  0.323,  0.473],
                 ...,
                [ 0.511,  0.319,  ...,  0.261,  0.042,  0.192]])
In [16]: %timeit [abs(x[i] - y[j]) 
                  for i in range(1000) for j in range(1000)]
         %timeit np.abs(xa[:1000,None] - ya[:1000])
1 loops, best of 3: 292 ms per loop
100 loops, best of 3: 18.4 ms per loop

In [1]: from IPython.core.magic import (register_line_magic, 
                                        register_cell_magic)

In [2]: @register_line_magic
        def hello(line):
            if line == 'french':
                print("Salut tout le monde!")
            else:
                print("Hello world!")
In [3]: %hello
Hello world!
In [4]: %hello french
Salut tout le monde!

In [5]: import pandas as pd
        #from StringIO import StringIO  # Python 2
        from io import StringIO  # Python 3

        @register_cell_magic
        def csv(line, cell):
            # We create a string buffer containing the
            # contents of the cell.
            sio = StringIO(cell)
            # We use pandas' read_csv function to parse
            # the CSV string.
            return pd.read_csv(sio)
In [6]: %%csv
        col1,col2,col3
        0,1,2
        3,4,5
        7,8,9
Out[6]:
    col1  col2  col3
0     0     1     2
1     3     4     5
2     7     8     9

In [7]: df = _
        df.describe()
Out[7]:
           col1      col2      col3
count  3.000000  3.000000  3.000000
mean   3.333333  4.333333  5.333333
...
min    0.000000  1.000000  2.000000
max    7.000000  8.000000  9.000000

In [8]: %%writefile csvmagic.py
        import pandas as pd
        #from StringIO import StringIO  # Python 2
        from io import StringIO  # Python 3
        def csv(line, cell):
            sio = StringIO(cell)
            return pd.read_csv(sio)

        def load_ipython_extension(ipython):
            """This function is called when the extension 
            is loaded. It accepts an 
            IPython InteractiveShell instance.
            We can register the magic with the
            `register_magic_function` method."""
            ipython.register_magic_function(csv, 'cell')
Overwriting csvmagic.py

In [9]: %load_ext csvmagic
In [10]: %%csv
         col1,col2,col3
         0,1,2
         3,4,5
         7,8,9
Out[10]:
   col1  col2  col3
0     0     1     2
1     3     4     5
2     7     8     9

from IPython.utils.traitlets import Int, Float, Unicode, Bool
from IPython.core.magic import (Magics, magics_class, line_magic)
import numpy as np

@magics_class
class RandomMagics(Magics):
    text = Unicode(u'{n}', config=True)
    max = Int(1000, config=True)
    seed = Int(0, config=True)

    def __init__(self, shell):
        super(RandomMagics, self).__init__(shell)
        self._rng = np.random.RandomState(self.seed or None)

    @line_magic
    def random(self, line):
        return self.text.format(n=self._rng.randint(self.max))

def load_ipython_extension(ipython):
    ipython.register_magics(RandomMagics)

In [1]: %load_ext random_magics
In [2]: %random
Out[2]: '635'
In [3]: %random
Out[3]: '47'

ipython --RandomMagics.text='Your number is {n}.' --RandomMagics.max=10 --RandomMagics.seed=1

In [1]: %load_ext random_magics
In [2]: %random
Out[2]: u'Your number is 5.'
In [3]: %random
Out[3]: u'Your number is 8.'

c.RandomMagics.text = 'random {n}'

In [4]: %random
Out[4]: 'random 652'

from IPython.kernel.zmq.kernelbase import Kernel
import numpy as np
import matplotlib.pyplot as plt
from io import BytesIO
import urllib, base64

def _to_png(fig):
    """Return a base64-encoded PNG from a 
    matplotlib figure."""
    imgdata = BytesIO()
    fig.savefig(imgdata, format='png')
    imgdata.seek(0)
    return urllib.parse.quote(
        base64.b64encode(imgdata.getvalue()))

_numpy_namespace = {n: getattr(np, n) 
                    for n in dir(np)}
def _parse_function(code):
    """Return a NumPy function from a string 'y=f(x)'."""
    return lambda x: eval(code.split('=')[1].strip(),
                          _numpy_namespace, {'x': x})

class PlotKernel(Kernel):
    implementation = 'Plot'
    implementation_version = '1.0'
    language = 'python'  # will be used for
                         # syntax highlighting
    language_version = ''
    banner = "Simple plotting"

def do_execute(self, code, silent,
               store_history=True,
               user_expressions=None,
               allow_stdin=False):

    # We create the plot with matplotlib.
    fig = plt.figure(figsize=(6,4), dpi=100)
    x = np.linspace(-5., 5., 200)
    functions = code.split('\n')
    for fun in functions:
        f = _parse_function(fun)
        y = f(x)
        plt.plot(x, y)
    plt.xlim(-5, 5)

    # We create a PNG out of this plot.
    png = _to_png(fig)

    if not silent:
        # We send the standard output to the client.
        self.send_response(self.iopub_socket,
            'stream', {
                'name': 'stdout', 
                'data': 'Plotting {n} function(s)'. \
                            format(n=len(functions))})

        # We prepare the response with our rich data
        # (the plot).
        content = {
            'source': 'kernel',

            # This dictionary may contain different
            # MIME representations of the output.
            'data': {
                'image/png': png
            },

            # We can specify the image size
            # in the metadata field.
            'metadata' : {
                  'image/png' : {
                    'width': 600,
                    'height': 400
                  }
                }
        }        

        # We send the display_data message with the
        # contents.
        self.send_response(self.iopub_socket,
            'display_data', content)

    # We return the execution results.
    return {'status': 'ok',
            'execution_count': self.execution_count,
            'payload': [],
            'user_expressions': {},
           }

if __name__ == '__main__':
    from IPython.kernel.zmq.kernelapp import IPKernelApp
    IPKernelApp.launch_instance(kernel_class=PlotKernel)

{
 "argv": ["python", "-m",
          "plotkernel", "-f",
          "{connection_file}"],
 "display_name": "Plot",
 "language": "python"
}