03_Over_schildpadden_en_Lussen.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "03 Over schildpadden en Lussen.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/stgslaze/Colab-Python-Cursus-NL/blob/master/03_Over_schildpadden_en_Lussen.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CSSV8iBw5t7f",
        "colab_type": "text"
      },
      "source": [
        "We gaan wat spelen met loops (lussen) en om het wat makkelijker visueel te maken doen we dat met een schildpadje.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lvxaTEyfHpAA",
        "colab_type": "text"
      },
      "source": [
        "In het code blok hieronder staan een drietal regels, wat ze betekenen staat erachter. Voer de code uit door op 'play' te klikken."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BbPj0ESQrIBK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!pip install ColabTurtle # Hiermee installeer je een externe bibliotheek met code.\n",
        "from ColabTurtle.Turtle import * # Hiermee importeren we de volledige inhoud in dit notebook\n",
        "initializeTurtle() # Een functie uit de bibliotheek om de schildpad mee te initialiseren"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loGh3SL-_KWn",
        "colab_type": "text"
      },
      "source": [
        "Voila, een boel tekst met daaronder een zwart scherm met daarin een cirkeltje met een pijl dat we vanaf nu de schildpad zullen noemen. Je hebt iets dergelijks mogelijk al eens eerder gezien. Met de schildpad kun je lijnen tekenen. Een kort overzicht van de functies van de schildpad:\n",
        "\n",
        "\n",
        "*   forward(x): x plaatsen vooruit lopen\n",
        "*   backward(x): x plaatsen achteruit lopen\n",
        "*   right(x): rechtsom x graden draaien\n",
        "*   left(x): linksom x graden draaien\n",
        "*   penup(): stoppen met tekenen\n",
        "*   pendown(): beginnen met tekenen\n",
        "*   speed(x): snelheid\n",
        "*   width(x): lijndikte in pixels\n",
        "\n",
        "Dan kun je nog kleuren kiezen. Je mag kiezen uit: 'white', 'yellow', 'orange', 'red', 'green', 'blue', 'purple', 'grey', 'black'. De kleuren kun je instellen met de volgende functies:\n",
        "\n",
        "*   color(x): lijnkleur \n",
        "*   bgcolor(x)L achtergrondkleur\n",
        "\n",
        "Je kunt het veld weer leegmaken met de functie: initializeTurtle()\n",
        "\n",
        "Voer het codeblok hieronder maar eens uit.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vMGxY3kAssHe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "forward(100)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jVVbzT7WEAU4",
        "colab_type": "text"
      },
      "source": [
        "Dat was makkelijk! In het volgende codeblok laten we de schildpad een kwartslag naar rechts gaan en daarna een nieuw stuk lijn maken. Voer het maar uit."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0vr6YvckF4Zf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "right(90)\n",
        "forward(100)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0eqphnNBGDF1",
        "colab_type": "text"
      },
      "source": [
        "Vul het codeblok hierboven zelf eens aan en zorg dat de schildpad een vierkantje loopt. Nadat je het hebt aangevuld moet je natuurlijk wel weer op 'play' drukken.\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "Tijd om de computer voor je te laten werken in plaats van alles in te tikken. Als het je gelukt is om de schildpad een vierkantje te laten lopen heeft dat je acht regels tekst gekost. Vier setjes van:\n",
        "> right(90)\n",
        "\n",
        "> forward(100)\n",
        "\n",
        "Als je toch al weet dat het er vier moeten zijn kunnen we dit in een herhalingslus zetten:\n",
        "\n",
        "> for i in range(4):\n",
        "\n",
        "Hiermee zeg je eigenlijk zoveel als:\n",
        "\n",
        "> tel van 1 tot vier, en doe elke keer het volgende:\n",
        "\n",
        "Die 'i' in de code is gewoon een variabele die je gebruikt om te tellen overigens. Hieronder zie je het effect (voorafgegaan door een 'initializeTurtle()'' om een schoon veld te krijgen).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-1ay_x2UKiXx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "for i in range(4):\n",
        "  right(90)\n",
        "  forward(100)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VsOikRwrfW73",
        "colab_type": "text"
      },
      "source": [
        "Eerder heb je gewerkt met 'while' lussen. Het lijkt allemaal erg op elkaar en je doorgaans maakt het niet heel veel uit welke je gebruikt. Met een while lus had het er als volgt uitgezien, dit kost iets meer code. Voor dit soort lussen is de for variant dan ook doorgaans prettiger:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZIjbidB0flvD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "i = 0\n",
        "while i < 4:\n",
        "  right(90)\n",
        "  forward(100)\n",
        "  i = i + 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bjPNxsOSgDDe",
        "colab_type": "text"
      },
      "source": [
        "Waar aangegeven moet je binnen de opgaven gebruik maken van een bepaald type lus. Als er niets staat aangegeven mag je het helemaal zelf weten.\n",
        "\n",
        "**Tip**: *Regelmatig staat er dat je de code in een blok moet aanpassen. Je kunt, als je het originele codeblok wilt bewaren, natuurlijk ook gewoon een nieuw codeblok toevoegen ...*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Myxsl2TtgOt7",
        "colab_type": "text"
      },
      "source": [
        "# Opgaven 1 t/m 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Jf7EJo1gQ3P",
        "colab_type": "text"
      },
      "source": [
        "1. Voer het codeblok hieronder eens uit. Zoals je ziet worden er meerdere vierkantjes gelopen door je schildpad. Er wordt hier gebruik gemaakt van een while-lus. Maak hier een for-lus van. De uitvoer moet natuurlijk gelijk blijven."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v-vqxGrPhUlq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle() #veld even schoonmaken\n",
        "color(\"red\")\n",
        "\n",
        "i = 0\n",
        "while i < 16:\n",
        "  forward(100)\n",
        "  right(90)\n",
        "  if i % 4 == 0:\n",
        "    right(90)\n",
        "  i = i + 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I-z2OsnyidXM",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "2. Een cirkel heeft 360 graden. Als je een zeshoek wilt maken moet je hoeken van 60 graden maken met je schildpad. Wijzig onderstaande code op zo'n manier dat je een nette 7 hoek krijgt."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gS5akIuWir9J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "for i in range(6):\n",
        "  forward(100)\n",
        "  right(60)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qCC8HpWAkTY2",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "3. Dat kost nogal wat rekenwerk als je dit voor elke hoek zelf zou moeten gaan doen. Wijzig onderstaande code zodat deze aan de gebruiker vraagt hoeveel hoeken de vorm moet hebben en teken deze daarna. Je zult daarbij gebruik moeten maken van de functie **input()**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vq7LrOUZkwvl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "for i in range(6):\n",
        "  forward(100)\n",
        "  right(60)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YLKFmDg3pAlS",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "4. Sterren maken kan ook. Dat zitten nog wel wat haken en ogen aan als het om even getallen gaat, maar voor oneven getallen boven de 4 ben je er als je voor de hoek de volgende formule gebruikt:\n",
        "```\n",
        "360 / aantal_hoeken * 2\n",
        "```\n",
        "Onderstaande code tekent een vijfhoek, gebruik bovenstaande formule voor de hoek zodat er een ster met vijf punten getekend wordt."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3LvEReMpp2RG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "for i in range(5):\n",
        "  forward(100)\n",
        "  right(72)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9eEOSvxyqbZX",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "5. Een moeilijke tussendoor: Vraag nu aan de gebruiker hoeveel hoeken hij wil hebben en teken deze ster!\n",
        "\n",
        "Je moet daarvoor achtereenvolgens:\n",
        "\n",
        "\n",
        "*   De gebruiker om een getal vragen\n",
        "*   Dit getal type-casten naar een int zodat ermee gerekend kan worden\n",
        "* Dit getal gebruiken in je range en in de formule voor de grootte van de hoek.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uv4mUrO6qqEb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "\n",
        "\n",
        "for i in range(5):\n",
        "  forward(100)\n",
        "  right(144)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2xi1Vo7srjvO",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "6. Een ruit maak je met twee hoeken van 60 graden en twee van 120. Maak in onderstaand codeblok de functie die de ruit moet tekenen af.\n",
        "\n",
        "Het moet er zo uit komen te zien:\n",
        "\n",
        "![Flower](https://raw.githubusercontent.com/stgslaze/Colab-Python-Cursus-NL/master/03-flower01.png)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z7uzyeO4sDhG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "def teken_ruit(): #maak deze functie af!\n",
        "  forward(100)\n",
        "  right(60)\n",
        "  \n",
        "teken_ruit()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-DMFKOsatUU0",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "7. Een ruit tover je weer in een soort bloem door je schildpad, na het tekenen van de ruit, een aantal graden te laten draaien. De functie 'teken_ruit()' heb je al gemaakt dus die hoef je niet opnieuw in te tikken. Zorg ervoor dat je bloem uit zeker 5 ruit-blaadjes bestaat, netjes verdeeld over de cirkel.\n",
        "\n",
        "Als het klopt ziet het er zo uit (met 7 blaadjes):\n",
        "\n",
        "![Flower](https://raw.githubusercontent.com/stgslaze/Colab-Python-Cursus-NL/master/03-flower02.png)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7_5SJW1Htt6h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "teken_ruit()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DsKrZEzTtyli",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "8. Je voelde hem zeker al aankomen: Maak nu een functie met de naam 'teken_bloem' en als parameter 'blaadjes'. De parameter staat uiteraard voor het aantal blaadjes dat de bloem moet hebben."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0jHUbWSBujT8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "def teken_bloem(blaadjes):\n",
        "  # maak de functie\n",
        "  for i in range(5):\n",
        "    teken_ruit()\n",
        "    right(144)\n",
        "  \n",
        "  \n",
        "  \n",
        "  \n",
        "teken_bloem(7) # om te testen of het werkt"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CBL1Z6zcu1SR",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "9. Deze voelde je vast niet aankomen maar is niet minder leuk: De kleuren die mogelijk zijn staan namelijk in een lijst. De lijst kun je gebruiken om verschillende kleuren te maken.\n",
        "\n",
        "De lijst heet VALID_COLORS\n",
        "\n",
        "Maak de functie set_random_color() nu af. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0AHeBBwbwFrF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from random import randint\n",
        "initializeTurtle()\n",
        "\n",
        "def set_random_color(): \n",
        "# Hints\n",
        "# - Neem een random getal dat tussen 0 en de lengte van de lijst zit.\n",
        "# (Let daarbij op dat je de lengte - 1 neemt ...)\n",
        "# - Gebruik de functie color(x) om de kleur te kiezen.\n",
        "# x is daarbij het item uit de lijst VALID_COLORS met het random getal als index\n",
        "  color(\"black\")\n",
        "\n",
        "\n",
        "set_random_color()\n",
        "teken_bloem(5)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wvBhAOmMxWhX",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "10. Je kunt heel veel gekleurde bloemen maken door de schildpad ook nog eens op verschillende plaatsen tevoorschijn te laten komen. De functie **goto(x, y)** kun je gebruiken om je schildpad op een plek op het veld tevoorschijn te laten komen.\n",
        "\n",
        "De maximale x coordinaat is 800, de maximale y coordinaat is 500. Kun je een functie **plaats_schildpad()** maken die de schildpad op een willekeurige plek neerzet.\n",
        "\n",
        "Je maakt daarbij gebruik van de functie **randint(min, max)** om een nummer tussen de waarden min en max te genereren. Als je dit voor **x** en voor **y** doet dan komt de schildpad ergens onverwach tevoorschijn.\n",
        "\n",
        "Alles bij elkaar krijg je iets als dit te zien:\n",
        "\n",
        "![Flower](https://raw.githubusercontent.com/stgslaze/Colab-Python-Cursus-NL/master/03-flower03.png)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvgUZg1WyX6X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "initializeTurtle()\n",
        "\n",
        "def plaats_schildpad():\n",
        "  # Maak de functie af!\n",
        "  goto(0, 0) # deze waarden moeten random zijn :D\n",
        "  \n",
        "# Onderstaande doet een aantal leuke dingen:\n",
        "# Er wordt met je eerder gemaakte functie een willekeurige kleur gekozen\n",
        "# De bloem wordt in die kleur getekend\n",
        "# De pen wordt even opgetild voor het verplaatsen\n",
        "# De schildpad wordt verplaatst naar een andere locatie (mits je functie werkt!)\n",
        "# De pen mag weer terug op het papier ...\n",
        "for i in range(100):\n",
        "  set_random_color()\n",
        "  teken_bloem(5)\n",
        "  penup()\n",
        "  plaats_schildpad()\n",
        "  pendown()\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aVAtw5J4yhDQ",
        "colab_type": "text"
      },
      "source": [
        "*NB: In bovenstaand codeblok nemen we nu niet meer de moeite om opnieuw de regel:*\n",
        "```\n",
        "from random import randint\n",
        "```\n",
        "*toe te voegen aan het begin van de code. Hiervoor deden we dat wel steeds voor de volledigheid. Je hebt deze regel in een vorig codeblok al geimporteerd dus hoeft het hier niet meer.*"
      ]
    }
  ]
}