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

  • 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?

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.

Mouse Vs Python

Creating a Presentation with Jupyter Notebook and RISE (Video)

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.

Want to learn more about Jupyter Notebook? Then check out my book, Jupyter Notebook 101 , available on Leanpub , Amazon , and Gumroad

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!

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/.

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

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.

The Ultimate Python Pandas Cheat Sheet

The Ultimate Python Pandas Cheat Sheet

The Successful AI Team: How to Hire and Keep a Happy and Productive Team

The Successful AI Team: How to Hire and Keep a Happy and Productive Team

How to Create Visualizations Using Matplotlib

How to Create Visualizations Using Matplotlib

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

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.

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
  • Choosing the Right Path Among a Plethora of Mobile App Development Methodologies
  • Building and Deploying a Chatbot With Google Cloud Run and Dialogflow
  • Efficient ITSM Incident Resolution: Leveraging Azure AI Services for Quick Solutions
  • O11y Guide, Cloud-Native Observability Pitfalls: Focusing on "The Pillars"

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:

Things Michael Thinks

Data science in learning, creating an interactive presentation with jupyter notebook and plotly.

Let’s say you have performed some analysis using Jupyter notebook and produced some great visualisations to back up your finding. How would you present this to your stakeholders and other people? One great way to ace this is to convert your jupyter notebook and plotly graphs to an interactive presentation that can impress people.

Introduction

I learned on creating slides using Jupyter Notebook from Tahsin Mayeesha’s medium post . However, I was curious to see if I can incorporate interactive graphs from Plotly in the slides. Therefore, I wrote this post to share what I’ve learned.

For this post, I will use the Titanic dataset from Kaggle . This dataset is a classic dataset used to learn machine learning models on classification problems.

In this case, my aim was to present my finding from an Exploratory Data Analysis on the Titanic dataset. I would include several visualisations and slides to show what you can do with Jupyter markdown and slides. Although I would use Plotly mostly for the slides, I have also included one plot with Seaborn and one plot from Pandas Profiling library to show the possibilities you can do.

For my presentation, I imported the following visualisation libraries.

  • Plotly, including the Plotly Express and Plotly Graph Objects
  • Pandas Profiling visualisation for missing values in the dataframe.

All the libraries above are not required to make the slides work, you can just simply use Plotly , Seaborn , or even simply Matplotlib . You can check the full notebook on my GitHub repo here .

Jupyter Notebook Slideshow View and Setting

alt text

Changing the view will allow you to set what type of slides you want for each cell. There are 5 Slide Types you can select:

  • Slide . This is the main content of a slide. You can place markdown, visuals, or even code here.
  • Sub-Slide . I will consider this as a new slide with transition animation. You have to use the down arrow navigation to access it from the main slide (Slide type).
  • Fragment . This will be a part or component of the immediate previous cell with Slide Type. For example, one cell with the heading will be set as Slide and the visualisation will be set as Fragment. The fragment will be inside the main slide but with a fade-in transition.
  • Skip . This cell will not be shown on the slides. Perfect for code and comment cells that you won’t show. Be aware that you can’t put skip for your visualisation code because the output will not be shown as well.
  • Notes . This will create Speaker notes, but I haven’t tried this function. From the NbConvert reference , you need to have a local copy of the Reveal.JS file to allow you having a presenter view with the notes.

Skip type for Non-Visualisation Code Cell

alt text

Slide type for Title and Markdown Cell

For the first slide or the cover, I will only use one markdown cell with title, subtitle, and author.

alt text

Slide + Fragment types for Mixture of Markdown and Code Cells

alt text

Hiding the Codes on the Slide

alt text

Specific for Plotly

If you use plotly, then you need to pay attention in this section. Otherwise, your plotly graphs won’t show up in the slides.

Plotly will require its JavaScript file ( plotly.js ) to produce the graph. There are three options you can choose:

  • A local copy of JavaScript file. This is the easiest and simplest way to ensure the Plotly graphs to work. You can download the latest JS file from this link and rename it into plotly.js. This file needs to be in the same folder or directory with the resulting HTML slides file.
  • Refer to CDN online. This is a great option if you want a lightweight HTML file and have constant access to the Internet. This is perfect if you want to embed the slides on a website. To do this, create a new code cell at the beginning, include this code here: from IPython.display import Javascript Javascript ( """require.config({ paths: { plotly: 'https://cdn.plot.ly/plotly-latest.min' } });""" )

