diff --git a/Connecting with the Qt Console.ipynb b/Connecting with the Qt Console.ipynb new file mode 100644 index 0000000..4794200 --- /dev/null +++ b/Connecting with the Qt Console.ipynb @@ -0,0 +1,130 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Connecting to an existing IPython kernel using the Qt Console" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Frontend/Kernel Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The traditional IPython (`ipython`) consists of a single process that combines a terminal based UI with the process that runs the users code.\n", + "\n", + "While this traditional application still exists, the modern Jupyter consists of two processes:\n", + "\n", + "* Kernel: this is the process that runs the users code.\n", + "* Frontend: this is the process that provides the user interface where the user types code and sees results.\n", + "\n", + "Jupyter currently has 3 frontends:\n", + "\n", + "* Terminal Console (`jupyter console`)\n", + "* Qt Console (`jupyter qtconsole`)\n", + "* Notebook (`jupyter notebook`)\n", + "\n", + "The Kernel and Frontend communicate over a ZeroMQ/JSON based messaging protocol, which allows multiple Frontends (even of different types) to communicate with a single Kernel. This opens the door for all sorts of interesting things, such as connecting a Console or Qt Console to a Notebook's Kernel. For example, you may want to connect a Qt console to your Notebook's Kernel and use it as a help\n", + "browser, calling `??` on objects in the Qt console (whose pager is more flexible than the\n", + "one in the notebook). \n", + "\n", + "This Notebook describes how you would connect another Frontend to an IPython Kernel that is associated with a Notebook.\n", + "The commands currently given here are specific to the IPython kernel." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Manual connection" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To connect another Frontend to a Kernel manually, you first need to find out the connection information for the Kernel using the `%connect_info` magic:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%connect_info" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that this magic displays everything you need to connect to this Notebook's Kernel." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Automatic connection using a new Qt Console" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also start a new Qt Console connected to your current Kernel by using the `%qtconsole` magic. This will detect the necessary connection\n", + "information and start the Qt Console for you automatically." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%qtconsole" + ] + } + ], + "metadata": { + "nbsphinx": { + "execute": "never" + }, + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Custom Keyboard Shortcuts.ipynb b/Custom Keyboard Shortcuts.ipynb new file mode 100644 index 0000000..9d26279 --- /dev/null +++ b/Custom Keyboard Shortcuts.ipynb @@ -0,0 +1,48 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Keyboard Shortcut Customization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can customize the `command` mode shortcuts from within the Notebook Application itself. \n", + "\n", + "Head to the **Settings** menu and select the **Settings Editor** item.\n", + "A dialog will guide you through the process of adding custom keyboard shortcuts.\n", + "\n", + "Keyboard shortcut set from within the Notebook Application will be persisted to your configuration file. \n", + "A single action may have several shortcuts attached to it." + ] + } + ], + "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.5.2" + }, + "nbsphinx": { + "execute": "never" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Importing Notebooks.ipynb b/Importing Notebooks.ipynb new file mode 100644 index 0000000..74702ff --- /dev/null +++ b/Importing Notebooks.ipynb @@ -0,0 +1,544 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Importing Jupyter Notebooks as Modules" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is a common problem that people want to import code from Jupyter Notebooks.\n", + "This is made difficult by the fact that Notebooks are not plain Python files,\n", + "and thus cannot be imported by the regular Python machinery.\n", + "\n", + "Fortunately, Python provides some fairly sophisticated [hooks](https://www.python.org/dev/peps/pep-0302/) into the import machinery,\n", + "so we can actually make Jupyter notebooks importable without much difficulty,\n", + "and only using public APIs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import io, os, sys, types" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from IPython import get_ipython\n", + "from nbformat import read\n", + "from IPython.core.interactiveshell import InteractiveShell" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import hooks typically take the form of two objects:\n", + "\n", + "1. a Module **Loader**, which takes a module name (e.g. `'IPython.display'`), and returns a Module\n", + "2. a Module **Finder**, which figures out whether a module might exist, and tells Python what **Loader** to use" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def find_notebook(fullname, path=None):\n", + " \"\"\"find a notebook, given its fully qualified name and an optional path\n", + "\n", + " This turns \"foo.bar\" into \"foo/bar.ipynb\"\n", + " and tries turning \"Foo_Bar\" into \"Foo Bar\" if Foo_Bar\n", + " does not exist.\n", + " \"\"\"\n", + " name = fullname.rsplit('.', 1)[-1]\n", + " if not path:\n", + " path = ['']\n", + " for d in path:\n", + " nb_path = os.path.join(d, name + \".ipynb\")\n", + " if os.path.isfile(nb_path):\n", + " return nb_path\n", + " # let import Notebook_Name find \"Notebook Name.ipynb\"\n", + " nb_path = nb_path.replace(\"_\", \" \")\n", + " if os.path.isfile(nb_path):\n", + " return nb_path" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notebook Loader" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we have our Notebook Loader.\n", + "It's actually quite simple - once we figure out the filename of the module,\n", + "all it does is:\n", + "\n", + "1. load the notebook document into memory\n", + "2. create an empty Module\n", + "3. execute every cell in the Module namespace\n", + "\n", + "Since IPython cells can have extended syntax,\n", + "the IPython transform is applied to turn each of these cells into their pure-Python counterparts before executing them.\n", + "If all of your notebook cells are pure-Python,\n", + "this step is unnecessary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "class NotebookLoader(object):\n", + " \"\"\"Module Loader for Jupyter Notebooks\"\"\"\n", + "\n", + " def __init__(self, path=None):\n", + " self.shell = InteractiveShell.instance()\n", + " self.path = path\n", + "\n", + " def load_module(self, fullname):\n", + " \"\"\"import a notebook as a module\"\"\"\n", + " path = find_notebook(fullname, self.path)\n", + "\n", + " print(\"importing Jupyter notebook from %s\" % path)\n", + "\n", + " # load the notebook object\n", + " with io.open(path, 'r', encoding='utf-8') as f:\n", + " nb = read(f, 4)\n", + "\n", + " # create the module and add it to sys.modules\n", + " # if name in sys.modules:\n", + " # return sys.modules[name]\n", + " mod = types.ModuleType(fullname)\n", + " mod.__file__ = path\n", + " mod.__loader__ = self\n", + " mod.__dict__['get_ipython'] = get_ipython\n", + " sys.modules[fullname] = mod\n", + "\n", + " # extra work to ensure that magics that would affect the user_ns\n", + " # actually affect the notebook module's ns\n", + " save_user_ns = self.shell.user_ns\n", + " self.shell.user_ns = mod.__dict__\n", + "\n", + " try:\n", + " for cell in nb.cells:\n", + " if cell.cell_type == 'code':\n", + " # transform the input to executable Python\n", + " code = self.shell.input_transformer_manager.transform_cell(cell.source)\n", + " # run the code in themodule\n", + " exec(code, mod.__dict__)\n", + " finally:\n", + " self.shell.user_ns = save_user_ns\n", + " return mod" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Module Finder" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The finder is a simple object that tells you whether a name can be imported,\n", + "and returns the appropriate loader.\n", + "All this one does is check, when you do:\n", + "\n", + "```python\n", + "import mynotebook\n", + "```\n", + "\n", + "it checks whether `mynotebook.ipynb` exists.\n", + "If a notebook is found, then it returns a NotebookLoader.\n", + "\n", + "Any extra logic is just for resolving paths within packages." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "class NotebookFinder(object):\n", + " \"\"\"Module finder that locates Jupyter Notebooks\"\"\"\n", + "\n", + " def __init__(self):\n", + " self.loaders = {}\n", + "\n", + " def find_module(self, fullname, path=None):\n", + " nb_path = find_notebook(fullname, path)\n", + " if not nb_path:\n", + " return\n", + "\n", + " key = path\n", + " if path:\n", + " # lists aren't hashable\n", + " key = os.path.sep.join(path)\n", + "\n", + " if key not in self.loaders:\n", + " self.loaders[key] = NotebookLoader(path)\n", + " return self.loaders[key]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Register the hook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we register the `NotebookFinder` with `sys.meta_path`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "sys.meta_path.append(NotebookFinder())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After this point, my notebooks should be importable.\n", + "\n", + "Let's look at what we have in the CWD:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ls nbpackage" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So I should be able to `import nbpackage.mynotebook`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import nbpackage.mynotebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Aside: displaying notebooks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is some simple code to display the contents of a notebook\n", + "with syntax highlighting, etc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from pygments import highlight\n", + "from pygments.lexers import PythonLexer\n", + "from pygments.formatters import HtmlFormatter\n", + "\n", + "from IPython.display import display, HTML\n", + "\n", + "formatter = HtmlFormatter()\n", + "lexer = PythonLexer()\n", + "\n", + "# publish the CSS for pygments highlighting\n", + "display(\n", + " HTML(\n", + " \"\"\"\n", + "\n", + "\"\"\"\n", + " % formatter.get_style_defs()\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def show_notebook(fname):\n", + " \"\"\"display a short summary of the cells of a notebook\"\"\"\n", + " with io.open(fname, 'r', encoding='utf-8') as f:\n", + " nb = read(f, 4)\n", + " html = []\n", + " for cell in nb.cells:\n", + " html.append(\"

%s cell

