>>> print("Hello world!")
Hello world!

>>> 2 + 2
4

>>> _ * 3
12

>>> !ls
my_notebook.ipynb

>>> %lsmagic
Available line magics:
%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %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  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode
Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

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

>>> %run?

>>> from IPython.display import HTML, SVG, YouTubeVideo

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

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

>>> YouTubeVideo('VQBZ2MqWBZI')

>>> import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    %matplotlib inline

>>> url = ("https://raw.githubusercontent.com/"
           "ipython-books/cookbook-2nd-data/"
           "master/bikes.csv")

>>> df = pd.read_csv(url, index_col='Date',
                     parse_dates=True, dayfirst=True)

>>> df.head(2)

>>> df.describe()

>>> df[['Berri1', 'PierDup']].plot(figsize=(10, 6),
                                   style=['-', '--'],
                                   lw=2)

>>> df.index.weekday_name
Index(['Tuesday', 'Wednesday', 'Thursday', 'Friday',
       'Saturday', 'Sunday', 'Monday', 'Tuesday',
       ...
       'Friday', 'Saturday', 'Sunday', 'Monday',
       'Tuesday', 'Wednesday'],
      dtype='object', name='Date', length=261)

>>> df_week = df.groupby(df.index.weekday).sum()
>>> df_week

>>> fig, ax = plt.subplots(1, 1, figsize=(10, 8))
    df_week.plot(style='-o', lw=3, ax=ax)
    ax.set_xlabel('Weekday')
    # We replace the labels 0, 1, 2... by the weekday
    # names.
    ax.set_xticklabels(
        ('Monday,Tuesday,Wednesday,Thursday,'
         'Friday,Saturday,Sunday').split(','))
    ax.set_ylim(0)  # Set the bottom axis to 0.

>>> from ipywidgets import interact
    
    @interact
    def plot(n=(1, 30)):
        fig, ax = plt.subplots(1, 1, figsize=(10, 8))
        df['Berri1'].rolling(window=n).mean().plot(ax=ax)
        ax.set_ylim(0, 7000)
        plt.show()

>>> import random
    import numpy as np

>>> n = 1000000
    x = [random.random() for _ in range(n)]
    y = [random.random() for _ in range(n)]
>>> x[:3], y[:3]
([0.926, 0.722, 0.962], [0.291, 0.339, 0.819])

>>> z = [x[i] + y[i] for i in range(n)]
    z[:3]
[1.217, 1.061, 1.781]

>>> %timeit [x[i] + y[i] for i in range(n)]
101 ms ± 5.12 ms per loop (mean ± std. dev. of 7 runs,
    10 loops each)

>>> xa = np.array(x)
    ya = np.array(y)
>>> xa[:3]
array([ 0.926,  0.722,  0.962])

>>> za = xa + ya
    za[:3]
array([ 1.217,  1.061,  1.781])

>>> %timeit xa + ya
1.09 ms ± 37.3 µs per loop (mean ± std. dev. of 7 runs,
    1000 loops each)

>>> %timeit sum(x)  # pure Python
3.94 ms ± 4.44 µs per loop (mean ± std. dev. of 7 runs
    100 loops each)
>>> %timeit np.sum(xa)  # NumPy
298 µs ± 4.62 µs per loop (mean ± std. dev. of 7 runs,
    1000 loops each)

>>> d = [abs(x[i] - y[j])
         for i in range(1000)
         for j in range(1000)]
>>> d[:3]
[0.635, 0.587, 0.106]

>>> da = np.abs(xa[:1000, np.newaxis] - ya[:1000])
>>> da
array([[ 0.635,  0.587,  ...,  0.849,  0.046],
       [ 0.431,  0.383,  ...,  0.646,  0.158],
       ...,
       [ 0.024,  0.024,  ...,  0.238,  0.566],
       [ 0.081,  0.033,  ...,  0.295,  0.509]])
>>> %timeit [abs(x[i] - y[j]) \
             for i in range(1000) \
             for j in range(1000)]
134 ms ± 1.79 ms per loop (mean ± std. dev. of 7 runs,
    1000 loops each)
>>> %timeit np.abs(xa[:1000, np.newaxis] - ya[:1000])
1.54 ms ± 48.9 µs per loop (mean ± std. dev. of 7 runs
    1000 loops each)

