GitLab upgrade completed. Current version is 17.10.3. We now benefit from the enhancements of 17.9 and 17.10 releases. Among other improvements, it is now possible to set the automatic deletion of continuous integration pipelines. You can help us reduce storage usage by setting an expiry date for your pipelines.
This is an archived project. Repository and other project resources are read-only.
"The course material of this Mooc is proposed in Jupyter notebooks which are documents that contain live code, equations, visualizations and narrative text. \n",
"\n",
"To manipulate these notebooks, the open-source web application Jupyter has been integrated into this Mooc. It does not require any installation on your side. All data and calculations will be hosted on our servers.\n",
"\n",
"This document is an example of a Jupyter Notebook. It presents you the Jupyter interface and how tu use the notebooks.\n",
"\n",
"Please note that **code parts can be evaluated and modified**. So you can easily try out variants around the original notebook. Don't hésitate because you will be able to reset to the original version of the notebook.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## How to use Jupyter Notebooks\n",
"### Executing Python code"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"At the top of the notebook, you have a menu bar, containing:\n",
"\n",
"* a menu bar with the entries `File`, `Edit`, `Insert`, `Cell`, `Kernel`;\n",
"* and a button bar that are shortcuts to some frequently used menus. If you leave your mouse over a button, a small text will appear, indicating what function the button is for.\n",
"\n",
"A notebook consists of a series of cells, either textual or containing code. The code cells are easily recognisable, they are preceded by `In [ ]:`. The cell following the one you are reading is a code cell.\n",
"\n",
"To start, select this code cell below with your mouse, and press in the menu bar - at the top of the notebook, therefore - on the one in the form of a triangular arrow to the right (Run) :"
"As you can see, the cell is \"executed\" (more commonly called evaluated), and we move on to the next cell.\n",
"\n",
"Alternatively, you can simply type on the keyboard ***Shift+Enter***, or according to the keyboards ***Maj-Entrée***, to get the same effect. In general, it is important to learn and use the keyboard shortcuts, this will save you a lot of time later."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The usual way to *execute* the entire notebook is to :\n",
"\n",
"* to select the first cell,\n",
"* and press ***Shift+Enter*** until the notebook is finished."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"When a code cell has been evaluated, Jupyter adds under the cell `In` a cell `Out` which gives the result of the Python code, above 600.\n",
"\n",
"Jupyter also adds a number between the square brackets to display, for example above, `In [1]:`. This number allows you to retrieve the order in which the cells were evaluated.."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can of course modify these code cells for testing purposes, so you can use the model below to calculate the square root of 3, or try the function on a negative number and see how the error is reported."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# math.sqrt (pour square root) calcule la racine carrée\n",
"import math\n",
"math.sqrt(2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is also possible to evaluate the whole notebook at once by using the menu *Cell -> Run All*."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Be careful to evaluate the cells in the right order"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"It is important that the code cells are evaluated in the correct order. If you do not respect the order in which the code cells are presented, the result may be unexpected.\n",
"\n",
"In fact, evaluating a programme in the form of a notebook is like cutting it up into small fragments, and if these fragments are executed in a disorderly manner, the result is naturally a different programme."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This can be seen in this example:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"message = \"Be careful about the order in which you evaluate the notebooks.\""
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(message)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If a little further on in the notebook we do for example :"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# this has the effect of deleting the variable 'message'.\n",
"del message"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"which makes the symbol `message` indefinite, then of course we can no longer evaluate the cell which makes `print` since the variable `message` is no longer known to the interpreter."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Reset the interpreter"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you make too many changes, or loose track of what you have evaluated, it may be useful to restart your interpreter:\n",
"* The *Kernel → Restart* menu allows you to do this, a bit like IDLE which starts from a blank interpreter when you use the F5 function.\n",
"* The *Kernel → Interrupt* menu can be used if your fragment takes too long to run (e.g. you have written a loop whose logic is broken and does not finish).\n",
"* The *Kernel → shutdown* menu can be used to close a running notebook if you need to free memory for exemple."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### You are working on a copy"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One of the main advantage of notebooks is that you can modify the code we have written, and see for yourself how the modified code behaves.\n",
"\n",
"For this reason, each student has his/her **own copy** of each notebook, you can of course make any changes you wish to your notebooks without affecting other students."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Back to the course version"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can always return to the \"course\" version through the menu\n",
"*File → Reset to original*."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Be careful, with this function you restore **the whole notebook** and therefore **you loose your modifications on it**."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Download in the format Python, html, pdf..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can download a notebook in Python, pdf, html... format to your computer through the menu\n",
"*File → Download as → Python*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For the Python download, text cells are preserved in the result as Python comments."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Adding cells"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can add a cell anywhere in the document with the **+** button on the button bar (or with the menu *Insert → Insert Cell Above* or *Insert → Insert Cell Below* ). \n",
"Also, when you reach the end of the document, a new cell is created each time you evaluate the last cell; this way you have a draft for your own tests. \n",
"When you create a new cell, you have to select its type between Markdown, Python."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Markdown cells\n",
"Markdown is lightweight markup languages. Github proposes a short and efficient introduction: <a href=\"https://guides.github.com/features/mastering-markdown/\">Mastering Markdown</a>."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## References about Jupyter notebook\n",
"\n",
"There are many documentations and tutorials on the use of Jupyter notebooks, here are a few of them:\n",
"* This [web page on dataquest blog](https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/) contains a number of tips on how to use Jupyter (including illustrations of the many IPython magic commands) that can improve your efficiency.\n",
"* This [Youtube playlist](https://www.youtube.com/playlist?list=PLRJx8WOUx5XcDMOxSQegCJUjTJePTlF9Z) contains many tutorials on the use of notebooks"
The course material of this Mooc is proposed in Jupyter notebooks which are documents that contain live code, equations, visualizations and narrative text.
To manipulate these notebooks, the open-source web application Jupyter has been integrated into this Mooc. It does not require any installation on your side. All data and calculations will be hosted on our servers.
This document is an example of a Jupyter Notebook. It presents you the Jupyter interface and how tu use the notebooks.
Please note that **code parts can be evaluated and modified**. So you can easily try out variants around the original notebook. Don't hésitate because you will be able to reset to the original version of the notebook.
%% Cell type:markdown id: tags:
## How to use Jupyter Notebooks
### Executing Python code
%% Cell type:markdown id: tags:
At the top of the notebook, you have a menu bar, containing:
* a menu bar with the entries `File`, `Edit`, `Insert`, `Cell`, `Kernel`;
* and a button bar that are shortcuts to some frequently used menus. If you leave your mouse over a button, a small text will appear, indicating what function the button is for.
A notebook consists of a series of cells, either textual or containing code. The code cells are easily recognisable, they are preceded by `In [ ]:`. The cell following the one you are reading is a code cell.
To start, select this code cell below with your mouse, and press in the menu bar - at the top of the notebook, therefore - on the one in the form of a triangular arrow to the right (Run) :
As you can see, the cell is "executed" (more commonly called evaluated), and we move on to the next cell.
Alternatively, you can simply type on the keyboard ***Shift+Enter***, or according to the keyboards ***Maj-Entrée***, to get the same effect. In general, it is important to learn and use the keyboard shortcuts, this will save you a lot of time later.
%% Cell type:markdown id: tags:
The usual way to *execute* the entire notebook is to :
* to select the first cell,
* and press ***Shift+Enter*** until the notebook is finished.
%% Cell type:markdown id: tags:
When a code cell has been evaluated, Jupyter adds under the cell `In` a cell `Out` which gives the result of the Python code, above 600.
Jupyter also adds a number between the square brackets to display, for example above, `In [1]:`. This number allows you to retrieve the order in which the cells were evaluated..
%% Cell type:markdown id: tags:
You can of course modify these code cells for testing purposes, so you can use the model below to calculate the square root of 3, or try the function on a negative number and see how the error is reported.
%% Cell type:code id: tags:
``` python
# math.sqrt (pour square root) calcule la racine carrée
importmath
math.sqrt(2)
```
%% Cell type:markdown id: tags:
It is also possible to evaluate the whole notebook at once by using the menu *Cell -> Run All*.
%% Cell type:markdown id: tags:
### Be careful to evaluate the cells in the right order
%% Cell type:markdown id: tags:
It is important that the code cells are evaluated in the correct order. If you do not respect the order in which the code cells are presented, the result may be unexpected.
In fact, evaluating a programme in the form of a notebook is like cutting it up into small fragments, and if these fragments are executed in a disorderly manner, the result is naturally a different programme.
%% Cell type:markdown id: tags:
This can be seen in this example:
%% Cell type:code id: tags:
``` python
message="Be careful about the order in which you evaluate the notebooks."
```
%% Cell type:code id: tags:
``` python
print(message)
```
%% Cell type:markdown id: tags:
If a little further on in the notebook we do for example :
%% Cell type:code id: tags:
``` python
# this has the effect of deleting the variable 'message'.
delmessage
```
%% Cell type:markdown id: tags:
which makes the symbol `message` indefinite, then of course we can no longer evaluate the cell which makes `print` since the variable `message` is no longer known to the interpreter.
%% Cell type:markdown id: tags:
### Reset the interpreter
%% Cell type:markdown id: tags:
If you make too many changes, or loose track of what you have evaluated, it may be useful to restart your interpreter:
* The *Kernel → Restart* menu allows you to do this, a bit like IDLE which starts from a blank interpreter when you use the F5 function.
* The *Kernel → Interrupt* menu can be used if your fragment takes too long to run (e.g. you have written a loop whose logic is broken and does not finish).
* The *Kernel → shutdown* menu can be used to close a running notebook if you need to free memory for exemple.
%% Cell type:markdown id: tags:
### You are working on a copy
%% Cell type:markdown id: tags:
One of the main advantage of notebooks is that you can modify the code we have written, and see for yourself how the modified code behaves.
For this reason, each student has his/her **own copy** of each notebook, you can of course make any changes you wish to your notebooks without affecting other students.
%% Cell type:markdown id: tags:
### Back to the course version
%% Cell type:markdown id: tags:
You can always return to the "course" version through the menu
*File → Reset to original*.
%% Cell type:markdown id: tags:
Be careful, with this function you restore **the whole notebook** and therefore **you loose your modifications on it**.
%% Cell type:markdown id: tags:
### Download in the format Python, html, pdf...
%% Cell type:markdown id: tags:
You can download a notebook in Python, pdf, html... format to your computer through the menu
*File → Download as → Python*
%% Cell type:markdown id: tags:
For the Python download, text cells are preserved in the result as Python comments.
%% Cell type:markdown id: tags:
### Adding cells
%% Cell type:markdown id: tags:
You can add a cell anywhere in the document with the **+** button on the button bar (or with the menu *Insert → Insert Cell Above* or *Insert → Insert Cell Below* ).
Also, when you reach the end of the document, a new cell is created each time you evaluate the last cell; this way you have a draft for your own tests.
When you create a new cell, you have to select its type between Markdown, Python.
%% Cell type:markdown id: tags:
### Markdown cells
Markdown is lightweight markup languages. Github proposes a short and efficient introduction: <ahref="https://guides.github.com/features/mastering-markdown/">Mastering Markdown</a>.
%% Cell type:markdown id: tags:
## References about Jupyter notebook
There are many documentations and tutorials on the use of Jupyter notebooks, here are a few of them:
* This [web page on dataquest blog](https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/) contains a number of tips on how to use Jupyter (including illustrations of the many IPython magic commands) that can improve your efficiency.
* This [Youtube playlist](https://www.youtube.com/playlist?list=PLRJx8WOUx5XcDMOxSQegCJUjTJePTlF9Z) contains many tutorials on the use of notebooks