\" % cell.cell_type)\n", + " if cell.cell_type == 'code':\n", + " html.append(highlight(cell.source, lexer, formatter))\n", + " else:\n", + " html.append(\"
%s
\" % cell.source)\n", + " display(HTML('\\n'.join(html)))\n", + "\n", + "\n", + "show_notebook(os.path.join(\"nbpackage\", \"mynotebook.ipynb\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So my notebook has some code cells,\n", + "one of which contains some IPython syntax.\n", + "\n", + "Let's see what happens when we import it" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from nbpackage import mynotebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hooray, it imported! Does it work?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "mynotebook.foo()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hooray again!\n", + "\n", + "Even the function that contains IPython syntax works:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "mynotebook.has_ip_syntax()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notebooks in packages" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also have a notebook inside the `nb` package,\n", + "so let's make sure that works as well." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ls nbpackage/nbs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the `__init__.py` is necessary for `nb` to be considered a package,\n", + "just like usual." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "show_notebook(os.path.join(\"nbpackage\", \"nbs\", \"other.ipynb\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from nbpackage.nbs import other\n", + "\n", + "other.bar(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So now we have importable notebooks, from both the local directory and inside packages.\n", + "\n", + "I can even put a notebook inside IPython, to further demonstrate that this is working properly:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import shutil\n", + "from IPython.paths import get_ipython_package_dir\n", + "\n", + "utils = os.path.join(get_ipython_package_dir(), 'utils')\n", + "shutil.copy(\n", + " os.path.join(\"nbpackage\", \"mynotebook.ipynb\"), os.path.join(utils, \"inside_ipython.ipynb\")\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and import the notebook from `IPython.utils`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from IPython.utils import inside_ipython\n", + "\n", + "inside_ipython.whatsmyname()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This approach can even import functions and classes that are defined in a notebook using the `%%cython` magic." + ] + } + ], + "metadata": { + "gist_id": "6011986", + "nbsphinx": { + "execute": "never" + }, + "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.5.1+" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/Notebook Basics.ipynb b/Notebook Basics.ipynb new file mode 100644 index 0000000..668a558 --- /dev/null +++ b/Notebook Basics.ipynb @@ -0,0 +1,254 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Notebook Basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Notebook dashboard" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you first start the notebook server, your browser will open to the notebook dashboard. The dashboard serves as a home page for the notebook. Its main purpose is to display the notebooks and files in the current directory. For example, here is a screenshot of the dashboard page for the `examples` directory in the Jupyter repository:\n", + "\n", + "![Jupyter dashboard showing files tab](images/dashboard_files_tab.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The top of the notebook list displays clickable breadcrumbs of the current directory. By clicking on these breadcrumbs or on sub-directories in the notebook list, you can navigate your file system.\n", + "\n", + "To create a new notebook, click on the \"New\" button at the top of the list and select a kernel from the dropdown (as seen below). Which kernels are listed depend on what's installed on the server. Some of the kernels in the screenshot below may not exist as an option to you.\n", + "\n", + "![Jupyter \"New\" menu](images/dashboard_files_tab_new.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notebooks and files can be uploaded to the current directory by dragging a notebook file onto the notebook list or by the \"click here\" text above the list.\n", + "\n", + "The notebook list shows green \"Running\" text and a green notebook icon next to running notebooks (as seen below). Notebooks remain running until you explicitly shut them down; closing the notebook's page is not sufficient.\n", + "\n", + "\n", + "![Jupyter dashboard showing one notebook with a running kernel](images/dashboard_files_tab_run.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To shutdown, delete, duplicate, or rename a notebook check the checkbox next to it and an array of controls will appear at the top of the notebook list (as seen below). You can also use the same operations on directories and files when applicable.\n", + "\n", + "![Buttons: Duplicate, rename, shutdown, delete, new, refresh](images/dashboard_files_tab_btns.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To see all of your running notebooks along with their directories, click on the \"Running\" tab:\n", + "\n", + "![Jupyter dashboard running tab](images/dashboard_running_tab.png)\n", + "\n", + "This view provides a convenient way to track notebooks that you start as you navigate the file system in a long running notebook server." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview of the Notebook UI" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you create a new notebook or open an existing one, you will be taken to the notebook user interface (UI). This UI allows you to run code and author notebook documents interactively. The notebook UI has the following main areas:\n", + "\n", + "* Menu\n", + "* Toolbar\n", + "* Notebook area and cells\n", + "\n", + "The notebook has an interactive tour of these elements that can be started in the \"Help:User Interface Tour\" menu item." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modal editor" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Starting with IPython 2.0, the Jupyter Notebook has a modal user interface. This means that the keyboard does different things depending on which mode the Notebook is in. There are two modes: edit mode and command mode." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Edit mode" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Edit mode is indicated by a green cell border and a prompt showing in the editor area:\n", + "\n", + "![Jupyter cell with green border](images/edit_mode.png)\n", + "\n", + "When a cell is in edit mode, you can type into the cell, like a normal text editor." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "Enter edit mode by pressing `Enter` or using the mouse to click on a cell's editor area.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Command mode" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Command mode is indicated by a grey cell border with a blue left margin:\n", + "\n", + "![Jupyter cell with blue & grey border](images/command_mode.png)\n", + "\n", + "When you are in command mode, you are able to edit the notebook as a whole, but not type into individual cells. Most importantly, in command mode, the keyboard is mapped to a set of shortcuts that let you perform notebook and cell actions efficiently. For example, if you are in command mode and you press `c`, you will copy the current cell - no modifier is needed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "Don't try to type into a cell in command mode; unexpected things will happen!\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "Enter command mode by pressing `Esc` or using the mouse to click *outside* a cell's editor area.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mouse navigation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All navigation and actions in the Notebook are available using the mouse through the menubar and toolbar, which are both above the main Notebook area:\n", + "\n", + "![Jupyter notebook menus and toolbar](images/menubar_toolbar.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first idea of mouse based navigation is that **cells can be selected by clicking on them.** The currently selected cell gets a grey or green border depending on whether the notebook is in edit or command mode. If you click inside a cell's editor area, you will enter edit mode. If you click on the prompt or output area of a cell you will enter command mode.\n", + "\n", + "If you are running this notebook in a live session (not on http://nbviewer.jupyter.org) try selecting different cells and going between edit and command mode. Try typing into a cell." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second idea of mouse based navigation is that **cell actions usually apply to the currently selected cell**. Thus if you want to run the code in a cell, you would select it and click the button in the toolbar or the \"Cell:Run\" menu item. Similarly, to copy a cell you would select it and click the button in the toolbar or the \"Edit:Copy\" menu item. With this simple pattern, you should be able to do most everything you need with the mouse.\n", + "\n", + "Markdown cells have one other state that can be modified with the mouse. These cells can either be rendered or unrendered. When they are rendered, you will see a nice formatted representation of the cell's contents. When they are unrendered, you will see the raw text source of the cell. To render the selected cell with the mouse, click the button in the toolbar or the \"Cell:Run\" menu item. To unrender the selected cell, double click on the cell." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Keyboard Navigation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The modal user interface of the Jupyter Notebook has been optimized for efficient keyboard usage. This is made possible by having two different sets of keyboard shortcuts: one set that is active in edit mode and another in command mode.\n", + "\n", + "The most important keyboard shortcuts are `Enter`, which enters edit mode, and `Esc`, which enters command mode.\n", + "\n", + "In edit mode, most of the keyboard is dedicated to typing into the cell's editor. Thus, in edit mode there are relatively few shortcuts. In command mode, the entire keyboard is available for shortcuts, so there are many more. The `Help`->`Keyboard Shortcuts` dialog lists the available shortcuts." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We recommend learning the command mode shortcuts in the following rough order:\n", + "\n", + "1. Basic navigation: `enter`, `shift-enter`, `up/k`, `down/j`\n", + "2. Saving the notebook: `s`\n", + "2. Change Cell types: `y`, `m`, `1-6`, `t`\n", + "3. Cell creation: `a`, `b`\n", + "4. Cell editing: `x`, `c`, `v`, `d`, `z`\n", + "5. Kernel operations: `i`, `0` (press twice)" + ] + } + ], + "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.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Running Code.ipynb b/Running Code.ipynb new file mode 100644 index 0000000..2587927 --- /dev/null +++ b/Running Code.ipynb @@ -0,0 +1,917 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Running Code" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First and foremost, the Jupyter Notebook is an interactive environment for writing and running code. The notebook is capable of running code in a wide range of languages. However, each notebook is associated with a single kernel. This notebook is associated with the IPython kernel, therefore runs Python code." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code cells allow you to enter and run code" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run a code cell using `Shift-Enter` or pressing the button in the toolbar above:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "a = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "print(a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are two other keyboard shortcuts for running code:\n", + "\n", + "* `Alt-Enter` runs the current cell and inserts a new one below.\n", + "* `Ctrl-Enter` run the current cell and enters command mode." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Managing the Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Code is run in a separate process called the Kernel. The Kernel can be interrupted or restarted. Try running the following cell and then hit the button in the toolbar above." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "time.sleep(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the Kernel dies you will be prompted to restart it. Here we call the low-level system libc.time routine with the wrong argument via\n", + "ctypes to segfault the Python interpreter:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "import sys\n", + "from ctypes import CDLL\n", + "\n", + "# This will crash a Linux or Mac system\n", + "# equivalent calls can be made on Windows\n", + "\n", + "# Uncomment these lines if you would like to see the segfault\n", + "\n", + "# dll = 'dylib' if sys.platform == 'darwin' else 'so.6'\n", + "# libc = CDLL(\"libc.%s\" % dll)\n", + "# libc.time(-1) # BOOM!!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cell menu" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The \"Cell\" menu has a number of menu items for running code in different ways. These includes:\n", + "\n", + "* Run and Select Below\n", + "* Run and Insert Below\n", + "* Run All\n", + "* Run All Above\n", + "* Run All Below" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Restarting the kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The kernel maintains the state of a notebook's computations. You can reset this state by restarting the kernel. This is done by clicking on the in the toolbar above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## sys.stdout and sys.stderr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The stdout and stderr streams are displayed as text in the output area." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hi, stdout\n" + ] + } + ], + "source": [ + "print(\"hi, stdout\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "hi, stderr\n" + ] + } + ], + "source": [ + "from __future__ import print_function\n", + "\n", + "print('hi, stderr', file=sys.stderr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Output is asynchronous" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All output is displayed asynchronously as it is generated in the Kernel. If you execute the next cell, you will see the output one piece at a time, not all at the end." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n" + ] + } + ], + "source": [ + "import time, sys\n", + "\n", + "for i in range(8):\n", + " print(i)\n", + " time.sleep(0.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Large outputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To better handle large outputs, the output area can be collapsed. Run the following cell and then single- or double- click on the active area to the left of the output:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n", + "12\n", + "13\n", + "14\n", + "15\n", + "16\n", + "17\n", + "18\n", + "19\n", + "20\n", + "21\n", + "22\n", + "23\n", + "24\n", + "25\n", + "26\n", + "27\n", + "28\n", + "29\n", + "30\n", + "31\n", + "32\n", + "33\n", + "34\n", + "35\n", + "36\n", + "37\n", + "38\n", + "39\n", + "40\n", + "41\n", + "42\n", + "43\n", + "44\n", + "45\n", + "46\n", + "47\n", + "48\n", + "49\n" + ] + } + ], + "source": [ + "for i in range(50):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Beyond a certain point, output will scroll automatically:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "3\n", + "7\n", + "15\n", + "31\n", + "63\n", + "127\n", + "255\n", + "511\n", + "1023\n", + "2047\n", + "4095\n", + "8191\n", + "16383\n", + "32767\n", + "65535\n", + "131071\n", + "262143\n", + "524287\n", + "1048575\n", + "2097151\n", + "4194303\n", + "8388607\n", + "16777215\n", + "33554431\n", + "67108863\n", + "134217727\n", + "268435455\n", + "536870911\n", + "1073741823\n", + "2147483647\n", + "4294967295\n", + "8589934591\n", + "17179869183\n", + "34359738367\n", + "68719476735\n", + "137438953471\n", + "274877906943\n", + "549755813887\n", + "1099511627775\n", + "2199023255551\n", + "4398046511103\n", + "8796093022207\n", + "17592186044415\n", + "35184372088831\n", + "70368744177663\n", + "140737488355327\n", + "281474976710655\n", + "562949953421311\n", + "1125899906842623\n", + "2251799813685247\n", + "4503599627370495\n", + "9007199254740991\n", + "18014398509481983\n", + "36028797018963967\n", + "72057594037927935\n", + "144115188075855871\n", + "288230376151711743\n", + "576460752303423487\n", + "1152921504606846975\n", + "2305843009213693951\n", + "4611686018427387903\n", + "9223372036854775807\n", + "18446744073709551615\n", + "36893488147419103231\n", + "73786976294838206463\n", + "147573952589676412927\n", + "295147905179352825855\n", + "590295810358705651711\n", + "1180591620717411303423\n", + "2361183241434822606847\n", + "4722366482869645213695\n", + "9444732965739290427391\n", + "18889465931478580854783\n", + "37778931862957161709567\n", + "75557863725914323419135\n", + "151115727451828646838271\n", + "302231454903657293676543\n", + "604462909807314587353087\n", + "1208925819614629174706175\n", + "2417851639229258349412351\n", + "4835703278458516698824703\n", + "9671406556917033397649407\n", + "19342813113834066795298815\n", + "38685626227668133590597631\n", + "77371252455336267181195263\n", + "154742504910672534362390527\n", + "309485009821345068724781055\n", + "618970019642690137449562111\n", + "1237940039285380274899124223\n", + "2475880078570760549798248447\n", + "4951760157141521099596496895\n", + "9903520314283042199192993791\n", + "19807040628566084398385987583\n", + "39614081257132168796771975167\n", + "79228162514264337593543950335\n", + "158456325028528675187087900671\n", + "316912650057057350374175801343\n", + "633825300114114700748351602687\n", + "1267650600228229401496703205375\n", + "2535301200456458802993406410751\n", + "5070602400912917605986812821503\n", + "10141204801825835211973625643007\n", + "20282409603651670423947251286015\n", + "40564819207303340847894502572031\n", + "81129638414606681695789005144063\n", + "162259276829213363391578010288127\n", + "324518553658426726783156020576255\n", + "649037107316853453566312041152511\n", + "1298074214633706907132624082305023\n", + "2596148429267413814265248164610047\n", + "5192296858534827628530496329220095\n", + "10384593717069655257060992658440191\n", + "20769187434139310514121985316880383\n", + "41538374868278621028243970633760767\n", + "83076749736557242056487941267521535\n", + "166153499473114484112975882535043071\n", + "332306998946228968225951765070086143\n", + "664613997892457936451903530140172287\n", + "1329227995784915872903807060280344575\n", + "2658455991569831745807614120560689151\n", + "5316911983139663491615228241121378303\n", + "10633823966279326983230456482242756607\n", + "21267647932558653966460912964485513215\n", + "42535295865117307932921825928971026431\n", + "85070591730234615865843651857942052863\n", + "170141183460469231731687303715884105727\n", + "340282366920938463463374607431768211455\n", + "680564733841876926926749214863536422911\n", + "1361129467683753853853498429727072845823\n", + "2722258935367507707706996859454145691647\n", + "5444517870735015415413993718908291383295\n", + "10889035741470030830827987437816582766591\n", + "21778071482940061661655974875633165533183\n", + "43556142965880123323311949751266331066367\n", + "87112285931760246646623899502532662132735\n", + "174224571863520493293247799005065324265471\n", + "348449143727040986586495598010130648530943\n", + "696898287454081973172991196020261297061887\n", + "1393796574908163946345982392040522594123775\n", + "2787593149816327892691964784081045188247551\n", + "5575186299632655785383929568162090376495103\n", + "11150372599265311570767859136324180752990207\n", + "22300745198530623141535718272648361505980415\n", + "44601490397061246283071436545296723011960831\n", + "89202980794122492566142873090593446023921663\n", + "178405961588244985132285746181186892047843327\n", + "356811923176489970264571492362373784095686655\n", + "713623846352979940529142984724747568191373311\n", + "1427247692705959881058285969449495136382746623\n", + "2854495385411919762116571938898990272765493247\n", + "5708990770823839524233143877797980545530986495\n", + "11417981541647679048466287755595961091061972991\n", + "22835963083295358096932575511191922182123945983\n", + "45671926166590716193865151022383844364247891967\n", + "91343852333181432387730302044767688728495783935\n", + "182687704666362864775460604089535377456991567871\n", + "365375409332725729550921208179070754913983135743\n", + "730750818665451459101842416358141509827966271487\n", + "1461501637330902918203684832716283019655932542975\n", + "2923003274661805836407369665432566039311865085951\n", + "5846006549323611672814739330865132078623730171903\n", + "11692013098647223345629478661730264157247460343807\n", + "23384026197294446691258957323460528314494920687615\n", + "46768052394588893382517914646921056628989841375231\n", + "93536104789177786765035829293842113257979682750463\n", + "187072209578355573530071658587684226515959365500927\n", + "374144419156711147060143317175368453031918731001855\n", + "748288838313422294120286634350736906063837462003711\n", + "1496577676626844588240573268701473812127674924007423\n", + "2993155353253689176481146537402947624255349848014847\n", + "5986310706507378352962293074805895248510699696029695\n", + "11972621413014756705924586149611790497021399392059391\n", + "23945242826029513411849172299223580994042798784118783\n", + "47890485652059026823698344598447161988085597568237567\n", + "95780971304118053647396689196894323976171195136475135\n", + "191561942608236107294793378393788647952342390272950271\n", + "383123885216472214589586756787577295904684780545900543\n", + "766247770432944429179173513575154591809369561091801087\n", + "1532495540865888858358347027150309183618739122183602175\n", + "3064991081731777716716694054300618367237478244367204351\n", + "6129982163463555433433388108601236734474956488734408703\n", + "12259964326927110866866776217202473468949912977468817407\n", + "24519928653854221733733552434404946937899825954937634815\n", + "49039857307708443467467104868809893875799651909875269631\n", + "98079714615416886934934209737619787751599303819750539263\n", + "196159429230833773869868419475239575503198607639501078527\n", + "392318858461667547739736838950479151006397215279002157055\n", + "784637716923335095479473677900958302012794430558004314111\n", + "1569275433846670190958947355801916604025588861116008628223\n", + "3138550867693340381917894711603833208051177722232017256447\n", + "6277101735386680763835789423207666416102355444464034512895\n", + "12554203470773361527671578846415332832204710888928069025791\n", + "25108406941546723055343157692830665664409421777856138051583\n", + "50216813883093446110686315385661331328818843555712276103167\n", + "100433627766186892221372630771322662657637687111424552206335\n", + "200867255532373784442745261542645325315275374222849104412671\n", + "401734511064747568885490523085290650630550748445698208825343\n", + "803469022129495137770981046170581301261101496891396417650687\n", + "1606938044258990275541962092341162602522202993782792835301375\n", + "3213876088517980551083924184682325205044405987565585670602751\n", + "6427752177035961102167848369364650410088811975131171341205503\n", + "12855504354071922204335696738729300820177623950262342682411007\n", + "25711008708143844408671393477458601640355247900524685364822015\n", + "51422017416287688817342786954917203280710495801049370729644031\n", + "102844034832575377634685573909834406561420991602098741459288063\n", + "205688069665150755269371147819668813122841983204197482918576127\n", + "411376139330301510538742295639337626245683966408394965837152255\n", + "822752278660603021077484591278675252491367932816789931674304511\n", + "1645504557321206042154969182557350504982735865633579863348609023\n", + "3291009114642412084309938365114701009965471731267159726697218047\n", + "6582018229284824168619876730229402019930943462534319453394436095\n", + "13164036458569648337239753460458804039861886925068638906788872191\n", + "26328072917139296674479506920917608079723773850137277813577744383\n", + "52656145834278593348959013841835216159447547700274555627155488767\n", + "105312291668557186697918027683670432318895095400549111254310977535\n", + "210624583337114373395836055367340864637790190801098222508621955071\n", + "421249166674228746791672110734681729275580381602196445017243910143\n", + "842498333348457493583344221469363458551160763204392890034487820287\n", + "1684996666696914987166688442938726917102321526408785780068975640575\n", + "3369993333393829974333376885877453834204643052817571560137951281151\n", + "6739986666787659948666753771754907668409286105635143120275902562303\n", + "13479973333575319897333507543509815336818572211270286240551805124607\n", + "26959946667150639794667015087019630673637144422540572481103610249215\n", + "53919893334301279589334030174039261347274288845081144962207220498431\n", + "107839786668602559178668060348078522694548577690162289924414440996863\n", + "215679573337205118357336120696157045389097155380324579848828881993727\n", + "431359146674410236714672241392314090778194310760649159697657763987455\n", + "862718293348820473429344482784628181556388621521298319395315527974911\n", + "1725436586697640946858688965569256363112777243042596638790631055949823\n", + "3450873173395281893717377931138512726225554486085193277581262111899647\n", + "6901746346790563787434755862277025452451108972170386555162524223799295\n", + "13803492693581127574869511724554050904902217944340773110325048447598591\n", + "27606985387162255149739023449108101809804435888681546220650096895197183\n", + "55213970774324510299478046898216203619608871777363092441300193790394367\n", + "110427941548649020598956093796432407239217743554726184882600387580788735\n", + "220855883097298041197912187592864814478435487109452369765200775161577471\n", + "441711766194596082395824375185729628956870974218904739530401550323154943\n", + "883423532389192164791648750371459257913741948437809479060803100646309887\n", + "1766847064778384329583297500742918515827483896875618958121606201292619775\n", + "3533694129556768659166595001485837031654967793751237916243212402585239551\n", + "7067388259113537318333190002971674063309935587502475832486424805170479103\n", + "14134776518227074636666380005943348126619871175004951664972849610340958207\n", + "28269553036454149273332760011886696253239742350009903329945699220681916415\n", + "56539106072908298546665520023773392506479484700019806659891398441363832831\n", + "113078212145816597093331040047546785012958969400039613319782796882727665663\n", + "226156424291633194186662080095093570025917938800079226639565593765455331327\n", + "452312848583266388373324160190187140051835877600158453279131187530910662655\n", + "904625697166532776746648320380374280103671755200316906558262375061821325311\n", + "1809251394333065553493296640760748560207343510400633813116524750123642650623\n", + "3618502788666131106986593281521497120414687020801267626233049500247285301247\n", + "7237005577332262213973186563042994240829374041602535252466099000494570602495\n", + "14474011154664524427946373126085988481658748083205070504932198000989141204991\n", + "28948022309329048855892746252171976963317496166410141009864396001978282409983\n", + "57896044618658097711785492504343953926634992332820282019728792003956564819967\n", + "115792089237316195423570985008687907853269984665640564039457584007913129639935\n", + "231584178474632390847141970017375815706539969331281128078915168015826259279871\n", + "463168356949264781694283940034751631413079938662562256157830336031652518559743\n", + "926336713898529563388567880069503262826159877325124512315660672063305037119487\n", + "1852673427797059126777135760139006525652319754650249024631321344126610074238975\n", + "3705346855594118253554271520278013051304639509300498049262642688253220148477951\n", + "7410693711188236507108543040556026102609279018600996098525285376506440296955903\n", + "14821387422376473014217086081112052205218558037201992197050570753012880593911807\n", + "29642774844752946028434172162224104410437116074403984394101141506025761187823615\n", + "59285549689505892056868344324448208820874232148807968788202283012051522375647231\n", + "118571099379011784113736688648896417641748464297615937576404566024103044751294463\n", + "237142198758023568227473377297792835283496928595231875152809132048206089502588927\n", + "474284397516047136454946754595585670566993857190463750305618264096412179005177855\n", + "948568795032094272909893509191171341133987714380927500611236528192824358010355711\n", + "1897137590064188545819787018382342682267975428761855001222473056385648716020711423\n", + "3794275180128377091639574036764685364535950857523710002444946112771297432041422847\n", + "7588550360256754183279148073529370729071901715047420004889892225542594864082845695\n", + "15177100720513508366558296147058741458143803430094840009779784451085189728165691391\n", + "30354201441027016733116592294117482916287606860189680019559568902170379456331382783\n", + "60708402882054033466233184588234965832575213720379360039119137804340758912662765567\n", + "121416805764108066932466369176469931665150427440758720078238275608681517825325531135\n", + "242833611528216133864932738352939863330300854881517440156476551217363035650651062271\n", + "485667223056432267729865476705879726660601709763034880312953102434726071301302124543\n", + "971334446112864535459730953411759453321203419526069760625906204869452142602604249087\n", + "1942668892225729070919461906823518906642406839052139521251812409738904285205208498175\n", + "3885337784451458141838923813647037813284813678104279042503624819477808570410416996351\n", + "7770675568902916283677847627294075626569627356208558085007249638955617140820833992703\n", + "15541351137805832567355695254588151253139254712417116170014499277911234281641667985407\n", + "31082702275611665134711390509176302506278509424834232340028998555822468563283335970815\n", + "62165404551223330269422781018352605012557018849668464680057997111644937126566671941631\n", + "124330809102446660538845562036705210025114037699336929360115994223289874253133343883263\n", + "248661618204893321077691124073410420050228075398673858720231988446579748506266687766527\n", + "497323236409786642155382248146820840100456150797347717440463976893159497012533375533055\n", + "994646472819573284310764496293641680200912301594695434880927953786318994025066751066111\n", + "1989292945639146568621528992587283360401824603189390869761855907572637988050133502132223\n", + "3978585891278293137243057985174566720803649206378781739523711815145275976100267004264447\n", + "7957171782556586274486115970349133441607298412757563479047423630290551952200534008528895\n", + "15914343565113172548972231940698266883214596825515126958094847260581103904401068017057791\n", + "31828687130226345097944463881396533766429193651030253916189694521162207808802136034115583\n", + "63657374260452690195888927762793067532858387302060507832379389042324415617604272068231167\n", + "127314748520905380391777855525586135065716774604121015664758778084648831235208544136462335\n", + "254629497041810760783555711051172270131433549208242031329517556169297662470417088272924671\n", + "509258994083621521567111422102344540262867098416484062659035112338595324940834176545849343\n", + "1018517988167243043134222844204689080525734196832968125318070224677190649881668353091698687\n", + "2037035976334486086268445688409378161051468393665936250636140449354381299763336706183397375\n", + "4074071952668972172536891376818756322102936787331872501272280898708762599526673412366794751\n", + "8148143905337944345073782753637512644205873574663745002544561797417525199053346824733589503\n", + "16296287810675888690147565507275025288411747149327490005089123594835050398106693649467179007\n", + "32592575621351777380295131014550050576823494298654980010178247189670100796213387298934358015\n", + "65185151242703554760590262029100101153646988597309960020356494379340201592426774597868716031\n", + "130370302485407109521180524058200202307293977194619920040712988758680403184853549195737432063\n", + "260740604970814219042361048116400404614587954389239840081425977517360806369707098391474864127\n", + "521481209941628438084722096232800809229175908778479680162851955034721612739414196782949728255\n", + "1042962419883256876169444192465601618458351817556959360325703910069443225478828393565899456511\n", + "2085924839766513752338888384931203236916703635113918720651407820138886450957656787131798913023\n", + "4171849679533027504677776769862406473833407270227837441302815640277772901915313574263597826047\n", + "8343699359066055009355553539724812947666814540455674882605631280555545803830627148527195652095\n", + "16687398718132110018711107079449625895333629080911349765211262561111091607661254297054391304191\n", + "33374797436264220037422214158899251790667258161822699530422525122222183215322508594108782608383\n", + "66749594872528440074844428317798503581334516323645399060845050244444366430645017188217565216767\n", + "133499189745056880149688856635597007162669032647290798121690100488888732861290034376435130433535\n", + "266998379490113760299377713271194014325338065294581596243380200977777465722580068752870260867071\n", + "533996758980227520598755426542388028650676130589163192486760401955554931445160137505740521734143\n", + "1067993517960455041197510853084776057301352261178326384973520803911109862890320275011481043468287\n", + "2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936575\n", + "4271974071841820164790043412339104229205409044713305539894083215644439451561281100045924173873151\n", + "8543948143683640329580086824678208458410818089426611079788166431288878903122562200091848347746303\n", + "17087896287367280659160173649356416916821636178853222159576332862577757806245124400183696695492607\n", + "34175792574734561318320347298712833833643272357706444319152665725155515612490248800367393390985215\n", + "68351585149469122636640694597425667667286544715412888638305331450311031224980497600734786781970431\n", + "136703170298938245273281389194851335334573089430825777276610662900622062449960995201469573563940863\n", + "273406340597876490546562778389702670669146178861651554553221325801244124899921990402939147127881727\n", + "546812681195752981093125556779405341338292357723303109106442651602488249799843980805878294255763455\n", + "1093625362391505962186251113558810682676584715446606218212885303204976499599687961611756588511526911\n", + "2187250724783011924372502227117621365353169430893212436425770606409952999199375923223513177023053823\n", + "4374501449566023848745004454235242730706338861786424872851541212819905998398751846447026354046107647\n", + "8749002899132047697490008908470485461412677723572849745703082425639811996797503692894052708092215295\n", + "17498005798264095394980017816940970922825355447145699491406164851279623993595007385788105416184430591\n", + "34996011596528190789960035633881941845650710894291398982812329702559247987190014771576210832368861183\n", + "69992023193056381579920071267763883691301421788582797965624659405118495974380029543152421664737722367\n", + "139984046386112763159840142535527767382602843577165595931249318810236991948760059086304843329475444735\n", + "279968092772225526319680285071055534765205687154331191862498637620473983897520118172609686658950889471\n", + "559936185544451052639360570142111069530411374308662383724997275240947967795040236345219373317901778943\n", + "1119872371088902105278721140284222139060822748617324767449994550481895935590080472690438746635803557887\n", + "2239744742177804210557442280568444278121645497234649534899989100963791871180160945380877493271607115775\n", + "4479489484355608421114884561136888556243290994469299069799978201927583742360321890761754986543214231551\n", + "8958978968711216842229769122273777112486581988938598139599956403855167484720643781523509973086428463103\n", + "17917957937422433684459538244547554224973163977877196279199912807710334969441287563047019946172856926207\n", + "35835915874844867368919076489095108449946327955754392558399825615420669938882575126094039892345713852415\n", + "71671831749689734737838152978190216899892655911508785116799651230841339877765150252188079784691427704831\n", + "143343663499379469475676305956380433799785311823017570233599302461682679755530300504376159569382855409663\n", + "286687326998758938951352611912760867599570623646035140467198604923365359511060601008752319138765710819327\n", + "573374653997517877902705223825521735199141247292070280934397209846730719022121202017504638277531421638655\n", + "1146749307995035755805410447651043470398282494584140561868794419693461438044242404035009276555062843277311\n", + "2293498615990071511610820895302086940796564989168281123737588839386922876088484808070018553110125686554623\n", + "4586997231980143023221641790604173881593129978336562247475177678773845752176969616140037106220251373109247\n", + "9173994463960286046443283581208347763186259956673124494950355357547691504353939232280074212440502746218495\n", + "18347988927920572092886567162416695526372519913346248989900710715095383008707878464560148424881005492436991\n", + "36695977855841144185773134324833391052745039826692497979801421430190766017415756929120296849762010984873983\n", + "73391955711682288371546268649666782105490079653384995959602842860381532034831513858240593699524021969747967\n", + "146783911423364576743092537299333564210980159306769991919205685720763064069663027716481187399048043939495935\n", + "293567822846729153486185074598667128421960318613539983838411371441526128139326055432962374798096087878991871\n", + "587135645693458306972370149197334256843920637227079967676822742883052256278652110865924749596192175757983743\n", + "1174271291386916613944740298394668513687841274454159935353645485766104512557304221731849499192384351515967487\n", + "2348542582773833227889480596789337027375682548908319870707290971532209025114608443463698998384768703031934975\n", + "4697085165547666455778961193578674054751365097816639741414581943064418050229216886927397996769537406063869951\n", + "9394170331095332911557922387157348109502730195633279482829163886128836100458433773854795993539074812127739903\n", + "18788340662190665823115844774314696219005460391266558965658327772257672200916867547709591987078149624255479807\n", + "37576681324381331646231689548629392438010920782533117931316655544515344401833735095419183974156299248510959615\n", + "75153362648762663292463379097258784876021841565066235862633311089030688803667470190838367948312598497021919231\n", + "150306725297525326584926758194517569752043683130132471725266622178061377607334940381676735896625196994043838463\n", + "300613450595050653169853516389035139504087366260264943450533244356122755214669880763353471793250393988087676927\n", + "601226901190101306339707032778070279008174732520529886901066488712245510429339761526706943586500787976175353855\n", + "1202453802380202612679414065556140558016349465041059773802132977424491020858679523053413887173001575952350707711\n", + "2404907604760405225358828131112281116032698930082119547604265954848982041717359046106827774346003151904701415423\n", + "4809815209520810450717656262224562232065397860164239095208531909697964083434718092213655548692006303809402830847\n", + "9619630419041620901435312524449124464130795720328478190417063819395928166869436184427311097384012607618805661695\n", + "19239260838083241802870625048898248928261591440656956380834127638791856333738872368854622194768025215237611323391\n", + "38478521676166483605741250097796497856523182881313912761668255277583712667477744737709244389536050430475222646783\n", + "76957043352332967211482500195592995713046365762627825523336510555167425334955489475418488779072100860950445293567\n", + "153914086704665934422965000391185991426092731525255651046673021110334850669910978950836977558144201721900890587135\n", + "307828173409331868845930000782371982852185463050511302093346042220669701339821957901673955116288403443801781174271\n", + "615656346818663737691860001564743965704370926101022604186692084441339402679643915803347910232576806887603562348543\n", + "1231312693637327475383720003129487931408741852202045208373384168882678805359287831606695820465153613775207124697087\n", + "2462625387274654950767440006258975862817483704404090416746768337765357610718575663213391640930307227550414249394175\n", + "4925250774549309901534880012517951725634967408808180833493536675530715221437151326426783281860614455100828498788351\n", + "9850501549098619803069760025035903451269934817616361666987073351061430442874302652853566563721228910201656997576703\n", + "19701003098197239606139520050071806902539869635232723333974146702122860885748605305707133127442457820403313995153407\n", + "39402006196394479212279040100143613805079739270465446667948293404245721771497210611414266254884915640806627990306815\n", + "78804012392788958424558080200287227610159478540930893335896586808491443542994421222828532509769831281613255980613631\n", + "157608024785577916849116160400574455220318957081861786671793173616982887085988842445657065019539662563226511961227263\n", + "315216049571155833698232320801148910440637914163723573343586347233965774171977684891314130039079325126453023922454527\n", + "630432099142311667396464641602297820881275828327447146687172694467931548343955369782628260078158650252906047844909055\n", + "1260864198284623334792929283204595641762551656654894293374345388935863096687910739565256520156317300505812095689818111\n", + "2521728396569246669585858566409191283525103313309788586748690777871726193375821479130513040312634601011624191379636223\n", + "5043456793138493339171717132818382567050206626619577173497381555743452386751642958261026080625269202023248382759272447\n", + "10086913586276986678343434265636765134100413253239154346994763111486904773503285916522052161250538404046496765518544895\n", + "20173827172553973356686868531273530268200826506478308693989526222973809547006571833044104322501076808092993531037089791\n", + "40347654345107946713373737062547060536401653012956617387979052445947619094013143666088208645002153616185987062074179583\n", + "80695308690215893426747474125094121072803306025913234775958104891895238188026287332176417290004307232371974124148359167\n", + "161390617380431786853494948250188242145606612051826469551916209783790476376052574664352834580008614464743948248296718335\n", + "322781234760863573706989896500376484291213224103652939103832419567580952752105149328705669160017228929487896496593436671\n", + "645562469521727147413979793000752968582426448207305878207664839135161905504210298657411338320034457858975792993186873343\n", + "1291124939043454294827959586001505937164852896414611756415329678270323811008420597314822676640068915717951585986373746687\n", + "2582249878086908589655919172003011874329705792829223512830659356540647622016841194629645353280137831435903171972747493375\n", + "5164499756173817179311838344006023748659411585658447025661318713081295244033682389259290706560275662871806343945494986751\n", + "10328999512347634358623676688012047497318823171316894051322637426162590488067364778518581413120551325743612687890989973503\n", + "20657999024695268717247353376024094994637646342633788102645274852325180976134729557037162826241102651487225375781979947007\n", + "41315998049390537434494706752048189989275292685267576205290549704650361952269459114074325652482205302974450751563959894015\n", + "82631996098781074868989413504096379978550585370535152410581099409300723904538918228148651304964410605948901503127919788031\n", + "165263992197562149737978827008192759957101170741070304821162198818601447809077836456297302609928821211897803006255839576063\n", + "330527984395124299475957654016385519914202341482140609642324397637202895618155672912594605219857642423795606012511679152127\n", + "661055968790248598951915308032771039828404682964281219284648795274405791236311345825189210439715284847591212025023358304255\n", + "1322111937580497197903830616065542079656809365928562438569297590548811582472622691650378420879430569695182424050046716608511\n", + "2644223875160994395807661232131084159313618731857124877138595181097623164945245383300756841758861139390364848100093433217023\n", + "5288447750321988791615322464262168318627237463714249754277190362195246329890490766601513683517722278780729696200186866434047\n", + "10576895500643977583230644928524336637254474927428499508554380724390492659780981533203027367035444557561459392400373732868095\n", + "21153791001287955166461289857048673274508949854856999017108761448780985319561963066406054734070889115122918784800747465736191\n", + "42307582002575910332922579714097346549017899709713998034217522897561970639123926132812109468141778230245837569601494931472383\n", + "84615164005151820665845159428194693098035799419427996068435045795123941278247852265624218936283556460491675139202989862944767\n", + "169230328010303641331690318856389386196071598838855992136870091590247882556495704531248437872567112920983350278405979725889535\n", + "338460656020607282663380637712778772392143197677711984273740183180495765112991409062496875745134225841966700556811959451779071\n", + "676921312041214565326761275425557544784286395355423968547480366360991530225982818124993751490268451683933401113623918903558143\n", + "1353842624082429130653522550851115089568572790710847937094960732721983060451965636249987502980536903367866802227247837807116287\n", + "2707685248164858261307045101702230179137145581421695874189921465443966120903931272499975005961073806735733604454495675614232575\n", + "5415370496329716522614090203404460358274291162843391748379842930887932241807862544999950011922147613471467208908991351228465151\n", + "10830740992659433045228180406808920716548582325686783496759685861775864483615725089999900023844295226942934417817982702456930303\n", + "21661481985318866090456360813617841433097164651373566993519371723551728967231450179999800047688590453885868835635965404913860607\n", + "43322963970637732180912721627235682866194329302747133987038743447103457934462900359999600095377180907771737671271930809827721215\n", + "86645927941275464361825443254471365732388658605494267974077486894206915868925800719999200190754361815543475342543861619655442431\n", + "173291855882550928723650886508942731464777317210988535948154973788413831737851601439998400381508723631086950685087723239310884863\n", + "346583711765101857447301773017885462929554634421977071896309947576827663475703202879996800763017447262173901370175446478621769727\n", + "693167423530203714894603546035770925859109268843954143792619895153655326951406405759993601526034894524347802740350892957243539455\n", + "1386334847060407429789207092071541851718218537687908287585239790307310653902812811519987203052069789048695605480701785914487078911\n", + "2772669694120814859578414184143083703436437075375816575170479580614621307805625623039974406104139578097391210961403571828974157823\n", + "5545339388241629719156828368286167406872874150751633150340959161229242615611251246079948812208279156194782421922807143657948315647\n", + "11090678776483259438313656736572334813745748301503266300681918322458485231222502492159897624416558312389564843845614287315896631295\n", + "22181357552966518876627313473144669627491496603006532601363836644916970462445004984319795248833116624779129687691228574631793262591\n", + "44362715105933037753254626946289339254982993206013065202727673289833940924890009968639590497666233249558259375382457149263586525183\n", + "88725430211866075506509253892578678509965986412026130405455346579667881849780019937279180995332466499116518750764914298527173050367\n", + "177450860423732151013018507785157357019931972824052260810910693159335763699560039874558361990664932998233037501529828597054346100735\n", + "354901720847464302026037015570314714039863945648104521621821386318671527399120079749116723981329865996466075003059657194108692201471\n", + "709803441694928604052074031140629428079727891296209043243642772637343054798240159498233447962659731992932150006119314388217384402943\n", + "1419606883389857208104148062281258856159455782592418086487285545274686109596480318996466895925319463985864300012238628776434768805887\n", + "2839213766779714416208296124562517712318911565184836172974571090549372219192960637992933791850638927971728600024477257552869537611775\n", + "5678427533559428832416592249125035424637823130369672345949142181098744438385921275985867583701277855943457200048954515105739075223551\n", + "11356855067118857664833184498250070849275646260739344691898284362197488876771842551971735167402555711886914400097909030211478150447103\n", + "22713710134237715329666368996500141698551292521478689383796568724394977753543685103943470334805111423773828800195818060422956300894207\n", + "45427420268475430659332737993000283397102585042957378767593137448789955507087370207886940669610222847547657600391636120845912601788415\n", + "90854840536950861318665475986000566794205170085914757535186274897579911014174740415773881339220445695095315200783272241691825203576831\n", + "181709681073901722637330951972001133588410340171829515070372549795159822028349480831547762678440891390190630401566544483383650407153663\n", + "363419362147803445274661903944002267176820680343659030140745099590319644056698961663095525356881782780381260803133088966767300814307327\n", + "726838724295606890549323807888004534353641360687318060281490199180639288113397923326191050713763565560762521606266177933534601628614655\n", + "1453677448591213781098647615776009068707282721374636120562980398361278576226795846652382101427527131121525043212532355867069203257229311\n", + "2907354897182427562197295231552018137414565442749272241125960796722557152453591693304764202855054262243050086425064711734138406514458623\n", + "5814709794364855124394590463104036274829130885498544482251921593445114304907183386609528405710108524486100172850129423468276813028917247\n", + "11629419588729710248789180926208072549658261770997088964503843186890228609814366773219056811420217048972200345700258846936553626057834495\n", + "23258839177459420497578361852416145099316523541994177929007686373780457219628733546438113622840434097944400691400517693873107252115668991\n", + "46517678354918840995156723704832290198633047083988355858015372747560914439257467092876227245680868195888801382801035387746214504231337983\n", + "93035356709837681990313447409664580397266094167976711716030745495121828878514934185752454491361736391777602765602070775492429008462675967\n", + "186070713419675363980626894819329160794532188335953423432061490990243657757029868371504908982723472783555205531204141550984858016925351935\n", + "372141426839350727961253789638658321589064376671906846864122981980487315514059736743009817965446945567110411062408283101969716033850703871\n", + "744282853678701455922507579277316643178128753343813693728245963960974631028119473486019635930893891134220822124816566203939432067701407743\n", + "1488565707357402911845015158554633286356257506687627387456491927921949262056238946972039271861787782268441644249633132407878864135402815487\n", + "2977131414714805823690030317109266572712515013375254774912983855843898524112477893944078543723575564536883288499266264815757728270805630975\n", + "5954262829429611647380060634218533145425030026750509549825967711687797048224955787888157087447151129073766576998532529631515456541611261951\n", + "11908525658859223294760121268437066290850060053501019099651935423375594096449911575776314174894302258147533153997065059263030913083222523903\n", + "23817051317718446589520242536874132581700120107002038199303870846751188192899823151552628349788604516295066307994130118526061826166445047807\n", + "47634102635436893179040485073748265163400240214004076398607741693502376385799646303105256699577209032590132615988260237052123652332890095615\n", + "95268205270873786358080970147496530326800480428008152797215483387004752771599292606210513399154418065180265231976520474104247304665780191231\n", + "190536410541747572716161940294993060653600960856016305594430966774009505543198585212421026798308836130360530463953040948208494609331560382463\n", + "381072821083495145432323880589986121307201921712032611188861933548019011086397170424842053596617672260721060927906081896416989218663120764927\n", + "762145642166990290864647761179972242614403843424065222377723867096038022172794340849684107193235344521442121855812163792833978437326241529855\n", + "1524291284333980581729295522359944485228807686848130444755447734192076044345588681699368214386470689042884243711624327585667956874652483059711\n", + "3048582568667961163458591044719888970457615373696260889510895468384152088691177363398736428772941378085768487423248655171335913749304966119423\n", + "6097165137335922326917182089439777940915230747392521779021790936768304177382354726797472857545882756171536974846497310342671827498609932238847\n", + "12194330274671844653834364178879555881830461494785043558043581873536608354764709453594945715091765512343073949692994620685343654997219864477695\n", + "24388660549343689307668728357759111763660922989570087116087163747073216709529418907189891430183531024686147899385989241370687309994439728955391\n", + "48777321098687378615337456715518223527321845979140174232174327494146433419058837814379782860367062049372295798771978482741374619988879457910783\n", + "97554642197374757230674913431036447054643691958280348464348654988292866838117675628759565720734124098744591597543956965482749239977758915821567\n", + "195109284394749514461349826862072894109287383916560696928697309976585733676235351257519131441468248197489183195087913930965498479955517831643135\n", + "390218568789499028922699653724145788218574767833121393857394619953171467352470702515038262882936496394978366390175827861930996959911035663286271\n", + "780437137578998057845399307448291576437149535666242787714789239906342934704941405030076525765872992789956732780351655723861993919822071326572543\n", + "1560874275157996115690798614896583152874299071332485575429578479812685869409882810060153051531745985579913465560703311447723987839644142653145087\n", + "3121748550315992231381597229793166305748598142664971150859156959625371738819765620120306103063491971159826931121406622895447975679288285306290175\n", + "6243497100631984462763194459586332611497196285329942301718313919250743477639531240240612206126983942319653862242813245790895951358576570612580351\n", + "12486994201263968925526388919172665222994392570659884603436627838501486955279062480481224412253967884639307724485626491581791902717153141225160703\n", + "24973988402527937851052777838345330445988785141319769206873255677002973910558124960962448824507935769278615448971252983163583805434306282450321407\n", + "49947976805055875702105555676690660891977570282639538413746511354005947821116249921924897649015871538557230897942505966327167610868612564900642815\n", + "99895953610111751404211111353381321783955140565279076827493022708011895642232499843849795298031743077114461795885011932654335221737225129801285631\n", + "199791907220223502808422222706762643567910281130558153654986045416023791284464999687699590596063486154228923591770023865308670443474450259602571263\n", + "399583814440447005616844445413525287135820562261116307309972090832047582568929999375399181192126972308457847183540047730617340886948900519205142527\n", + "799167628880894011233688890827050574271641124522232614619944181664095165137859998750798362384253944616915694367080095461234681773897801038410285055\n", + "1598335257761788022467377781654101148543282249044465229239888363328190330275719997501596724768507889233831388734160190922469363547795602076820570111\n", + "3196670515523576044934755563308202297086564498088930458479776726656380660551439995003193449537015778467662777468320381844938727095591204153641140223\n", + "6393341031047152089869511126616404594173128996177860916959553453312761321102879990006386899074031556935325554936640763689877454191182408307282280447\n", + "12786682062094304179739022253232809188346257992355721833919106906625522642205759980012773798148063113870651109873281527379754908382364816614564560895\n", + "25573364124188608359478044506465618376692515984711443667838213813251045284411519960025547596296126227741302219746563054759509816764729633229129121791\n", + "51146728248377216718956089012931236753385031969422887335676427626502090568823039920051095192592252455482604439493126109519019633529459266458258243583\n", + "102293456496754433437912178025862473506770063938845774671352855253004181137646079840102190385184504910965208878986252219038039267058918532916516487167\n", + "204586912993508866875824356051724947013540127877691549342705710506008362275292159680204380770369009821930417757972504438076078534117837065833032974335\n", + "409173825987017733751648712103449894027080255755383098685411421012016724550584319360408761540738019643860835515945008876152157068235674131666065948671\n", + "818347651974035467503297424206899788054160511510766197370822842024033449101168638720817523081476039287721671031890017752304314136471348263332131897343\n", + "1636695303948070935006594848413799576108321023021532394741645684048066898202337277441635046162952078575443342063780035504608628272942696526664263794687\n" + ] + } + ], + "source": [ + "for i in range(500):\n", + " print(2**i - 1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/Typesetting Equations.ipynb b/Typesetting Equations.ipynb new file mode 100644 index 0000000..761d03e --- /dev/null +++ b/Typesetting Equations.ipynb @@ -0,0 +1,280 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Markdown parser included in the Jupyter Notebook is MathJax-aware. This means that you can freely mix in mathematical expressions using the [MathJax subset of Tex and LaTeX](https://docs.mathjax.org/en/latest/input/tex/). [Some examples from the MathJax demos site](https://mathjax.github.io/MathJax-demos-web/) are reproduced below, as well as the Markdown+TeX source." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Motivating Examples\n", + "\n", + "## The Lorenz Equations\n", + "### Source\n", + "```\n", + "\\begin{align}\n", + "\\dot{x} & = \\sigma(y-x) \\\\\n", + "\\dot{y} & = \\rho x - y - xz \\\\\n", + "\\dot{z} & = -\\beta z + xy\n", + "\\end{align}\n", + "```\n", + "### Display\n", + "\n", + "$\\begin{align}\n", + "\\dot{x} & = \\sigma(y-x) \\\\\n", + "\\dot{y} & = \\rho x - y - xz \\\\\n", + "\\dot{z} & = -\\beta z + xy\n", + "\\end{align}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Cauchy-Schwarz Inequality\n", + "### Source\n", + "```\n", + "\\begin{equation*}\n", + "\\left( \\sum_{k=1}^n a_k b_k \\right)^2 \\leq \\left( \\sum_{k=1}^n a_k^2 \\right) \\left( \\sum_{k=1}^n b_k^2 \\right)\n", + "\\end{equation*}\n", + "```\n", + "### Display\n", + "\n", + "$\\begin{equation*}\n", + "\\left( \\sum_{k=1}^n a_k b_k \\right)^2 \\leq \\left( \\sum_{k=1}^n a_k^2 \\right) \\left( \\sum_{k=1}^n b_k^2 \\right)\n", + "\\end{equation*}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A Cross Product Formula\n", + "### Source\n", + "```\n", + "\\begin{equation*}\n", + "\\mathbf{V}_1 \\times \\mathbf{V}_2 = \\begin{vmatrix}\n", + "\\mathbf{i} & \\mathbf{j} & \\mathbf{k} \\\\\n", + "\\frac{\\partial X}{\\partial u} & \\frac{\\partial Y}{\\partial u} & 0 \\\\\n", + "\\frac{\\partial X}{\\partial v} & \\frac{\\partial Y}{\\partial v} & 0\n", + "\\end{vmatrix} \n", + "\\end{equation*}\n", + "```\n", + "### Display\n", + "\n", + "$\\begin{equation*}\n", + "\\mathbf{V}_1 \\times \\mathbf{V}_2 = \\begin{vmatrix}\n", + "\\mathbf{i} & \\mathbf{j} & \\mathbf{k} \\\\\n", + "\\frac{\\partial X}{\\partial u} & \\frac{\\partial Y}{\\partial u} & 0 \\\\\n", + "\\frac{\\partial X}{\\partial v} & \\frac{\\partial Y}{\\partial v} & 0\n", + "\\end{vmatrix} \n", + "\\end{equation*}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The probability of getting \\(k\\) heads when flipping \\(n\\) coins is\n", + "### Source\n", + "```\n", + "\\begin{equation*}\n", + "P(E) = {n \\choose k} p^k (1-p)^{ n-k} \n", + "\\end{equation*}\n", + "```\n", + "### Display\n", + "\n", + "$\\begin{equation*}\n", + "P(E) = {n \\choose k} p^k (1-p)^{ n-k} \n", + "\\end{equation*}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## An Identity of Ramanujan\n", + "### Source\n", + "```\n", + "\\begin{equation*}\n", + "\\frac{1}{\\Bigl(\\sqrt{\\phi \\sqrt{5}}-\\phi\\Bigr) e^{\\frac25 \\pi}} =\n", + "1+\\frac{e^{-2\\pi}} {1+\\frac{e^{-4\\pi}} {1+\\frac{e^{-6\\pi}}\n", + "{1+\\frac{e^{-8\\pi}} {1+\\ldots} } } } \n", + "\\end{equation*}\n", + "```\n", + "### Display\n", + "$\\begin{equation*}\n", + "\\frac{1}{\\Bigl(\\sqrt{\\phi \\sqrt{5}}-\\phi\\Bigr) e^{\\frac25 \\pi}} =\n", + "1+\\frac{e^{-2\\pi}} {1+\\frac{e^{-4\\pi}} {1+\\frac{e^{-6\\pi}}\n", + "{1+\\frac{e^{-8\\pi}} {1+\\ldots} } } } \n", + "\\end{equation*}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A Rogers-Ramanujan Identity\n", + "### Source\n", + "```\n", + "\\begin{equation*}\n", + "1 + \\frac{q^2}{(1-q)}+\\frac{q^6}{(1-q)(1-q^2)}+\\cdots =\n", + "\\prod_{j=0}^{\\infty}\\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},\n", + "\\quad\\quad \\text{for $|q|<1$}. \n", + "\\end{equation*}\n", + "```\n", + "### Display\n", + "\n", + "$$\\begin{equation*}\n", + "1 + \\frac{q^2}{(1-q)}+\\frac{q^6}{(1-q)(1-q^2)}+\\cdots =\n", + "\\prod_{j=0}^{\\infty}\\frac{1}{(1-q^{5j+2})(1-q^{5j+3})},\n", + "\\quad\\quad \\text{for $|q|<1$}. \n", + "\\end{equation*}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Maxwell's Equations\n", + "### Source\n", + "```\n", + "\\begin{align}\n", + "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\ \\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n", + "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n", + "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n", + "\\end{align}\n", + "```\n", + "### Display\n", + "\n", + "$\\begin{align}\n", + "\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\ \\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n", + "\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n", + "\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n", + "\\end{align}$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Equation Numbering and References\n", + "\n", + "Equation numbering and referencing will be available in a future version of the Jupyter notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inline Typesetting (Mixing Markdown and TeX)\n", + "\n", + "While display equations look good for a page of samples, the ability to mix math and *formatted* **text** in a paragraph is also important.\n", + "\n", + "### Source\n", + "```\n", + "This expression $\\sqrt{3x-1}+(1+x)^2$ is an example of a TeX inline equation in a [Markdown-formatted](https://daringfireball.net/projects/markdown/) sentence. \n", + "```\n", + "\n", + "### Display\n", + "This expression $\\sqrt{3x-1}+(1+x)^2$ is an example of a TeX inline equation in a [Markdown-formatted](https://daringfireball.net/projects/markdown/) sentence. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other Syntax\n", + "\n", + "You will notice in other places on the web that `$$` are needed explicitly to begin and end MathJax typesetting. This is **not** required if you will be using TeX environments, but the Jupyter notebook will accept this syntax on legacy notebooks. \n", + "\n", + "## Source\n", + "\n", + "```\n", + "$$\n", + "\\begin{array}{c}\n", + "y_1 \\\\\\\n", + "y_2 \\mathtt{t}_i \\\\\\\n", + "z_{3,4}\n", + "\\end{array}\n", + "$$\n", + "```\n", + "\n", + "```\n", + "$$\n", + "\\begin{array}{c}\n", + "y_1 \\cr\n", + "y_2 \\mathtt{t}_i \\cr\n", + "y_{3}\n", + "\\end{array}\n", + "$$\n", + "```\n", + "\n", + "```\n", + "$$\\begin{eqnarray} \n", + "x' &=& &x \\sin\\phi &+& z \\cos\\phi \\\\\n", + "z' &=& - &x \\cos\\phi &+& z \\sin\\phi \\\\\n", + "\\end{eqnarray}$$\n", + "```\n", + "\n", + "```\n", + "$$\n", + "x=4\n", + "$$\n", + "```\n", + "\n", + "## Display\n", + "\n", + "$$\n", + "\\begin{array}{c}\n", + "y_1 \\\\\\\n", + "y_2 \\mathtt{t}_i \\\\\\\n", + "z_{3,4}\n", + "\\end{array}\n", + "$$\n", + "\n", + "$$\n", + "\\begin{array}{c}\n", + "y_1 \\cr\n", + "y_2 \\mathtt{t}_i \\cr\n", + "y_{3}\n", + "\\end{array}\n", + "$$\n", + "\n", + "$$\\begin{eqnarray} \n", + "x' &=& &x \\sin\\phi &+& z \\cos\\phi \\\\\n", + "z' &=& - &x \\cos\\phi &+& z \\sin\\phi \\\\\n", + "\\end{eqnarray}$$\n", + "\n", + "$$\n", + "x=4\n", + "$$" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/What is the Jupyter Notebook.ipynb b/What is the Jupyter Notebook.ipynb new file mode 100644 index 0000000..8534f23 --- /dev/null +++ b/What is the Jupyter Notebook.ipynb @@ -0,0 +1,180 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# What is the Jupyter Notebook?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Jupyter Notebook is an **interactive computing environment** that enables users to author notebook documents that include: \n", + "- Live code\n", + "- Interactive widgets\n", + "- Plots\n", + "- Narrative text\n", + "- Equations\n", + "- Images\n", + "- Video\n", + "\n", + "These documents provide a **complete and self-contained record of a computation** that can be converted to various formats and shared with others using email, [Dropbox](https://www.dropbox.com/), version control systems (like git/[GitHub](https://github.com)) or [nbviewer.jupyter.org](https://nbviewer.jupyter.org)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "### Components" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Jupyter Notebook combines three components:\n", + "\n", + "* **The notebook web application**: An interactive web application for writing and running code interactively and authoring notebook documents.\n", + "* **Kernels**: Separate processes started by the notebook web application that runs users' code in a given language and returns output back to the notebook web application. The kernel also handles things like computations for interactive widgets, tab completion and introspection. \n", + "* **Notebook documents**: Self-contained documents that contain a representation of all content visible in the notebook web application, including inputs and outputs of the computations, narrative\n", + "text, equations, images, and rich media representations of objects. Each notebook document has its own kernel." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Notebook web application" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The notebook web application enables users to:\n", + "\n", + "* **Edit code in the browser**, with automatic syntax highlighting, indentation, and tab completion/introspection.\n", + "* **Run code from the browser**, with the results of computations attached to the code which generated them.\n", + "* See the results of computations with **rich media representations**, such as HTML, LaTeX, PNG, SVG, PDF, etc.\n", + "* Create and use **interactive JavaScript widgets**, which bind interactive user interface controls and visualizations to reactive kernel side computations.\n", + "* Author **narrative text** using the [Markdown](https://daringfireball.net/projects/markdown/) markup language.\n", + "* Include mathematical equations using **LaTeX syntax in Markdown**, which are rendered in-browser by [MathJax](https://www.mathjax.org/)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Through Jupyter's kernel and messaging architecture, the Notebook allows code to be run in a range of different programming languages. For each notebook document that a user opens, the web application starts a kernel that runs the code for that notebook. Each kernel is capable of running code in a single programming language and there are kernels available in the following languages:\n", + "\n", + "* Python(https://github.com/ipython/ipython)\n", + "* Julia (https://github.com/JuliaLang/IJulia.jl)\n", + "* R (https://github.com/IRkernel/IRkernel)\n", + "* Ruby (https://github.com/minrk/iruby)\n", + "* Haskell (https://github.com/gibiansky/IHaskell)\n", + "* Scala (https://github.com/Bridgewater/scala-notebook)\n", + "* node.js (https://gist.github.com/Carreau/4279371)\n", + "* Go (https://github.com/takluyver/igo)\n", + "\n", + "The default kernel runs Python code. The notebook provides a simple way for users to pick which of these kernels is used for a given notebook. \n", + "\n", + "Each of these kernels communicate with the notebook web application and web browser using a JSON over ZeroMQ/WebSockets message protocol that is described [here](https://jupyter-client.readthedocs.io/en/latest/messaging.html#messaging). Most users don't need to know about these details, but it helps to understand that \"kernels run code.\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Notebook documents" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notebook documents contain the **inputs and outputs** of an interactive session as well as **narrative text** that accompanies the code but is not meant for execution. **Rich output** generated by running code, including HTML, images, video, and plots, is embeddeed in the notebook, which makes it a complete and self-contained record of a computation. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you run the notebook web application on your computer, notebook documents are just **files on your local filesystem with a** `.ipynb` **extension**. This allows you to use familiar workflows for organizing your notebooks into folders and sharing them with others." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notebooks consist of a **linear sequence of cells**. There are three basic cell types:\n", + "\n", + "* **Code cells:** Input and output of live code that is run in the kernel\n", + "* **Markdown cells:** Narrative text with embedded LaTeX equations\n", + "* **Raw cells:** Unformatted text that is included, without modification, when notebooks are converted to different formats using nbconvert\n", + "\n", + "Internally, notebook documents are [JSON](https://en.wikipedia.org/wiki/JSON) **data** with **binary values** [base64](https://en.wikipedia.org/wiki/Base64) encoded. This allows them to be **read and manipulated programmatically** by any programming language. Because JSON is a text format, notebook documents are version control friendly.\n", + "\n", + "**Notebooks can be exported** to different static formats including HTML, reStructeredText, LaTeX, PDF, and slide shows ([reveal.js](https://revealjs.com)) using Jupyter's `nbconvert` utility.\n", + "\n", + "Furthermore, any notebook document available from a **public URL or on GitHub can be shared** via [nbviewer](https://nbviewer.jupyter.org). This service loads the notebook document from the URL and renders it as a static web page. The resulting web page may thus be shared with others **without their needing to install the Jupyter Notebook**." + ] + } + ], + "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.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Working With Markdown Cells.ipynb b/Working With Markdown Cells.ipynb new file mode 100644 index 0000000..82f6864 --- /dev/null +++ b/Working With Markdown Cells.ipynb @@ -0,0 +1,369 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Markdown Cells" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Text can be added to Jupyter Notebooks using Markdown cells. You can change the cell type to Markdown by using the `Cell` menu, the toolbar, or the key shortcut `m`. Markdown is a popular markup language that is a superset of HTML. Its specification can be found here:\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Markdown basics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can make text *italic* or **bold** by surrounding a block of text with a single or double * respectively" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can build nested itemized or enumerated lists:\n", + "\n", + "* One\n", + " - Sublist\n", + " - This\n", + " - Sublist\n", + " - That\n", + " - The other thing\n", + "* Two\n", + " - Sublist\n", + "* Three\n", + " - Sublist\n", + "\n", + "Now another list:\n", + "\n", + "1. Here we go\n", + " 1. Sublist\n", + " 2. Sublist\n", + "2. There we go\n", + "3. Now this" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can add horizontal rules:\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is a blockquote:\n", + "\n", + "> Beautiful is better than ugly.\n", + "> Explicit is better than implicit.\n", + "> Simple is better than complex.\n", + "> Complex is better than complicated.\n", + "> Flat is better than nested.\n", + "> Sparse is better than dense.\n", + "> Readability counts.\n", + "> Special cases aren't special enough to break the rules.\n", + "> Although practicality beats purity.\n", + "> Errors should never pass silently.\n", + "> Unless explicitly silenced.\n", + "> In the face of ambiguity, refuse the temptation to guess.\n", + "> There should be one-- and preferably only one --obvious way to do it.\n", + "> Although that way may not be obvious at first unless you're Dutch.\n", + "> Now is better than never.\n", + "> Although never is often better than *right* now.\n", + "> If the implementation is hard to explain, it's a bad idea.\n", + "> If the implementation is easy to explain, it may be a good idea.\n", + "> Namespaces are one honking great idea -- let's do more of those!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And shorthand for links:\n", + "\n", + "[Jupyter's website](https://jupyter.org)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can use backslash \\ to generate literal characters which would otherwise have special meaning in the Markdown syntax.\n", + "\n", + "```\n", + "\\*literal asterisks\\*\n", + " *literal asterisks*\n", + "```\n", + "\n", + "Use double backslash \\ \\ to generate the literal $ symbol." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Headings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can add headings by starting a line with one (or multiple) `#` followed by a space, as in the following example:\n", + "\n", + "```\n", + "# Heading 1\n", + "# Heading 2\n", + "## Heading 2.1\n", + "## Heading 2.2\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Embedded code" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can embed code meant for illustration instead of execution in Python:\n", + "\n", + " def f(x):\n", + " \"\"\"a docstring\"\"\"\n", + " return x**2\n", + "\n", + "or other languages:\n", + "\n", + " for (i=0; i\n", + "\n", + "Header 1\n", + "Header 2\n", + "\n", + "\n", + "row 1, cell 1\n", + "row 1, cell 2\n", + "\n", + "\n", + "row 2, cell 1\n", + "row 2, cell 2\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Local files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you have local files in your Notebook directory, you can refer to these files in Markdown cells directly:\n", + "\n", + " [subdirectory/]\n", + "\n", + "For example, in the images folder, we have the Python logo:\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "and a video with the HTML5 video tag:\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "These do not embed the data into the notebook file, and require that the files exist when you are viewing the notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Security of local files" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that this means that the Jupyter notebook server also acts as a generic file server\n", + "for files inside the same tree as your notebooks. Access is not granted outside the\n", + "notebook folder so you have strict control over what files are visible, but for this\n", + "reason it is highly recommended that you do not run the notebook server with a notebook\n", + "directory at a high level in your filesystem (e.g. your home directory).\n", + "\n", + "When you run the notebook in a password-protected manner, local file access is restricted\n", + "to authenticated users unless read-only views are active." + ] + }, + { + "attachments": { + "pycon-logo.jpg": { + "image/jpeg": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Markdown attachments\n", + "\n", + "Since Jupyter notebook version 5.0, in addition to referencing external file you can attach a file to a markdown cell. \n", + "To do so drag the file from in a markdown cell while editing it:\n", + "\n", + "![pycon-logo.jpg](attachment:pycon-logo.jpg)\n", + "\n", + "Files are stored in cell metadata and will be automatically scrubbed at save-time if not referenced. You can recognized attached images from other files by their url that starts with `attachment:`. For the image above:\n", + "\n", + " ![pycon-logo.jpg](attachment:pycon-logo.jpg)\n", + " \n", + "Keep in mind that attached files will increase the size of your notebook. \n", + "\n", + "You can manually edit the attachment by using the `View > Cell Toolbar > Attachment` menu, but you should not need to. " + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.7.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples_index.rst b/examples_index.rst new file mode 100644 index 0000000..5f3cb08 --- /dev/null +++ b/examples_index.rst @@ -0,0 +1,21 @@ +================= +Notebook Examples +================= + +The pages in this section are all converted notebook files. You can also +`view these notebooks on nbviewer`__. + +__ https://nbviewer.jupyter.org/github/jupyter/notebook/blob/main/ + docs/source/examples/Notebook/ + +.. toctree:: + :maxdepth: 2 + + What is the Jupyter Notebook + Notebook Basics + Running Code + Working With Markdown Cells + Custom Keyboard Shortcuts + Importing Notebooks + Connecting with the Qt Console + Typesetting Equations diff --git a/images/command_mode.png b/images/command_mode.png new file mode 100644 index 0000000..4482de3 Binary files /dev/null and b/images/command_mode.png differ diff --git a/images/dashboard_files_tab.png b/images/dashboard_files_tab.png new file mode 100644 index 0000000..1809d7c Binary files /dev/null and b/images/dashboard_files_tab.png differ diff --git a/images/dashboard_files_tab_btns.png b/images/dashboard_files_tab_btns.png new file mode 100644 index 0000000..b76af88 Binary files /dev/null and b/images/dashboard_files_tab_btns.png differ diff --git a/images/dashboard_files_tab_new.png b/images/dashboard_files_tab_new.png new file mode 100644 index 0000000..d0d02f8 Binary files /dev/null and b/images/dashboard_files_tab_new.png differ diff --git a/images/dashboard_files_tab_run.png b/images/dashboard_files_tab_run.png new file mode 100644 index 0000000..65c7259 Binary files /dev/null and b/images/dashboard_files_tab_run.png differ diff --git a/images/dashboard_running_tab.png b/images/dashboard_running_tab.png new file mode 100644 index 0000000..54f2bd2 Binary files /dev/null and b/images/dashboard_running_tab.png differ diff --git a/images/edit_mode.png b/images/edit_mode.png new file mode 100644 index 0000000..9d52aaa Binary files /dev/null and b/images/edit_mode.png differ diff --git a/images/menubar_toolbar.png b/images/menubar_toolbar.png new file mode 100644 index 0000000..c22d960 Binary files /dev/null and b/images/menubar_toolbar.png differ diff --git a/images/nbconvert_arch.png b/images/nbconvert_arch.png new file mode 100644 index 0000000..27cd69b Binary files /dev/null and b/images/nbconvert_arch.png differ diff --git a/nbpackage/__init__.py b/nbpackage/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/nbpackage/mynotebook.ipynb b/nbpackage/mynotebook.ipynb new file mode 100644 index 0000000..191e181 --- /dev/null +++ b/nbpackage/mynotebook.ipynb @@ -0,0 +1,69 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# My Notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def foo():\n", + " return \"foo\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def has_ip_syntax():\n", + " listing = !ls\n", + " return listing" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def whatsmyname():\n", + " return __name__" + ] + } + ], + "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.5.1+" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/nbpackage/nbs/__init__.py b/nbpackage/nbs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/nbpackage/nbs/other.ipynb b/nbpackage/nbs/other.ipynb new file mode 100644 index 0000000..43825b8 --- /dev/null +++ b/nbpackage/nbs/other.ipynb @@ -0,0 +1,46 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Other notebook\n", + "\n", + "This notebook just defines `bar`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def bar(x):\n", + " return \"bar\" * x" + ] + } + ], + "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.5.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}