The get_plotlyjs function would return the whole minified Plotly JS script and by using the Javascript function from IPython we include this in the notebook. The resulting file would be 3MB larger because of the inclusion. However, you will only have one HTML file that you can just send or use anytime.

Converting the Notebook to Slides

To produce the slides from the jupyter notebook, run the following code on your command prompt or bash:

Here we are calling nbconvert function that can be used to convert the notebook into slides (HTML format with Reveal.js) or other formats as can be referred on the documentation .

The TagRemovePreprocessor will remove any code with to_remove tag as we specified. Again, this can be replaced with any other tag you specified before hand.

If you check your directory, the html version of your notebook will be there. You can open this on the web browser and use the directional pad on the screen or arrow keys on your keyboard to navigate. I was able to open the file and interact with Plotly graphs successfully using Chrome, Firefox, Opera, and Microsoft Edge. I heard this might not work so well with Safari but I can’t confirm this.

For me personally, I found that using --post serve , I could not terminate the server using Ctrl-C as described even after many tries. However, I also found that I can omit this in my command prompt and still get the HTML slides file.

Final Output of the Slides

Here are the following slides I produced from my jupyter notebook that you can find on GitHub

  • presentation

Create Parameterized Presentation in Jupyter Notebook

Create Parameterized Presentation in Jupyter Notebook

In this article, I will show you how you can easily add interactive widgets to the presentation with Mercury framework.

Jupyter Notebook Presentation

In the previous article, I describe how to create a Jupyter Notebook presentation with Reveal.js . The notebook is presented below:

It can be converted to a static HTML file with nbconvert application:

The HTML presentation can be published as static HTML website.

You can check the code of Jupyter Notebook with a presentation in the GitHub repository .

Add widgets to the presentation

The Mercury framework can be used to add interactive widgets to the presentation easily. The widgets are added based on the YAML header inserted in the notebook's first raw cell. You can read more about available YAML parameters in Mercury's documentation .

Below the YAML header adding four widgets to the presentation:

There are added four widgets to the presentation:

  • greetings a select widget,
  • name a text input,
  • points_count a slider widget,
  • color a select widget.

Please note that widgets have the same names as Python variables. The important update in the notebook is to move all variables that are controlled by external widgets into the same cell. The cell with variables should be just below the YAML header.

All variables that are controlled with widgets are in one cell:

Please install the mljar-mercury package to check the presentation:

Mercury server can be run locally with the following command:

The server will automatically detect all notebooks in the directory and serve them as interactive web applications. Here is a preview of how the presentation looks in the Mercury app:

The User can change widgets values and click the Run button to recompute slides:

It is possible to update the chart during the slideshow:

You can open the presentation in full-screen mode by pressing the F on the keyboard. Please press Esc to exit the full-screen view.

The Jupyter Notebook presentations can be very helpful for sharing your results with non-technical stakeholders. You can create a presentation with a mix of code and Markdown. There is no need to copy & paste charts in slides manually. The presentation update is just rerunning all cells. You can go one step further with Mercury open-source framework and create interactive presentations. The widgets can be added to the presentation. The user can tweak widgets values and recompute slides during the slideshow. What is more, Mercury gives you nice features like:

  • export slides to PDF format,
  • restricted access for authenticated users only,
  • scheduled execution of slides.

Ready-to-use Presentations

Pick a topic to present with ready-made presentations, introduction to jupyter notebooks with python, module source.

Get started with Jupyter notebooks for Python

In this workshop, you will learn how to use Jupyter notebooks to run Python by building a 🚀 spaceship manual 🚀 that has interactive, runnable Markdown and code elements.

workshop walk-through

🎥 Click this image to watch Chris walk you through the workshop starting at 1:16:00

Pre-Learning

Read this introduction to GitHub .

Prerequisites

Python 3 or greater.

You will build a project using Python, so you will also need Python installed locally. To test if you have Python installed, open a command or terminal window and run the following commands:

