B06 Badge - Fail Tests, Fix Code, Pass Tests v1.5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Badge 06: Test Driven Development.\n",
    "\n",
    "## See tests Fail, fix the code, then see tests Pass."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This badge prepares you for pair programming labs. They will contain sets of tasks and you will work in pairs to solve these programming challanges.\n",
    "\n",
    "Each challange will include: \n",
    "\n",
    "- A description of what you are meant to do. Usually with a documentation in \"\"\" brackets.\n",
    "- An incomplete solution, some code to get you started.\n",
    "- Tests, snippets of code that will tell you how correct your code is.\n",
    "\n",
    "TOP TIPS:\n",
    "- Shift+Enter will RUN the current code cell i.e. the one that's highlighted/selected.\n",
    "- If you need to add another cell e.g. to write your own tests, in top menu go Insert > Insert Cell "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Driven Development (TDD): Know expected result before you start building.\n",
    "We will see more of this in the Tutorial, but here are some example tests for you:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK 1: Understanding TDD Workflow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**🍌🍌🍌IMPORTANT: PLEASE DO NOT CHANGE ANY CODE UNTIL YOU ARE TOLD TO DO SO. FOR THE FIRST 15 MINUTES OF THE LAB YOU WILL ONLY READ AND RUN CODE. You will know it's time to start coding when you see banana emoji's: 🍌🍌🍌**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GOAL: Write a function that decides if a number is positive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-9a31d60b12dae17c",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# You have a function to begin with, but it does not work fully.\n",
    "\n",
    "def is_number_positive(a_number):\n",
    "    \"\"\"\n",
    "    Tripple quote opens a new type of 'special comment' called Documentation.\n",
    "    You can add these at the beginning of functions, to explain what they will do. \n",
    "    E.g.:\n",
    "    Check if a number is positive. \n",
    "    Return True if it is positive.\n",
    "    Return False if it is negative or zero.\n",
    "    \"\"\"\n",
    "    return \"Banana\" # DO NOT CHANGE THIS CODE YET, YOU WILL BE TOLD WHEN TO DO SO!\n",
    "\n",
    "# Note: This function is not returning anything useful yet. \n",
    "# I mean, \"Banana\" isn't a logical answer to 'is_number_positive'?.\n",
    "# It will be your job to fix it, but LATER.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TEST DRIVEN DEVELOPMENT: Write Tests First, See Them Fail, Then Write The Code. \n",
    "\n",
    "1. Run the cell with your function (above) to \"put its definition in the memory\"\n",
    "2. Run tests below to see if your function worked (they should fail).\n",
    "3. DO NOT FIX the above function, yet.\n",
    "\n",
    "Note for later: If there are many tests in one cell, you will see the details of the FIRST FAILING TEST but not all of the failing tests. That's why we are putting one test per cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's a playground for you where you can run your function and see what it returns.\n",
    "# If you need to print something to help you with your work, you'll see it here.\n",
    "\n",
    "\n",
    "is_number_positive(1)\n",
    "\n",
    "# Note: If you are getting 'NameError: name 'is_number_positive' is not defined'...\n",
    "# You probably forgot to run the cell with function definition.\n",
    "# So Python does not know where to look for the definition of 'is_number_positive'.\n",
    "# Go back and run the cell with the definition, that will load it into the memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert is_number_positive(1) == True, \"1 should be positive\"\n",
    "print(\"Tests Passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert is_number_positive(10) == True, \"10 should be positive\"\n",
    "print(\"Tests Passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert is_number_positive(-1) == False, \"-1 should not be positive\"\n",
    "print(\"Tests Passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert is_number_positive(-123) == False, \"-123 should not be positive\"\n",
    "print(\"Tests Passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert is_number_positive(0) == False, \"0 should not be positive\"\n",
    "print(\"Tests Passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# END OF TESTS (for now... keep reading)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Your TDD Workflow (Test Driven Development)**:\n",
    "\n",
    "- Run the cell with your function definition, so it is loaded into the memory.\n",
    "\n",
    "- Run the tests, and see if all are passing (succeeding, correct). \n",
    "    - If this is the first time you're here read all the tests before running them.\n",
    "    - If you have no tests, write them!\n",
    "    - Tests should always fail first. If tests never fail, it's not much of a test, is it?\n",
    "    \n",
    "- If any tests are failing:\n",
    "    - Identify which tests are failing and try to understand why.\n",
    "    - Fix your function definition so it is closer to the solution.\n",
    "    - Try to work in the smallest possible increments. If possible don't address the whole job in one go.\n",
    "    - Go back to the first step.\n",
    "\n",
    "Important notes:\n",
    "\n",
    "**RUN YOUR TESTS FIRST, AND SEE THEM FAIL, AND ONLY THEN WRITE THE SOLUTION** \n",
    "\n",
    "- Otherwise you might have tests that always succeed (that's pointless) or you could end up doing too much work, e.g. continuing to work on your solution when it is already good enough. \n",
    "\n",
    "**ALL TESTS SHOULD BE FAILABLE**\n",
    "\n",
    "- At the beginning, all of your tests should be failing. Otherwise there is no point in us writing them. Think of the phrase '**IF IT AIN'T BROKE, DON'T FIX IT**'. You want to fail some tests so you see what that looks like from a coding perspective. This helps you catch your code out, and subsequently correct potential errors. A test like, ```assert 2 == 2``` does not make much sense, because it will ALWAYS succeed.\n",
    "\n",
    "**WHEN TEST PASSES, IT PASSES SILENTLY, WHEN IT FAILS IT PRINTS THE ERROR**\n",
    "\n",
    "- This is one of the reasons why you should see your tests fail first! Otherwise you don't know if you're actually testing anything.\n",
    "- It's good practise to write something like \"tests passed\", so you can see when this has happened."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#example, failing test throws an AssertionError\n",
    "number = 7\n",
    "assert number == 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#example: passing test will not return or throw anything\n",
    "number = 7\n",
    "assert number == 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#example: that's why sometimes it's a good idea to put a print(\"tests passed\") at the end,\n",
    "# just so you know you've actually run a cell with tests. (if one of the tests failed, you'd see it)\n",
    "\n",
    "number = 7\n",
    "assert number == 7\n",
    "print(\"tests passed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**🍌🍌🍌 DO THIS LITTLE EXERCISE BEFORE YOU ACTUALLY WRITE THE SOLUTION TO 'is_number_positive( )'**\n",
    "\n",
    "Here's a quick hack/temporary solution, which I really encourage you to try every time. Try to find an easy win:\n",
    "\n",
    "What if we assumed that EVERY NUMBER IS POSITIVE? Try it. Go all the way to the top of the definition in 'is_number_positive()' and change the code **so that the function always returns True**. \n",
    "\n",
    "Replace ``` return \"Banana\" ``` with ```return True```.\n",
    "\n",
    "Then re-run the tests. Are some of them passing?\n",
    "\n",
    "Note: When a test fails, it throws an Error, but when a test passes it returns nothing. So if you see no Error the tests have passed.\n",
    "\n",
    "When you think about it, it is not a completely wrong solution - it will return a correct answer to half of the possible inputs Half of the numbers in the world are positive so should return True!\n",
    "\n",
    "Feeding the function only the positive numbers will fool half of the tests into thinking it works, and that is good enough.\n",
    "\n",
    "Go and do it now. You should see about half of your tests succeeding!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**FOR REAL, GO AND CHANGE YOUR CODE WITH 'return True' AND RUN THE TESTS AGAIN, AND ONLY THEN CONTINUE READING. THANKS!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do you have an idea of how to fix the ```is_number_positive()``` function above so that it actually returns True for positive numbers and False for negative numbers and zero?\n",
    "\n",
    "When you are unsure of some specifics of what you're asked to do, e.g. whether 0 should be considered positive or not, have a look at the tests. Basically always there will be a test that answers your question of the \"but what if the input is ...\" variety.\n",
    "\n",
    "**Tests are your Single Point Of Truth (they are always right). Tests are like your client. Your job is to make them happy, to ultimately make all tests pass.**\n",
    "\n",
    "At some point soon, you will be expected to write your own tests and your own \"\"\" documentation, but not yet.\n",
    "\n",
    "**🍌🍌🍌 OK, NOW YOU ARE ALLOWED TO GO AND TRY TO COMPLETE THE FIRST CHALLANGE ABOVE. If after a few minutes it is still hard, see hints below.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have you managed to solve the above puzzle and make all the tests pass?\n",
    "\n",
    "If you're really struggling here's a hint.\n",
    "\n",
    "**ONLY USE HINTS IF YOU ARE STRUGGLING FOR MORE THAN 5 MINUTES**\n",
    "\n",
    "<details><summary style='color:blue'>CLICK HERE TO SEE THE HINT 1</summary>\n",
    "    \n",
    "    HINT:\n",
    "    \n",
    "    Split the challange into smaller tasks:\n",
    "    \n",
    "    1. What makes some numbers a positive number?\n",
    "    \n",
    "    - It is larger than Zero.\n",
    "    \n",
    "    2. How do you evaluate in code that one number is smaller or larger than another number?\n",
    "    \n",
    "    - Code ```x < 5``` will return True if 'x' is smaller than 5, and False otherwise.\n",
    "    - Code ```y >= 10 ``` will return True if 'y' is larger or equal to 10, and False otherwise.\n",
    "    \n",
    "</details>\n",
    "\n",
    "<details><summary style='color:blue'>CLICK HERE TO SEE THE HINT 2</summary>\n",
    "    \n",
    "    3. So how would you write a comparison if a variable 'number' is smaller than zero?\n",
    "    \n",
    "    4. How would you write an 'if statement' that uses the above comparison to return True if it is True, and False if it is False?\n",
    "    \n",
    "    \n",
    "</details>\n",
    "\n",
    "Note that there are a few correct ways to solve this challange, varying by length and complexity. When you find a correct way, try just for another minute to optimise it. Make it cleaner and more DRY, but without breaking it.\n",
    "    \n",
    "<details><summary style='color:blue'>CLICK HERE TO SEE THE HINT 3</summary>\n",
    "    \n",
    "    5. Ok, here's the answer: Function should return if number is larger than 0, \n",
    "    \n",
    "    instead of return \"Banana\"\n",
    "    \n",
    "    use this:\n",
    "    \n",
    "    return a_number > 0\n",
    "    \n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have succeeded with the above exercise, here are some exercises for you to attempt with your partner:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK 2 - Doing it by yourself: REMEMBER to run the tests (and see them fail) before you start fixing the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-5205a6b420e3f0b2",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def which_number_is_larger(number_1, number_2):\n",
    "    \"\"\"Rerurn the larger number.\n",
    "    If they are the same, return any of them.\"\"\"\n",
    "    return 0\n",
    "\n",
    "# Notice that starting with a nonsense hardcoded answer such as 0 is often a good idea. \n",
    "# Maybe even a bit better than returning string \"Banana\".\n",
    "# It will make most of your tests fail, which is good.\n",
    "\n",
    "# A TRICKY BIT: Unfortunately though there can be some unexpected consequences.\n",
    "# For historic reasons, in Python, False == 0.\n",
    "# Whatever you choose to write in your first, wrong definition of the test, be aware of False basically being 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(1,3) == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(5,3) == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(29999,30000) == 30000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(-1,1) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(0,10) == 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(-10,0) == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(10,10) == 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(-10,-10) == -10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(-10,-3) == -3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert which_number_is_larger(0,0) == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# END OF TESTS\n",
    "\n",
    "# Did any of them Pass? How do you know? Why?\n",
    "\n",
    "# Now go and fix the function, then re-run the tests."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK 3: Writing your own test (remember to see them fail, before you write the solution)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Are both numbers of the same sign? (both positive or both negative)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def are_both_of_the_same_sign(number_1, number_2):\n",
    "    \"\"\"Return True if both numbers are positive, or if both numbers are negative.\n",
    "    Return False if one number is positive and another negative\n",
    "    Return False if one or both of the numbers is zero\"\"\"\n",
    "    return \"Banana\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this task you need to write your own tests. When you write your own tests, you need to act like a devil's advocate, and find all the possible scenarios that could make your function NOT WORK.\n",
    "\n",
    "Write 6 or more tests. Remember that during the writing of the tests you will most likely get a good understanding of what the function should do.\n",
    "\n",
    "- Start with one or two tests that should be obvious and test on a basic level that something works (e.g. something obviously True and obviously False).\n",
    "- Make sure that the order doesn't impact the solution. Write at least one test with reversed arguments, like 'my_function(1,2)' and 'my_function(2,1)'.\n",
    "- Identify 'Edge Cases': What if one or both numbers are zero, or negative.\n",
    "- Write any tests that could make your function fail.\n",
    "\n",
    "Your job when you are writing tests is to **CATCH YOUR CODE DOING SOMETHING WRONG**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's one to get you started:\n",
    "\n",
    "assert are_both_of_the_same_sign(3,-4) == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# END OF TESTS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TASK 4: Googling/internet search when you don't know something (and again, remember to see the tests fail before solving the task)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function which checks if the number is even (can be divided by 2, and returns a whole number, not a fraction). Examples would be:  2, 4, 6, 100, -8, 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you write and run your tests below, try solving that problem.\n",
    "\n",
    "As you know, you have not yet learned how to check if something can be wholly divided by a number in Python. You will need to Google/internet search for this Python method. It is an important learnong step to be able to know what to ask to find effective solutions.\n",
    "\n",
    "Try searching in Google, or another search engine for \"Python is number even\" or \"Python division remainder\".\n",
    "\n",
    "<details><summary style='color:blue'>CLICK HERE ONLY IF YOU HAVE NOT FOUND AN ANSWER WITHIN 5 MINUTES</summary>\n",
    "    \n",
    "    HINT:\n",
    "    \n",
    "    x % y will return the remainder of dividing 'x' over 'y'. for example.\n",
    "    12 % 10 will return 2 (because 12 == 10 * 1 + 2).\n",
    "    32 % 10 will return 2 (because 32 == 10 * 3 + 2).\n",
    "    15 % 6 will return 3 (because 15 == 6 * 2 + 3).\n",
    "    18 % 6 will return 0 (because 18 == 6 * 2 + 0) - Notice that this means 18 is divisible by 6.\n",
    "    \n",
    "    In other words - if the remainder of dividing a 'number_1' by 'number_2' is 0, it means that 'number_1' is divisible by 'number_2'.\n",
    "    E.g. in code: number % 5 == 0 that would mean that number is a multiple of 5 (like 5, 10, 15, 100, etc.)\n",
    "    \n",
    "    How would you then assess if a number is divisible by 2? In other words, it's the same as if a number is even.\n",
    "    \n",
    "</details>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_this_number_even(number):\n",
    "    \"\"\"Return True if number is even (a multiple of 2) like 2,4,8,0,100,-2,-10\n",
    "    Return false if number is odd (cannot be represented as a multiple of 2), like 3,7,-9\"\"\"\n",
    "    return \"Banana\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here's one to get you started:\n",
    "\n",
    "assert is_this_number_even(4) == True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:\n",
    "\n",
    "assert is_this_number_even(-3) == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your tests here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# END OF TESTS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### This concludes this badge. Your labs will be basically a notebook with a lot of tasks like the ones above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ⭐️⭐️⭐️💥 What you have learned in this session: Three stars and a wish. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**In your own words** write in your Learn diary:\n",
    "\n",
    "- 3 things you would like to remember from this badge.\n",
    "- 1 thing you wish to understand better in the future or a question you'd like to ask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ⛏ Bonus Minitask: Write challanges and solve them using Test Driven Development.\n",
    "\n",
    "- Come up with some function ideas. Describe in a sentence what they will do.\n",
    "- Write tests that will test if they do what you expected (minimum 4 tests each).\n",
    "- Write an empty function, returning something silly, like False or \"Banana\".\n",
    "- **See your tests fail**\n",
    "- Fix the function so that it passes the tests.\n",
    "\n",
    "Here are some ideas, but it's up to you what you want to experiment with:\n",
    "\n",
    "- Function that takes 2 numbers and returns result of multiplying them.\n",
    "- Function that takes a number and returns the absolute value of it (ignoring the sign, e.g. -3 becomes 3, but 3 stays 3).\n",
    "- Function that takes 3 numbers and returns middle largest one.\n",
    "\n",
    "Come up with a few challenges on your own. Good luck."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Create Assignment",
  "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}