Mouse Vs Python

Creating Presentations with Jupyter Notebook

Jupyter Notebook can be turned into a slide presentation that is kind of like using Microsoft Powerpoint, except that you can run the slide’s code live! It’s really neat how well it works. The only con in my book is that there isn’t a lot of theming that can be applied to your slides, so they do end up looking a bit plain.

In this article, we will look at two methods of creating a slideshow out of your Jupyter Notebook. The first method is by using Jupyter Notebook’s built-in slideshow capabilities. The second is by using a plug-in called RISE .

Let’s get started!

Note: This article assumes that you already have Jupyter Notebook installed. If you don’t, then you might want to go to their website and learn how to do so.

The first thing we need to do is to create a new Notebook. Once you have that done and running, let’s create three cells so that we can have three slides. Your Notebook should now look like the following:

how to make a presentation in jupyter notebook

Now let’s turn on the “slideshow” tools. Go to the View menu and then click on the Cell Toolbar menu option. You will find a sub-menu in there that is called Slideshow . Choose that. Now your Notebook’s cell should look like this:

how to make a presentation in jupyter notebook

There are now little comboboxes on the top right of each cell. These widgets give you the following options:

You can just create a series of Slides if you like, but you can make the slideshow a bit more interesting by adding Sub-Slides and Fragments. Sub-slides are just slides that are below the previous one while Fragments are basically fragments within the previous slide. As an aside, I have actually never used Fragments myself. Anyway you can also set a slide to Skip, which just allows you to skip a slide or Notes, which are just speaker notes.

Let’s add some text to our first cell. We will add the text “# Hello Slideshow” to it and set the cell type to Markdown. Note the pound sign at the beginning of the text. This will cause the text to be a heading.

In cell two, we can add a simple function. Let’s use the following code:

For the last cell, we will add the following text:

Make sure you set that to be a Markdown cell as well. This is what my cells ended up looking like when I was done:

how to make a presentation in jupyter notebook

To make things simple, just set each of the cell’s individual comboboxes to Slide .

Now we just need to turn it into an actual slideshow. To do that, you will need save your Notebook and shut down the Jupyter Notebook server. Next you will need to run the following command:

how to make a presentation in jupyter notebook

To navigate your slideshow, you can use your left and right arrow keys or you can use spacebar to go forward and shift_spacebar to go back. This creates a pretty nice and simple slideshow, but it doesn’t allow you to run the cells. For that, we will need to use the RISE plugin!

Getting Started with RISE

Reveal.js – Jupyter/IPython Slideshow Extension (RISE) is a plugin that uses *reveal.js* to make the slideshow run live. What that means is that you will now be able to run your code in the slideshow without exiting the slideshow. The first item that we need to learn about is how to get RISE installed.

Installing rise with conda

If you happen to be an Anaconda user, then this is the method you would use to install RISE:

This is the easiest method of installing RISE. However most people still use regular CPython, so next we will learn how to use pip!

Installing rise with pip

You can use Python’s pip installer tool to install RISE like this:

You can also do `python -m pip install RISE` is you want to. Once the package is installed, you have a second step of installing the JS and CSS in the proper places, which requires you to run the following command:

If you somehow get a version of RISE that is older than 5.3.0, then you would also need to enable the RISE extension in Jupyter. However, I recommend just using the latest version so you don’t have to worry about that.

Using RISE for a SlideShow

Now that we have RISE installed and enabled, let’s re-open the Jupyter Notebook we created earlier. Your Notebook should now look like this:

how to make a presentation in jupyter notebook

You will notice that I circled a new button that was added by RISE to your Notebook. If you mouse over that button you will see that it has a tooltip that appears that says “Enter/Exit RISE Slideshow”. Click it and you should see a slideshow that looks a lot like the previous one. The difference here is that you can actually edit and run all the cells while in the slideshow. Just double-click on the first slide and you should see it transform to the following:

how to make a presentation in jupyter notebook

After you are done editing, press SHIFT+ENTER to run the cell. Here are the primary shortcuts you will need to run the slideshow effectively:

  • SPACEBAR – Goes forward a slide in the slideshow
  • SHIFT+SPACEBAR – Goes back a slide in the slideshow
  • SHIFT+ENTER – Runs the cell on the current slide
  • DOUBLE-CLICK – To edit a Markdown cell

You can view all the Keyboard shortcuts by going to the Help menu when not in Slideshow mode and clicking the Keyboard Shortcuts option. Most if not all of these shortcuts should work inside of a RISE slideshow.

If you want to start the slideshow on a specific cell, just select that cell and then press the Enter Slideshow button.

RISE also works with Notebook widgets. Try creating a new cell with the following code:

Now start the slideshow on that cell and try running the cell (SHIFT+ENTER). You should see something like this:

how to make a presentation in jupyter notebook

You can use RISE to add neat widgets, graphs and other interactive elements to your slideshow that you can edit live to demonstrate concepts to your attendees. It’s really quite fun and I have used RISE personally for presenting intermediate level material in Python to engineers.

RISE also has several different themes that you can apply as will as minimal support for slide transitions. See the documentation for full information.

Wrapping Up

In this chapter we learned about two good methods for creating presentations out of our Jupyter Notebooks. You can use Jupyter directly via their nbconvert tooling to generate a slideshow from the cells in your Notebook. This is nice to have, but I personally like RISE better. It makes the presentations so much more interactive and fun. I highly recommend it. You will find that using Jupyter Notebook for your presentations will make the slides that much more engaging and it is so nice to be able to fix slides during the presentation too!

Related Reading

  • Presenting code using Jupyter Notebook
  • The RISE Github page
  • Jupyter nbconvert Usage
  • How to build interactive presentations with Jupyter Notebook and Reveal JS

4 thoughts on “Creating Presentations with Jupyter Notebook”

Pingback: Jupyter Notebook Extension Basics | The Mouse Vs. The Python

Pingback: Creating Jupyter Notebook Widgets with interact - The Mouse Vs. The Python

Pingback: How to Export Jupyter Notebooks into Other Formats - The Mouse Vs. The Python

Pingback: Jupyter Notebook Extension Basics - The Mouse Vs. The Python

Comments are closed.

  • presentation

Create Presentation from Jupyter Notebook

Create Presentation from Jupyter Notebook

You don't need to install any additional framework to make a presentation from Jupyter Notebook. Jupyter is using Reveal.js library for creating slides. However, I strongly recommend to install RISE ( R eveal.js I Python S lideshow E xtension) extension. It greatly simplifies the process of slide creation with a live preview.

The outline for this article:

  • create a simple notebook with one chart,
  • convert notebook to a slideshow,
  • presentation development with RISE extension,
  • parameterized presentations,
  • publishing presentation.

Create Jupyter Notebook

Let's create a Jupyter notebook. It will have a few Markdown and Python cells.

Example Notebook

Please notice that we can mix Python variables with Markdown thanks to IPython.display.Markdown() function:

The output of the above code cell will contain a Markdown. There is a simple scatter plot in the notebook for randomly generated points:

The matplotlib scatter plot:

Scatter Plot from Notebook

It is a simple notebook created for example purposes. There is no limit on the number of slides or cells. From my experience, I was creating a presentation with more than 70 slides with many plots/images, and the slideshow was working smoothly, even with the presentation published as a website (hosted in the cloud).

Create Presentation

The notebook is saved in ipynb format . The next step is to convert it to a slideshow. We need to provide information on how to use cells in the presentation. Please click View ➡️ Cell Toolbar ➡️ Slideshow .

Cell Toolbar in Jupyter Notebook, Please select Slideshow

Each cell will have a toolbar with the select widget. You can select there how cells will be used in the presentation:

  • Slide - the cell will be a new slide;
  • Sub-Slide - the cell will be shown in the current slide as a replacement for previous content. It will be available in arrow-down navigation;
  • Fragment - the cell will appear in the current slide, it will append to the previous content. It will be available in arrow-down and arrow-right navigation;
  • Skip - the content will not be displayed in the presentation;
  • Notes - notes for slide, the cell content is not displayed in the presentation;

Please select the Slide Type for every cell and save the notebook.

Cells with selected Slide Type

How to create a presentation for Jupyter Notebook? We need to use the nbconvert tool. It is installed with Jupyter Notebook. There is a command for converting notebook to presentation:

You can open the output file presentation.slides.html in the web browser (just double-click on the file). Alternatively, you can serve slides with jupyter ; slides will be available at http://127.0.0.1:8000/presentation.slides.html :

There are several ways to hide the code in the presentation, one of them is to pass --no-input parameter to nbconvert :

The presentation with hidden code:

It is possible to convert the Jupyter Notebook presentation into PDF slides. One of the ways to do this is to add ?print-pdf in the URL in a web browser while displaying HTML format:

The presentation will be in a format ready to print. To save it as a PDF, just print the website with Save as PDF selected for the destination.

Jupyter Notebook Presentation save as PDF

RISE Extension

There is a RISE extension that may be helpful for developing presentations in Jupyter Notebook. It can be easily installed with pip or conda :

You get a small chart icon in the top toolbar after installation. You switch between the notebook and presentation views by clicking on the chart icon.

What is more, you can edit the code in presentation mode. The RISE extension doesn't have the option to hide the code ( GitHub issue discussion about hiding code feature in RISE repository ). If you would like to hide/show the code during the presentation development, you need to install an additional extension called hide_code .

Parameterized Presentation

What if you would like to change or recompute charts in the presentation based on user input? There is an open-source framework called Mercury that makes it possible.

You can easily add interactive widgets to the presentation and publish it with Mercury . Widgets are added based on the YAML header. They are directly connected with Python variables in the notebook. User changes, tweak widgets, and execute the notebook with new values. The slides in the presentation will be automatically recomputed.

The video from an interactive presentation about Mercury :

Publishing Presentation

The final presentation is in HTML format. You can publish it as a static website. There are several ways to publish Jupyter Notebook; you can host it on GitHub Pages, Netlify, or Vercel. If you are using Mercury framework for parameterized presentations, you can host it in the cloud (soon, there will be available online service runmercury.com for hosting notebooks).

Jupyter Notebook Presentations might be a great alternative to traditional presentation software. You will save time by building the presentation in the same environment where your code is. Any update in code or chart change will immediately affect the presentation - no need to manually copy-paste results. The parameterized presentation can take your slides one step further. Imagine your supervisor or manager playing with your slides and recomputing new charts.

Create interactive slides with Python in 8 Jupyter Notebook cells

Creating presentations in Jupyter Notebook is a great alternative to manually updating slides in other presentation creation software. If your data changes, you just re-execute the cell and slide chart is updated.

Jupyter Notebook is using Reveal.js (opens in a new tab) for creating slides from cells. The standard approach is to write slides code and Markdown in the Jupyter Notebook. When notebook is ready, it can be exported to standalone HTML file with presentation.

What if, you would like to update slides during the slide show? What is more, it would be fantastic to have interactive widgets in the presentation. You can do this in Mercury framework.

In this tutorial, we will create an interactive presentation in Jupyter Notebook and serve it with Mercury.

Create presentation in notebook

Please enable Slideshow toolbar in Jupyter Notebook. It can be done by clicking View -> Cell Toolbar -> Slideshow . It is presented in the screenshot below:

Enable cell toolbar

We will need following packages to create presentation in Python notebook:

Please make sure that they are installed in your environment.

1. Import packages and App setup

The first step is to import packages and setup Mercury App :