If Python is installed a version number will be displayed, such as 3.8.10 . Otherwise, an error message is displayed. You can install Python as needed:

Visual Studio Code

Be sure to have Visual Studio Code , an open source code editor, installed locally.

What you will learn

Suppose you are a crew member on a spaceship. Your mission is to deliver some important equipment to the International Space Station (ISS). If you’re not familiar with some of the many buttons on the spaceship’s console, it’s better not to learn by the trial-and-error method, mid-flight! In this workshop, you’ll build a ship’s manual as a Jupyter notebook, discovering the many ways to use this technology. You will:

  • Set up your environment
  • Create and run a notebook

Use advanced commands

  • Take a quiz

Introduction

Learn about Jupyter notebooks and get ready to build!

Setup your environment

Install Python, VS Code, and the Python extension, if you haven’t yet done so.

Create and run your notebook

Create a notebook for your ship’s manual. Write an element in Markdown and write some runnable code.

Using Numpy, perform ship calculations and show them as a visualization.

Test your knowledge!

Take a quiz either on Learn or via the slides.

This module introduced some core elements of the many things you can do in Jupyter notebooks. For inspiration, you can check out an interesting gallery of Jupyter notebooks on GitHub .

Now you know how to create and use Jupyter notebooks, you can learn how to use them in the context of Data Science and Machine Learning. Explore this learning path on Data Science with Notebooks to learn more about the many tools you can use to build your own data science projects. To learn more about Python as a language, complete this learning path on Python .

Be sure to give feedback about this workshop !

Code of Conduct

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!

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

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 }

pdf

Comment ouvrir, consulter et éditer un fichier IPYNB ?

Si vous travaillez avec Jupyter Notebook, il est probable que vous vous serviez de fichiers IPYNB. Dans ce guide, nous allons vous apprendre tout ce que vous devez savoir à propos de cette extension de fichier. Nous verrons ce qu'est un fichier IPYNB, à quoi il sert le plus souvent, comment l'ouvrir et l'éditer.

Qu'est-ce qu'un fichier IPYNB ?

Histoire de l’extension de fichier ipynb, à quoi servent les fichiers ipynb , avantages et inconvénients du format ipynb, comment ouvrir un fichier ipynb , comment créer et éditer un fichier ipynb , comment convertir un fichier ipynb en pdf , d’autres formats similaires au ipynb, faq fichier ipynb.

Une extension de fichier IPYNB est un fichier texte utilisé par Jupyter Notebook – un programme informatique interactif basé sur le web qui aide les utilisateurs à analyser et à manipuler des données en utilisant le langage de programmation Python. IPYNB est l'extension officielle des fichiers Jupyter Notebook.

Les fichiers IPYNB contiennent le contenu d'une session Jupyter Notebook, comme les données d'entrée et de sortie des calculs, les fonctions numériques et le texte.

Que signifie IPYNB ?

Jupyter Notebook est le successeur d'un logiciel officiellement appelé IPython Notebook, ce qui explique le nom du fichier IPYNB. L'extension de fichier .ipynb est une abréviation de IPython Notebook. Bien que le format de fichier IPYNB ait été initialement conçu pour être utilisé avec IPython, il est aujourd'hui principalement utilisé par Jupyter Notebook, conservant ainsi son nom d'origine.

Découvrez les outils en ligne d'Adobe

Utilisez les outils gratuits d'Adobe Acrobat

Comme mentionné précédemment, l'extension du fichier IPYNB provient du logiciel IPython Notebook. Fernando Pérez et une équipe de physiciens ont publié la première version des bloc-notes pour IPython en 2011. L'idée était de créer un flux de travail interactif permettant aux utilisateurs d'analyser de grandes quantités de données de manière transparente et collaborative. 

En 2014, Pérez a présenté un projet dérivé pour IPython appelé Project Jupyter. Le projet Jupyter a ensuite remplacé IPython, car il a évolué pour prendre en charge les données interactives et l'informatique scientifique à travers plus de 100 langages de programmation différents. Les fichiers IPYNB sont aujourd’hui essentiellement utilisés par Jupyter Notebook.

Ces types de fichiers de bloc-notes ont diverses utilisations :

Exploiter et analyser le langage Python

