Inleiding-Jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inleiding Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voor het oefenen met MongoDB in Python gebruiken we [Jupyter Notebooks](https://jupyter.org).\n",
    "Hiermee kun je op een interactieve manier aan de slag, waarbij je alle vrijheden hebt om je eigen varianten uit te proberen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Een notebook bestaan uit cellen.\n",
    "\n",
    "Je selecteert een cel door op de cel te klikken, of in de kantlijn links van de cel.\n",
    "Je selecteert de volgende/vorige cel met de pijltjestoetsen up/down.\n",
    "**Selecteer nu deze cel.**\n",
    "\n",
    "Er zijn twee soorten cellen: **Code** en **Markdown**. \n",
    "Het type van de geselecteerde cel vind je in de interface-balk bovenin.\n",
    "Met dit menu kun je ook het type van de cel veranderen\n",
    "Deze cel is een **Markdown** cel, de volgende cel is een (Python) **Code** cel. **Controleer dit.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3 * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code-cellen\n",
    "\n",
    "**Uitvoeren van een cel**. De cel hierboven is een Code-cel, met daarin een Python opdracht. **Voer deze cel uit (Run)**:\n",
    "\n",
    "1. Selecteer de cel\n",
    "2. Voer de cel uit, via Run (pijltje) in het menu hierboven, of via SHIFT-RETURN.\n",
    "\n",
    "Zoals je ziet verschijnt het resultaat van de Python-opdracht onder de cel.\n",
    "\n",
    "> Bij het uitvoeren van een Code-cel verschijnt er in de kantlijn een getal tussen rechte haken. Dit geeft de volgorde van de uitgevoerde cellen aan. Als je de cel nogmaals uitvoert, zie je een volgend getal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Aanpassen van een cel.** Je kunt de code in een Code-cel eenvoudig aanpassen: selecteer de cel, en verander de tekst.\n",
    "\n",
    "**Verander de Python-code in de cel hieronder in:** `2 + 3 * 5` en **voer de cel uit**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code: samengestelde opdrachten\n",
    "\n",
    "Je kunt in een cel willekeurige stukken Python-code opnemen, inclusief import-opdrachten, functie-definities, enz.\n",
    "De definities en declaraties kun je in de volgende cellen weer gebruiken:\n",
    "op die manier kun je een groter programma stap voor stap opbouwen.\n",
    "\n",
    "Als je een cel uitvoert, wordt de laatste expressie van die cel daaronder als resultaat getoond."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def succ(x):\n",
    "    return x+1\n",
    "\n",
    "succ(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Opeenvolgende cellen.** Je kunt alle Code-cellen in een Notebook beschouwen als één groot Python-programma, dat je stukje bij beetje (cel voor cel) kunt uitvoeren.\n",
    "Bij het uitvoeren van een cel wordt de waarde van de laatste expressie in de cel afgedrukt:\n",
    "dit gebruik je meestal om tussenresultaten te kunnen controleren.\n",
    "\n",
    "**Voer de onderstaande 2 cellen achtereenvolgens uit**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 13\n",
    "b = a * 2\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 14\n",
    "2 * a + b + c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Een Code-cel bevat een stukje Python-programma. Dat kan ook een functie-defintie zijn.\n",
    "Deze functie kan dan in dezelfde of in een volgende cel gebruikt worden.\n",
    "\n",
    "**Voer de onderstaande 2 code-cellen achtereenvolgens uit**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sqr (x):\n",
    "    return x * x\n",
    "\n",
    "sqr(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 12\n",
    "sqr(num + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Je kunt de tekst in een Markdown-cel aanpassen door deze in **edit-mode** te brengen.\n",
    "Dit doe je door een dubbel-klik op de cel.\n",
    "Je herkent deze mode aan het gebruik van een ander lettertype.\n",
    "\n",
    "**Pas de inhoud van deze cel aan**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Een Markdown-cell breng je van edit-mode naar de geformatteerde tekst-mode door deze cel uit te voeren.\n",
    "Je *voert een cel uit* (*Run*) door op het pijl-symbool bovenin te klikken, of door SHIFT-RETURN.\n",
    "\n",
    "**Voer de cel hierboven uit om deze weer in geformatteerde tekst-mode te brengen.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Het uitvoeren van een Markdown-cel resulteert in het formatteren van de tekst.\n",
    "* Het uitvoeren van een Code-cel resulteert in het uitvoeren van de code.\n",
    "\n",
    "## Opdrachten\n",
    "\n",
    "1. pas de tekst in deze cel aan (edit-mode) en voer deze cel uit.\n",
    "2. pas de tekst van de cel hieronder aan en voer die cel uit.\n",
    "3. verander het type van de cel hieronder en voer die cel uit.\n",
    "   Let op het verschil tussen (2) en (3).\n",
    "\n",
    "2 + 3 * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code werkt over meerdere cellen\n",
    "\n",
    "Code die je uitvoert kan een zij-effect: bijvoorbeeld het definiëren van een functie of een variabele.\n",
    "Het resultaat van dit zij-effect blijft bewaard en kun je gebruiken bij de uitvoering van een volgende cel.\n",
    "We gebruiken dit later om een groter programma in kleinere delen te presenteren.\n",
    "\n",
    "De onderstaande expressie gebruikt de functie die je hierboven gedefinieerd hebt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = succ(5)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En de cel hieronder gebruikt de variabele die je hiervoor gedefinieerd hebt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "succ(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code: shell-opdrachten in Python\n",
    "\n",
    "In Python-code (in Jupyter Notebooks) kun je ook shell-opdrachten uitvoeren.\n",
    "Deze worden dan uitgevoerd in het onderliggende operating system.\n",
    "Het resultaat van zo'n opdracht kun je weer in Python verwerken.\n",
    "\n",
    "Een shell-opdracht geef je aan met een `!`, bijvoorbeeld `!ls` \n",
    "(voor het opvragen van de namen van de bestanden in de huidige map)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "files = !ls\n",
    "files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(files)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kernel\n",
    "\n",
    "De code-cellen worden uitgevoerd door een *Kernel*-proces op de server.\n",
    "In ons geval is dat een Python-Kernel.\n",
    "Er zijn ook kernels voor andere programmeertalen beschikbaar.\n",
    "\n",
    "De toestand van de kernel wordt bepaald door de cellen die je uitvoert,\n",
    "in de volgorde zoals je die uitvoert.\n",
    "Dit is niet altijd de volgorde waarin ze in het Notebook staan.\n",
    "\n",
    "### Herstarten van de Kernel\n",
    "\n",
    "Als je allerlei experimenten uitgevoerd hebt, wil je soms weer \"met een schone lei beginnen\".\n",
    "Hiervoor kun je de Kernel herstarten via het menu bovenin.\n",
    "In het bijzonder is het handig om daarbij de uitvoer van alle cellen ook te verwijderen:\n",
    "dan is duidelijk wat er tot nu toe uitgevoerd is, en wat niet.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learn Python - the hard way\n",
    "\n",
    "De cursus [Learn Python - the hard way](https://learnpythonthehardway.org) bevat allerlei opdrachten die letterlijk overgetypt moeten worden.\n",
    "De auteur legt er de nadruk op dat je die voorbeelden zelf moet intikken: van copy-paste leer je veel minder.\n",
    "Het intikken vraagt meer aandacht, en je maakt mogelijk leerzame fouten.\n",
    "\n",
    "In het materiaal gebruiken we zo nu en dan stukjes Python om over te tikken.\n",
    "Je zou gebruik kunnen maken van Copy-Paste, maar dan leer je er veel minder van.\n",
    "\n",
    "Tik de onderstaande code over in de volgende cel, en voer dan de cel uit\n",
    "\n",
    "```Python\n",
    "def pred(x):\n",
    "  return x-1\n",
    "  \n",
    "pred(succ(succ(3)))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Volgorde\n",
    "\n",
    "Bij de opzet van de Notebooks proberen we de volgende regels te gebruiken.\n",
    "Deze verminderen de kans op fouten en verwarring.\n",
    "\n",
    "1. De volgorde van de cellen in het notebook is de natuurlijke volgorde: in principe voer je deze van voor naar achter uit.\n",
    "2. De code in een cel is zoveel mogelijk *idempotent*: het maakt niet uit of je deze één keer of vaker uitvoert.\n",
    "\n",
    "Regel (1) betekent dat als je een cel in het midden van een reeks cellen opnieuw uitvoert,\n",
    "dat je dan in principe de cellen daarna ook opnieuw moet uitvoeren.\n",
    "\n",
    "Regel (2) betekent dat je opdrachten van de vorm `x = x + 1` moet vermijden. Voer in zo'n geval een nieuwe variabele in: `x1 = x + 1` o.i.d."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tussenvoegen en verwijderen van cellen\n",
    "\n",
    "Je kunt een cel toevoegen na de huidge cel met het `+`-symbool in het interface bovenin.\n",
    "\n",
    "De huidige cel verwijder je met het schaar-symbool in het interface bovenin.\n",
    "(Met Z -undo cell operation- maak je dat weer ongedaan.)\n",
    "\n",
    "Je kunt een cel verplaatsen met behulp van het handvat in de linker kantlijn.\n",
    "(Dit werkt alleen voor de nieuwere JupyterLab, niet voor Jupyter Notebook.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Samenvatting\n",
    "\n",
    "* een notebook bestaat uit cellen; een cel kan *tekst* bevatten (Markdown), zoals deze cel, of (Python) *code*, zoals de cellen hieronder.\n",
    "* je voert een cel uit door deze te selecteren (cursor in de cel), en vervolgens SHIFT-RETURN in te toetsen.\n",
    "  Ook het pijltje in de opdrachtenbalk hierboven kun je gebruiken.\n",
    "* onder de cel zie je dan de uitvoer van deze opdracht.\n",
    "* alle variabelen enz. die je introduceert in de code van een cel kun je in de volgende cellen gebruiken.\n",
    "* met een `!` kun je een shell-opdracht uitvoeren; het resultaat kun je in Python gebruiken (als string).\n",
    "* om problemen te voorkomen voer je cellen alleen uit *in de volgorde in het notebook*.\n",
    "* je kunt eventueel opnieuw beginnen door de \"Kernel\" opnieuw te starten (via het cirkeltje, als bij een reload in de browser).\n",
    "* zie voor meer informatie: help, en [tutorial](https://www.dataquest.io/blog/jupyter-notebook-tutorial/)\n",
    "\n",
    "De meeste code-cellen kun je zo uitvoeren; probeer de code en de uitvoer te begrijpen.\n",
    "Bij sommige opdrachten moet je de code aanpassen, en dan de cel uitvoeren."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shortcuts\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Volgende Notebooks\n",
    "\n",
    "Ga nu verder met:\n",
    "\n",
    "* [MongoDB-intro](MongoDB-intro.ipynb) - met mongo-shell voorbeelden, of\n",
    "* [Connect](Connect.ipynb) - begin van MongoDB in Python\n",
    "\n",
    "Zie ook: [Inhoudsopgave](Inhoud.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}