We setup title and description for App object.

Please note that we set Slide Type to Skip . This cell will not appear in the presentation.

2. Add title

The second cell is a Markdown with title:

The Slide Type is set to Slide . It is our first slide!

3. Add slide with Markdown

Add new Markdown cell with the following cell.

Please set Slide Type to Slide . It will be a second slide. I'm using ## as slide title ( # will produce too large title in my opinion).

4. Add Mercury Widget

Please add code cell with Text widget. We will use it, to ask users about their name.

We set Slide Type as Skip , so this cell will not appear in the presentation.

5. Display name

Let's use the name.value in the slide. Please add a code cell. We will display a Markdown text with Python variables by using Markdown function from Mercury package.

Please set the Slide Type to Slide .

You can display Markdown with Python variables by calling mr.Markdown() or mr.Md() functions. Both do the same.

The first five cells of the notebook:

Notebook code for presentation in Jupyter Notebook

You can enter your name in the widget during the notebook development. There will be no change in other cells. If you want to update the cell with new widget value, please execute it manually.

6. More widgets

We can add more widgets to the presentation. They will be used to control chart in the next slide.

We have used Slider and Select widgets. They are displayed in the notebook. This cell will not be displayed in the presentation, so set Slide Type to Skip .

7. Scatter plot

We will add a new code cell. It will have Slide Type set to Slide .

We used widgets values by accessing them with samples.value and color.value .

Screenshot of the notebook with scatter plot:

Notebook code for presentation in Jupyter Notebook

8. Final slide

Please add a last Markdown cell. Its Slide Type will be set to Slide :

Please notice that link is added with HTML syntax. There is a target="_blank" used to open link in a new tab.

Run presentation in Mercury

Please run Mercury local server in the same directory as notebook:

The above command will open a web browser at http://127.0.0.1:8000 . Please click on a card with presentation.

You can navigate between slides with arrows in the bottom right corner. You can enter the full screen mode by pressing F on the keyboard. Please use Esc to exit full screen mode.

You can change widgets values in the sidebar and presentation slides will be automatically recomputed:

You can export your slides as PDF or HTML by clicking Download button in the sidebar.

Create a slide deck using Jupyter Notebooks

Person reading a book and digital copy

There are many options when it comes to creating slides for a presentation. There are straightforward ways, and generating slides directly from Jupyter is not one of them. But I was never one to do things the easy way. I also have high expectations that no other slide-generation software quite meets.

Why transition from slides to Jupyter?

I want four features in my presentation software:

  • An environment where I can run the source code to check for errors
  • A way to include speaker notes but hide them during the presentation
  • To give attendees a useful handout for reading
  • To give attendees a useful handout for exploratory learning

More Great Content

  • Free online course: RHEL technical overview
  • Learn Advanced Linux Commands
  • Download Cheat Sheets
  • Find an Open Source Alternative
  • Read Top Linux Content
  • Check out open source resources

There is nothing more uncomfortable about giving a talk than having someone in the audience point out that there is a coding mistake on one of my slides. Often, it's misspelling a word, forgetting a return statement, or doing something else that becomes invisible as soon as I leave my development environment, where I have a linter running to catch these mistakes.

After having one too many of these moments, I decided to find a way to run the code directly from my slide editor to make sure it is correct. There are three "gotchas" I needed to consider in my solution:

  • A lot of code is boring. Nobody cares about three slides worth of import statements, and my hacks to mock out the socket module distract from my point. But it's essential that I can test the code without creating a network outage.
  • Including boilerplate code is almost as boring as hearing me read words directly off of the slide. We have all heard (or even given) talks where there are three bullet points, and the presenter reads them verbatim. I try to avoid this behavior by using speaker notes.
  • There is nothing more annoying to the audience when the talk's reference material doesn't have any of the speaker notes. So I want to generate a beautiful handout containing all of my notes and the slides from the same source. Even better, I don't want to have slides on one handout and a separate GitHub repository for the source code.

As is often the case, to solve this issue, I found myself reaching for JupyterLab and its notebook management capabilities.

Using Jupyter Notebooks for presentations

I begin my presentations by using Markdown and code blocks in a Jupyter Notebook, just like I would for anything else in JupyterLab. I write out my presentation using separate Markdown sections for the text I want to show on the slides and for the speaker notes. Code snippets go into their own blocks, as you would expect.

Because you can add a "tag" to cells, I tag any cell that has "boring" code as no_markdown .

Using tags in Jupyter Notebook

(Moshe Zadka, CC BY-SA 4.0 )

Then I convert my Notebook to Markdown with:

There are ways to convert Markdown to slides —but I have no idea how to use any of them and even less desire to learn. Plus, I already have my favorite presentation-creation tool: Beamer .

But Beamer requires custom LaTeX, and that is not usually generated when you convert Markdown to LaTeX. Thankfully, one Markdown implementation– Pandoc Markdown —has a feature that lets me do what I want. Its raw_attribute extension allows including "raw" bits of the target format in the Markdown.

This means if I run pandoc on the Markdown export from a notebook that includes raw_attribute LaTeX bits, I can have as much control over the LaTeX as I want:

The --listings makes pandoc use LaTeX's listings package, which makes code look much prettier. Putting those two pieces together, I can generate LaTeX from the notebook.

Through a series of conversion steps, I was able to hide the parts I wanted to hide by using:

  • LaTeX raw_attribute bits inside Jupyter Notebook's Markdown cells
  • Tagging boring cells as no_markdown
  • Jupyter's "nbconvert" to convert the notebook to Markdown
  • Pandoc to convert the Markdown to LaTeX while interpolating the raw_attribute bits
  • Beamer to convert the Pandoc output to a PDF slide-deck
  • Beamer's beamerarticle mode

All combined with a little bit of duct-tape, in the form of a UNIX shell script, to produce slide-deck creation software. Ultimately, this pipeline works for me. With these tools, or similar, and some light UNIX scripting, you can make your own customized slide created pipeline, optimized to your needs and preferences.

What is the most complicated pipeline you have ever used to build a slide deck? Let me know about it—and whether you would use it again—in the comments.

Polaroids and palm trees

Edit images with Jupyter and Python

Who needs to learn an image-editing application when you can do the job with open source tools you already know?

How to write a web service using Python Flask

JupyterLab teaches Python developers magic

JupyterLab, the successor to Jupyter Notebook, feels like playing video games with the cheat codes enabled.

Blender Hotkey Cheat Sheet

Markdown beginner's cheat sheet

Learn Markdown syntax to be ready to contribute to open source software.

Moshe sitting down, head slightly to the side. His t-shirt has Guardians of the Galaxy silhoutes against a background of sound visualization bars.

Related Content

Real python in the graphic jungle

Natalie B. Hogg

Cosmologist

Using a Jupyter notebook to make presentation slides

how to make a presentation in jupyter notebook

  • Open a blank Jupyter notebook.
  • Add a cell and convert it to Markdown (either esc + m ) or by using the drop down menu at the top of the notebook.
  • Add your text, equation or image to the cell (images can be added via the edit menu, though some HTML tags may be needed to render and/or resize the image).
  • Choose a slide type in the drop down menu of the cell itself (slide, sub-slide, fragment, skip or notes).
  • Save the notebook.
  • In the terminal, run jupyter nbconvert *.ipynb --to slides .
  • Open the resulting .html file in a browser and use the arrow keys to navigate.

I turn coffee Lapsang Souchong tea into code; if you found this post useful you can contribute to my habit here: https://ko-fi.com/nataliebhogg .

I’m in a strange kind of limbo at the moment. I’m not being paid, since I can’t sign my new contract without being physically present in Spain. And, until the 30th of March, it was physically impossible to enter Spain unless you were a Spanish resident, since the borders were closed due to Covid restrictions. Due to Brexit, I also need a visa in order to be able to stay in Spain for more than ninety days and to legally work there. So, I have an appointment at the Spanish consulate in London on Friday to submit my visa application. I’m hoping for a quick decision so I can book a flight, get to Madrid, sign my contract and start working (and drawing a salary). But, until then, I’m in this strange, semi-working state.

I could have taken this time off completely, but with the UK in lockdown and everything shut, I know I would have quickly got bored in the face of a two or three month holiday with nothing to do and nowhere to go. So, I resolved to keep working, despite the lack of pay, albeit at a reduced pace. I’ve been attending journal clubs and mainly working on turning a chapter of my PhD thesis into a paper.

As a result, it was nice to take a full five days off over the Easter weekend. I finished reading three books: Island of Dreams by Dan Boothby (ok if you are interested in Gavin Maxwell, Scotland or otters), The Nine Tailors by Dorothy L. Sayers (which I highly recommend!) and Never Split the Difference by Chris Voss (probably only useful if you’re a hostage negotiator or someone working in big business). It was a conscious decision to try and read more and I’m glad it paid off. I always forget how refreshed I feel after even just a couple of days off from work.

This morning I finished making my slides for my talk at Britgrav next week. I’m going to be presenting my work from a few months ago on how the distance duality relation can be constrained with standard sirens and how modified gravity effects can bias this type of analysis. I tend to use either Google Slides or LaTeX Beamer to make presentations, depending on the content and audience, but this time I decided to use Markdown in a Jupyter Notebook which I then converted to HTML.

how to make a presentation in jupyter notebook

This produces very clean looking slides, and it’s easy to write LaTeX commands too (unlike in Google Slides).

how to make a presentation in jupyter notebook

The process I followed to create the slides is very simple.

The same week that I’m giving this talk, I’m also presenting the H0 review paper by Di Valentino et al (we’re having a special H0 tension week, as someone else is going to present Efstathiou’s recent offering on the same topic) and the following week I’ve been invited to give a seminar at my old undergraduate institution, Aberystwyth University, which I’m really looking forward to.

Share this:

  • Click to share on Twitter (Opens in new window)
  • Click to share on Facebook (Opens in new window)

Natalie Hogg

Leave a comment Cancel reply

Create a website or blog at WordPress.com

' src=

  • Already have a WordPress.com account? Log in now.
  • Subscribe Subscribed
  • Copy shortlink
  • Report this content
  • View post in Reader
  • Manage subscriptions
  • Collapse this bar

Creating Interactive Slideshows in Jupyter Notebooks

May 23, 2019

how to make a presentation in jupyter notebook

Have you ever wanted to create a slideshow using Python? I’ve found a lot of useful tools for making slideshows in Jupyter Notebooks while developing Python for data science workshops for the University of Cincinnati and 84.51° , but I’m yet to see all of this information in one place. This blog post changes that by directly teaching you how to create interactive slideshows in Jupyter Notebooks.

This post covers the benefits of using Python and Jupyter to create slideshows and how to set up the technology, create a slideshow, and view/operate the created slideshow.

Why to create slideshows in Python and Jupyter

Using Python and Jupyter Notebooks to create slideshows has many benefits:

  • Version control your slideshows
  • Make your slideshows dynamic
  • Share your code in group settings
  • Maintain a single analysis/presentation document

While there are many other benefits to using Python and Jupyter Notebooks to create, these reasons alone are rather convincing - especially given how easy creating the slideshows is.

What you need to already know

Creating slideshows is easy, but only if you know a few of the basics. This tutorial assumes you have a working knowledge of basic Python, Jupyter Notebooks, and the command line. In addition, it will be helpful to have experiences installing and working with Jupyter Notebooks extensions and Python packages.