Les fichiers IPYNB sont surtout utilisés par Jupyter Notebook – un programme informatique interactif conçu pour aider les utilisateurs à maîtriser et à analyser le langage Python.

Créer des documents de calcul

L'extension de fichier IPYNB permet aux utilisateurs de créer des fichiers de calcul dans Jupyter Notebook. Lorsque vous créez un nouveau document Jupyter, le fichier est automatiquement enregistré au format IPYNB, autrement appelée extension de fichier Jupyter Notebook.

Garder une trace des données de calcul 

Les fichiers IPYNB servent à enregistrer les calculs, car ils contiennent un journal du contenu d'une session web Jupyter Notebook. Il peut s'agir d'entrées et de sorties de calcul, de fonctions mathématiques et de textes explicatifs.

Favoriser la collaboration 

Parfois, les utilisateurs téléchargent les fichiers au format IPYNB grâce à une URL accessible au public. Cela permet à d'autres utilisateurs de télécharger et d'accéder facilement à ces fichiers en ligne, sans avoir à installer de logiciel tiers. Un avantage qui favorise assurément la collaboration entre plusieurs parties prenantes d’un projet. 

Avec Adobe, découvrez d'autres types de formats de fichiers de texte et d’autres formats de document . 

Comme tous les autres types de formats, les fichiers IPYNB présentent leurs propres avantages et inconvénients.

Avantages du format IPYNB

  • Un format lisible pour l'homme : il s'agit de fichiers de texte brut formatés à l'aide de JSON (JavaScript Object Notation), ce qui les rend faciles à lire. 
  • Une norme ouverte : IPYN a été enregistrée dans un format ouvert. Cela signifie essentiellement que les données sont ouvertes à tous. 
  • Possibilité de conversion dans d'autres formats : les fichiers IPYNB peuvent être convertis aux formats HTML , PDF, reStructuredText et LateX.

Inconvénients du format IPYNB

  • Capacités textuelles limitées : il n'est pas possible d'y ajouter du texte formaté, comme des tailles et des styles de police différents.
  • Problèmes de débogage : l'exécution non linéaire peut rendre le débogage des documents IPYNB difficile, en particulier si vous perdez la trace des cellules que vous avez ou n'avez pas exécuté.
  • Un format difficile à mettre en place dans des environnements plus complexes : si vous travaillez avec de grandes quantités de données qui sont trop grandes pour la mémoire de votre ordinateur, l'utilisation d'IPYNB peut s'avérer difficile.

Vous pouvez ouvrir un fichier IPYNB sous Windows, Mac, Linux et sur le Web avec Jupyter Notebook. 

Pour commencer, suivez les étapes suivantes :

  • Installez Jupyter Notebook sur votre ordinateur. Vous pouvez également ouvrir l'application si Jupyter Notebook est déjà installé.
  • Cliquez sur l'icône « Upload », située dans le coin droit de l'écran.
  • Une page pop-up s'ouvre dans laquelle vous pouvez rechercher et sélectionner le fichier IPYNB que vous désirez lancer.    
  • Une fois que vous avez localisé votre fichier IPYNB, cliquez sur « Ouvrir ».
  • Double-cliquez sur le fichier dans l'application Jupyter. Cela devrait ouvrir votre fichier IPYNB dans un onglet séparé.

Vous pouvez créer et éditer un fichier IPYNB dans Jupyter Notebook. Pour commencer, il suffit de :

  • Installer ou ouvrir l'application Jupyter Notebook
  • Cliquer sur l'onglet « Nouveau » (situé dans le coin droit de l'écran).
  • Sélectionner Python 3 dans le menu déroulant
  • Un nouveau fichier de carnet de notes IPYNB s'ouvre afin que vous puissiez le créer et l’éditer à votre guise. 

Vous pouvez également créer et enregistrer des fichiers IPYNB à l'aide de Microsoft Visual Studio Code.

Si vous souhaitez convertir votre fichier .ipynb dans un format plus facile à partager, le convertisseur PDF en ligne gratuit d'Adobe est un excellent point de départ.

C’est très simple :

  • Glissez-déposez votre fichier dans l'outil ou sélectionnez-le à partir de votre appareil.
  • Attendez que la conversion s'effectue, ce processus peut prendre quelques secondes
  • Téléchargez ou partagez le document converti. 

