1. Beginning with Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\" style=\"background-color: #301E40; border: 0px; -moz-border-radius: 10px; -webkit-border-radius: 10px;\">\n",
    "<br/><br/>\n",
    "<h1 style=\"font-size: 45px; color: white; align: center;\"><center>\n",
    "<img src=\"https://raw.githubusercontent.com/HumbleData/beginners-data-workshop/master/media/humble-data-logo-white-transparent.png\" width=\"250px\" /><br/><br/>\n",
    "Introduction to Python\n",
    "</center></h1>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Welcome to learning Python!\n",
    "\n",
    "These notebooks contain a mix of text and code. This makes it easy to experiment with code and keep documentation like this in the same place. Another nice thing about these notebooks is that you can execute each cell individually and therefore work incrementally with your code. If you want to execute a cell, you can press the \"►\" button above when you have highlighted the cell. Alternatively, you can hit **Shift + Enter** to execute and progress to next cell or alternatively **Ctrl + Enter** (Win) or **Cmd + Enter** (Mac). \n",
    "\n",
    "We will walk you through different aspects of the Python language interactively. Take your time to experiment with it if you like and don't hesitate to ask or Google things. One of the first lessons in programming is using the documentation and information shared by other programmers. Jupyter has another trick, where you can put your cursor into the brackets of a function call such as `print()` and hit **Shift + Tab**. This will let you see the documentation of a function directly in the notebook (*pro-tip*: you can hit it up to four times for different effects).\n",
    "\n",
    "As for Python itself, one of the big strengths of Python is the extensibility. It has a surprising amount of functionality directly within the core language, however, you can `import` almost arbitrary code others make available as libraries. Below you can see a special import that shows you the \"Zen of Python\" a set of guidelines that could guide your programming journey.\""
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# We can use comments to document our code in a coding cell.\n",
    "import this  # Zen of Python"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**--> Simple is better than complex.**  \n",
    "It is really easy to print ***Hello World*** in Python:"
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "print('Hello World!')"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**PEP 8** is Python's style guide. You can find it here:\n",
    "https://www.python.org/dev/peps/pep-0008/\n",
    "\n",
    "It is good to know about, but when you become a professional programmer there are programs called a \"linter\" that will help you adhere to PEP 8."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Variables\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "In programming it's very useful to store values. Accessing values through names is called a variable. Python is very user-friendly in that it will let you store most things in a variable, without making space in the computer's space explicitly. Moreover, computers need to differentiate between the type of data, such as, `5` being an integer and `'Hello'` being a string, but Python attempts to handle these intuitively for you. You will learn about the different types in the following sections!\n",
    "\n",
    "**Python is an object oriented programming language. You do not need to declare variables (or their types) before using them as every variable in Python is an object.** "
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "name = 'Sandrine'"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "print(name)"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Moreover, variables can easily be updated. Try it out below!"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "***Note***: when you see cells that starts with `# !cat` means that it is a cell that can give you ***a*** solution. Remember there can be more than one solution to a problem in programming!\n",
    "\n",
    "If you would like to see the solution, you will have to remove the `#` using **Ctrl + /** (Windows) or **Cmd + /** (macOS) and then run the cell.\n",
    "\n",
    "Try solving it yourself before getting the solution.\n",
    "\n",
    "\n",
    "---"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Assign another string to the variable 'name' and print this variable"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "|"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_01.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**!!! Variable can change type when re-assigned.**"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Assign a number (without quotes) to the variable 'name' and print this variable"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_02.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "---"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Strings\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "A string always begins and ends with a single ( ' ) or double ( \\\" ) quotes. There is no difference, except if there is an apostrophe ( ' ) inside the string."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "'Beginners Data Workshop'"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "\"Beginner's Data Workshop\""
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Write *I'm enjoying this workshop!* using double quotes, and then single quotes."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# double quotes\n"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_03.py"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# single quotes\n"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_04.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**Oh no, an error!** Errors are nothing to be afraid of. Think of them as friendly messages trying to help you understand what's gone wrong. Here's how to read this:\n",
    "- Read errors backwards, so start at the bottom! It's a \"SyntaxError\" which means there's something wrong with our Python code.\n",
    "- There's a tiny arrow `^` pointing to what went wrong. Something near the m of `I'm`\n",
    "- On the top line, it says the error was on \"line 2\". This is often helpful when trying to fix (or \"debug\") broken code.\n",
    "\n",
    "**It turns out, if you want to use single quotes inside single quotes, you need to \"escape\" the quote with a backslash ( \\\\ ).**\n",
    "\n",
    ">Let's try that!"
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# single quotes, second try\n"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_05.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "As mentioned before, Python tries to handle everything as intuitively as possible. That means strings can be added together."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "'We are ' + 'everywhere around the world.'"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Also, strings can even be multiplied by a number."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "'Great! 🎉' * 3"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "'😂' * 50"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "We can access parts of strings by slicing the string. A character of a string (which is considered as a string of length 1 by Python) using slice, and a substring using slice range. Something important to note:\n",
    "\n",
    "**!!! Like birthdays, Python starts counting from 0! (It is \"zero-indexed\")** \n",
    "\n",
    "(If you're interested why, here's a historical [letter from Dijkstra](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html) about it.)"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "![image.png](attachment:image.png)"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "s = 'I am a Pythonista.'"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***Slice***  \n",
    "We can access characters of a string by referencing the position (\"index\") numbers within square brackets."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Selecting the first character of the string s\n",
    "s[0]"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "> Select the last character of the string s"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_06.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "***Slice range***  \n",
    "We can get a range of characters of a string by using a slicing range."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Select from position 2 up to but not including position 6 of the string s\n",
    "s[2:6]  # 6 is excluded"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "We can skip the start (resp. stop) number `s[:6]`. Then it start form index 0 (resp. end at the highest index)."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Select the last 3 characters of the string s"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_07.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "We can check if a string contains another string inside of it (a \"substring\"), using *in* and *not in*.\n",
    "\n",
    "**!!! Python is case-sensitive! The string `'a'` is not equal to `'A'`***"
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Checking if s contains 'python'\n",
    "print(s)\n",
    "'python' in s"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "> Check if s does not contain 'I' (capital i)"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_08.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Numbers\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Python has different numerical types. Two of which are used more often than others:\n",
    "- **Integers:** These are whole numbers, i.e. `1`, `2`, `-5`\n",
    "- **Floats:** \"Floating point\" numbers are those with a decimal point, i.e. `3.14158`, `2.5`, `0.1` and even `3.0`. \n",
    "\n",
    "Python attempts to deal with these numbers intuitively when integers and floats are mixed."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Basic Operators"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**Addition:**  \n",
    ">Try adding two numbers."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_09.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**Subtraction:**\n",
    "> Try subtracting two numbers."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_10.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**Multiplication:**  \n",
    "The sign for multiplication is *.  \n",
    ">Try multiplying two numbers."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_11.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**Exponent:**  \n",
    "The sign for exponent (or power) is *`**`*.\n",
    "\n",
    "> Try the power of an integer."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_12.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Try the power of a float"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_13.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Try the power of an integer written as a float (e.g. 12.0)"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_14.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**Division and modulo**\n",
    "- The sign for division is **`/`**.\n",
    "- The sign for floor division is **`//`**. It returns the \"quotient\" of a division - how many times one number goes into another. (\"If a carton holds six eggs, and we have 99 eggs, how many cartons can we fill?\")\n",
    "- The **`%`** sign is the [modulo](https://en.wikipedia.org/wiki/Modulo_operation), which returns the \"remainder\" after division."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Divide 6 by 2"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_15.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Try the floor division of 6 by 2"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_16.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Divide 19 by 5"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_17.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "*Note*: division returns a float."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**The floor division returns an int, the non-fractional part.**  \n",
    ">Try the floor division of 19 by 5"
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_18.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**Modulo returns the remainder of the division**"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Calculate 19 modulo 5"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_19.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**--> 19 = 3 * 5 + 4**"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Order of operations\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "The order of operations in Python respects the usual rules of mathematics (brackets -> powers -> division/multiplication -> add/subtract). **If in doubt, use brackets** to make it clear (to yourself, and anyone who might be reading your code) what you're trying to do."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "5 + 6 * 10"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "(5 + 6) * 10"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Booleans\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Booleans are the two constant values `True` and `False`. The numerical value of 'True is '1' and the numerical value of 'False' is '0'. These values are especially important for comparisons, therefore, we'll also learn about a new operator:\n",
    "\n",
    "**`==`** is an equality operator,  different from **`=`** which is the assignment operator you used to assign variables."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "True == 1  # '==' is an equality operator,  different from '=' which is an assignment operator"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "False * 3"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Using **`!=`** , check if `False` is not equal to `2`."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_20.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Check if the length of your name is greater than 8."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_21.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "We can use `and` and `or` operators with booleans in Python. Type them below and see how the color of the text changes, because Python recognises the keyword! These can be used to chain together multiple comparisons. These follow mathematical logic.\n",
    "\n",
    "| A     | B     | A and B | A or B |\n",
    "| :---  | :---  | :---    | :---   |\n",
    "| True  | True  | True    | True   |\n",
    "| True  | False | False   | True   |\n",
    "| False | True  | False   | True   |\n",
    "| False | False | False   | False  |\n",
    "\n",
    "> Check if the length of your name is greater than 5 and the length of your mentor's name is less than 7."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_22.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Lists\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "A list is a list of comma-separated values between square brackets.\n",
    "\n",
    "The items of a list can have different types."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "list_greeting = ['Hallo', 'Bonjour', 10, 'Hello', 'Ciao', False]"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "We can access a single value using a slice, and several values using slice range. Check the \"string slicing\" section above for this."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Get the first item of the list."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_23.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Get every the items from the list, starting with the 4th one.\n",
    "\n",
    "Note that there is no need to put a number after the colon when when want to select until the end of the list."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Get the items starting with the one with index 3 until the end of the list."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_24.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "**Get the items from the list until the 4th one.**"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Get the items from the beginning of the list until the value with index 4 (index 4 is excluded)."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_25.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**Advanced slicing allows us to set how the list's index will increment between the start/stop indexes we select.**  \n",
    "The slicing then looks like this: [start:stop:step]  \n",
    "For example, if we want to select every third items of a list, we will set the step as 3."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Get every other items from the list of greetings"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_26.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**We can update a list by re-assigning a value selected using a slice.**  \n",
    "For example, we can replace False with 'Ave' in list_greeting."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "list_greeting[-1] = 'Ave'\n",
    "print(list_greeting)"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Replace 10 with Hola in list_greetings, then print list_greeting to check it."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_27.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "We can have lists inside a list, these are often called \"nested lists\":"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "list_of_lists = [[1, 2, 3], [4, 5]]"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "list_of_lists[0]  # access the first element of the list, which is a list."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "list_of_lists[0][-1]  # access the last element of the first list."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "We can concatenate lists using ' + '."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "[1, 2, 3] + [4, 5, 6]"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "We can also use the multiplication to repeat values in a list (only works with integers)."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "['Hey'] * 5"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "We can also use `in` / `not in` with lists."
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Check if `10` is in `list_greeting`."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_28.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Check if 'Ole' is not in list_greeting."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_29.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Built-in functions\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "You've seen your first function at the very beginning of this notebook, i.e. `print(\"Hello World\")`. Functions are a way for you to write reusable code. In the case before `print()` is Python's way for you to show an output you provide. However, there are many other useful functions that Python comes with, that are provided by other libraries, or written by you yourself to save you from repeating some code.\n",
    "\n",
    "The functions that are always available in Python can be found here:\n",
    "https://docs.python.org/3/library/functions.html"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Print *'Here we are!'*."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_30.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Compute the length of the string variable `snakes`."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "snakes = \"🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍\""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_31.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Compute the length of list_greeting."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_32.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Work out the maximum of 1, 2, 3, 4 and 5."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_33.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Round the number 123.45 to the nearest integer."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_34.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Round the number 123.45 to 1 decimal place."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_35.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Methods\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "A method is a function associated to an object. Basically, it provides a way for an object to know functions about themselves.\n",
    "\n",
    "For example, we can change the string `s` to upper case using the `.upper()` method."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "s.upper()"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": ">Using the append method, add 'Aloha' to list_greeting."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_36.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\" style=\"padding: 0px; padding-left: 20px; padding-top: 5px;\"><h2 style=\"color: #301E40\">\n",
    "Importing modules\n",
    "</h2><br>\n",
    "</div>"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "We can import modules (Python code that can define functions, classes and variables).\n",
    "\n",
    "Usually, we write all the imports at the beginning of a Python program or notebook."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "**A small warning**  \n",
    "Ensure you trust the packages you're installing!\n",
    "\n",
    "Ask:\n",
    "1. Who wrote this code?\n",
    "2. Do I trust giving their code access to my computer?\n",
    "3. `pip install` especially can be a little more dangerous, anyone can upload something to the Python Package Index (\"PyPI\" for short), which is where `pip` installs from. So be very careful especially as the smallest typo can be a security risk!\n",
    "4. `conda install` is more of a walled garden and as such better positioned for enterprise usage."
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "> From the **math** library, import **sqrt** to work out the square root of **24 336**."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_37.py"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Python programmers really are lazy! (Or obsessive about productivity, take your pick!)\n",
    "\n",
    "Hence, you can define aliases for imports. The `as np` is two characters long, whereas `numpy` is five. It's less to type, when you write long programs.\n",
    "\n",
    "> Import `numpy as np` and try **`np.sin(np.pi/4)`**."
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# !cat solutions/01_38.py"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# 🎉 Congratulations, you made it to the end of Notebook 1! 🎉\n",
    "Take a well deserved break, brew a relaxing beverage of your choice or go have a snack, maybe share a picture of your snack/drink in the #random channel, we love to see pictures from everyone attending around the world. ☕️\n",
    "\n",
    "![](https://media0.giphy.com/media/3otPoS81loriI9sO8o/200.gif)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (beginners-data-workshop)",
   "language": "python",
   "name": "beginners-data-workshop"
  },
  "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}