python_basics/python_intro_part1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/makagan/SSI_Projects/blob/main/python_basics/python_intro_part1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8JypCKds4WOY"
   },
   "source": [
    "# Introduction to Python (Part I)\n",
    "\n",
    "Based on [W3Schools tutorial](https://www.w3schools.com/python/python_intro.asp).\n",
    "\n",
    "Python is a popular programming language. It was created by Guido van Rossum, and released in 1991.\n",
    "\n",
    "It is used for:\n",
    "\n",
    "* web development (server-side)\n",
    "* software development\n",
    "* mathematics\n",
    "* system scripting\n",
    "\n",
    "### **What can Python do?**\n",
    "\n",
    "* can be used on a server to create web applications\n",
    "* can be used alongside software to create workflows\n",
    "* can connect to database systems\n",
    "* can read and modify files\n",
    "* can be used to handle big data and perform complex mathematics\n",
    "* can be used for rapid prototyping, or for production-ready software development\n",
    "\n",
    "### **Why Python?**\n",
    "\n",
    "* works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc)\n",
    "* has a simple syntax similar to the English language\n",
    "* has syntax that allows developers to write programs with fewer lines than some other programming languages\n",
    "* runs on an interpreter system, meaning that code can be executed as soon as it is written (quick prototyping)\n",
    "* can be treated in a procedural way, an object-oriented way or a functional way"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-ZlZ7YTf60Qk"
   },
   "source": [
    "## Quickstart\n",
    "\n",
    "Python is an interpreted programming language, this means that as a developer you write Python (`.py`) files in a text editor and then put those files into the python interpreter to be executed.\n",
    "\n",
    "The way to run a python file is like this on the command line:\n",
    "\n",
    "`python helloworld.py`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oPAf570A6eY-"
   },
   "outputs": [],
   "source": [
    "#Fetch python script from github\n",
    "!curl https://raw.githubusercontent.com/jngadiub/ML_course_Pavia_23/main/python_basics/helloworld.py -o helloworld.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lX6bEtDG9BQE"
   },
   "outputs": [],
   "source": [
    "#Execute script\n",
    "!python helloworld.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cXwMrmn39ZDa"
   },
   "source": [
    "Let's look at the [script](https://raw.githubusercontent.com/jngadiub/ML_course_Padova_23/main/helloworld.py).\n",
    "\n",
    "**NB:** the exclamation sign `!` when executing the script or any other command is only need in a jupyter notebook. It is not needed when executing from terminal (which is the standard use).\n",
    "\n",
    "Because we are in jupyter we can also just type the content of `.py` script here as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GrbxeqM-9RbQ"
   },
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "popB6lS1_Uec"
   },
   "source": [
    "Let's also try python interactively from a terminal. First check that you have python installed typing:\n",
    "\n",
    "```\n",
    "python --version\n",
    "```\n",
    "\n",
    "And then type:\n",
    "\n",
    "```\n",
    "python\n",
    "```\n",
    "\n",
    "To exit type:\n",
    "\n",
    "```\n",
    "exit()\n",
    "```\n",
    "\n",
    "If you find that you do not have Python installed on your computer, then you can download it for free from the following website: https://www.python.org/."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UU45l29tAZ_E"
   },
   "source": [
    "## Indentation\n",
    "\n",
    "Indentation refers to the spaces at the beginning of a code line.\n",
    "\n",
    "Where in other programming languages the indentation in code is for readability only, the indentation in Python is very important.\n",
    "\n",
    "Python uses indentation to indicate a block of code.\n",
    "\n",
    "Let's see a few examples:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Upu60WG9A8MK"
   },
   "source": [
    "**Example 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uCCzajsz-19x"
   },
   "outputs": [],
   "source": [
    "if 5 > 2:\n",
    "  print(\"Five is greater than two!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WzUdiPdjA_jJ"
   },
   "source": [
    "**Example 2**\n",
    "\n",
    "Python will give you an error if you skip the indentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KuretVUoA-fZ"
   },
   "outputs": [],
   "source": [
    "if 5 > 2:\n",
    "print(\"Five is greater than two!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ueWgl4N5BQ8K"
   },
   "source": [
    "**Example 3**\n",
    "\n",
    "The number of spaces is up to you as a programmer, the most common use is four, but it has to be at least one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oTn0UbTFBICm"
   },
   "outputs": [],
   "source": [
    "if 5 > 2:\n",
    " print(\"Five is greater than two!\")\n",
    "if 5 > 2:\n",
    "        print(\"Five is greater than two!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PAu2x_A8BmGE"
   },
   "source": [
    "**Example 4**\n",
    "\n",
    "You have to use the same number of spaces in the same block of code, otherwise Python will give you an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pa_TbznpBU0j"
   },
   "outputs": [],
   "source": [
    "if 5 > 2:\n",
    " print(\"Five is greater than two!\")\n",
    "        print(\"Five is greater than two!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "97lbclF_PGai"
   },
   "source": [
    "## Comments\n",
    "\n",
    "Python has commenting capability for the purpose of in-code documentation.\n",
    "\n",
    "Comments start with a #, and Python will render the rest of the line as a comment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ygo5MqD0CjMJ"
   },
   "outputs": [],
   "source": [
    "#This is a comment.\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aq9a-tcxPwde"
   },
   "source": [
    "Comments can be placed at the end of a line, and Python will ignore the rest of the line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TuCIDZ-QPxwn"
   },
   "outputs": [],
   "source": [
    " print(\"Hello, World!\") #This is a comment "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "96Xrx4PwPz8D"
   },
   "source": [
    "A comment does not have to be text that explains the code, it can also be used to prevent Python from executing code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kJLR7x5MP5_6"
   },
   "outputs": [],
   "source": [
    "#print(\"Hello, World!\")\n",
    "print(\"Cheers, Mate!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8u12Tj9_QQzC"
   },
   "source": [
    "For multi line comment you can use a multiline string.\n",
    "\n",
    "Since Python will ignore string literals that are not assigned to a variable, you can add a multiline string (triple quotes) in your code, and place your comment inside it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5qqi2ZH7QaKp"
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "This is a comment\n",
    "written in\n",
    "more than just one line\n",
    "\"\"\"\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "q2csPbUuQi7Q"
   },
   "source": [
    "As long as the string is not assigned to a variable, Python will read the code, but then ignore it, and you have made a multiline comment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4a9d0WdBRAVW"
   },
   "source": [
    "## Variables\n",
    "\n",
    "Python has no command for declaring a variable.\n",
    "\n",
    "A variable is created the moment you first assign a value to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9IyhyMx8RHko"
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = \"John\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ujsO0fkYRKQZ"
   },
   "source": [
    "*Exercise: print the values of x of and y in one line.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kZzFX0t2RL2G"
   },
   "source": [
    "Variables do not need to be declared with any particular type, and can even change type after they have been set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z8OFnawwRoqO"
   },
   "outputs": [],
   "source": [
    "x = 4       # x is of type int\n",
    "x = \"Sally\" # x is now of type str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9RX5GWFsRrM2"
   },
   "source": [
    "If you want to specify the data type of a variable, this can be done with casting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sHIRL1U5RvzT"
   },
   "outputs": [],
   "source": [
    "x = str(3)    # x will be '3'\n",
    "y = int(3)    # y will be 3\n",
    "z = float(3)  # z will be 3.0 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DEJBkO1NRxgm"
   },
   "source": [
    "You can get the data type of a variable with the `type()` function. You can find several built-in data types at [this link](https://www.w3schools.com/python/python_datatypes.asp).\n",
    "\n",
    "*Exercise 1: print the type of the above variables.*\n",
    "\n",
    "*Exercise 2: declare a number as str and cast to float. What's the final type after the casting?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5NdDtEA-R-X0"
   },
   "source": [
    "Python allows you to assign values to multiple variables in one line and also to assign the same value to multiple variables in one line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DE6OxT3zSVRz"
   },
   "outputs": [],
   "source": [
    "x, y, z = \"Orange\", \"Banana\", \"Cherry\"\n",
    "x = y = z = \"Orange\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ojdSJl8ySZQ0"
   },
   "source": [
    "If you have a collection of values in a list, tuple etc. Python allows you to extract the values into variables. This is called *unpacking*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "FNQYmPuqS0eD"
   },
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "x, y, z = fruits\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jEj8PUjdS711"
   },
   "source": [
    "*Exercise: declare three variables of any type of your choice and print their sum.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Dg62kD4QTUy2"
   },
   "source": [
    "Variables that are created outside of a function (as in all of the examples above) are known as global variables.\n",
    "\n",
    "Global variables can be used by everyone, both inside of functions and outside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3Ypm4jwqUX7I"
   },
   "outputs": [],
   "source": [
    "x = \"awesome\"\n",
    "\n",
    "def myfunc():\n",
    "  print(\"Python is \" + x)\n",
    "\n",
    "myfunc() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XFR180ihUfBg"
   },
   "source": [
    "If you create a variable with the same name inside a function, this variable will be local, and can only be used inside the function. The global variable with the same name will remain as it was, global and with the original value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qIqLjBTLUZob"
   },
   "outputs": [],
   "source": [
    "x = \"awesome\"\n",
    "\n",
    "def myfunc():\n",
    "  x = \"fantastic\"\n",
    "  print(\"Python is \" + x)\n",
    "\n",
    "myfunc()\n",
    "\n",
    "print(\"Python is \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0d4CGvc0UkOw"
   },
   "source": [
    "Normally, when you create a variable inside a function, that variable is local, and can only be used inside that function.\n",
    "\n",
    "To create a global variable inside a function, you can use the `global` keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4KJkEWIHUwgV"
   },
   "outputs": [],
   "source": [
    "def myfunc():\n",
    "  global x\n",
    "  x = \"fantastic\"\n",
    "\n",
    "myfunc()\n",
    "\n",
    "print(\"Python is \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1Pnpfrv6ZUEU"
   },
   "source": [
    "## Conditions and `if` statements\n",
    "\n",
    "Python supports the usual logical conditions from mathematics:\n",
    "\n",
    "* Equals: `a == b`\n",
    "* Not Equals: `a != b`\n",
    "* Less than: `a < b`\n",
    "* Less than or equal to: `a <= b`\n",
    "* Greater than: `a > b`\n",
    "* Greater than or equal to: `a >= b`\n",
    "\n",
    "These conditions can be used in several ways, most commonly in \"if statements\" and loops.\n",
    "\n",
    "An \"if statement\" is written by using the `if` keyword.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "PjfJKq0QbUlj"
   },
   "outputs": [],
   "source": [
    "a = 33\n",
    "b = 200\n",
    "if b > a:\n",
    "  print(\"b is greater than a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SRSOMuUNbcZG"
   },
   "source": [
    "The `elif` keyword is pythons way of saying \"if the previous conditions were not true, then try this condition\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BkAYGehrbgBX"
   },
   "outputs": [],
   "source": [
    "a = 33\n",
    "b = 33\n",
    "if b > a:\n",
    "  print(\"b is greater than a\")\n",
    "elif a == b:\n",
    "  print(\"a and b are equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DFhzPz-fbrfi"
   },
   "source": [
    "The `else` keyword catches anything which isn't caught by the preceding conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "iRaPZ3cUbm3M"
   },
   "outputs": [],
   "source": [
    "a = 200\n",
    "b = 33\n",
    "if b > a:\n",
    "  print(\"b is greater than a\")\n",
    "elif a == b:\n",
    "  print(\"a and b are equal\")\n",
    "else:\n",
    "  print(\"a is greater than b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Aw0Bu1ENbxv7"
   },
   "source": [
    "NB, You can also have an `else` without the `elif`. It depends on the logic you want to implement, i.e. if you have multiple options or not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I23H-sY7cBY9"
   },
   "source": [
    "If you have only one condition to check, you can put it on the same line as the `if` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RqlvEjI3cGN8"
   },
   "outputs": [],
   "source": [
    "a = 200\n",
    "b = 33\n",
    "if a > b: print(\"a is greater than b\")\n",
    "print(\"A\") if a > b else print(\"B\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Po0Ps5o2cW40"
   },
   "source": [
    "You can also have multiple else statements on the same line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "yOE-TFKIbuWI"
   },
   "outputs": [],
   "source": [
    "print(\"A\") if a > b else print(\"=\") if a == b else print(\"B\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GRatfWtscdOl"
   },
   "source": [
    "The `and` keyword is a logical operator, and is used to combine conditional statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dU6GAhFZcfBM"
   },
   "outputs": [],
   "source": [
    "a = 200\n",
    "b = 33\n",
    "c = 500\n",
    "if a > b and c > a:\n",
    "  print(\"Both conditions are True\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YU8rbf78chEK"
   },
   "source": [
    "Similarly, the `or` keyword is a logical operator, and is used to combine conditional statements.\n",
    "\n",
    "*Exercise: implement an `or` condition and check result.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-h32GTPfgb6Q"
   },
   "source": [
    "## Arrays\n",
    "\n",
    "Arrays (also called `list` in Python) are used to store multiple values in one single variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KSY47eC4gsJp"
   },
   "outputs": [],
   "source": [
    "cars = [\"Ford\", \"Volvo\", \"BMW\"] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "juTWbB9Zgv21"
   },
   "source": [
    "You can access the element of an array as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GF2UwXCmg-92"
   },
   "outputs": [],
   "source": [
    "x = cars[0]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ocyun9_BzgRo"
   },
   "source": [
    "Negative indexing means start from the end\n",
    "\n",
    "`-1` refers to the last item, `-2` refers to the second last item etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wm4PGNDZziNz"
   },
   "outputs": [],
   "source": [
    "print(cars[-1])\n",
    "print(cars[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5AEuzGTgzvK7"
   },
   "source": [
    "You can specify a range of indexes by specifying where to start and where to end the range.\n",
    "\n",
    "When specifying a range, the return value will be a new list with the specified items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "r06gHcJozwQK"
   },
   "outputs": [],
   "source": [
    "cars = [\"Ford\", \"Volvo\", \"BMW\", \"Toyota\", \"Jeep\", \"Honda\"]\n",
    "print(cars[2:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8l4cO2bG0Roc"
   },
   "source": [
    "By leaving out the start value, the range will start at the first item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-ZO2jAqq0SWA"
   },
   "outputs": [],
   "source": [
    "print(cars[:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8n-7NSAb0aU1"
   },
   "source": [
    "By leaving out the end value, the range will go on to the end of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "988pj4CC0azD"
   },
   "outputs": [],
   "source": [
    "print(cars[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2qMThXwD0jPh"
   },
   "source": [
    "To determine if a specified item is present in a list use the `in` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5TSSm23e0lvd"
   },
   "outputs": [],
   "source": [
    "if \"Volvo\" in cars:\n",
    "  print(\"Yes, 'Volvo' is in the cars list\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cm3E4Q_K0lQq"
   },
   "source": [
    "And you can also determin if a specified item is NOT in a list using the `not in` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5HvpUIoR1CtB"
   },
   "outputs": [],
   "source": [
    "if \"Hyundai\" not in cars:\n",
    "  print(\"No, 'Hyundai' is not in the cars list\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ElUbYVQzhCC7"
   },
   "source": [
    "You can also modify the value of an element of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SRwIGYDvhHac"
   },
   "outputs": [],
   "source": [
    "cars = [\"Ford\", \"Volvo\", \"BMW\"] \n",
    "cars[0] = \"Toyota\"\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LBl6deWF1Wo2"
   },
   "source": [
    "To change the value of multiple items, define a list with the new values, and refer to the range of index numbers where you want to insert the new values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "w8RKuOxK1gxR"
   },
   "outputs": [],
   "source": [
    "cars = [\"Ford\", \"Volvo\", \"BMW\", \"Toyota\", \"Jeep\", \"Honda\"]\n",
    "cars[1:3] = [\"Hyundai\", \"Fiat\"]\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ObuziB6M2CEd"
   },
   "source": [
    "*Question 1: what happens **if** you insert **more** items than you replace?*\n",
    "\n",
    "*Question 2: what happens **if** you insert **less** items than you replace?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5t4Kq6RwhTmC"
   },
   "source": [
    "Use the `len()` method to return the length of an array (the number of elements in an array)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "L4P1Bbm2hVJ3"
   },
   "outputs": [],
   "source": [
    "print(len(cars))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sI3N-UIxhb9Z"
   },
   "source": [
    "You can use the `append()` method to add an element to an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CQ2YdGaphdv0"
   },
   "outputs": [],
   "source": [
    "cars = [\"Ford\", \"Volvo\", \"BMW\"] \n",
    "cars.append(\"Honda\") \n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3wE8R6B1hhir"
   },
   "source": [
    "You can use the `pop()` method to remove an element from the array using its index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Hv7jFkljhkMh"
   },
   "outputs": [],
   "source": [
    "cars.pop(1) \n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TffLx7DP4qtf"
   },
   "source": [
    "Or you can use the `remove()` method to remove an element from the array using its value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sjQddkoi41fm"
   },
   "outputs": [],
   "source": [
    "cars = [\"Ford\", \"Volvo\", \"BMW\"] \n",
    "cars.remove(\"BMW\") \n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M06OmhUe3ZB_"
   },
   "source": [
    "To insert a new list item, without replacing any of the existing values, we can use the `insert()` method, which inserts an item at the specified index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bC9Jg4Y63eey"
   },
   "outputs": [],
   "source": [
    "cars = [\"Ford\", \"Volvo\", \"BMW\"] \n",
    "cars.insert(2,\"Honda\") \n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8HivpL064DCQ"
   },
   "source": [
    "To append elements from another list to the current list, use the `extend()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i8_gvTYF4H_S"
   },
   "outputs": [],
   "source": [
    "my_cars = [\"Ford\", \"Volvo\", \"BMW\"] \n",
    "your_cars = [\"Toyota\", \"Jeep\", \"Honda\", \"Hyundai\"]\n",
    "my_cars.extend(your_cars)\n",
    "print(my_cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3bElPtF9gRC3"
   },
   "source": [
    "List objects have a `sort()` method that will sort the list alphanumerically, ascending, by default:\n",
    "\n",
    "**Example 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "A6Gp5EHZgTOL"
   },
   "outputs": [],
   "source": [
    "thislist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
    "thislist.sort()\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jCb8jre0gV2I"
   },
   "source": [
    "**Example 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pFzwLbr8gXd7"
   },
   "outputs": [],
   "source": [
    "thislist = [100, 50, 65, 82, 23]\n",
    "thislist.sort()\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qUhuAzbRgmmU"
   },
   "source": [
    "To sort descending, use the keyword argument `reverse = True`:\n",
    "\n",
    "**Example 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nK0eDEY8gsd-"
   },
   "outputs": [],
   "source": [
    "thislist = [\"orange\", \"mango\", \"kiwi\", \"pineapple\", \"banana\"]\n",
    "thislist.sort(reverse = True)\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MoMd-E_OgtqP"
   },
   "source": [
    "**Example 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "T8AcdrIygvJb"
   },
   "outputs": [],
   "source": [
    "thislist = [100, 50, 65, 82, 23]\n",
    "thislist.sort(reverse = True)\n",
    "print(thislist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hh_g7Lxq5Kn6"
   },
   "source": [
    "Find more array methods at [this link](https://www.w3schools.com/python/python_lists_methods.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IhU7w1QGiSTk"
   },
   "source": [
    "## Strings\n",
    "\n",
    "Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.\n",
    "\n",
    "However, Python does not have a character data type, a single character is simply a string with a length of 1.\n",
    "\n",
    "This means that a string can be treated exactly as the arrays of the previous section, importing all the array methods.\n",
    "\n",
    "At the same time, there are methods for string types existing that facilitate their manipulation. See a few selected examples below, while the full list can be found at [this link](https://www.w3schools.com/python/python_ref_string.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Sh4iAR2l6G9X"
   },
   "source": [
    "The `replace()` method replaces a string with another string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "l1JSpev26IqI"
   },
   "outputs": [],
   "source": [
    "a = \"Hello, World!\"\n",
    "print(a.replace(\"H\", \"J\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VWI0SpyH6K1l"
   },
   "source": [
    "The `split()` method returns a list where the text between the specified separator becomes the list items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "V9jI4tT_6Nt_"
   },
   "outputs": [],
   "source": [
    "a = \"Hello, World!\"\n",
    "print(a.split(\",\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3DvO3NZy6SxM"
   },
   "source": [
    "Find more strings methods at [this link](https://www.w3schools.com/python/python_ref_string.asp)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L2iNkT_Q6eHp"
   },
   "source": [
    "To concatenate, or combine, two strings you can use the `+` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rVXgsehe6i-I"
   },
   "outputs": [],
   "source": [
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "GXmJ8kpM6ley"
   },
   "source": [
    "*Exercise: add a space or a comma between the two words \"Hello\" and \"World\"*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SId7YYAO6w_B"
   },
   "source": [
    "As we learned, we cannot combine strings and numbers like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NDYrQwtY69xq"
   },
   "outputs": [],
   "source": [
    "age = 36\n",
    "txt = \"My name is John, I am \" + age\n",
    "print(txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L0TAoO0s7BEA"
   },
   "source": [
    "But we can combine strings and numbers by using the `format()` method!\n",
    "\n",
    "The `format()` method takes the passed arguments, formats them, and places them in the string where the placeholders `{}` are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f5aKGVrO7Ggn"
   },
   "outputs": [],
   "source": [
    "age = 36\n",
    "txt = \"My name is John, and I am {}\".format(age)\n",
    "print(txt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u1XwNa5G7PCT"
   },
   "source": [
    "The `format()` method takes unlimited number of arguments, and are placed into the respective placeholders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "I32jl1yy7Kxa"
   },
   "outputs": [],
   "source": [
    "quantity = 3\n",
    "itemno = 567\n",
    "price = 49.95\n",
    "myorder = \"I want {} pieces of item {} for {} dollars.\".format(quantity, itemno, price)\n",
    "print(myorder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RFPk-sqX7Tb1"
   },
   "source": [
    "You can use index numbers `{0}` to be sure the arguments are placed in the correct placeholders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tjvNou8I7XoP"
   },
   "outputs": [],
   "source": [
    "quantity = 3\n",
    "itemno = 567\n",
    "price = 49.95\n",
    "myorder = \"I want to pay {2} dollars for {0} pieces of item {1}.\".format(quantity, itemno, price)\n",
    "print(myorder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h6YhCRIU7qRK"
   },
   "source": [
    "You can also use named indexes by entering a name inside the curly brackets (ex, `{PRICE}`), but then you must use names when you pass the parameter values (ex, `txt.format(PRICE=price)` or `txt.format(PRICE=70)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ByZs2Xpv72Td"
   },
   "outputs": [],
   "source": [
    "quantity = 3\n",
    "itemno = 567\n",
    "price = 49.95\n",
    "myorder = \"I want to pay {PRICE} dollars for {QUANTITY} pieces of item {ITEMNO}.\".format(QUANTITY=quantity, ITEMNO=itemno, PRICE=price)\n",
    "print(myorder)\n",
    "myorder = \"I want to pay {PRICE} dollars for {QUANTITY} pieces of item {ITEMNO}.\".format(QUANTITY=quantity, ITEMNO=itemno, PRICE=70)\n",
    "print(myorder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QvIter3Mc47m"
   },
   "source": [
    "## Loops: `while` and `for`\n",
    "\n",
    "With the `while` loop we can execute a set of statements as long as a condition is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1x9mJh0ZdLS0"
   },
   "outputs": [],
   "source": [
    "i=1\n",
    "while i < 6:\n",
    "  print(i)\n",
    "  i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "usPpyegNdfpU"
   },
   "source": [
    "With the `break` statement we can stop the loop even if the while condition is true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ivlxqVR0dNdb"
   },
   "outputs": [],
   "source": [
    "i=1\n",
    "while i < 6:\n",
    "  print(i)\n",
    "  if i==3: break\n",
    "  i+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9_V3GDHadrEJ"
   },
   "source": [
    "With the `continue` statement we can stop the current iteration, and continue with the next:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rZdmsCZGdncC"
   },
   "outputs": [],
   "source": [
    "i=1\n",
    "while i < 6:\n",
    "  i+=1\n",
    "  if i==3: continue\n",
    "  print(i)\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4setwG4veVcY"
   },
   "source": [
    "*Question: why are the `print` and `i+=1` statement inverted wrt the previous example?*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kbyyMpTnf-au"
   },
   "source": [
    "A `for` loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).\n",
    "\n",
    "This is less like the for keyword in other programming languages, and works more like an iterator method as found in other object-orientated programming languages.\n",
    "\n",
    "With the `for` loop we can execute a set of statements, once for each item in an array, tuple, set etc.\n",
    "\n",
    "The `for` loop does not require an indexing variable to set beforehand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f3bZbwz-dvRv"
   },
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rhJParHT-jNi"
   },
   "source": [
    "As discussed in a previous section, strings are arrays such that you can loop over the character in the same way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NF9Dqq4a-YSJ"
   },
   "outputs": [],
   "source": [
    "for x in \"banana\":\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SEp8Qrwe-0qF"
   },
   "source": [
    "With the `break` statement we can stop the loop before it has looped through all the items:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aJ1QPayg-3dp"
   },
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "  print(x)\n",
    "  if x == \"banana\":\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zgv7KtxE_Cn9"
   },
   "source": [
    "With the `continue` statement we can stop the current iteration of the loop, and continue with the next:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "I-jxQUae_EME"
   },
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "  if x == \"banana\":\n",
    "    continue\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9SDRnJGv_I6j"
   },
   "source": [
    "To loop through a set of code a specified number of times, we can use the `range()` function,\n",
    "\n",
    "The `range()` function returns a sequence of numbers, starting from `0` by default, and increments by `1` (by default), and ends at a specified number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LR3cGDJ8_NAc"
   },
   "outputs": [],
   "source": [
    "for x in range(6):\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nnUZyWFb_S_d"
   },
   "source": [
    "The `range()` function defaults to `0` as a starting value, however it is possible to specify the starting value by adding a parameter: `range(2, 6)`, which means values from `2` to `6` (but not including `6`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cQSMCgv-_Ylf"
   },
   "outputs": [],
   "source": [
    "for x in range(2, 6):\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vpKUtiY__d6u"
   },
   "source": [
    "The `range()` function defaults to increment the sequence by `1`, however it is possible to specify the increment value by adding a third parameter: `range(2, 30, 3)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7fD5t9hA_hga"
   },
   "outputs": [],
   "source": [
    "for x in range(2, 30, 3):\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jY7oGMxJ_pRB"
   },
   "source": [
    "*Exercise 1: insert `if` and `else` statements in the loop.*\n",
    "\n",
    "*Exercise 2: code one nested loop with `if` and `else` statements.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ba3kyy57h7Hc"
   },
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are used to store data values in **key:value pairs**. A dictionary is a collection which is ordered, changeable and do not allow duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aVbJVC0ciggX"
   },
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Utgu2hD5jJQo"
   },
   "source": [
    "Dictionaries cannot have two items with the same key and duplicate values will overwrite existing values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3ro7zn1ajOfa"
   },
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964,\n",
    "  \"year\": 2020\n",
    "}\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "McVbKtXujd5N"
   },
   "source": [
    "To determine how many items a dictionary has, use the `len()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pZUvOxSXjf4b"
   },
   "outputs": [],
   "source": [
    "print(len(thisdict))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "McJYEfwKjmDf"
   },
   "source": [
    "The values in dictionary items can be of any data type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Kn8x4R_Ejm7I"
   },
   "outputs": [],
   "source": [
    " thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"electric\": False,\n",
    "  \"year\": 1964,\n",
    "  \"colors\": [\"red\", \"white\", \"blue\"]\n",
    "}\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9dMBePo3j6xd"
   },
   "source": [
    "It is also possible to use the `dict()` constructor to make a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GBrrV0h--r59"
   },
   "outputs": [],
   "source": [
    "thisdict = dict(name = \"John\", age = 36, country = \"Norway\")\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2nTVLWMJkYAR"
   },
   "source": [
    "As dictionary items are presented in **key:value pairs**, you can access the items of a dictionary by referring to its key name, inside square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZeA5nieskXUG"
   },
   "outputs": [],
   "source": [
    " thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"electric\": False,\n",
    "  \"year\": 1964,\n",
    "  \"colors\": [\"red\", \"white\", \"blue\"]\n",
    "}\n",
    "print(thisdict[\"brand\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BheNssTkkqvC"
   },
   "source": [
    "The `keys()` method will return a list of all the keys in the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_9PuQxr_ksoF"
   },
   "outputs": [],
   "source": [
    "print(thisdict.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "djl6gnyllQBm"
   },
   "source": [
    "The `values()` method will return a list of all the values in the dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kgklomULlljQ"
   },
   "outputs": [],
   "source": [
    "print(thisdict.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vC4c_yKRlw6u"
   },
   "source": [
    "*Exercise 1: modify the value of one of the key:value pairs of the dictionary.*\n",
    "\n",
    "*Exercise 2: add a new key:value pair to the dictionary.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2VJFWCqbl11t"
   },
   "source": [
    "The `items()` method will return each item in a dictionary, as tuples (i.e. a set of two elements) in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i206YckXl452"
   },
   "outputs": [],
   "source": [
    "print(thisdict.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X4kgjSBBpYIX"
   },
   "source": [
    "To determine if a specified key is present in a dictionary use the `in` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6azreBFYpaKM"
   },
   "outputs": [],
   "source": [
    "if \"year\" in thisdict:\n",
    "  print(\"Yes, 'year' is one of the keys in the thisdict dictionary\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Hem_4idNq4un"
   },
   "source": [
    "There are several methods to remove items from a dictionary. The `pop()` method removes the item with the specified key name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bSDN2dCzq_Pi"
   },
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "thisdict.pop(\"model\")\n",
    "print(thisdict) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8ZBTe5S5rGJ8"
   },
   "source": [
    "The `popitem()` method removes the last inserted item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9PLhiliRrKXK"
   },
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "thisdict.popitem()\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HK2xqwMErTw9"
   },
   "source": [
    "The `del` keyword removes the item with the specified key name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "fgo2jBaurVch"
   },
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "del thisdict[\"model\"]\n",
    "print(thisdict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NRP58CHOr2Lt"
   },
   "source": [
    "You can loop through a dictionary by using a `for` loop over the key:value pairs or over the keys and values only in several ways:\n",
    "\n",
    "**Example 1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MiIq7AMVsGgn"
   },
   "outputs": [],
   "source": [
    "thisdict =\t{\n",
    "  \"brand\": \"Ford\",\n",
    "  \"model\": \"Mustang\",\n",
    "  \"year\": 1964\n",
    "}\n",
    "\n",
    "for x in thisdict: print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4Drar_aysOwk"
   },
   "source": [
    "**Example 2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WSuy_WQGl1X3"
   },
   "outputs": [],
   "source": [
    "for x in thisdict: print(thisdict[x]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "S2HRLXbMsbCG"
   },
   "source": [
    "**Example 3**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EOXlYmGSscgs"
   },
   "outputs": [],
   "source": [
    "for x in thisdict.values(): print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VQDYei0Rsjat"
   },
   "source": [
    "**Example 4**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AeXhFW2Wj4D3"
   },
   "outputs": [],
   "source": [
    "for x in thisdict.keys(): print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CVmWSdDhsp1j"
   },
   "source": [
    "**Example 5**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IAt7yOJQsrBY"
   },
   "outputs": [],
   "source": [
    "for x, y in thisdict.items(): print(x, y) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Xf_EtFH4s1bf"
   },
   "source": [
    "*Exercise: create a nested dictionary, i.e. a dictionary containing one or more other dictionaries.*"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}