Si votre fichier IPYNB n'est pas lisible dans sa forme actuelle, vous pouvez utiliser un logiciel gratuit en ligne pour le convertir au format TXT ou DOCX, puis le convertir au format PDF comme indiqué ci-dessus à l'aide du convertisseur général ou du convertisseur Word en PDF .

Découvrez ce type de fichier, utilisé par divers programmes et systèmes d'exploitation pour conserver une trace des événements survenus sur votre ordinateur.

Cliquez ici pour en savoir plus sur le format de fichier standard pour enregistrer des documents dans Microsoft Word.

Tout ce que vous devez savoir sur le type de fichier qui sert aux utilisateurs de Microsoft Outlook à échanger des messages électroniques et des rendez-vous.

Le document texte standard, qui peut être ouvert et modifié dans n'importe quel éditeur de texte ou programme de traitement de texte. Notre guide sur le .txt vous en dévoilera plus. 

Découvrez d'autres types de fichiers Adobe

Zoom sur les extensions de fichiers et autres types de formats de fichier texte par Adobe

Quelle est la différence entre un fichier PY et un fichier IPYNB ? 

La principale différence entre un fichier PY et un fichier IPYNB réside dans le fait que le fichier PY est un fichier de programmation Python ordinaire, c'est-à-dire un fichier de texte brut qui ne contient que du code. En revanche, un fichier IPYNB est un fichier de bloc-notes Python qui contient du code de bloc-notes ainsi que des résultats d'exécution et d'autres réglages internes. 

Comment supprimer un fichier IPYNB ?

Vous pouvez supprimer un fichier IPYNB en ouvrant l'application Jupyter Notebook et en accédant au tableau de bord. À partir de là, sélectionnez la petite case à cocher (située à gauche du nom du fichier), puis sélectionnez l'icône rouge de la poubelle, en haut à gauche du menu du tableau de bord. 

Comment convertir un fichier IPYNB en format python .PY ?

Convertir un fichier LPYNB en PY ne pose aucun problème. Il suffit de lancer l'application Jupyter Notebook, puis d'ouvrir le fichier LPYNB à convertir. Naviguez vers le menu Fichier et sélectionnez la commande qui permet de télécharger le fichier. Cliquez ensuite sur l'option « Python » (.py). Et voilà, c'est aussi simple que cela.

Comment réduire la taille de mon fichier IPYNB ?

Pour réduire la taille de votre fichier IPYNB, sélectionnez le menu « Cellule » (Cell) en haut de l'application Jupyter Notebook. Sélectionnez « Toutes les sorties » (All Output) dans le menu déroulant , puis « Effacer » (Clear). Enregistrez ensuite votre fichier. Cette opération devrait diminuer la taille de votre fichier et vous permettre d'accélérer le temps d'ouverture du fichier.

Pourquoi mon fichier IPYNB est-il si lourd ?

Lorsque vous enregistrez un fichier IPYNB, il enregistre toutes les sorties de toutes les cellules, ce qui implique parfois de grandes quantités de données. Pour réduire la taille de votre fichier LPYNB, cliquez sur le menu « Toutes les sorties » (All Output) de l'application Jupyter Notebook, puis sur « Effacer » (Clear).

Découvrez d’autres formats de fichiers

  • Fichier WPS
  • Fichier .ASC
  • Fichier LOG

Testez ces outils Acrobat en ligne.

Convertir un PDF

PDF en Word

PDF en Excel

Convertisseur PDF

Convertir en PDF

Word en PDF

Excel en PDF

Réduire la taille des fichiers

Compresser un PDF

Modifier un PDF

Fusionner des PDF

Fractionner un PDF

Recadrer un PDF

Supprimer des pages PDF

Faire pivoter les pages d’un PDF

Réorganiser des pages PDF

Extraire des pages d’un PDF

Insérer des pages dans un PDF

Numéroter les pages d'un PDF

Signer et protéger

Remplir et signer

Demander des signatures électroniques

Protéger un PDF

Language Navigation