If you don’t already have this knowledge, that’s alright - you should still be able to follow most of this tutorial if you have Python and Jupyter Notebooks installed.

How to set up the tech

Installing python and jupyter notebooks.

If you don’t already have Python and Jupyter Notebooks installed, the first thing you’ll need to do is install them. I recommend using Anaconda Navigator for a fast and easy setup. Anaconda’s installation instructions are easy to follow.

Installing RISE

RISE , developed by Damian Avila, is the best slideshow engine I’ve found for Python and Jupyter Notebooks. It stands for Reveal.js IPython/Jupyter Slideshow Extension.

In order to install RISE, you’ll need to use the command line. If you’ve installed Anaconda, you can use:

Otherwise, you can install with pip :

You won’t interact directly with RISE. Instead, you’ll be able to access it through Jupyter Notebooks.

How to create a slideshow

Enabling slideshow mode.

In order to create a slideshow, you’ll need to start Jupyter Notebooks and open a new notebook (note that you must do this after you’ve installed RISE). Once you have a fresh Jupyter Notebook, you’ll need to enable the slideshow. You can do this by doing the following:

  • Click on “View” in the Jupyter toolbar
  • Hover over “Cell Toolbar” in the “View” menu
  • Click on “Slideshow” in the “Cell Toolbar” menu

how to make a presentation in jupyter notebook

You’ve now enabled slideshow mode.

Creating the slides with cells

At this point, you should you a cell toolbar with a dropdown menu on the right-side:

how to make a presentation in jupyter notebook

You should see six options here. This dropdown and its options determine how each cell fits into the slideshow. These The options and their descriptions are below:

  • slide - indicates that the selected cell should be the start of a new slide
  • sub-slide - indicates that the selected cell should be the start of a new sub-slide, which appears in a new frame beneath the previous slide
  • fragment - indicates that the selected cell should appear as a build to the previous slide
  • skip - indicates that the selected cell should be skipped and not be a part of the slideshow
  • notes - indicates that the selected cell should just be presenter notes
  • - - indicates that the selected cell should follow the behavior of the previous cell, which is useful when a markdown cell and a code cell should appear simultaneously

Each of these options can include Python code or markdown/HTML/LaTeX code like a traditional Jupyter Notebook.

Viewing and operating the slideshow

Viewing the slideshow.

Once cells have been used to create slide material for the slideshow, the slideshow can be viewed from directly within the notebook.

There are two options to view the slideshow:

  • Using the OPTION + R shortcut ( ALT + R on Windows) to enter and exit presentation mode from within the notebook
  • Clicking the “Presentation Mode” button frmo within the notebook - this will only appear if you’ve installed RISE

how to make a presentation in jupyter notebook

After entering presentation mode, you should see a screen that looks like this:

how to make a presentation in jupyter notebook

This means the presentation is active.

Operating the slideshow

Changing slides

While it may be tempting to use the <- and -> keys to change slides in the slideshow, this will not fully work - it will skip the cells marked as sub-slides. Instead, SPACE should be used to move the slideshow forward and SHIFT + SPACE should be used to move the slideshow backward.

There are many other keyboard shortcuts that can be accesed within the slideshow by clicking the question mark in the bottom-left corner.

Running code and editing on-the-fly

One of the great things about RISE is that it work in a live Python session - that means you can edit and run code while the presentation is running!

If a code cell is marked as slide, sub-slide, fragment, or -, it will appear in the slideshow as editable and runnable. Here’s an example:

Further resources

If you’re interested in learning more about creating slideshows in Jupyter, stay tuned for additional posts.

You can also view an example here of a training slideshow created using Python, Jupyter Notebooks, and RISE.

Nikolai Janakiev

Freelance Data Scientist and Data Engineer with a focus on Python, geospatial applications, routing, and all things data.

© 2023. All rights reserved.

home · about · projects

how to make a presentation in jupyter notebook

Creating Slides with Jupyter Notebook

Table of contents, preparation, convert slides for reveal.js, serve slides with https server, export as pdf.

Jupyter notebook is a powerful tool to interactively code in web-based notebooks with a whole plethora of programming languages. With it, it is also possible to create web-based slideshows with reveal.js .

The slides functionality is already included in Jupyter Notebook, so there is no need to install plugins. Although slides do not work at the time of writing for JupyterLab . To open the slides toolbar for each cell in your Jupyter Notebook, enable it via View > Cell Toolbar > Slideshow :

Jupyter Slides Toolbar

Now you can specify for each cell what kind of slide type you want. The available types are Slide (new slide), Sub-Slide (new slide below last one), Fragment (fragment within previous slide), Skip (skip this cell) and Notes (adding speaker notes):

Jupyter Slides Toolbar