>>> from IPython.core.magic import (register_line_magic,
                                    register_cell_magic)

>>> @register_line_magic
    def hello(line):
        if line == 'french':
            print("Salut tout le monde!")
        else:
            print("Hello world!")
>>> %hello
Hello world!
>>> %hello French
Salut tout le monde!

>>> import pandas as pd
    from io import StringIO
    
    @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)
>>> %%csv
    col1,col2,col3
    0,1,2
    3,4,5
    7,8,9

>>> df = _
    df.describe()

>>> %%writefile csvmagic.py
    import pandas as pd
    from io import StringIO
    
    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 of the shell
        instance."""
        ipython.register_magic_function(csv, 'cell')
Writing csvmagic.py

>>> %load_ext csvmagic
>>> %%csv
    col1,col2,col3
    0,1,2
    3,4,5
    7,8,9

>>> %%writefile random_magics.py
    
    from traitlets import Int, Float, Unicode, Bool
    from IPython.core.magic import (Magics, magics_class,
                                    line_magic)
    import numpy as np
Writing random_magics.py

>>> %%writefile random_magics.py -a
    
    @magics_class
    class RandomMagics(Magics):
        text = Unicode(u'{n}', config=True)
        max = Int(1000, config=True)
        seed = Int(0, config=True)
Appending to random_magics.py

>>> %%writefile random_magics.py -a
    
        def __init__(self, shell):
            super(RandomMagics, self).__init__(shell)
            self._rng = np.random.RandomState(
                self.seed or None)
Appending to random_magics.py

>>> %%writefile random_magics.py -a
    
        @line_magic
        def random(self, line):
            return self.text.format(
                n=self._rng.randint(self.max))
Appending to random_magics.py

>>> %%writefile random_magics.py -a
    
    def load_ipython_extension(ipython):
        ipython.register_magics(RandomMagics)
Appending to random_magics.py

>>> %load_ext random_magics
>>> %random
'430'
>>> %random
'305'

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

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

>>> %%writefile plotkernel.py
    
    from ipykernel.kernelbase import Kernel
    import numpy as np
    import matplotlib.pyplot as plt
    from io import BytesIO
    import urllib, base64
Writing plotkernel.py

>>> %%writefile plotkernel.py -a
    
    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()))
Appending to plotkernel.py

>>> %%writefile plotkernel.py -a
    
    _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})
Appending to plotkernel.py

>>> %%writefile plotkernel.py -a
    
    class PlotKernel(Kernel):
        implementation = 'Plot'
        implementation_version = '1.0'
        language = 'python'  # will be used for
                             # syntax highlighting
        language_version = '3.6'
        language_info = {'name': 'plotter',
                         'mimetype': 'text/plain',
                         'extension': '.py'}
        banner = "Simple plotting"
Appending to plotkernel.py

>>> %%writefile plotkernel.py -a
    
        def do_execute(self, code, silent,
                       store_history=True,
                       user_expressions=None,
                       allow_stdin=False):
    
            # We create the plot with matplotlib.
            fig, ax = plt.subplots(1, 1, 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)
                ax.plot(x, y)
            ax.set_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 exection results.
            return {'status': 'ok',
                    'execution_count':
                        self.execution_count,
                    'payload': [],
                    'user_expressions': {},
                   }
Appending to plotkernel.py

>>> %%writefile plotkernel.py -a
    
    if __name__ == '__main__':
        from ipykernel.kernelapp import IPKernelApp
        IPKernelApp.launch_instance(
            kernel_class=PlotKernel)
Appending to plotkernel.py

>>> %mkdir -p plotter/
>>> %%writefile plotter/kernel.json
    {
     "argv": ["python", "-m",
              "plotkernel", "-f",
              "{connection_file}"],
     "display_name": "Plotter",
     "name": "Plotter",
     "language": "python"
    }
Writing plotter/kernel.json

>>> !jupyter kernelspec install --user plotter
[InstallKernelSpec] Installed kernelspec plotter in
~/.local/share/jupyter/kernels/plotter

>>> !jupyter kernelspec list
Available kernels:
  bash         ~/.local/share/jupyter/kernels/bash
  ir           ~/.local/share/jupyter/kernels/ir
  plotter      ~/.local/share/jupyter/kernels/plotter
  sagemath     ~/.local/share/jupyter/kernels/sagemath
  ...