IMAGES

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

    presentation in jupyter notebook

  2. How to Create Presentation Slides from Jupyter Notebooks

    presentation in jupyter notebook

  3. Getting Started with Machine Learning: Free Jupyter Notebooks

    presentation in jupyter notebook

  4. presentation in jupyter notebook

    presentation in jupyter notebook

  5. how to make a presentation in jupyter notebook

    presentation in jupyter notebook

  6. how to make a presentation in jupyter notebook

    presentation in jupyter notebook

VIDEO

  1. Jupyter Notebook Quickstart

  2. jupyter notebook create python file

  3. convert jupyter notebook to python file

  4. Python 01 Jupyter Notebook Setting

  5. Jupyter Notebook Batch Fix JSON files

  6. Insert Image in Jupyter Notebook

COMMENTS

  1. 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.

  2. Presenting Code Using Jupyter Notebook Slides

    Jupyter notebook slides offer a simple, clear layout and are incredibly easy to create. While they do not offer the amount of formatting and design features as other presentation applications,...

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

    The presentation slides option from jupyter notebook speaks for itself. This is an alternative to copy-and-pasting screen captures into other presentation software. 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

  4. 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.

  5. Create a slide deck using Jupyter Notebooks

    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.

  6. 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.

  7. 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.

  8. 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

  9. 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...

  10. Creating a Presentation with Jupyter Notebook and RISE (Video)

    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. Creating a Presentation with Jupyter Notebook and RISE Watch on Want to learn more about Jupyter Notebook? Then check out my book, Jupyter Notebook 101, available on Leanpub, Amazon, and Gumroad

  11. 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 ...

  12. Using a Jupyter notebook to make presentation slides

    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. The same week that I'm giving this talk, I'm also presenting the H0 review ...

  13. 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 s...

  14. 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.

  15. 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...

  16. 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.

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

    Jan 14 -- When considering tools for creating slide presentations, the usual suspects often come to mind: Microsoft PowerPoint and Google Slides. Both are excellent choices, offering a wide array...

  18. 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

  19. 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....

  20. Creating an Interactive Presentation with Jupyter Notebook and Plotly

    You can check the full notebook on my GitHub repo here. Jupyter Notebook Slideshow View and Setting. In Jupyter Notebook, each cell can play a part in the presentation slides. To set the role each cell play, you have to change the cell toolbar view by View -> Cell Toolbar -> Slideshow.

  21. Create Parameterized Presentation in Jupyter Notebook

    The Jupyter Notebook presentations can be very helpful for sharing your results with non-technical stakeholders. You can create a presentation with a mix of code and Markdown. There is no need to copy & paste charts in slides manually. The presentation update is just rerunning all cells. You can go one step further with Mercury open-source ...

  22. Introduction to Jupyter Notebooks with Python

    In this workshop, you will learn how to use Jupyter notebooks to run Python by building a 🚀 spaceship manual 🚀 that has interactive, runnable Markdown and code elements. Video 🎥 Click this image to watch Chris walk you through the workshop starting at 1:16:00 Pre-Learning Read this introduction to GitHub. Prerequisites Python 3 or greater

  23. Working with Jupyter Notebooks in Visual Studio Code

    Jupyter (formerly IPython Notebook) is an open-source project that lets you easily combine Markdown text and executable Python source code on one canvas called a notebook. Visual Studio Code supports working with Jupyter Notebooks natively, and through Python code files.

  24. How to share Jupyter notebooks

    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 ...

  25. 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 ...

  26. Anaconda Documentation

    Anaconda Documentation

  27. 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.

  28. Notebooks as code

    Notebooks as code¶ The percent format¶. The percent format is a representation of Jupyter notebooks as scripts, in which all cells are explicitly delimited with a commented double percent sign # %%.The percent format is currently available for these languages.. The format was introduced by Spyder in 2013, and is now supported by many editors, including ...

  29. Fichiers IPYNB: tout savoir sur le format Jupyter Notebook

    Lorsque vous créez un nouveau document Jupyter, le fichier est automatiquement enregistré au format IPYNB, autrement appelée extension de fichier Jupyter Notebook. Garder une trace des données de calcul Les fichiers IPYNB servent à enregistrer les calculs, car ils contiennent un journal du contenu d'une session web Jupyter Notebook.