You can now convert the notebook with the jupyter-nbconvert command line tool and the --to slides option. First, you need to add/clone reveal.js into your folder with the presentation ( git clone https://github.com/hakimel/reveal.js/ ) and then you can run the command:

If you want to enable scrolling you can add the following to the jupyter nbconvert command (thanks to Hannah Augustin for the hint):

It is also possible serve slides with an https server by using the --post serve option as in the command:

This will run a server which opens the presentation in your browser ready for presentation. Another neat thing is RISE , a Jupyter slideshow extension that allows you to instantly turn your Jupyter Notebooks into a slideshow with the press of a button in your notebook:

Jupyter Slides RISE

Finally, if you want to create a PDF from your slides, you can do that by adding ?print-pdf to the url of the previously hosted slides:

After opening this url, you can now print the page to PDF. You can find other configuration options in the nbconvert documentation .

Happy presenting!

Related Posts

Installing and running jupyter on a server 12 feb 2019, manage jupyter notebook and jupyterlab with systemd 10 nov 2020, remove jupyter notebook output from terminal and when using git 06 nov 2021.

Presenting with Jupyter Notebooks

The best way to walk through this tutorial is using the accompanying jupyter notebook:.

[ Jupyter Notebook ]

In the last year I’ve started presenting work using Jupyter Notebooks, rebelling against the Bill Gates'-driven status-quo. Here I’ll explain how to do it. It’s not difficult, but in my opinion makes presentations look slicker, whilst allowing you to run code live in a presentation if you like. First, we need to download the plug-in that gives us the presentation functionality, it’s called RISE . We can do this easily using pip in a terminal window:

Once installed, our first move is to add the presentation toggles to our notebook cells. We do this by clicking View in the menu bar, then Cell Toolbar , then Slideshow :

Adding Presentation Toggles to Cells

Slide types.

This adds a Slide Type dropdown to each cell in the notebook. Here we can choose one of five options:

  • Slide : Used to start a new chapter in your presentation, think of this as a section heading in LaTeX.
  • Sub-slide : Slide falling within the chapter defined by a Slide cell.
  • Fragment : this is to split the contents of one slide into pieces; a cell marked as a fragment will create a break inside the slide; it will not show up right away, you will need to press Space one more time to see it.
  • Skip : Skips cell when in presenter mode.
  • Notes : Cell that allows the author to write notes on a slide that aren’t shown in presenter view.

As with any notebook, we can define the cell type to be either Markdown or Code . As you’d expect, we present any text or image-based slide in Markdown , reserving the Code cell type if and only if we want to explicitly run some code in the presentation. If you aren’t familiar, Markdown is a straightforward language for text formatting; I won’t go into the details here, but suffice to say you can learn the basics of Markdown in 5 minutes. You can find a useful cheatsheet here .

Adding images is easy too. I advise creating a sub-directory in your working directory called /images and storing anything you want to present there. Then you display them in a markdown file using some simple HTML syntax:

<img class="" src="images/london_deaths.jpeg" style="width:75%">

You can manipulate the style attribute to change the size of the image. Don’t worry, this is the only HTML you need to know!

how to make a presentation in jupyter notebook

Entering Presentation Mode

To view your slideshow click on the bar-chart button in the menu bar. This will start the presentation from the cell currently selected:

That’s it! This tutorial has given you an introduction to the basics of RISE for presenting with Jupyter Notebooks, you can of course customise these to your heart’s content using further plug-ins and more advanced Markdown. Here’s a summary of the useful links from this document to finish:

  • RISE Documentation
  • Markdown Cheatsheet
  • Markdown Table Generator

Twitter: @enjeeneer

Website: https://enjeeneer.io/.

  • Alumni & Careers
  • News & Events

The Hong Kong University of Science and Technology

Turn your Jupyter Notebook into interactive Presentation Slides using Anaconda

Table of contents, download our sample and try it yourself, 1. open powershell prompt in anaconda, 2. change directory to current folder, 3. type jupyter nbconvert command, 1. enable slideshow view, explanation of each “slide type”, 3. add tag to hide code of charts on the slide, next article – host html file online.

In our “Learn Python From Zero For Absolute Beginner” series , you have learnt how to use Python to do some data manipulation tasks and create interactive charts using Plotly within Jupyter Notebook. After completing your analysis, it is common that you will need to deliver a presentation to present your findings. Traditionally, this might involve manually capturing screenshots of your notebook’s code and charts, and creating static slides using PowerPoint or Canva for your presentation. However, there is a more time-saving and dynamic approach, allowing you to convert your Jupyter Notebook into interactive slides . You can showcase your code , visualizations, and insights while retaining the interactivity of the Plotly charts you created. Give a try to this approach and captivate your audience with an interactive presentation experience derived directly from your Jupyter Notebook! At the end of this article, you will be able to convert your Jupyter Notebook (.ipynb file) to one single HTML file . By double clicking the HTML file, you can view your Jupyter Notebook content as below in the browser:

Before we proceed with configuring the settings in Anaconda to transform cells into slides, let’s first walk through the straightforward process of converting an .ipynb file to an HTML file .

To help you grasp the speed and simplicity of this conversion, please download our sample Jupyter Notebook (.ipynb file) here and follow the steps outlined below.

You may find the content in this .ipynb file familiar if you have been following our “Learn Python From Zero For Absolute Beginners” series as we have taken code snippets from the first two lessons and compiled them into this .ipynb file.

Preview of jupyter slide ipynb sample file

Convert ipynb file to HTML file

Open Powershell Prompt in Anaconda

If you need guidance on how to install or use Anaconda, you can refer to our previous article here .

If you are a Mac user, you have the advantage of utilizing the Terminal directly on your Mac for the subsequent steps.

Terminal in Mac

  • Windows user: Powershell Prompt in Anaconda
  • Mac user: Terminal in Mac

In the Powershell Prompt window or Terminal, use the cd command to change directory to the folder that you stored the .ipynb file.

Method 1: Using command below

Method 2: Drag and drop

Drag and drop the folder where storing the .ipynb file to the Powershell Prompt window or Terminal after typing cd .

Type the command below in the Powershell Prompt window. You may change sample.ipynb to the filename of your .ipynb file. This command uses nbconvert tool to convert an .ipynb notebook file into various static formats like HTML.

If you are using Terminal in Mac, you may need to execute the following command before executing the jupyter nbconvert command.

After executing the jupyter nbconvert command, an HTML file will be automatically generated in the current folder ( sample.slides.html in this case). The generated HTML file retains the content and structure of the ipynb Notebook, now conveniently presented in a slide format. One notable advantage is that the generated HTML file has a relatively small file size, which is beneficial for sharing and transferring files.

If you have a good understanding of HTML, you can further customize the generated HTML file, making modifications to the styling or content of the slides.

ouput after converted the ipynb file to html file

Configure settings in Jupyter Notebook to transform cells into slides

Before proceeding with the conversion process to HTML as outlined above, you need to make some configurations in Jupyter Notebook using Anaconda .

This configuration allows you to selectively choose which cells to display , ensuring that only the relevant content appears in the HTML output, showcasing the most important code snippets, explanations, and visualizations. This flexibility empowers you to tailor the HTML slides to your specific needs and deliver a concise and impactful presentation to your audience.

In the menu bar, click “ View ” → “ Cell Toolbar ” → “ Slideshow “.

how to make a presentation in jupyter notebook

2. Select Slide Type for each cell

After enabling the slideshow view, you can now select the “Slide Type” of each cell at the top right hand corner.

how to make a presentation in jupyter notebook

If you prefer showcasing charts or visualizations on the slides without including the corresponding code, you can assign specific tags to the desired cells.

In the menu bar, click “ View ” → “ Cell Toolbar ” → “ Tags “.

how to make a presentation in jupyter notebook

Type to_remove in the top right hand corner of the cell, and click “ Add tag “.

add tag in Jupyter Notebook

After configured each cell in Jupyter Notebook using Anaconda, you can now follow the steps in the previous section “Convert ipynb file to HTML file” to turn your Jupyter Notebook into interactive HTML Presentation Slides. The generated output is a single HTML file, making it incredibly convenient to share and save on a USB drive. Simply double-click on the HTML file to open it in any web browser. This portability and accessibility make it ideal for presenting in a classroom setting too. Good luck on your presentation!

As the converted file is in HTML format, you can also choose to host it as a website online like below. In our upcoming article, we will guide you through the process of hosting your HTML file on GitHub Pages. Stay tuned!

Kam, M. (2020, June 28). Creating an interactive presentation with Jupyter Notebook and Plotly. Things Michael Thinks. https://www.michaelkam.id/data-visualisation/2020/06/28/creating-an-interactive-presentation-with-jupyter-notebook-and-plotly.html

Krishnamurthy, D. (2015, December 5). Jupyter Notebook, Reveal.js and Github Pages. kdheepak. https://kdheepak.com/blog/jupyter-notebook-revealjs-and-github-pages

Mayeesha, T. (2018, February 12). Present your data science projects with Jupyter Notebook slides! Medium. https://medium.com/learning-machine-learning/present-your-data-science-projects-with-jupyter-slides-75f20735eb0f

– By Holly Chan , Library

October 6, 2023

You may also be interested in…

how to make a presentation in jupyter notebook

How to host your website on GitHub Page

Learn python from zero for absolute beginner (2): data visualization.

Create new Google Colab file

How to open .ipynb file (Jupyter Notebook)

How to Create Presentations Using RISE in Jupyter Notebook

blog image

Table of Contents

What is rise , what are the basic capabilities of rise, how to use rise chalkboard, how to use speaker notes in rise.

Jupyter Notebook has become a pretty standard tool in the world of data science and machine learning. While it does have its problems, there is probably no better way of sharing important information with others, and demonstrating results of data analysis with graphs and similar tools, than with Jupyter Notebook.

  • How to Write and Run Code in Jupyter Notebook
  • Quick Guide: How to Start a New Jupyter Notebook

However, while using Jupyter Notebook is very convenient for sharing information between those that are involved in data science in one way or another, there is still the problem of sharing the contents of a Jupyter Notebook with somebody who doesn't know how to program. Each data scientist will, sooner or later, need to present their findings to people who are not necessarily tech-savvy, and, in that case, Jupyter Notebook might not be the best tool for that job.

The recent pandemic didn't help with the technology-knowledge gap. While more people have started working from home, which is also a trend that was adopted by many colleges and other institutions, teaching others has become a completely new experience with no contact policies and everyone is feeling the strain. While it makes sense to demonstrate code using a Jupyter Notebook, going over the theoretical background behind data science and programming concepts is not very practical without using visualizations.

  • AI Adoption During COVID-19
  • Humans vs. AI: Why AI (Probably) Won't Take Your Job

One way to deal with this issue is to create a presentation and switch between a presentation and a Jupyter Notebook to combine theory with demonstrations of practical applications, but that is often way too clunky and impractical. Your best bet is to find something that combines the aesthetics of presentational tools, such as Microsoft PowerPoint or Apple Keynote , with the best of Jupyter Notebook. That something is RISE .

RISE is a Jupyter Notebook extension that allows you to easily create reveal.js -based presentations from Jupyter Notebook. RISE is a relatively powerful tool with a lot of in-built functionality, which is also simple enough to be used by beginners. That being said, more advanced users familiar with HTML and CSS will get the most out of it, but 90 % of its functionality can be accessed by total beginners. 

There are many things even beginners can customize:

  • Presentation theme and slide customization
  • Transitions between slides
  • Slide sizes
  • Slide decoration (header, footer, background)
  • Automatic selection of cells
  • Using custom CSS
  • Presentation flow
  • Auto-launch presentation mode
  • Where to start the presentation
  • Using a leap motion controller
  • Keyboard shortcuts
  • Chalkboard capabilities

Aside from dabbling with HTML and CSS , most of the aforementioned can be used by interacting with a very simple and intuitive interface.

Article continues below

Want to learn more? Check out some of our courses:

To use RISE , you need to first install it. It is available on PyPI , but it can also be installed using Anaconda .

  • How to Install Anaconda: Intro to Programming: How to Get Your Computer Ready to Run Python

Depending on what you prefer, you need to run one of the following two to install RISE :

  • pip install RISE
  • conda install-c conda-forge rise

Once RISE is installed, you can find it next to the command palette button in a Jupyter notebook:

The command palette in Jupyter Notebook with the RISE extension installed

Before you start the slideshow using this button, you'll need to define your slides. 

To do that, you need to enter the View tab of your Jupyter notebook and access the now available option Slideshow that exists with the Cell Toolbar section:

Cell Toolbar in Jupyter RISE extension

Image Source: Jupyter RISE, https://rise.readthedocs.io/en/stable/index.html

This will automatically convert the original look of the notebook into one that looks like this:

Slide Type added to each Markdown code cell in Jupyter RISE

As shown above, a special indicator for Slide Type has been added to each markdown and code cell. These different types of slides are:

  • Slide - the basic type of slide
  • Sub-slide - subsegment of the "Slide" type
  • Fragment - information that appears on the same slide as the "Slide" or "Sub-slide" type
  • Skip - this cell gets skipped during the presentation
  • Notes - special, will mention in-detail later

how to make a presentation in jupyter notebook

Few things to note here:

  • If you do know how to work with HTML and CSS , you can customize the content more easily than those that don't. However, even the default version looks pretty good.
  • The Sub-slide type of slides is relatively redundant in my opinion and they work very similar to slides. For a simple presentation, you can just avoid the Sub-slide type and use only the Slide type and the Fragment type of slides.
  • The Skip slides and Notes slides will be skipped when you show the presentation.
  • There are two symbols on the left side of the screen that you can hide if you want. The X symbol moves you back to the notebook from the presentation, while the ? symbol accesses the help section of RISE and shows you RISE key bindings.

This is all you need to know to create a basic presentation, similar to those created using PowerPoint or Keynote . This doesn't mean that that is all you can do with RISE , so let's take a look at some more advanced functionalities.

How to Use Advanced Capabilities in RISE

Knowing HTML and CSS is crucial for fully taking advantage of everything that RISE has to offer, but that doesn't necessarily mean that if you don't know HTML and CSS you are left with the basic look of RISE . You can still customize quite a lot of different things.

There are a few things you can do to optimize RISE :

  • The nbextensions_configurator tool
  • Custom CSS files
  • Embed settings in the notebook itself

The easiest way to customize RISE is to install the nbextensions_configurator . This is also the preferred option because it is a useful tool overall, and allows you to easily enable, disable, and tweak all kinds of different Jupyter Notebook extensions. 

To install nbextensions_configurator   just run the following: 

Once you have the nbextensions_configurator installed, you can very easily, using an UI, configure RISE . 

To access, just click on Nbextensions tab:

Nbextensions in RISE

This UI allows you to modify a lot of different things:

Nbextensions applied to Jupyter RISE

Out of all of the different options, the two most important ones for beginners are the ones near the end of the video:

  • Theme : for the theme of your presentation, there are various themes you can use by visiting this page https://github.com/hakimel/reveal.js#theming
  • Reveal.js ones that you find on the internet

Aside from the above, there are two things that I need to yet mention: the Chalkboard and the Notes section.

The Chalkboard allows you to draw on slides. It is very easy to use and is also fully covered in the Help sections. You can access the Help sections under the ? symbol. 

Keyboard shortcuts in RISE

These shortcuts allow you to do different stuff with the Chalkboard , but mostly what you will be doing is drawing stuff and erasing stuff:

Aside from the Chalkboard , there is a functionality called Speaker Notes . It is, in essence, a much more advanced version of the presentation: it displays the current view, the next slide, and the notes for the next slide defined in the Notes slide type. 

RISE Notes speaker

RISE Notes are anonymous, so you can set them up so that they are only seen by the person using RISE to hold a presentation. 

Overall, RISE is a pretty good tool that allows you present material in a way very similar to PowerPoint presentations. In this article, I explained and demonstrated what you can do with RISE . Even though the tool itself is very powerful, the most important reason why you should consider using it is that it allows you to, actually run the code that is presented in a slide, which is something you can't do if you decide to use PowerPoint presentations to present some material. 

  • Intro to Image Augmentation: What Are Pixel-Based Transformations?

In general, if you are working in an environment where you often need to hold presentations that involve code to others RISE will prove to be invaluable in helping you to better get your point across to those listening to you.

  • Read next: How to Build a Data-Driven Organization > >

Boris Delovski

Data Science Trainer

Boris delovski.

Boris is a data science trainer and consultant who is passionate about sharing his knowledge with others.

Before Edlitera, Boris applied his skills in several industries, including neuroimaging and metallurgy, using data science and deep learning to analyze images.

[Future of Work Ep. 4]: The Future of Sales with Santosh Sharan: Is AI Coming for Sales Jobs?

[Future of Work Ep. 4]: The Future of Sales with Santosh Sharan: Is AI Coming for Sales Jobs?

The Ultimate Guide to Data Processing with Python

The Ultimate Guide to Data Processing with Python

How Modern AI is Paradoxically Intelligent

How Modern AI is Paradoxically Intelligent

  • 90% Refund @Courses
  • Free Python 3 Tutorial
  • Control Flow
  • Exception Handling
  • Python Programs
  • Python Projects
  • Python Interview Questions
  • Python Database
  • Data Science With Python
  • Machine Learning with Python

Related Articles

  • Solve Coding Problems
  • Jupyter Notebook - Cell Magic Functions
  • How to Add a Table of Contents in the Jupyter Notebook
  • Useful IPython magic commands
  • How to Optimize Jupyter Notebook Performance ?
  • How to Delete Markdown in Jupyter Notebook
  • Ways to recover deleted Jupyter notebook cell?
  • Magic Commands for Profiling in Jupyter Notebook
  • How to Change the Theme in Jupyter Notebook
  • How to interrupt the kernel in Jupyter notebook
  • How to Customize Line Graph in Jupyter Notebook
  • How to Hide all Codes in Jupyter Notebook
  • Stop the Jupyter Kernel if Kernel is not responding
  • "How to Fix 'jupyter: command not found' Error After Installing with pip "
  • How to Add a Python 3 Kernel to Jupyter IPython
  • Data Visualization in jupyter notebook
  • How to Work in Jupyter Notebook with Multiple Languages
  • Keyboard Shortcuts to Clear Cell Output in Jupyter Notebook
  • How to Fix Kernel Error in Jupyter Notebook
  • Configure Keyboard Shortcuts in Jupyter Notebook

Creating Interactive Slideshows in Jupyter Notebooks

We all have been very well acquainted with the creation of slideshows by using Microsoft PowerPoint for our schools, colleges, or offices in our day-to-day lives. But, have we ever wondered how would it be to create a slideshow through the Jupyter Notebook? The advantages of creating slideshows with Python and Jupyter are its version control capability, dynamicity in the slideshows, easy sharing of codes with others in the groups, and a single presentation document, but the only con with this is that it doesn’t have many themes to apply in the slides, due to which it may look sort of a little plain.

In this article, we will walk through the different methods used for creating interactive slideshows in Jupyter Notebook like through RISE, with Jupyter’s built-in slideshow feature, Jupyter widgets, and ipywidgets and voila and voila-reveal. Also, we will read about the importance of creating interactive slideshows, how to customize our slides in the slideshows, and the processes involved in exporting the slideshow.

Now, coming to the basic query to ask everyone, and which every individual has in their mind is

Why Interactive SlideShow?

Some of the reasons why interactive slideshows are appreciated are mentioned below:

1. It easily helps in capturing audiences’ attention because of its interactive clickable elements, colours, images, videos, etc. making the presentation more memorable.

2. Users can delve further into data visualization s, charts, and graphs in interactive slideshows for data-driven presentations. To acquire deeper insights, they might filter data or zoom in on particular data points.

3. Interactive slideshows possess features like surveys and quizzes to collect feedback and gauge audience comprehension in real-time, which can be useful for training or instructional purposes.

4. Presenters can adapt their information to their audience’s demands by using interactive slideshows. Users can take their own route through the content by concentrating on the subjects that are most interesting or important to them, creating a more individualized experience.

Customizing Slides in Jupyter Notebook

Customizing slides refers to applying uniqueness to the appearance, content, and behaviour of individual slides to meet specific preferences. Similarly, we can also customize our slides in Jupyter Notebook. This can be done by adding metadata to the individual slides in the cells. Metadata is specified in the cell’s metadata tag, present under the “Cell Toolbar” option. From there you can customize the slide according to your own choice (Metadata is here referred to the information about the book, it is used to control the features and behavior of the notebook).

metadata-(1)-(1)

The above image will apply “Edit Metadata” to all the slides.

edit-metadata

You can now add any metadata to customize your slides as shown in the above image.

Exporting SlideShows in Jupyter Notebook

Once you are done with the creation and customization of the slides, you can export your slideshow from the Jupyter Notebook to your local machine. The slides can be exported in different formats such as HTML, PDF, LaTex, Reveal JS, Markdown (md), ReStructured Text (rst) and executable script. After exporting the file, save it in the same folder as that of where your Jupyter Notebook is installed. Finally, you will be able to easily present your slideshow from your local system to the outside world.

You can do so with the help of nbconvert tool. The nbconvert tool, is a Jupyter Notebook tool that converts notebooks to various other formats via Jinja templates. In order to used the nbconvert tool, you need to follow its basic command.

From the Command Line, use nbconvert to convert a Jupyter Notebook (input) to a different format (output). The basic command structure is given below:

where <output format> is the desired format in which the notebook is converted and <input notebook> is the filename of your own Jupyter Notebook which you want to convert.

For example: CONVERT JUPYTERNOTEBOOK SLIDESHOW TO HTML

This command creates an HTML file named as slideshow.ipynb.

Creating Interactive Slidshows in Jupyter Notebook using RISE

Step 1: set up all the requirements.

Installing Python and Jupyter Notebook

In order to start with the slideshows, firstly you need to install Python and Jupyter Notebook, using Anaconda Navigator.

Installing RISE

RISE , is an acronym which stands for Reveal.js IPython/Jupyter Slideshow Extension and as the name suggests RISE is a Jupyter Notebook extension that enables you to create dynamic presentation slides from your Jupyter Notebook. Through RISE, a notebook is rendered as a Reveal.js based slideshow during which you can execute code, display plots or show your audience any actions you would perform inside the notebook itself.

To use rise, first you need to install this. If you are using Anaconda then, use the command

or if you are using Command Prompt then use the command

You won’t be able to interact directly with RISE, instead you will be access it through your Jupyter Notebook.

Step 2: How to Create a SlideShow

Enabling slideshow mode.

To start with the creation of slideshows, you will need to start the Jupyter Notebook and open a new Notebook in it (must do this after installing RISE). Once you’re in the new fresh Notebook, you will need to enable the slideshow. For doing this, follow the following steps given below:

1. Click on the “View” tab in the Jupyter Notebook.

2. A dropdown menu will appear. Hover and select over the “Cell Toolbar” option.

3. Another dropdown appears. Now, select the “Slideshow” option in the “Cell Toolbar” menu.

cell-toolbar

You’ve now enabled the slideshow mode.

Creating the slides with cells

Now, at this point, start working with the cell toolbar present in the dropdown menu.

first-cell

Once, you open the first cell in the Notebook, you’ll observe a “ Slide Type ” option present at the top right corner of the cell. This contains different types options which determines how each slide would fit in the slideshow. Those are:

slide – designates the selected cell as the first of a new slide.

slide

sub-slide – indicates that the selected cell should be the start of a new sub-slide, which appears in a new frame beneath the previous slide.

sub-slide

fragment – denotes that the chosen cell should be added to the previous slide as a build.

fragment

skip – indicates that the selected cell should not be included in the slideshow and should instead be skipped.

skip

notes – indicates that the selected cell should just be the presenter notes.

notes

– – indicates that the selected cell should follow the behavior of the previous cell, which is useful when a markdown cell and a code cell should appear simultaneously.

Step 3: Viewing and Operating the SlideShows

Viewing the slideshow.

The slideshow can be seen directly from the notebook once the slide material has been created using cells for the slideshow.

There are two options to view the slideshow:

1. Using the shortcut ALT + R on Windows to enter and exit into the presentation mode within the notebook.

2. Clicking the “Presentation Mode” button from the notebook (Note that it would only appear if you’ve successfully installed RISE) as present at the right most, shown in the image given below.

toolbar

Once you choose enter into the slideshow presentation mode, a window will open as shown below

Screenshot-2023-10-30-062436

This means the presentation is active now.

Operating the slideshow

Changing the slides.

When you enter in the slideshow window, you will see four different types of arrows in the bottom-right corner for controlling the slides. Although using the keys <- and -> may look attractive, but it can lead to skip of many sub-slides. Instead, its recommended to use SPACE for moving the slides forward and SPACE+SHIFT for moving the slides backward, respectively.

Apart from this, you may also access many other keyboard shortcuts within the slideshow by clicking the question mark (?) in the bottom-left corner.

Running and Editing the code

One of the best features of RISE is that you can update and run code while the presentation is in progress because it operates in a live Python session.

A code cell will show up in the slideshow as editable and runnable if it is identified as a slide, sub-slide, fragment, or -. Here’s an illustration:

Finally, you are done with the slideshow to showcase it to others.

Creating Interactive Slideshow using Jupyter’s built-in Slideshow Features

Until now, we learnt about the different ways of creating interactive slideshows in Jupyter Notebook with the help of RISE. But, there are some other methods too, which can be used for creating slideshows in Jupyter Notebook. One of them is “Jupyter’s built-in slideshow feature”. To create interactive slideshows in Jupyter Notebook with the help of its built-in feature, perform the following steps:

Step 1: Open a New Notebook

To start with, open a new notebook and rename it.

Step 2: Create new Slides

Once you are inside a new fresh notebook, start creating slides as much as you want to add in your slideshow.

Step 3: Enable SlideShow Mode

After you are done with the creation of all the slides, define them as specific slide-type such as “Slide”, “Sub-Slide”, “Fragment”, “Skip”, “Notes”, “Markdown”. Also, enable the slideshow mode through the “Cell Toolbar” in the Notebook toolbar.

Step 4: Run the Notebook for SlideShow

Next, save your notebook and close it. Open the Command Prompt, and run the below mentioned command to see your notebook as a slideshow.

Replace myslideshow.ipynb with your notebook filename. The above command will convert your Jupyter Notebook to a slideshow.

Creating Interactive Slideshow using Jupyter Widgets and IPYwidgets

Ipywidgets, is a python libraray, often termed as Jupyter widgets or simply widgets in short. With this, you can build interactive HTML widgets that will display in your Jupyter Notebook. They are interactive Graphical User Interface (GUI) elements which incorporate user interaction into your code, enhancing the interest and usefulness of your notebooks. They are especially beneficial for activities like data exploration, data analysis, parameter adjustment, and concept demonstration.

There are many different controls available with Jupyter widgets, including buttons, sliders, text input fields, dropdown menus, checkboxes, and more. These features allow for real-time data manipulation and display, parameter changes, and action triggering without the need to run code cells again.

Jupyter widgets or ipywidgets, also helps in building interactive slideshows. You just need to apply the following steps:

Step 1: Install IPYwidgetsINSTALL ‘IPYWIDGETS’

In order to start working with widgets, you need to first install it. For this, you can use Command Prompt or Anaconda.

Step 2: Import the Libraries

In the next step, import the necessary required libraries in your notebook.

Step 3: Create Interactive Widgets

Now, select the type of interactive widget, you want to include in your presentation. For example, here I have used the slider widget.

Here, we can assign the min and max value, step value and the description of the slider.

Step 4: Display the Widgets

This will display the widget which is applied to the slide.

Step 5: Run the SlideShow

Next, when you are done creating the widgets for all the specific slides, turn on the slideshow mode. To do this, go to View -> Cell Toolbar -> Slideshow. Thereafter, use the “Slide Type” dropdown menu in the toolbar to specify how each cell should be treated (e.g., slide, sub-slide, fragment, skip and notes).

Step 6: Start the Slideshow

Finally, start the slideshow by clicking the “Enter/Exit Live Reveal Slideshow” button in the toolbar. Your presentation will begin, and interactive widgets will be functional.

Creating Interactive Slideshow using Voila and Voila-Reveal

Voila is an open-source framework or we can say a web application, with the help of which one can convert Jupyter notebooks into dashboards and interactive online applications. Although it’s primarily responsible for creating web applications, it can also be used to create interactive slideshows for Jupyter notebooks.

On the other hand, Voila-Reveal is just an extension of voila. It allows to convert simple jupyter notebook into a Reveal.js based interactive slideshow.

In order to do so, one can follow the below mentioned steps:

Step 1: Install VOILA

To install voila, you can use Command Prompt

Step 2: Create the Slides

Then, create or open Notebook where you will build the presentation. If you want to customize the slides using Reveal.js features like slide backgrounds, transitions, and themes, then do so by adding appropriate metadata to Markdown cells.

voila2-(1)-(1)

Step 3: Run VOILA

Once you created the slides, close your notebook. Then, in the command prompt, navigate to the path where your notebook is stored.

Replace C:\Users\hp with your folder path.

Then, start to run your notebook in the Command Prompt.

Rename Voila.ipynb with the name of your notebook file.

Once you run your file, voila will start a local server and generate the Reveal.js-based presentation from your notebook. It will provide you with a URL, which is typically something like http://localhost:8866 . Open this URL in a web browser to view your interactive slideshow presentation.

voila-output-(1)-(1)-(1)

NOTE : Voila will convert all the slides in the cells in the notebook to a dashboard.

Don't miss your chance to ride the wave of the data revolution! Every industry is scaling new heights by tapping into the power of data. Sharpen your skills and become a part of the hottest trend in the 21st century.

Dive into the future of technology - explore the Complete Machine Learning and Data Science Program by GeeksforGeeks and stay ahead of the curve.

Please Login to comment...

  • Geeks Premier League 2023
  • Jupyter-notebook
  • Geeks Premier League
  • Apple's New AI-powered Tool: Editing Through Text Prompts
  • Rebranding Google Bard to Gemini: All You Need to Know, Android App and Advanced subscriptions
  • Youtube TV's Multiview Update: Tailor Your Experience in 4 Easy Steps
  • Kore.ai Secures $150 Million for AI-Powered Growth
  • 10 Best IPTV Service Provider Subscriptions

Improve your Coding Skills with Practice

 alt=

What kind of Experience do you want to share?

DZone

  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
  • Manage My Drafts

Modernizing APIs : Share your thoughts on GraphQL, AI, microservices, automation , and more for our April report (+ enter a raffle for $250!).

DZone Research Report : A look at our developer audience, their tech stacks, and topics and tools they're exploring.

Getting Started With Large Language Models : A guide for both novices and seasoned practitioners to unlock the power of language models.

Managing API integrations : Assess your use case and needs — plus learn patterns for the design, build, and maintenance of your integrations.

  • Norm of a One-Dimensional Tensor in Python Libraries
  • Improving Sentiment Score Accuracy With FinBERT and Embracing SOLID Principles
  • Apache Flink
  • How To Use Amazon SageMaker for Machine Learning
  • Non-Volatile Random Access Memory: Key Guidelines for Writing an Efficient NVRAM Algorithm
  • Why Apache Kafka and Apache Flink Work Well Together to Boost Real-Time Data Analytics
  • The Essential Guide To Effective Software Testing
  • Amazon Bedrock: Game-Changing Disruption in 4 Sectors

Creating Presentations With Jupyter Notebook

When you build a presentation using jupyter notebook, you'll be able to run code live from your slides..

Mike Driscoll user avatar

Join the DZone community and get the full member experience.

Jupyter Notebook can be turned into a slide presentation that is kind of like using Microsoft PowerPoint, except that you can run the slide's code live! It's really neat how well it works. The only con in my book is that there isn't a lot of theming that can be applied to your slides, so they do end up looking a bit plain.

In this article, we will look at two methods of creating a slideshow out of your Jupyter Notebook. The first method is by using Jupyter Notebook's built-in slideshow capabilities. The second is by using a plug-in called RISE .

Let's get started!

The first thing we need to do is to create a new Notebook. Once you have that done and running, let's create three cells so that we can have three slides. Your Notebook should now look like the following:

Image title

An empty notebook with 3 cells

Now let's turn on the "slideshow" tools. Go to the View menu and then click on the Cell Toolbar menu option. You will find a sub-menu in there that is called Slideshow . Choose that. Now your Notebook's cell should look like this:

Image title

An empty slideshow

There are now little comboboxes on the top right of each cell. These widgets give you the following options:

You can just create a series of Slides if you like, but you can make the slideshow a bit more interesting by adding Sub-Slides and Fragments. Sub-slides are just slides that are below the previous one while Fragments are basically fragments within the previous slide. As an aside, I have actually never used Fragments myself. Anyway you can also set a slide to Skip, which just allows you to skip a slide or Notes, which are just speaker notes.

Let's add some text to our first cell. We will add the text "# Hello Slideshow" to it and set the cell type to Markdown. Note the pound sign at the beginning of the text. This will cause the text to be a heading.

In cell two, we can add a simple function. Let's use the following code:

For the last cell, we will add the following text:

Make sure you set that to be a Markdown cell as well. This is what my cells ended up looking like when I was done:

Image title

Getting the slideshow ready

To make things simple, just set each of the cell's individual comboboxes to Slide .

Now we just need to turn it into an actual slideshow. To do that, you will need save your Notebook and shut down the Jupyter Notebook server. Next you will need to run the following command:

Image title

Running the slideshow

To navigate your slideshow, you can use your left and right arrow keys or you can use spacebar to go forward and shift_spacebar to go back. This creates a pretty nice and simple slideshow, but it doesn't allow you to run the cells. For that, we will need to use the RISE plugin!

Getting Started With RISE

Reveal.js - Jupyter/IPython Slideshow Extension (RISE) is a plugin that uses *reveal.js* to make the slideshow run live. What that means is that you will now be able to run your code in the slideshow without exiting the slideshow. The first item that we need to learn about is how to get RISE installed.

Installing rise with conda

If you happen to be an Anaconda user, then this is the method you would use to install RISE:

This is the easiest method of installing RISE. However most people still use regular CPython, so next we will learn how to use pip!

Installing rise with pip

You can use Python's pip installer tool to install RISE like this:

You can also do `python -m pip install RISE` if you want to. Once the package is installed, you have a second step of installing the JS and CSS in the proper places, which requires you to run the following command:

If you somehow get a version of RISE that is older than 5.3.0, then you would also need to enable the RISE extension in Jupyter. However, I recommend just using the latest version so you don't have to worry about that.

Using RISE for a SlideShow

Now that we have RISE installed and enabled, let's re-open the Jupyter Notebook we created earlier. Your Notebook should now look like this:

Image title

Adding RISE

You will notice that I circled a new button that was added by RISE to your Notebook. If you mouse over that button you will see that it has a tooltip that appears that says "Enter/Exit RISE Slideshow." Click it and you should see a slideshow that looks a lot like the previous one. The difference here is that you can actually edit and run all the cells while in the slideshow. Just double-click on the first slide and you should see it transform to the following:

Image title

Running with RISE

After you are done editing, press SHIFT+ENTER to run the cell. Here are the primary shortcuts you will need to run the slideshow effectively:

  • SPACEBAR - Goes forward a slide in the slideshow
  • SHIFT+SPACEBAR - Goes back a slide in the slideshow
  • SHIFT+ENTER - Runs the cell on the current slide
  • DOUBLE-CLICK - To edit a Markdown cell

You can view all the Keyboard shortcuts by going to the Help menu when not in Slideshow mode and clicking the Keyboard Shortcuts option. Most — if not all — of these shortcuts should work inside a RISE slideshow.

If you want to start the slideshow on a specific cell, just select that cell and then press the Enter Slideshow button.

RISE also works with Notebook widgets. Try creating a new cell with the following code:

Now start the slideshow on that cell and try running the cell (SHIFT+ENTER). You should see something like this:

Image title

Using a widget in RISE

You can use RISE to add neat widgets, graphs and other interactive elements to your slideshow that you can edit live to demonstrate concepts to your attendees. It's really quite fun and I have used RISE personally for presenting intermediate-level material in Python to engineers.

RISE also has several different themes that you can apply as well as minimal support for slide transitions. See the documentation for full information.

Wrapping Up

In this chapter we learned about two good methods for creating presentations out of our Jupyter Notebooks. You can use Jupyter directly via their nbconvert tooling to generate a slideshow from the cells in your Notebook. This is nice to have, but I personally like RISE better. It makes the presentations so much more interactive and fun. I highly recommend it. You will find that using Jupyter Notebook for your presentations will make the slides that much more engaging and it is so nice to be able to fix slides during the presentation too!

Related Reading

  • Presenting code using  Jupyter Notebook
  • The RISE  Github page
  • Jupyter nbconvert  Usage
  • How to build interactive presentations with  Jupyter Notebook and Reveal JS

Published at DZone with permission of Mike Driscoll , DZone MVB . See the original article here.

Opinions expressed by DZone contributors are their own.

Partner Resources

  • About DZone
  • Send feedback
  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone
  • Terms of Service
  • Privacy Policy
  • 3343 Perimeter Hill Drive
  • Nashville, TN 37211
  • [email protected]

Let's be friends:

XDA Developers

How to use Jupyter Notebook on Windows, Linux, and macOS

Quick links, what is jupyter notebook, how to install jupyter notebook: pip vs anaconda, launching jupyter notebook for the first time, getting familiar with the jupyter notebook interface, how to write and execute code in jupyter notebook.

If you want to get into development, there’s never been a better time to do so. You can use ChatGPT to learn how to code , start software development on affordable Chromebooks , and browse through thousands of easily accessible tutorials and courses. Python is one of the best programming languages to start with, as it’s relatively easy to learn yet powerful in fields like data science, artificial intelligence, and scientific computing.

However, to make the most of Python, you need to be familiar with the concept of Jupyter Notebook, which is a user-friendly, open-source web application that lets you write, execute, and share Python code interactively. In this guide, we’ll teach you how to install and create your first notebook.

Think of Jupyter Notebook as an interactive web application for creating and sharing documents with live code, equations, visualization, and narrative text. Its user-friendly interface makes it highly accessible, and its robust features make it all the more valuable for seasoned developers. People often use it for the development and presentation of data science projects. A “notebook” is similar to a document that can execute your code, display the output, and show explanations to make the whole process easier to understand.

Jupyter Notebook is not constrained to a specific language or system configuration. It supports over 40 programming languages, including R, Julia, and Scala. You can use it on the best laptops for software development or even on a cheaper Chromebook. On top of all that, Jupyter Notebooks can be easily converted to other formats, such as PDFs or HTML. This makes them a strong tool for presentations.

We've already discussed how to install Jupyter Notebook in a previous guide. There are two primary methods: by using PIP or with Anaconda. PIP is a package manager for Python, and it simplifies the process of installing, upgrading, and managing dependencies or libraries. It’s the default package management system that people use for installing and managing software packages written in Python. If you’re comfortable with Python and its ecosystem and only need Jupyter Notebook without additional packages, installing via PIP is a good choice.

You could also use Anaconda. It’s a free and open-source distribution of the Python and R programming languages. It simplifies package management even further by giving you a sleek graphical user interface. You can use it to launch, update, and manage packages without touching the command line.

If you plan on diving into data science, Anaconda comes bundled with most of the libraries and tools that you need. It all depends on your workflow and what you plan to learn in the future, so we’ll be covering both methods in this guide.

Now that you've successfully installed Jupyter Notebook, it's time to put it to good use. We recommend grabbing a comfortable chair , as you'll spend a lot of time getting familiar with Python and Jupyter in the near future.

Now, before you dive into the dozens of tutorials and videos online, you must understand the lay of the land. We can't teach you everything that there is to know about Jupyter Notebook in this section, but we'll break down some of the major components.

First, let's launch Jupyter Notebook for the first time.

  • If you installed Jupyter Notebook via PIP, open the Command Prompt app in Windows (or the Terminal on macOS or Linux) and type jupyter notebook. Hit Enter on your keyboard to launch the app.
  • If you installed Jupyter via Anaconda, open the Anaconda Navigator, find Jupyter Notebook, and click on Launch. Close
  • Once you're in the notebook dashboard, find and click on the New button. It's usually located at the top right.
  • From the dropdown menu, select Python 3 to create a new notebook.
  • A new tab will open in your browser with your new notebook. You should see a toolbar at the top and an empty cell below it. This is where you can write your code.

You should now have a blank notebook open in front of you. Now, let's get familiar with cells, command mode, edit mode, markdown, keyboard shortcuts, and everything else you need to know to get accustomed with Jupyter Notebook.

With a new notebook in front of you, you're now ready to start experimenting with everything that Jupyter Notebook has to offer. Let's start by exploring the toolbar.

The Toolbar

When you get more used to Jupyter, you'll be using keyboard shortcuts more than the toolbar. However, it still helps to know the function of each available button.

  • Starting from the left, you can click on the floppy disk icon to save your progress. Alternatively, you can also press the Ctrl + S ( Cmd + S on Mac) keys to save your progress manually. Jupyter Notebook does have an autosave feature, but you should frequently save manually so you don't lose any progress.
  • Clicking on the plus (+) icon will allow you to add a new cell below the existing ones.
  • The next button features a scissor icon, and clicking on this will cut or delete a selected cell.
  • The next two buttons are for copying and pasting selected cells. You can also just use the traditional Ctrl + C and Ctrl + V keyboard shortcuts for this.
  • Next to the copy/paste icons, you'll find two arrow icons that allow you to move cells up or down depending on how you want to arrange them.
  • The next couple of icons allow you to run, stop, restart, or rerun all the commands or code in the notebook. These actions are indicated by play , stop , restart , and fast-forward icons.
  • Finally, there's a drop-down menu that allows you to change the cell type for a selected cell. You can set this to Code , Markdown , or Raw NBConvert. More on all that later.

That's all there is to it for the toolbar. At the very end, there's also a command pallette that displays all the commands and their respective keyboard shortcuts that you can use within the notebook. We recommend going through this when you can, as keyboard shortcuts can save you a lot of time.

What are cells in Jupyter Notebook?

Think of cells as the main body of your notebook. Within each cell, you can write text using the Markdown markup language, or write and execute Python code. Cells can be interacted with in two modes — Command mode and Edit mode.

Command mode allows you to add or delete cells, change cell type, navigate between different cells, and rearrange their position in the notebook. When you're in command mode, a cell will be highlighted with a blue outline. You can also press A on your keyboard to add a new cell above an existing one, press B to add one below it, or press X to delete a highlighted cell.

Edit mode allows you to add, remove, or replace the content within a cell. When in edit mode, the cell that you're working with will be highlighted with a green outline.

You can switch between both modes with ease. To enter command mode, press the Esc key or click outside the cell. Similarly, to enter edit mode, press the Enter key or click inside the cell you want to edit.

Markdown mode and writing text

While programming, it's good practice to leave comments around your code to make it more readable. Markdown is a simple markup language that allows you to write or format text within Jupyter Notebook, and it's a bit more sophisticated compared to comments in traditional code editors like Visual Studio.

If you want to write text within a cell, you can change the cell type from the toolbar. While in command mode, you can also use keyboard shortcuts to speed things up. Select a code cell while in command mode, and simply press M on your keyboard to make it a Markdown cell.

In markdown cells, you can write plain text, but there are quite a few formatting options as well.

  • To add a heading, add a # sign before the text to turn it into a header. If you add two # signs before a text, it will turn into a second-level header. Similarly, adding three will turn into a third-level header.
  • Add two ** signs before and after a text to make it bold.
  • To make the text italic, add a _ sign before and after it.
  • Add a ` sign before and after a text to make it an in-line code block. This is also called formatted code in Jupyter.
  • For lists, start consecutive lines with the - sign to make bulleted lists. To create numbered lists, start lines with numbers followed by a period.

Here's what all the options should look like while you're writing them as text within the cells:

While you're still in editing mode, press the Shift + Enter keys on your keyboard to run the cell. Here's what the output should look like:

Up to this point, we've discussed cells, markdown mode, and the toolbar. However, let's not forget about one of the most important aspects of Jupyter Notebook: writing and executing code. Follow the steps below to write your first piece of code within Jupyter Notebook.

  • Open a new notebook, and click within the empty cell to enter Edit mode.
  • To test things out, you can enter any simple piece of code into this cell. Printing something like "Hello World" is always a safe bet. Here's the command for printing "Hello World" in Python:

print("Hello, World!")

  • To run your code, press Shift + Enter on your keyboard. You should see the words "Hello, World!" as the output displayed below our cell.
  • To save the notebook, click the Save icon in the toolbar to save your work. Alternatively, you can also press the Ctrl + S keys on your keyboard to save your progress.

Congrats! You just wrote your first bit of code in Python while using Jupyter Notebook. It's not exactly complex, but it's something to get you started. After saving your notebook, you can close the browser tab to exit Jupyter Notebook.

Making the most of Jupyter Notebook

By now, you should be a bit familiar with the Jupyter Notebook interface and all the features it has to offer. Try creating basic programs like simple arithmetic operations or experimenting with variable assignments to get you started. While you're at it, get familiar with the Markdown features in Jupyter Notebook for making your code more readable. Finally, make a habit of regularly saving your notebook to avoid losing any important work. Happy coding!

How to use Jupyter Notebook on Windows, Linux, and macOS

The good, the bad & the ugly: how to share Jupyter notebooks

By Eric Wendt

Updated on February 20, 2023

Sharing is caring when it comes to data analysis. Check out your options for sharing Jupyter notebooks — and the pros and cons of each.

Illustrative image for blog post

Why do data teams need to share Jupyter notebooks? Let us count the ways.

Code reviews, team presentations, delivering insights to non-programmers, general hotdogging (we all need to show off now and then) — the list goes on and on.

But sharing a Jupyter notebook is problematic (i.e., painful). You end up jumping through annoying, time-consuming hoops just to share the results of your analysis. And the workarounds you use often defeat the purpose of sharing your notebook in the first place.

As with most things in data work, there’s a good, bad, and ugly way of getting it done. Let’s look at the different ways you can share a Jupyter notebook and weigh the advantages and disadvantages of each approach.

What it means to share

Before we start comparing and contrasting different Jupyter notebook sharing options, let’s be clear on what we mean by “share.” There’s a whole spectrum of sharing, ranging from “I literally just want your eyeballs on this output” to “Go ahead and edit my code.”

Sometimes you want people to run your notebook. Maybe you even want them to be able to toggle a few dropdown menus so they can actually explore the data. Other times it’s more of a look-but-don’t-touch situation.

At the end of the day, we share to collaborate. And successful data collaboration is dependent on:

  • Speed (our ability to share work quickly)
  • Reproducibility (our ability to duplicate it)
  • Interactivity (our ability to work together on it)

Those are the criteria we’ll use to evaluate different sharing options. So, without further ado, here are your choices for sharing a data notebook.

Ugly: the file option

Downloading and emailing .ipynb files — the bane of many a data professional’s existence.

Since Jupyter files run on your local machine, you can’t simply send someone a link to your notebook. Instead, you have to download the file (which takes way too long) and send it off to a teammate so they can fire it up on their machine (which also takes way too long).

Unfortunately, none of your assets are included. Maybe you add your database password to help speed things along (the exact kind of behavior that keeps your security team up at night), but now your colleague has to set up their environment from scratch. Only after the necessary Python packages have been installed and the environment configuration is complete can they run your notebook.

It’s not exactly what you’d call high-speed — but it’s better than exporting your notebook as a static file or copying and pasting screenshots. With those options, reproducibility and interactivity go right out the window.

Say you need to share your notebook with a non-technical stakeholder — they’re not interested in running it, just getting to the insights you uncovered. You download it as a PDF and send it over. Then they spot a mistake that needs to be fixed. Or they have a follow-up request not covered in your analysis. Or your results lead to another question that needs to be answered.

No matter the issue, you’ll have to go back to your notebook, rerun it, re-export it, resend it, and repeat until the stakeholder is satisfied. On and on and on. You (and your teammates) get stuck in a never-ending loop of busy work that makes exploring and collaborating on data a grind.

Bad: the view option

The challenge of sharing a Jupyter notebook is nothing new — that’s why there’s a cottage industry built around making it easier to view them.

GitHub repositories are a great way to organize static data notebooks and make them accessible to teammates, but therein lies the rub: They’re static. Notebooks are rendered on GitHub, not run. Reproducing the work, collaborating in real time, commenting — none of it is an option. Ditto for tools like nbviewer.

There’s also Binder, which claims to help you “turn a Git repo into a collection of interactive notebooks.” But “interactive” is a stretch. Once you get past the time it takes to load a repository and the custom libraries you need, you realize notebooks are displayed in isolated environments.

After you close that URL, the notebook goes poof. You may feel like you’re sharing the real deal, but as soon as you want to actually do anything collaborative, it instantly falls apart. Tools like this are good for quickly reproducing a notebook, but interactivity is ultimately an illusion.

Good: the cloud option

Cloud-based technology allows you to share fully executable notebooks with a link — no muss, no fuss.

invite-members.png

This isn't the same as JupyterHub, which is a DIY option that requires organizations to install and manage their own Jupyter notebook servers (i.e., you have to manage everything and deal with computing power and storage limits). Cloud-based notebooks are hosted for you, giving you an easy and scalable way to quickly share and reproduce projects.

But keep in mind that not all cloud-based notebooks are created equal — the ability to easily share your notebook doesn’t always mean you can collaborate on it. Take Google Colab, for instance. You and your teammates can’t share the same execution environment simultaneously or leave comments for each other. Each time a person makes an edit and saves the notebook, it reverts to their copy and destroys whatever their colleagues were working on.

Then there’s the question of permissions. Not all cloud-based notebooks have the same level of granularity when it comes to who can access notebooks and how they can use them (e.g., run a notebook but not alter the code).

access-controls.png

Your best bet is a cloud-based data notebook that’s truly collaborative by design (hint: That’s what we made).

sql_python.png

It looks like this:

  • Sharing the same environment with collaborators at the same time, complete with database connections and environment configuration
  • Editing code with collaborators in real time and leaving comments for each other
  • Assigning granular access levels to collaborators, from view-only to full code access and everything in between
  • Giving collaborators a shared workspace where they can easily store, organize, and find their teammates’ notebooks to view, work on, or duplicate a project
  • Publishing shareable notebooks as articles, dashboards, and interactive apps with just a click to make sharing insights with stakeholders that much easier

Sharing data notebooks seems like such a simple task, but the truth is it’s as complicated as any machine learning model. Combining shared environments and accessibility controls — and spinning it up in a package that’s fast and accessible to people of all technical levels — is not easy. Some sharing options do a passable imitation, but the devil’s in the details.

Data collaboration is a computational puzzle every team has to solve on its own. Next time you need to share a Jupyter notebook, consider a solution that’s built for real teamwork.

Simplify sharing Jupyter notebooks with Deepnote

Get started for free to see how easy it is to share and collaborate on data notebooks.

Senior Content Editor @ Deepnote

Follow Eric on LinkedIn

Illustrative image for blog post

How Deepnote uses Deepnote

By Megan Lieu

Updated on December 27, 2023

Illustrative image for blog post

Deepnote AI: So, what’s the impact? (Part 1)

By Gabor Szalai

Updated on December 11, 2023

Illustrative image for blog post

8 Data notebook myths - busted

Updated on October 9, 2023

Try Deepnote today

Start on a Team plan trial to see what Deepnote can do. On a big team? Book a call with us!

a post with jupyter notebook

July 04, 2023

2023   ·   formatting   jupyter     ·   sample-posts  

To include a jupyter notebook in a post, you can use the following code:

Let’s break it down: this is possible thanks to Jekyll Jupyter Notebook plugin that allows you to embed jupyter notebooks in your posts. It basically calls jupyter nbconvert --to html to convert the notebook to an html page and then includes it in the post. Since Kramdown is the default Markdown renderer for Jekyll, we need to surround the call to the plugin with the ::nomarkdown tag so that it stops processing this part with Kramdown and outputs the content as-is.

The plugin takes as input the path to the notebook, but it assumes the file exists. If you want to check if the file exists before calling the plugin, you can use the file_exists filter. This avoids getting a 404 error from the plugin and ending up displaying the main page inside of it instead. If the file does not exist, you can output a message to the user. The code displayed above outputs the following:

Sorry, the notebook you are looking for does not exist.

Note that the jupyter notebook supports both light and dark themes.

giscus comments misconfigured > Please follow instructions at http://giscus.app and update your giscus configuration. {: .block-danger }

TensorFlow #

TensorFlow enables your data science, machine learning, and artificial intelligence workflows. This page shows how to install TensorFlow using the conda package manager included in Anaconda and Miniconda.

TensorFlow CPU with conda is supported on 64-bit Ubuntu Linux 16.04 or later and macOS 10.12.6 or later.

TensorFlow GPU with conda is only available though version 2.4.1 (2021). For the latest TensorFlow GPU installation, follow the installation instructions on the TensorFlow website .

Install TensorFlow #

Download and install Anaconda or Miniconda .

Open a terminal application and use the default bash shell.

Choose a name for your TensorFlow environment, such as “tf”.

Use the following commands to install the current release of TensorFlow. CPU-only is recommended for beginners.

GPU TensorFlow is only available via conda for Windows and Linux.

TensorFlow is now installed and ready to use.

For using TensorFlow with a GPU, refer to the TensorFlow documentation , specifically the section on device placement .

CUDA versions #

GPU TensorFlow uses CUDA. For a version compatibility table for GPU TensorFlow on Linux, see https://www.tensorflow.org/install/source#gpu . For Windows, see https://www.tensorflow.org/install/source_windows#gpu .

GPU TensorFlow conda packages are currently only supported for Windows or Linux.

TensorFlow 2.10 was the last release that supported GPU on Windows Native.

To install GPU TensorFlow with a non-default CUDA version like 9.0, run the following commands:

Nightly builds #

Advanced users may wish to install the latest nightly build of TensorFlow. These nightly builds are unstable and are only available as pip packages on PyPI.

To install the nightly build of CPU-only TensorFlow:

Or, to install the nightly build of GPU TensorFlow on Linux or Windows:

IMAGES

  1. How to Create Presentation Slides from Jupyter Notebooks

    how to make a presentation in jupyter notebook

  2. 5 Slides for Tips on Presentation Mode in Jupyter Notebook

    how to make a presentation in jupyter notebook

  3. how to make a presentation in jupyter notebook

    how to make a presentation in jupyter notebook

  4. Create Presentation from Jupyter Notebook

    how to make a presentation in jupyter notebook

  5. how to make a presentation in jupyter notebook

    how to make a presentation in jupyter notebook

  6. how to make a presentation in jupyter notebook

    how to make a presentation in jupyter notebook

VIDEO

  1. Python 01 Jupyter Notebook Setting

  2. convert jupyter notebook to python file

  3. jupyter notebook create python file

  4. Jupyter Notebook Installation From CMD

  5. #pythonmodule #pythonmodules #python #pythontrending videos #pythonprogramming

  6. What are Jupyter Notebook and JupyterLab? How to install them?

COMMENTS

  1. Creating Presentations with Jupyter Notebook

    The first method is by using Jupyter Notebook's built-in slideshow capabilities. The second is by using a plug-in called RISE. Let's get started! Note: This article assumes that you already have Jupyter Notebook installed. If you don't, then you might want to go to their website and learn how to do so.

  2. Create Presentation from Jupyter Notebook

    You can create a presentation directly from Jupyter Notebook. The presentation slides can be constructed from single, multi-code or Markdown cells. The cell's code can be hidden in the presentation (to not scare nontechnical viewers). The final slides can be shared as a website or converted to a PDF file.

  3. 5 Slides for Tips on Presentation Mode in Jupyter Notebook

    The first step is to enable the Slideshow option in the View > Cell Toolbar options. Just click on the Slideshow option and continue reading. Enable Slideshow Each cell in the Jupyter Notebook will now have a Slide Type option in the upper-right corner. Slideshow is Now Enabled An Example Notebook with Slideshow

  4. Create interactive slides with Python in 8 Jupyter Notebook cells

    Creating presentations in Jupyter Notebook is a great alternative to manually updating slides in other presentation creation software. If your data changes, you just re-execute the cell and slide chart is updated. Jupyter Notebook is using Reveal.js for creating slides from cells.

  5. Present Your Data Science Projects with Jupyter Notebook Slides!

    1 The art of going from code to communication. Making presentation slides for technical lectures, product live-demo's and sharing analysis is one of those boring tasks that has high return...

  6. Creating a Presentation with Jupyter Notebook and RISE

    In this tutorial, you will learn how to use Jupyter Notebooks to create slide show presentations. This allows you to run and edit live code in your slides.Wa...

  7. Create a slide deck using Jupyter Notebooks

    Create a slide deck using Jupyter Notebooks Jupyter may not be the most straightforward way to create presentation slides and handouts, but it affords more control than simpler options. By Moshe Zadka (Correspondent) September 9, 2020 | 1 Comment | 4 min read 69 readers like this.

  8. How to Create Presentation Slides from Jupyter Notebooks

    This video, titled Build Jupyter Notebook Slideshow with Just One Click | Jupyter Magic Commands, shows how to turn your Jupyter notebook into presentation slides so that you can...

  9. Using a Jupyter notebook to make presentation slides

    TL;DR: Open a blank Jupyter notebook. Add a cell and convert it to Markdown (either esc + m) or by using the drop down menu at the top of the notebook. Add your text, equation or image to the cell (images can be added via the edit menu, though some HTML tags may be needed to render and/or resize the image).

  10. Create Presentation Slides from Jupyter

    0:00 / 3:37 Create Presentation Slides from Jupyter LiveLessons 23.8K subscribers Subscribe 402 46K views 4 years ago Jamie Whitacre demonstrates how to create dynamic presentation slides...

  11. Creating Interactive Slideshows in Jupyter Notebooks

    Have you ever wanted to create a slideshow using Python? I've found a lot of useful tools for making slideshows in Jupyter Notebooks while developing Python for data science workshops for the University of Cincinnati and 84.51°, but I'm yet to see all of this information in one place.This blog post changes that by directly teaching you how to create interactive slideshows in Jupyter ...

  12. Creating Slides with Jupyter Notebook

    First, you need to add/clone reveal.js into your folder with the presentation ( git clone https://github.com/hakimel/reveal.js/) and then you can run the command: jupyter-nbconvert --to slides presentation.ipynb --reveal-prefix=reveal.js

  13. Presenting with Jupyter Notebooks :: Scott Jeen

    The best way to walk through this tutorial is using the accompanying Jupyter Notebook: [Jupyter Notebook] - In the last year I've started presenting work using Jupyter Notebooks, rebelling against the Bill Gates'-driven status-quo. Here I'll explain how to do it. It's not difficult, but in my opinion makes presentations look slicker, whilst allowing you to run code live in a presentation ...

  14. Turn your Jupyter Notebook into interactive Presentation Slides using

    After configured each cell in Jupyter Notebook using Anaconda, you can now follow the steps in the previous section "Convert ipynb file to HTML file" to turn your Jupyter Notebook into interactive HTML Presentation Slides. The generated output is a single HTML file, making it incredibly convenient to share and save on a USB drive.

  15. Presenting Code Using Jupyter Notebook Slides

    When you make a slide presentation, there are a few programs you likely think of: Microsoft PowerPoint, Google Slides, Prezi (just kidding). PPT and Slides are great applications, to be sure....

  16. How to Create Presentations Using RISE in Jupyter Notebook

    RISE is a Jupyter Notebook extension that allows you to easily create reveal.js -based presentations from Jupyter Notebook. RISE is a relatively powerful tool with a lot of in-built functionality, which is also simple enough to be used by beginners.

  17. How to create data-driven presentations with jupyter notebooks, reveal

    Towards Data Science · 16 min read · Aug 8, 2019 … in which I discuss a workflow where you can start writing your contents on a jupyter notebook, create a reveal.js slide deck, and host it on github for presentations. This is for a very simple presentation that you can fully control yourself A first simple slide deck Part I: Basic slide deck

  18. Creating Interactive Slideshows in Jupyter Notebooks

    1. It easily helps in capturing audiences' attention because of its interactive clickable elements, colours, images, videos, etc. making the presentation more memorable. 2. Users can delve further into data visualizations, charts, and graphs in interactive slideshows for data-driven presentations.

  19. Presenting Data Using Jupyter Notebook Slides (VS Code)

    Example Presentation Conclusion. Jupyter Notebook slides provide a straightforward and uncluttered layout, making them remarkably easy to generate. Although they may not boast the extensive ...

  20. Creating Presentations With Jupyter Notebook

    Jupyter Notebook can be turned into a slide presentation that is kind of like using Microsoft PowerPoint, except that you can run the slide's code live! It's really neat how well it works....

  21. Shortcut key for presentation mode in Jupyter

    2. My issue was I tried to enable the "Enter RISE" button. So, to fix my issue, I used conda install -c damianavila82 rise instead of pip install RISE (I normally use pip to install new Python library, anyway). However, if you are looking for a shortcut for the presentation mode you can try "Atl + r" for entering and exiting RISE.

  22. python

    Here you can see a reproducible example to create Jupyter notebook slides via Anaconda-navigator: When running this command in the terminal: jupyter nbconvert slides_test.ipynb --to slides --post serve. It will outputs this in your browser: And for the code cell output: This is very nice and I would like to use this but in VScode.

  23. How to use Jupyter Notebook on Windows, Linux, and macOS

    Once you're in the notebook dashboard, find and click on the New button. It's usually located at the top right. From the dropdown menu, select Python 3 to create a new notebook.; A new tab will ...

  24. How to share Jupyter notebooks

    The challenge of sharing a Jupyter notebook is nothing new — that's why there's a cottage industry built around making it easier to view them. GitHub repositories are a great way to organize static data notebooks and make them accessible to teammates, but therein lies the rub: They're static. Notebooks are rendered on GitHub, not run.

  25. #10 How to Create Presentation Slides in Jupyter Notebook

    You can also use your Jupyter Notebook to create presentation slides too. In this video i'll tell you step by step method that how can you easily create Pres...

  26. a post with jupyter notebook

    It basically calls jupyter nbconvert --to html to convert the notebook to an html page and then includes it in the post. Since Kramdown is the default Markdown renderer for Jekyll, we need to surround the call to the plugin with the ::nomarkdown tag so that it stops processing this part with Kramdown and outputs the content as-is.

  27. Anaconda Documentation

    Anaconda Documentation

  28. TensorFlow

    TensorFlow#. TensorFlow enables your data science, machine learning, and artificial intelligence workflows. This page shows how to install TensorFlow using the conda package manager included in Anaconda and Miniconda. TensorFlow CPU with conda is supported on 64-bit Ubuntu Linux 16.04 or later and macOS 10.12.6 or later.