How to Upload a Folder to Jupyter Notebook
How to Use Jupyter Notebook in 2020: A Beginner'due south Tutorial
Published: August 24, 2020
What is Jupyter Notebook?
The Jupyter Notebook is an incredibly powerful tool for interactively developing and presenting information science projects. This commodity will walk yous through how to use Jupyter Notebooks for data science projects and how to gear up it upwards on your local machine.
Start, though: what is a "notebook"?
A notebook integrates code and its output into a single document that combines visualizations, narrative text, mathematical equations, and other rich media. In other words: it's a single document where you tin run code, display the output, and also add explanations, formulas, charts, and brand your work more transparent, understandable, repeatable, and shareable.
Using Notebooks is now a major role of the information science workflow at companies across the world. If your goal is to piece of work with data, using a Notebook volition speed upwardly your workflow and brand information technology easier to communicate and share your results.
Best of all, as role of the open source Project Jupyter, Jupyter Notebooks are completely free. You can download the software on its own, or as function of the Anaconda data scientific discipline toolkit.
Although information technology is possible to utilise many dissimilar programming languages in Jupyter Notebooks, this commodity will focus on Python, as it is the most common utilize case. (Amidst R users, R Studio tends to be a more popular pick).
How to Follow This Tutorial
To get the virtually out of this tutorial you should be familiar with programming — Python and pandas specifically. That said, if you accept experience with another language, the Python in this commodity shouldn't be too cryptic, and will still assistance you get Jupyter Notebooks ready locally.
Jupyter Notebooks tin as well act as a flexible platform for getting to grips with pandas and even Python, every bit volition become apparent in this tutorial.
We will:
- Comprehend the basics of installing Jupyter and creating your first notebook
- Delve deeper and learn all the of import terminology
- Explore how easily notebooks tin can be shared and published online.
(In fact, this article was written as a Jupyter Notebook! Information technology's published hither in read-just class, simply this is a good example of how versatile notebooks can be. In fact, nigh of our programming tutorials and even our Python courses were created using Jupyter Notebooks).
Instance Data Analysis in a Jupyter Notebook
Beginning, nosotros will walk through setup and a sample assay to reply a existent-life question. This will demonstrate how the flow of a notebook makes data scientific discipline tasks more than intuitive for united states as we work, and for others once it'due south time to share our work.
So, let's say yous're a data analyst and you've been tasked with finding out how the profits of the largest companies in the United states changed historically. You lot find a data prepare of Fortune 500 companies spanning over 50 years since the list's start publication in 1955, put together from Fortune's public archive. Nosotros've gone ahead and created a CSV of the data you can use hither.
As we shall demonstrate, Jupyter Notebooks are perfectly suited for this investigation. First, let's get ahead and install Jupyter.
Installation
The easiest way for a beginner to become started with Jupyter Notebooks is by installing Anaconda.
Anaconda is the most widely used Python distribution for information science and comes pre-loaded with all the most popular libraries and tools.
Some of the biggest Python libraries included in Anaconda include NumPy, pandas, and Matplotlib, though the total 1000+ list is exhaustive.
Anaconda thus lets us hit the ground running with a fully stocked data scientific discipline workshop without the hassle of managing countless installations or worrying about dependencies and Bone-specific (read: Windows-specific) installation issues.
To get Anaconda, simply:
- Download the latest version of Anaconda for Python 3.8.
- Install Anaconda by post-obit the instructions on the download page and/or in the executable.
If you are a more advanced user with Python already installed and prefer to manage your packages manually, you can simply apply pip:
pip3 install jupyter Creating Your First Notebook
In this section, we're going to larn to run and save notebooks, familiarize ourselves with their construction, and empathize the interface. We'll become intimate with some cadre terminology that will steer y'all towards a practical agreement of how to use Jupyter Notebooks by yourself and set us up for the next section, which walks through an example data analysis and brings everything we learn here to life.
Running Jupyter
On Windows, you tin run Jupyter via the shortcut Anaconda adds to your start menu, which volition open a new tab in your default web browser that should wait something like the following screenshot.
This isn't a notebook just yet, but don't panic! There'due south not much to it. This is the Notebook Dashboard, specifically designed for managing your Jupyter Notebooks. Think of information technology every bit the launchpad for exploring, editing and creating your notebooks.
Be aware that the dashboard will give y'all access merely to the files and sub-folders contained within Jupyter's start-up directory (i.e., where Jupyter or Anaconda is installed). However, the start-up directory can be changed.
It is also possible to start the dashboard on any organisation via the command prompt (or last on Unix systems) by entering the command jupyter notebook; in this instance, the electric current working directory will be the kickoff-up directory.
With Jupyter Notebook open up in your browser, you may accept noticed that the URL for the dashboard is something similar https://localhost:8888/tree. Localhost is not a website, but indicates that the content is beingness served from yourlocal car: your own computer.
Jupyter's Notebooks and dashboard are web apps, and Jupyter starts up a local Python server to serve these apps to your web browser, making it essentially platform-independent and opening the door to easier sharing on the web.
(If y'all don't empathise this nonetheless, don't worry — the important point is just that although Jupyter Notebooks opens in your browser, it'south being hosted and run on your local machine. Your notebooks aren't actually on the spider web until you determine to share them.)
The dashboard's interface is mostly self-explanatory — though we will come back to information technology briefly later on. So what are we waiting for? Browse to the folder in which you would similar to create your first notebook, click the "New" drop-down button in the tiptop-correct and select "Python 3":
Hey presto, here we are! Your start Jupyter Notebook will open up in new tab — each notebook uses its own tab because you can open multiple notebooks simultaneously.
If you switch back to the dashboard, you lot will see the new file Untitled.ipynb and y'all should see some green text that tells you your notebook is running.
What is an ipynb File?
The short answer: each.ipynb file is one notebook, then each time you create a new notebook, a new.ipynb file will be created.
The longer reply: Each .ipynb file is a text file that describes the contents of your notebook in a format called JSON. Each cell and its contents, including image attachments that take been converted into strings of text, is listed therein along with some metadata.
You lot can edit this yourself — if you know what yous are doing! — by selecting "Edit > Edit Notebook Metadata" from the bill of fare bar in the notebook. You can besides view the contents of your notebook files past selecting "Edit" from the controls on the dashboard
However, the key word at that place is tin can. In most cases, there's no reason you should always demand to edit your notebook metadata manually.
The Notebook Interface
Now that yous take an open notebook in front of you, its interface volition hopefully not wait entirely alien. After all, Jupyter is essentially just an advanced word processor.
Why non take a wait effectually? Cheque out the menus to become a experience for it, particularly have a few moments to scroll down the list of commands in the command palette, which is the small-scale push button with the keyboard icon (or Ctrl + Shift + P).
There are 2 fairly prominent terms that you lot should notice, which are probably new to you:cells andkernels are cardinal both to agreement Jupyter and to what makes it more than than just a word processor. Fortunately, these concepts are not difficult to empathize.
- A kernel is a "computational engine" that executes the code contained in a notebook document.
- A cell is a container for text to be displayed in the notebook or code to be executed by the notebook'due south kernel.
Cells
We'll render to kernels a petty later, but outset let'southward come to grips with cells. Cells form the body of a notebook. In the screenshot of a new notebook in the section above, that box with the greenish outline is an empty prison cell. There are two primary cell types that we will cover:
- Alawmaking cell contains code to be executed in the kernel. When the code is run, the notebook displays the output below the lawmaking cell that generated information technology.
- AMarkdown cell contains text formatted using Markdown and displays its output in-place when the Markdown cell is run.
The first cell in a new notebook is always a code cell.
Permit'southward test it out with a classic hello world instance: Blazon impress('Hello World!') into the cell and click the run push button
in the toolbar above or pressCtrl + Enter.
The result should await like this:
impress ( 'How-do-you-do Globe!' ) Hello Globe! When we run the cell, its output is displayed below and the label to its left volition have changed from In [ ] toIn [ane].
The output of a code prison cell also forms function of the document, which is why you can see information technology in this commodity. Y'all can e'er tell the deviation between code and Markdown cells because lawmaking cells have that characterization on the left and Markdown cells do not.
The "In" part of the characterization is simply short for "Input," while the label number indicates when the jail cell was executed on the kernel — in this case the cell was executed first.
Run the jail cell once again and the label volition change to In [ii] considering now the jail cell was the 2nd to be run on the kernel. It will get clearer why this is so useful later when we accept a closer expect at kernels.
From the bill of fare bar, clickInsert and selectInsert Jail cell Beneath to create a new code cell underneath your start and try out the following code to see what happens. Do you find anything different?
import time time.sleep( 3 ) This cell doesn't produce any output, merely it does take 3 seconds to execute. Notice how Jupyter signifies when the cell is currently running by changing its label to In [*].
In general, the output of a cell comes from any text data specifically printed during the prison cell's execution, equally well every bit the value of the last line in the jail cell, exist it a solitary variable, a office call, or something else. For case:
def say_hello (recipient) : return 'Hello, {}!' .format(recipient) say_hello( 'Tim' ) 'Hullo, Tim!' You'll detect yourself using this well-nigh constantly in your own projects, and we'll run across more than of information technology later on.
Keyboard Shortcuts
I final thing you may have observed when running your cells is that their border turns blue, whereas it was green while y'all were editing. In a Jupyter Notebook, there is always i "active" cell highlighted with a border whose colour denotes its current mode:
- Green outline — cell is in "edit style"
- Blue outline — cell is in "command mode"
So what can nosotros do to a cell when it's in command mode? So far, we take seen how to run a cell withCtrl + Enter, but there are plenty of other commands nosotros tin utilize. The best way to utilise them is with keyboard shortcuts
Keyboard shortcuts are a very popular aspect of the Jupyter environment because they facilitate a speedy cell-based workflow. Many of these are deportment you can carry out on the active cell when it's in command mode.
Below, you lot'll find a list of some of Jupyter's keyboard shortcuts. Yous don't need to memorize them all immediately, but this list should give you lot a good idea of what'due south possible.
- Toggle between edit and command way with
EscandEnter, respectively. - One time in control way:
- Scroll up and down your cells with your
UpandDownwardlykeys. - Press
AorBto insert a new cell above or beneath the active cell. -
Mwill transform the active cell to a Markdown jail cell. -
Yvolition prepare the active prison cell to a code cell. -
D + D(Dtwice) will delete the active jail cell. -
Zvolition undo cell deletion. - Hold
Shiftand printingUporDownto select multiple cells at once. With multiple cells selected,Shift + 1000volition merge your choice.
- Scroll up and down your cells with your
-
Ctrl + Shift + -, in edit mode, will split the active cell at the cursor. - Yous can likewise click and
Shift + Clickin the margin to the left of your cells to select them.
Go ahead and effort these out in your own notebook. In one case y'all're ready, create a new Markdown cell and nosotros'll larn how to format the text in our notebooks.
Markdown
Markdown is a lightweight, piece of cake to acquire markup language for formatting plain text. Its syntax has a one-to-ane correspondence with HTML tags, and then some prior knowledge here would exist helpful simply is definitely non a prerequisite.
Recall that this article was written in a Jupyter notebook, so all of the narrative text and images you accept seen and then far were accomplished writing in Markdown. Let'due south cover the basics with a quick example:
# This is a level 1 heading ## This is a level two heading This is some obviously text that forms a paragraph. Add emphasis via **bold** and __bold__, or *italic* and _italic_. Paragraphs must be separated by an empty line. * Sometimes we want to include lists. * Which can be bulleted using asterisks. 1. Lists can as well be numbered. 2. If we want an ordered list. [It is possible to include hyperlinks](https://www.instance.com) Inline code uses single backticks: `foo()`, and code blocks use triple backticks: ``` bar() ``` Or can be indented past 4 spaces: foo() And finally, adding images is easy:  Here's how that Markdown would await once yous run the cell to render information technology:
(Note that the alt text for the prototype is displayed here considering we didn't actually utilise a valid image URL in our instance)
When attaching images, you have three options:
- Use a URL to an image on the web.
- Use a local URL to an image that you volition exist keeping alongside your notebook, such as in the aforementioned git repo.
- Add an attachment via "Edit > Insert Epitome"; this will catechumen the image into a string and shop it inside your notebook
.ipynbfile. Notation that this will make your.ipynbfile much larger!
There is plenty more to Markdown, especially around hyperlinking, and information technology's too possible to simply include plain HTML. Once you lot observe yourself pushing the limits of the nuts to a higher place, you can refer to the official guide from Markdown'south creator, John Gruber, on his website.
Kernels
Behind every notebook runs a kernel. When you lot run a code prison cell, that code is executed inside the kernel. Any output is returned back to the jail cell to be displayed. The kernel'south state persists over time and between cells — it pertains to the certificate as a whole and non individual cells.
For case, if you import libraries or declare variables in one cell, they will exist available in some other. Let's try this out to get a feel for it. First, nosotros'll import a Python bundle and ascertain a function:
import numpy as np def square (x) : return x * x Once we've executed the cell above, nosotros can reference np andfoursquare in any other cell.
ten = np.random.randint( one , 10 ) y = square(x) print ( '%d squared is %d' % (10, y) ) 1 squared is 1 This will work regardless of the order of the cells in your notebook. As long as a cell has been run, any variables you declared or libraries you lot imported will be available in other cells.
You can endeavour it yourself, permit'south impress out our variables again.
impress ( 'Is %d squared %d?' % (ten, y) ) Is ane squared i? No surprises hither! But what happens if we change the value ofy?
y = 10 impress ( 'Is %d squared is %d?' % (x, y) ) If nosotros run the cell above, what do you think would happen?
We will get an output like:Is 4 squared 10?. This is considering once nosotros've run they = x code jail cell, y is no longer equal to the square of x in the kernel.
Most of the time when you lot create a notebook, the menses will be superlative-to-bottom. But it's common to get back to make changes. When we do need to make changes to an earlier cell, the order of execution we tin see on the left of each cell, such every bit In [6], can help the states diagnose problems by seeing what guild the cells have run in.
And if we ever wish to reset things, there are several incredibly useful options from the Kernel menu:
- Restart: restarts the kernel, thus clearing all the variables etc that were defined.
- Restart & Clear Output: same as above just will also wipe the output displayed below your code cells.
- Restart & Run All: same equally above but will also run all your cells in society from first to last.
If your kernel is ever stuck on a computation and you lot wish to stop it, you tin choose the Interrupt choice.
Choosing a Kernel
You lot may have noticed that Jupyter gives y'all the option to change kernel, and in fact at that place are many different options to choose from. Back when you lot created a new notebook from the dashboard by selecting a Python version, you were really choosing which kernel to use.
There kernels for unlike versions of Python, and also for over 100 languages including Java, C, and fifty-fifty Fortran. Data scientists may be particularly interested in the kernels for R and Julia, as well as both imatlab and the Calysto MATLAB Kernel for Matlab.
The SoS kernel provides multi-language support within a single notebook.
Each kernel has its own installation instructions, but will probable require you to run some commands on your reckoner.
Example Analysis
Now we've looked atwhat a Jupyter Notebook is, it's time to look athow they're used in practice, which should give us clearer understanding of why they are so popular.
Information technology's finally time to get started with that Fortune 500 information fix mentioned earlier. Remember, our goal is to detect out how the profits of the largest companies in the US changed historically.
It'due south worth noting that anybody will develop their own preferences and way, but the general principles still apply. Y'all can follow along with this section in your own notebook if you lot wish, or use this as a guide to creating your own approach.
Naming Your Notebooks
Earlier you kickoff writing your project, you'll probably desire to requite it a meaningful name. file proper noun Untitled in the upper left of the screen to enter a new file proper noun, and striking the Save icon (which looks like a floppy deejay) beneath it to save.
Note that endmost the notebook tab in your browser volition not "close" your notebook in the way closing a document in a traditional application volition. The notebook's kernel volition continue to run in the background and needs to be shut downwards before it is truly "closed" — though this is pretty handy if you accidentally close your tab or browser!
If the kernel is shut downwardly, you can close the tab without worrying about whether it is withal running or not.
The easiest manner to do this is to select "File > Close and Halt" from the notebook carte du jour. However, yous can besides shutdown the kernel either by going to "Kernel > Shutdown" from within the notebook app or by selecting the notebook in the dashboard and clicking "Shutdown" (see image below).
Setup
It's common to start off with a lawmaking cell specifically for imports and setup, then that if yous choose to add or alter anything, you tin can simply edit and re-run the jail cell without causing any side-effects.
%matplotlib inline import pandas every bit pd import matplotlib.pyplot as plt import seaborn as sns sns.set(way= "darkgrid" ) We'll import pandas to work with our data, Matplotlib to plot charts, and Seaborn to make our charts prettier. It'south besides mutual to import NumPy but in this case, pandas imports it for united states of america.
That first line isn't a Python command, but uses something called a line magic to instruct Jupyter to capture Matplotlib plots and render them in the cell output. We'll talk a bit more nearly line magics later, and they're also covered in our advanced Jupyter Notebooks tutorial.
For now, let'southward go ahead and load our data.
df = pd.read_csv( 'fortune500.csv' ) It's sensible to also do this in a single cell, in case we need to reload it at whatever point.
Salvage and Checkpoint
Now we've got started, information technology's best do to salvage regularly. PressingCtrl + Due south will save our notebook past calling the "Salvage and Checkpoint" control, just what is this checkpoint thing?
Every fourth dimension we create a new notebook, a checkpoint file is created forth with the notebook file. It is located within a subconscious subdirectory of your salvage location called .ipynb_checkpoints and is too a.ipynb file.
By default, Jupyter will autosave your notebook every 120 seconds to this checkpoint file without altering your primary notebook file. When you "Save and Checkpoint," both the notebook and checkpoint files are updated. Hence, the checkpoint enables y'all to recover your unsaved work in the event of an unexpected consequence.
You can revert to the checkpoint from the menu via "File > Revert to Checkpoint."
Investigating Our Data Set
At present we're actually rolling! Our notebook is safely saved and we've loaded our data readydf into the most-used pandas data structure, which is chosen aDataFrame and basically looks similar a table. What does ours look similar?
df.caput( ) | Year | Rank | Visitor | Acquirement (in millions) | Profit (in millions) | |
|---|---|---|---|---|---|
| 0 | 1955 | 1 | General Motors | 9823.5 | 806 |
| 1 | 1955 | two | Exxon Mobil | 5661.4 | 584.8 |
| ii | 1955 | 3 | U.S. Steel | 3250.4 | 195.4 |
| iii | 1955 | four | General Electric | 2959.i | 212.six |
| iv | 1955 | 5 | Esmark | 2510.8 | 19.i |
df.tail( ) | Year | Rank | Company | Revenue (in millions) | Profit (in millions) | |
|---|---|---|---|---|---|
| 25495 | 2005 | 496 | Wm. Wrigley Jr. | 3648.six | 493 |
| 25496 | 2005 | 497 | Peabody Energy | 3631.6 | 175.four |
| 25497 | 2005 | 498 | Wendy's International | 3630.4 | 57.8 |
| 25498 | 2005 | 499 | Kindred Healthcare | 3616.vi | seventy.6 |
| 25499 | 2005 | 500 | Cincinnati Financial | 3614.0 | 584 |
Looking good. We have the columns nosotros demand, and each row corresponds to a unmarried visitor in a single yr.
Let'due south just rename those columns so we can refer to them subsequently.
df.columns = [ 'twelvemonth' , 'rank' , 'company' , 'revenue' , 'profit' ] Next, we need to explore our data ready. Is it complete? Did pandas read it as expected? Are any values missing?
len(df) 25500 Okay, that looks good — that's 500 rows for every year from 1955 to 2005, inclusive.
Let's check whether our data set has been imported every bit we would expect. A simple bank check is to see if the data types (or dtypes) have been correctly interpreted.
df.dtypes year int64 rank int64 company object revenue float64 profit object dtype: object Uh oh. It looks like there's something wrong with the profits cavalcade — we would look information technology to be afloat64 like the revenue column. This indicates that information technology probably contains some non-integer values, and then let'due south take a await.
non_numberic_profits = df.profit.str.contains( '[^0-9.-]' ) df.loc[non_numberic_profits] .head( ) | year | rank | company | revenue | profit | |
|---|---|---|---|---|---|
| 228 | 1955 | 229 | Norton | 135.0 | Northward.A. |
| 290 | 1955 | 291 | Schlitz Brewing | 100.0 | North.A. |
| 294 | 1955 | 295 | Pacific Vegetable Oil | 97.ix | N.A. |
| 296 | 1955 | 297 | Liebmann Breweries | 96.0 | N.A. |
| 352 | 1955 | 353 | Minneapolis-Moline | 77.iv | Northward.A. |
Only as we suspected! Some of the values are strings, which take been used to indicate missing information. Are there whatsoever other values that have crept in?
set(df.profit[non_numberic_profits] ) {'Northward.A.'} That makes it easy to interpret, but what should nosotros practice? Well, that depends how many values are missing.
len(df.turn a profit[non_numberic_profits] ) 369 Information technology's a small fraction of our data gear up, though non completely inconsequential as information technology is yet around 1.5%.
If rows containing Northward.A. are, roughly, uniformly distributed over the years, the easiest solution would just be to remove them. Then allow'due south have a quick look at the distribution.
bin_sizes, _, _ = plt.hist(df.yr[non_numberic_profits] , bins=range( 1955 , 2006 ) ) 
At a glance, we tin run across that the near invalid values in a single year is fewer than 25, and equally in that location are 500 data points per year, removing these values would account for less than iv% of the data for the worst years. Indeed, other than a surge around the 90s, most years accept fewer than one-half the missing values of the peak.
For our purposes, let'south say this is acceptable and go ahead and remove these rows.
df = df.loc[ ~non_numberic_profits] df.profit = df.profit.use(pd.to_numeric) We should bank check that worked.
len(df) 25131 df.dtypes year int64 rank int64 visitor object revenue float64 profit float64 dtype: object Great! We have finished our data ready setup.
If we were going to present your notebook as a written report, we could get rid of the investigatory cells nosotros created, which are included here as a demonstration of the flow of working with notebooks, and merge relevant cells (encounter the Advanced Functionality section below for more on this) to create a single data set setup cell.
This would mean that if we always mess up our data prepare elsewhere, nosotros can merely rerun the setup cell to restore it.
Plotting with matplotlib
Adjacent, nosotros tin get to addressing the question at paw by plotting the boilerplate profit by yr. We might also plot the revenue besides, so commencement nosotros can ascertain some variables and a method to reduce our code.
group_by_year = df.loc[ : , [ 'twelvemonth' , 'acquirement' , 'profit' ] ] .groupby( 'year' ) avgs = group_by_year.hateful( ) x = avgs.index y1 = avgs.profit def plot (x, y, ax, title, y_label) : ax.set_title(title) ax.set_ylabel(y_label) ax.plot(ten, y) ax.margins(ten= 0 , y= 0 ) Now let's plot!
fig, ax = plt.subplots( ) plot(x, y1, ax, 'Increase in mean Fortune 500 company profits from 1955 to 2005' , 'Profit (millions)' ) 
Wow, that looks similar an exponential, simply it'due south got some huge dips. They must correspond to the early 1990s recession and the dot-com chimera. It's pretty interesting to see that in the data. But how come profits recovered to even higher levels post each recession?
Possibly the revenues can tell u.s.a. more.
y2 = avgs.revenue fig, ax = plt.subplots( ) plot(x, y2, ax, 'Increase in mean Fortune 500 visitor revenues from 1955 to 2005' , 'Revenue (millions)' ) 
That adds some other side to the story. Revenues were non as desperately hit — that'south some great accounting work from the finance departments.
With a little assist from Stack Overflow, we tin superimpose these plots with +/- their standard deviations.
def plot_with_std (10, y, stds, ax, title, y_label) : ax.fill_between(ten, y - stds, y + stds, alpha= 0.two ) plot(x, y, ax, title, y_label) fig, (ax1, ax2) = plt.subplots(ncols= 2 ) title = 'Increase in mean and std Fortune 500 visitor %due south from 1955 to 2005' stds1 = group_by_year.std( ) .turn a profit.values stds2 = group_by_year.std( ) .revenue.values plot_with_std(x, y1.values, stds1, ax1, title % 'profits' , 'Profit (millions)' ) plot_with_std(10, y2.values, stds2, ax2, championship % 'revenues' , 'Revenue (millions)' ) fig.set_size_inches( 14 , 4 ) fig.tight_layout( ) 
That's staggering, the standard deviations are huge! Some Fortune 500 companies make billions while others lose billions, and the adventure has increased along with rising profits over the years.
Perhaps some companies perform better than others; are the profits of the tiptop 10% more than or less volatile than the bottom 10%?
There are plenty of questions that nosotros could look into next, and it's piece of cake to meet how the flow of working in a notebook tin can match i'southward own thought process. For the purposes of this tutorial, we'll terminate our analysis hither, but experience gratuitous to continue digging into the information on your ain!
This catamenia helped usa to easily investigate our data set in one place without context switching betwixt applications, and our work is immediately shareable and reproducible. If nosotros wished to create a more curtailed report for a item audience, we could quickly refactor our piece of work by merging cells and removing intermediary lawmaking.
Sharing Your Notebooks
When people talk about sharing their notebooks, at that place are generally two paradigms they may be considering.
Almost ofttimes, individuals share the end-outcome of their piece of work, much like this commodity itself, which ways sharing non-interactive, pre-rendered versions of their notebooks. Even so, it is also possible to interact on notebooks with the aid of version control systems such as Git or online platforms like Google Colab.
Before You Share
A shared notebook volition appear exactly in the land it was in when you lot export or salve it, including the output of any lawmaking cells. Therefore, to ensure that your notebook is share-ready, so to speak, there are a few steps you lot should have before sharing:
- Click "Cell > All Output > Clear"
- Click "Kernel > Restart & Run All"
- Wait for your code cells to terminate executing and cheque ran as expected
This will ensure your notebooks don't incorporate intermediary output, have a stale state, and execute in club at the time of sharing.
Exporting Your Notebooks
Jupyter has born support for exporting to HTML and PDF equally well as several other formats, which you lot can find from the menu under "File > Download As."
If you wish to share your notebooks with a small private group, this functionality may well be all you need. Indeed, as many researchers in academic institutions are given some public or internal webspace, and because you lot can consign a notebook to an HTML file, Jupyter Notebooks tin be an peculiarly convenient way for researchers to share their results with their peers.
But if sharing exported files doesn't cut it for you, there are as well some immensely popular methods of sharing.ipynb files more than direct on the web.
GitHub
With the number of public notebooks on GitHub exceeding 1.8 million past early 2018, it is surely the about popular independent platform for sharing Jupyter projects with the earth. GitHub has integrated support for rendering.ipynb files directly both in repositories and gists on its website. If you aren't already aware, GitHub is a code hosting platform for version control and collaboration for repositories created with Git. You'll demand an account to apply their services, merely standard accounts are free.
Once y'all have a GitHub account, the easiest mode to share a notebook on GitHub doesn't really require Git at all. Since 2008, GitHub has provided its Gist service for hosting and sharing code snippets, which each become their own repository. To share a notebook using Gists:
- Sign in and navigate to gist.github.com.
- Open up your
.ipynbfile in a text editor, select all and copy the JSON inside. - Paste the notebook JSON into the gist.
- Give your Gist a filename, remembering to add
.iypnbor this will not piece of work. - Click either "Create hole-and-corner gist" or "Create public gist."
This should wait something like the following:
If you created a public Gist, you will at present be able to share its URL with anyone, and others will be able to fork and clone your work.
Creating your own Git repository and sharing this on GitHub is beyond the scope of this tutorial, just GitHub provides plenty of guides for yous to get started on your own.
An actress tip for those using git is to add an exception to your.gitignore for those hidden.ipynb_checkpoints directories Jupyter creates, so as not to commit checkpoint files unnecessarily to your repo.
Nbviewer
Having grown to return hundreds of thousands of notebooks every week by 2015, NBViewer is the virtually popular notebook renderer on the web. If yous already have somewhere to host your Jupyter Notebooks online, exist it GitHub or elsewhere, NBViewer will render your notebook and provide a shareable URL forth with it. Provided as a complimentary service equally part of Project Jupyter, it is bachelor at nbviewer.jupyter.org.
Initially developed before GitHub'southward Jupyter Notebook integration, NBViewer allows anyone to enter a URL, Gist ID, or GitHub username/repo/file and it will render the notebook as a webpage. A Gist's ID is the unique number at the stop of its URL; for instance, the string of characters later on the last backslash inhttps://gist.github.com/username/50896401c23e0bf417e89cd57e89e1de. If you enter a GitHub username or username/repo, you will see a minimal file browser that lets yous explore a user's repos and their contents.
The URL NBViewer displays when displaying a notebook is a constant based on the URL of the notebook information technology is rendering, then y'all can share this with anyone and it volition work as long equally the original files remain online — NBViewer doesn't cache files for very long.
If you lot don't like Nbviewer, at that place are other similar options — here's a thread with a few to consider from our community.
Extras: Jupyter Notebook Extensions
We've already covered everything you demand to go rolling in Jupyter Notebooks.
What Are Extensions?
Extensions are precisely what they sound like — additional features that extend Jupyter Notebooks's functionality. While a base of operations Jupyter Notebook can practise an atrocious lot, extensions offering some additional features that may help with specific workflows, or that only improve the user experience.
For example, 1 extension called "Table of Contents" generates a table of contents for your notebook, to make large notebooks easier to visualize and navigate effectually.
Another i, called Variable Inspector, will bear witness you the value, type, size, and shape of every variable in your notebook for like shooting fish in a barrel quick reference and debugging.
Another, chosen ExecuteTime, lets you know when and for how long each cell ran — this tin can be specially convenient if y'all're trying to speed upwards a snippet of your code.
These are just the tip of the iceberg; there are many extensions bachelor.
Where Can You Get Extensions?
To go the extensions, yous need to install Nbextensions. You can do this using pip and the command line. If you accept Anaconda, it may be ameliorate to do this through Anaconda Prompt rather than the regular command line.
Close Jupyter Notebooks, open Anaconda Prompt, and run the following command: pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install.
Once yous've washed that, start up a notebook and you should seen an Nbextensions tab. Clicking this tab will show you a list of available extensions. Merely tick the boxes for the extensions y'all want to enable, and y'all're off to the races!
Installing Extensions
Once Nbextensions itself has been installed, there's no demand for boosted installation of each extension. However, if you lot've already installed Nbextensons simply aren't seeing the tab, you're not alone. This thread on Github details some common issues and solutions.
Extras: Line Magics in Jupyter
Nosotros mentioned magic commands earlier when we used %matplotlib inline to make Matplotlib charts render correct in our notebook. There are many other magics nosotros can use, too.
How to Use Magics in Jupyter
A skilful first footstep is to open a Jupyter Notebook, type %lsmagic into a cell, and run the cell. This volition output a listing of the available line magics and prison cell magics, and it volition also tell you whether "automagic" is turned on.
- Line magics operate on a single line of a code cell
- Cell magics operate on the unabridged lawmaking cell in which they are called
If automagic is on, you lot can run a magic but by typing it on its own line in a lawmaking prison cell, and running the cell. If it is off, yous will need to put% before line magics and%% before cell magics to use them.
Many magics require additional input (much like a function requires an argument) to tell them how to operate. We'll look at an example in the adjacent section, only you can run across the documentation for any magic by running it with a question mark, like so:
%matplotlib? When you run the above prison cell in a notebook, a lengthy docstring volition pop up onscreen with details near how you can utilise the magic.
A Few Useful Magic Commands
We cover more in the advanced Jupyter tutorial, simply here are a few to become you started:
| Magic Command | What information technology does |
|---|---|
| %run | Runs an external script file equally part of the cell being executed. For example, if %run myscript.py appears in a code cell, myscript.py volition be executed past the kernel every bit function of that cell. |
| %timeit | Counts loops, measures and reports how long a code cell takes to execute. |
| %writefile | Save the contents of a cell to a file. For example,%savefile myscript.py would save the code jail cell as an external file called myscript.py. |
| %store | Save a variable for use in a unlike notebook. |
| %pwd | Print the directory path you're currently working in. |
| %%javascript | Runs the jail cell as JavaScript code. |
There's plenty more where that came from. Hop into Jupyter Notebooks and start exploring using %lsmagic!
Last Thoughts
Starting from scratch, we have come to grips with the natural workflow of Jupyter Notebooks, delved into IPython's more advanced features, and finally learned how to share our work with friends, colleagues, and the earth. And we accomplished all this from a notebook itself!
It should exist clear how notebooks promote a productive working experience past reducing context switching and emulating a natural development of thoughts during a project. The power of using Jupyter Notebooks should too be evident, and nosotros covered plenty of leads to get you started exploring more than advanced features in your own projects.
If you'd like further inspiration for your own Notebooks, Jupyter has put together a gallery of interesting Jupyter Notebooks that you may find helpful and the Nbviewer homepage links to some actually fancy examples of quality notebooks.
More than Great Jupyter Notebooks Resource
- Advanced Jupyter Notebooks Tutorial – Now that you've mastered the nuts, go a Jupyter Notebooks pro with this advanced tutorial!
- 28 Jupyter Notebooks Tips, Tricks, and Shortcuts – Make yourself into a power user and increment your efficiency with these tips and tricks!
- Guided Project – Install and Learn Jupyter Notebooks – Give yourself a great foundation working with Jupyter Notebooks by working through this interactive guided project that'll go you lot ready upward and teach you lot the ropes.
Ready to keep learning?
Never wonder What should I learn next? once more!
On our Python for Data Science path, y'all'll learn:
- Data cleaning, assay, and visualization with matplotlib and pandas
- Hypothesis testing, probability, and statistics
- Automobile learning, deep learning, and decision copse
- ...and much more than!
Showtime learning today with any of our threescore+ free missions:
Tags
bendrodtbodem1958.blogspot.com
Source: https://www.dataquest.io/blog/jupyter-notebook-tutorial/