week1_intro_to_python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "week1_intro_to_python.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "oym5-FtJuif9",
        "4olvm05ptc3f",
        "CUxrLJY4xDru",
        "5ezyKoyD5ZT_",
        "GKxfE_YK5lCD"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fOQQ8JHF4rK6",
        "colab_type": "text"
      },
      "source": [
        "# Big Data Colab Week 1: Intro to Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rhwX99splTFn",
        "colab_type": "text"
      },
      "source": [
        "Welcome to week one of MAGIC's Big Data Colab. This module contains an intro to python as well as an introduction to computational thinking. All important stuff. Let's get started"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IMaMYKrTlrhN",
        "colab_type": "text"
      },
      "source": [
        "Python is a powerful and popular programming language for data science, web backends, and scientific computing. Its popularity comes from its ease of both reading and writing. It isn't hard to get started with python! This tutorial will start with the basics and work up to more complex code. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6zJSn7f6mHxu",
        "colab_type": "text"
      },
      "source": [
        "## Basic Data Types:\n",
        "\n",
        "The starting point for any programming is understanding its basic data types. Data types are just what a program uses to store data. We, as programmers, have a need to store all types of data (e.g. numbers, addresses, party membership, whatever!). Its a good thing python makes it easy to store all sorts of data types\n",
        "\n",
        "The following code blocks introduce integers, floats, booleans, strings, and some basic operators."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9bF_j4Xb45Ng",
        "colab_type": "text"
      },
      "source": [
        "### Integers and Floats"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "19b-VIfLlSQk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f6e3c032-6d47-4d7a-f3aa-39acae7994b3"
      },
      "source": [
        "# Surprise, surprise. Python can store numbers.\n",
        "\n",
        "zebras=10\n",
        "pandas=5\n",
        "\n",
        "total_animals_in_zoo= pandas + zebras\n",
        "print(total_animals_in_zoo)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qa5o6HWYnjYt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Python also makes it easy to store decimals (floating point values or floats).\n",
        "# Its also easy to convert between integers and floats\n",
        "my_height_in_inches =71.5\n",
        "your_height_in_cms= 67.75\n",
        "\n",
        "combined_height_in_inches= my_height_in_inches + (your_height_in_cms/2.54)\n",
        "print(combined_height_in_inches)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7iZGF3usvHl6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "4bf604a7-d5fe-4579-efb1-7396722c25c3"
      },
      "source": [
        "# We can also compare numbers.\n",
        "print(3<2)\n",
        "print(10<=20)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IdPkkDHCoxR3",
        "colab_type": "text"
      },
      "source": [
        "**1.1)** You're up. Using the variables, calculate the area of the circles defined\n",
        "below and figure out which circle is larger. Print the result to the console. Area=pi*r^2\n",
        "\n",
        "[Here's](https://www.jpl.nasa.gov/edu/news/2016/3/16/how-many-decimals-of-pi-do-we-really-need/) a cool article about the precision of pi used in the code for interplanetary navegation. :)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CysUJ7dvo-7o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pi=3.14159 # Aprox.\n",
        "diameter1=10\n",
        "diameter2=15\n",
        "\n",
        "###### YOUR CODE HERE ##########\n",
        "\n",
        "\n",
        "\n",
        "print(\"Circle one is larger than circle two. True or False\")\n",
        "\n",
        "################################"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mmv0FkU6p644",
        "colab_type": "text"
      },
      "source": [
        "### Strings\n",
        "\n",
        "Being able to store numbers is obviously important. But we do need to be able to store other types of data. What if we want to store a name or address?\n",
        "\n",
        "Enter strings! Programs use strings to store characters and words."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JzksSa2p6je",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cdaf24a4-b639-45c6-b195-26c6e5caea17"
      },
      "source": [
        "first_name = \"Sam\"\n",
        "last_name = 'Schoberg' \n",
        "\n",
        "full_name = first_name + \" \" + last_name\n",
        "print(full_name)\n",
        "# Notice in python you can use single or double quotes to declare a string. \n",
        "# In python, it depends on your style. In other languages, you can only use\n",
        "# double quotes and single quotes can only declare individual characters. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sam Schoberg\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VMkunRrTrKs1",
        "colab_type": "text"
      },
      "source": [
        "Strings themselves aren't that useful. We need operators to make them more powerful. Python gives you [a lot](https://www.programiz.com/python-programming/methods/string) to work with out of the box. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5cueKusCrJcO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        " print(\"length: \" + len(\"I wonder how long this sentence is.\")) # Casting "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2SThgtpzsGpx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "a1e063a5-49b3-4288-aafb-5345567ecbf7"
      },
      "source": [
        "my_str=\"yelling? Im not yelling.\"\n",
        "print(my_str)\n",
        "print(my_str.upper())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "yelling? Im not yelling.\n",
            "YELLING? IM NOT YELLING.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hc59-JUrs--m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "str1 = \"string 1\"\n",
        "str2 = \"string 2\"\n",
        "str3 = \"string 1\"\n",
        "\n",
        "print(str1 == str2)\n",
        "print(str1 == \"string 1\")\n",
        "print(str1 < str2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "96pA3Ul8vYzT",
        "colab_type": "text"
      },
      "source": [
        "**1.2)** Fill in the address fields and concatenate the strings. Make sure the address is all upper case then print it to the console. Can you do it without declaring the zip_code as a string to start?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yG1to1eivZHv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "street_address = \"\"\n",
        "city = \"\"\n",
        "state = \"\"\n",
        "zip_code = "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oym5-FtJuif9",
        "colab_type": "text"
      },
      "source": [
        "### Booleans and Conditional Branching\n",
        "\n",
        "As you've seen above, boolean variables (i.e. true and false) are also important. A lot of functions depend on the logical combinations of boolean variables, for example logical AND OR and NOT. [Here](https://medium.com/i-math/intro-to-truth-tables-boolean-algebra-73b331dd9b94) is a gentle intro to boolean logic. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_BqYM7BOtcjd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sam_likes_pizza = True\n",
        "jim_likes_pizza = True\n",
        "max_likes_pizza = False\n",
        "\n",
        "sam_and_max_like_pizza = sam_likes_pizza and max_likes_pizza\n",
        "sam_and_jim_like_pizza = sam_likes_pizza and jim_likes_pizza\n",
        "\n",
        "sam_or_max_like_pizza = sam_likes_pizza or max_likes_pizza\n",
        "sam_or_jim_like_pizza = sam_likes_pizza or jim_likes_pizza\n",
        "\n",
        "what_will_this_be = not sam_likes_pizza"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jfrM1MsOZlBM",
        "colab_type": "text"
      },
      "source": [
        "True and false values are important for controlling the flow of a program. For example, if the user is new, show them a sign up screen, else show them their home screen. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3s_PZAVHZ0zh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "40bf29f1-e362-4bc3-8b23-30f5aac4f37c"
      },
      "source": [
        "four_legs = True\n",
        "floppy_ears = True\n",
        "two_legs = False\n",
        "onek_legs = False\n",
        "\n",
        "if(four_legs is True):\n",
        "  if(floppy_ears is True):\n",
        "    print(\"its a dog\")\n",
        "  else:\n",
        "    print(\"its a bunny\")\n",
        "elif(onek_legs):\n",
        "  print(\"its a millipede \")\n",
        "else:\n",
        "  print(\"Animal unidentified\")\n",
        "\n",
        "\n",
        "# Often times we can condense if blocks\n",
        "\n",
        "if(four_legs and floppy_ears):\n",
        "  print(\"its a dog\")\n",
        "elif(two_legs and floppy_ears):\n",
        "  print(\"its a bunny\")\n",
        "elif(onek_legs):\n",
        "  print(\"its a bunny\")\n",
        "else:\n",
        "  print(\"Animal unidentified\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "its a dog\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xh3FNTMhbG0q",
        "colab_type": "text"
      },
      "source": [
        "**1.3)** Your turn. Consider all the conditions needed to come together for a thunderstorm (e.g. rain, thunder, lightning, low pressure, etc). Write a sequence of if statements that can correctly identify a thunderstorm given a series of conditions. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2l4ElYIRTWXr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4olvm05ptc3f",
        "colab_type": "text"
      },
      "source": [
        "### Collections: Lists and Dicts\n",
        "\n",
        "So far we've seen numbers, strings, and boolean data types. These are useful, but a lot of times we need... more ... things.\n",
        "\n",
        "The last two data types we'll see are types of collections. Collections store groups of basic data types or even groups of other collections. The two basic collections we'll look at are lists and maps aka dictionaries.\n",
        "\n",
        "[Here](https://www.w3schools.com/python/python_ref_list.asp) is a list of common list functions.\n",
        "\n",
        "[Here](https://www.w3schools.com/python/python_ref_dictionary.asp) is a list of common dictionary functions. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "myiWtBnFxQmP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "811c28d1-f9e2-41b6-d43c-b439cf0f4cdc"
      },
      "source": [
        "my_list = [1,2,3,4,5]\n",
        "\n",
        "# lists can also be mixed type\n",
        "my_mixed_list = [1, \"two\", False]\n",
        "my_mixed_list.append(\"new element\")\n",
        "my_mixed_list.remove(\"two\")\n",
        "my_mixed_list.index(False)\n",
        "my_mixed_list.clear()\n",
        "\n",
        "# lists can store other lists ?!?!\n",
        "list_o_lists = [['1.1', '1.2', '1.3'], ['2.1', '2.2', '2.3', 2.4]]\n",
        "print(list_o_lists[1][2])\n",
        "# Under the hood what is a string? :O\n",
        "\n",
        "# You can access a list items based on their indexes\n",
        "my_list = [1,2,3,4,5]\n",
        "print(my_list[3])\n",
        "\n",
        "# A popular function for lists/maps is the 'in' keyword\n",
        "\n",
        "print(1 in my_list)\n",
        "print(43 in my_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.3\n",
            "4\n",
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EOWMIM7j4IKO",
        "colab_type": "text"
      },
      "source": [
        "**1.3)** You are analyzing sports teams.  Members of each team are stored in a list. The Coach is the first name in the list, the captain is the second name in the list, and other players are listed after that. \n",
        "These lists are stored in another list, which starts with the best team and proceeds through the list to the worst team last.  Complete the function below to select the **captain** of the worst team and print to console."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yd-5aKeh4Nu2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "real_madrid=['zidane', 'ramos', 'marcelo']\n",
        "barcelona=['valverde', 'messi', 'pique']\n",
        "\n",
        "teams = [real_madrid, barcelona]\n",
        "\n",
        "######### YOUR CODE HERE ##############"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x7pdc7lnzMyQ",
        "colab_type": "text"
      },
      "source": [
        "A map/dictionary is a collection that stores key value pairs. Think of it like a literal dictionary. When you need something you find the word (key) and get the definition (value). But unlike a real dictionary, a python dictionary doesn't just map strings to strings. It can map any data type to any other data type."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6VwKhXxQzJ1S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "capitals={'United States': 'DC', 'France': 'Paris', 'Mexico': 'DF'}\n",
        "\n",
        "populations = dict()\n",
        "populations['UMD'] = 40000\n",
        "populations['Towson'] = 30000\n",
        "populations['UMBC'] = 20000\n",
        "\n",
        "\n",
        "print(populations.get('UMD'))\n",
        "print(capitals['United States'])\n",
        "print(capitals['Canada'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zgq5nDvvdhB2",
        "colab_type": "text"
      },
      "source": [
        "**1.4)** Declare a new dict that contains state capitals. The key should be the state name and the value should be the capital. After adding three entries, [clear](https://www.w3schools.com/python/ref_dictionary_clear.asp) the dict. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DK4R-ZAMd1s8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CUxrLJY4xDru",
        "colab_type": "text"
      },
      "source": [
        "### Loops\n",
        "\n",
        "Now that we've seen collections, you can see how it might be important (majorily important cough cough) to be able to iterate over the collection and look at everything inside.\n",
        "\n",
        "Loop loop loop loop loop loop loop loop loop loop loop loop loop \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uxj99p430vfo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Simple loop\n",
        "for i in range(10):\n",
        "  print(i)\n",
        "\n",
        "# Nested for loop\n",
        "for i in range(0, 100, 10):\n",
        "  for j in range(10):\n",
        "    print(i+j)\n",
        "\n",
        "# Summation loop\n",
        "sum=0\n",
        "for i in range(0, 100, 10):\n",
        "  sum = sum + 10\n",
        "  print(\"sum: \" + str(sum))\n",
        "\n",
        "print(\"sum: \" + str(sum))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wjcF224q00uH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Appending to list using a loop\n",
        "my_list = []\n",
        "\n",
        "for i in range(10):\n",
        "  my_list.append(i)\n",
        "\n",
        "# Looping over a dict and a list\n",
        "name_dict=dict()\n",
        "name_dict['santa'] = 'claus'\n",
        "name_dict['easter'] = 'bunny'\n",
        "name_dict['tooth'] = 'fairy'\n",
        "\n",
        "for k,v in name_list.items():\n",
        "  print(k, v)\n",
        "\n",
        "for num in my_list:\n",
        "  print(num)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xTBADXwweClQ",
        "colab_type": "text"
      },
      "source": [
        "**1.5)** You've seen earlier that python gives you an 'in' function to test if an element is in a list or a dict. It isn't magic that makes the 'in' function work. Engineers had to design the 'in' function for you to use. \n",
        "\n",
        "Given a list of items and a check_item, think about how you could check to see if the list contains that check_item. If the item is in the list, print \"true\" else print \"false\". *(Hint: You should be thinking about loops and if conditions)*.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GI9s3XuDe7eS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "######## YOUR CODE HERE ##############\n",
        "\n",
        "my_list = [1,2,3,4,5,6,8,9,10]\n",
        "check_item = 7"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ezyKoyD5ZT_",
        "colab_type": "text"
      },
      "source": [
        "### Functions\n",
        "\n",
        "In the section above, you wrote a useful snipped of code that replicates the 'in' function. A lot of times in programming you write something useful that you want to use again. Instead of rewriting the logic each time you use it, you can use a function to call the logic in multiple places.\n",
        "\n",
        "A function contains a keyword def, a name, arguments, and a return value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jONb8_BIf2fj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "4af1e29b-3610-48f2-e180-a90fd75d4da9"
      },
      "source": [
        "def list_shorter_10_elements(list):\n",
        "  if(len(list) < 10):\n",
        "    return True\n",
        "  else:\n",
        "    return False\n",
        "\n",
        "my_list = []\n",
        "for i in range(0,100):\n",
        "  my_list.append(i)\n",
        "\n",
        "print(list_shorter_10_elements(my_list))\n",
        "\n",
        "my_list.clear()\n",
        "\n",
        "for i in range(0, 9):\n",
        "  my_list.append(i)\n",
        "\n",
        "print(list_shorter_10_elements(my_list))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zAW1swWzgMyc",
        "colab_type": "text"
      },
      "source": [
        "**1.6)** Convert the logic you wrote in 1.5 into a function (two arguments?) and test it on multiple lists. Think about if there are any scenarios where your function might break. Some people's entire job is testing the code that others wrote (QA testing [link text](https://twitter.com/brenankeller/status/1068615953989087232)). Edge cases are important in computer science :) . "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_h3UXw67hAbD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#### YOUR CODE HERE ###########\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GKxfE_YK5lCD",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "### Computational Thinking\n",
        "\n",
        "Most of programming is just manipulating all the the structures and language features described above. Solving coding puzzles can help you become a better problem solver and a better program. As an additional incentive, most coding modern coding interviews are just a series of problems solving exercises.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fZ7Vx9Bv8MiR",
        "colab_type": "text"
      },
      "source": [
        "**1.7)** Write a function called list_max that takes in a single list of numbers as an argument. Your function must return the max value in the list or return None if the list is empty. Then create a second function called list_min that does the same but for the minimum element. Don't use Python's prebuilt max or min :) ."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PlbcCpOX8Lgu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "###### YOUR CODE HERE ########\n",
        "\n",
        "def list_max(lst):\n",
        "\n",
        "\n",
        "####### min_list here #########"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "POqmLueV-L6e",
        "colab_type": "text"
      },
      "source": [
        "**1.8)** Summing a series a numbers comes up often in programming. For example, the total cost of all the items in a shopping cart. Write a function that takes in a list of numbers as an argument and returns the sum of the list. Return 0 for an empty list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IncILUd0_Rf0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#### YOUR CODE HERE ######\n",
        "def sum_list(lst):\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2I-xUU51TihZ",
        "colab_type": "text"
      },
      "source": [
        "**1.9)** Write a function that takes in two lists, lst1 and lst2. The function should concatenate the lists (i.e. each element of lst2 starting with the first should be added to the end of lst1)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8o-DyjQwT5d1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "###### YOUR CODE HERE ########\n",
        "def concat_lists(lst1, lst2):\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vhpIVF6N9R3Z",
        "colab_type": "text"
      },
      "source": [
        "**1.10)** The modulus (%) is a common mathematical operator in python. The the expression (a % b) is equivalent to the remainder of a divided by b. For example, 10 % 7 is 3 and 20 % 3 is 2.\n",
        "\n",
        "It's common to use modulus 2 to determine if a number is even or odd in programming. Notice that any number % 2 is either 0 or 1. If a % 2 is 0, a is even. If a % 2 is 1, a is odd.\n",
        "\n",
        "Given that knowledge, try to figure out what the code below is doing. I purposefully made the variable names meaningless. Its probably easiest to look at and explain one function at a time then try to combine them. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YftN-IYN9r0E",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "100740dc-710a-44e3-ea61-03b2611120b6"
      },
      "source": [
        "#### Try out some mod exaples here ####\n",
        "print(10 % 2)\n",
        "print(11 % 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NdSXyBNz_gLZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def foo(lst):\n",
        "  magic = []\n",
        "  for i in lst:\n",
        "    if(i % 2 == 0):\n",
        "      magic.append(i)\n",
        "  \n",
        "  return magic\n",
        "\n",
        "def bar(lst):\n",
        "  cat = lst.sort() # We haven't seen this but you should get it :)\n",
        "  return lst[-1] # Hint: negative indexes wrap around to the back of the list\n",
        "\n",
        "dog = [1,43,543,53,3,64,90,32,45,692,2, 20, -10,785]\n",
        "\n",
        "print(foo(dog))\n",
        "print(bar(dog))\n",
        "print(bar(foo(dog)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gg3PhFZPUsFF",
        "colab_type": "text"
      },
      "source": [
        "A really important skill for python specifically and programmig in general is the ability to find things you need on Google. Many times, you may not know how to solve but a problem, but the good news is, someone else has definitley already thought about it.\n",
        "\n",
        "This problem is a little more advanced and involves two data structures. If you get stuck, google away! Programmers are just really good googlers. \n",
        "\n",
        "**1.10)**  Given two equal length lists named keys and vals as an arguments, write a function that turns the two lists into a dictionary where each corresponding index of the item in the key list maps to the index of the val list.\n",
        "\n",
        "For example:\n",
        "\n",
        "keys = [1, 2, 3]\n",
        "vals = ['one', 'two', 'three']\n",
        "\n",
        "Your function will return dict = {1 : 'one', 2 : 'two', 3 : 'three'}"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXTRLejiWr_Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "##### YOUR CODE HERE ########\n",
        "\n",
        "def lists_to_dict(keys, vals):\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XPKDiM5j5rd3",
        "colab_type": "text"
      },
      "source": [
        "### Challenge Exercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LvhBimOpXBFG",
        "colab_type": "text"
      },
      "source": [
        "**1.11)** Given a list of numbers, write a function that returns a list with all of the negative numbers removed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JJ2J3KadXLiq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QvWr5FRnXNif",
        "colab_type": "text"
      },
      "source": [
        "**1.12)** Given a list of strings, write a function that returns the string of the shortest length."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pM0tQ9wRXMuJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E2PuqNJHXgZl",
        "colab_type": "text"
      },
      "source": [
        "**1.13)** Given a dictionary with strings as keys, write a function that returns a list of the keys sorted in ascending order."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uE_XP-QeXu4u",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z1eTDdd7XuiJ",
        "colab_type": "text"
      },
      "source": [
        "**1.14)** Write a function that takes in a string and a number. The string can either be \"cm\" or \"in\". If the string is \"cm\" then your function must convert from the number from centimeters to inches. If the string is \"in\", your function must convert the number from inches to centimeters. If the string isn't \"cm\" or \"in\", print \"Unit unrecognized.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZZI-1caSYbW6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#### YOUR CODE HERE #######\n",
        "def convert(str, num):"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4pzg5JHTqsWI",
        "colab_type": "text"
      },
      "source": [
        "### Mini-Project\n",
        "\n",
        "In this part, I'm providing some of the code and you have to write some of the code.\n",
        "\n",
        "It is your job to complete the code for a program that counts and prints the frequency of words in a chapter of a book. The chapter of the book is represented as a list of strings (e.g. ['This', 'is', 'an', 'example']). The list does not contain any punctuation. The words in the list may contain uppercase letters but all variations of upper and lower case letter are treated equally. For example, the word 'Apple' is equvialent to the word 'apple' and the word 'APPle'. Your code will iterate over the list of words and add them to a dictionary where the key is the word and the value is the frequency of the word in the list.\n",
        "\n",
        "You'll find it useful to come up with a testing list where you know the correct value of the frequency of all the words in the list to test your code."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MCslt-kgsc6B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "alice_chapter_one = \"\"\"Alice was beginning to get very tired of sitting by her sister on the bank, and of having \n",
        "nothing to do: once or twice she had peeped into the book her sister was reading, but it had \n",
        "no pictures or conversations in it, 'and what is the use of a book,' thought Alice 'without\n",
        "pictures or conversation?'\n",
        "So she was considering in her own mind (as well as she could, for the hot day made her\n",
        "feel very sleepy and stupid), whether the pleasure of making a daisy-chain would be worth \n",
        "the trouble of getting up and picking the daisies, when suddenly a White Rabbit with pink\n",
        "eyes ran close by her.\n",
        "There was nothing so VERY remarkable in that; nor did Alice think it so VERY much\n",
        "out of the way to hear the Rabbit say to itself, 'Oh dear! Oh dear! I shall be late!' (when she\n",
        "thought it over afterwards, it occurred to her that she ought to have wondered at this, but at\n",
        "the time it all seemed quite natural); but when the Rabbit actually TOOK A WATCH OUT\n",
        "OF ITS WAISTCOAT-POCKET, and looked at it, and then hurried on, Alice started to her\n",
        "feet, for it flashed across her mind that she had never before seen a rabbit with either a\n",
        "waistcoat-pocket, or a watch to take out of it, and burning with curiosity, she ran across the\n",
        "field after it, and fortunately was just in time to see it pop down a large rabbit-hole under\n",
        "the hedge.\n",
        "In another moment down went Alice after it, never once considering how in the world\n",
        "she was to get out again.\n",
        "The rabbit-hole went straight on like a tunnel for some way, and then dipped suddenly\n",
        "down, so suddenly that Alice had not a moment to think about stopping herself before she\n",
        "found herself falling down a very deep well.\n",
        "Either the well was very deep, or she fell very slowly, for she had plenty of time as she\n",
        "went down to look about her and to wonder what was going to happen next. First, she tried\n",
        "to look down and make out what she was coming to, but it was too dark to see anything;\n",
        "then she looked at the sides of the well, and noticed that they were filled with cupboards\n",
        "and book-shelves; here and there she saw maps and pictures hung upon pegs. She took\n",
        "down a jar from one of the shelves as she passed; it was labelled 'ORANGE\n",
        "MARMALADE', but to her great disappointment it was empty: she did not like to drop the\n",
        "jar for fear of killing somebody, so managed to put it into one of the cupboards as she fell\n",
        "past it.\n",
        "'Well!' thought Alice to herself, 'after such a fall as this, I shall think nothing of tumbling\n",
        "down stairs! How brave they'll all think me at home! Why, I wouldn't say anything about it,\n",
        "even if I fell off the top of the house!' (Which was very likely true.)\n",
        "Down, down, down. Would the fall NEVER come to an end! 'I wonder how many miles\n",
        "I've fallen by this time?' she said aloud. 'I must be getting somewhere near the centre of the\n",
        "earth. Let me see: that would be four thousand miles down, I think—' (for, you see, Alice\n",
        "had learnt several things of this sort in her lessons in the schoolroom, and though this was\n",
        "not a VERY good opportunity for showing off her knowledge, as there was no one to listen\n",
        "to her, still it was good practice to say it over) '—yes, that's about the right distance—but\n",
        "then I wonder what Latitude or Longitude I've got to?' (Alice had no idea what Latitude\n",
        "was, or Longitude either, but thought they were nice grand words to say.)\n",
        "Presently she began again. 'I wonder if I shall fall right THROUGH the earth! How funny\n",
        "it'll seem to come out among the people that walk with their heads downward! The\n",
        "Antipathies, I think—' (she was rather glad there WAS no one listening, this time, as it\n",
        "didn't sound at all the right word) '—but I shall have to ask them what the name of the\n",
        "country is, you know. Please, Ma'am, is this New Zealand or Australia?' (and she tried to\n",
        "curtsey as she spoke—fancy CURTSEYING as you're falling through the air! Do you think \n",
        "you could manage it?) 'And what an ignorant little girl she'll think me for asking! No, it'll\n",
        "never do to ask: perhaps I shall see it written up somewhere.'\n",
        "Down, down, down. There was nothing else to do, so Alice soon began talking again.\n",
        "'Dinah'll miss me very much to-night, I should think!' (Dinah was the cat.) 'I hope they'll\n",
        "remember her saucer of milk at tea-time. Dinah my dear! I wish you were down here with\n",
        "me! There are no mice in the air, I'm afraid, but you might catch a bat, and that's very like a\n",
        "mouse, you know. But do cats eat bats, I wonder?' And here Alice began to get rather\n",
        "sleepy, and went on saying to herself, in a dreamy sort of way, 'Do cats eat bats? Do cats eat\n",
        "bats?' and sometimes, 'Do bats eat cats?' for, you see, as she couldn't answer either question,\n",
        "it didn't much matter which way she put it. She felt that she was dozing off, and had just\n",
        "begun to dream that she was walking hand in hand with Dinah, and saying to her very\n",
        "earnestly, 'Now, Dinah, tell me the truth: did you ever eat a bat?' when suddenly, thump!\n",
        "thump! down she came upon a heap of sticks and dry leaves, and the fall was over.\n",
        "Alice was not a bit hurt, and she jumped up on to her feet in a moment: she looked up,\n",
        "but it was all dark overhead; before her was another long passage, and the White Rabbit was\n",
        "still in sight, hurrying down it. There was not a moment to be lost: away went Alice like the\n",
        "wind, and was just in time to hear it say, as it turned a corner, 'Oh my ears and whiskers,\n",
        "how late it's getting!' She was close behind it when she turned the corner, but the Rabbit\n",
        "was no longer to be seen: she found herself in a long, low hall, which was lit up by a row of\n",
        "lamps hanging from the roof.\n",
        "There were doors all round the hall, but they were all locked; and when Alice had been\n",
        "all the way down one side and up the other, trying every door, she walked sadly down the\n",
        "middle, wondering how she was ever to get out again.\n",
        "Suddenly she came upon a little three-legged table, all made of solid glass; there was\n",
        "nothing on it except a tiny golden key, and Alice's first thought was that it might belong to\n",
        "one of the doors of the hall; but, alas! either the locks were too large, or the key was too\n",
        "small, but at any rate it would not open any of them. However, on the second time round,\n",
        "she came upon a low curtain she had not noticed before, and behind it was a little door\n",
        "about fifteen inches high: she tried the little golden key in the lock, and to her great delight\n",
        "it fitted!\n",
        "Alice opened the door and found that it led into a small passage, not much larger than a\n",
        "rat-hole: she knelt down and looked along the passage into the loveliest garden you ever\n",
        "saw. How she longed to get out of that dark hall, and wander about among those beds of\n",
        "bright flowers and those cool fountains, but she could not even get her head through the\n",
        "doorway; 'and even if my head would go through,' thought poor Alice, 'it would be of very\n",
        "little use without my shoulders. Oh, how I wish I could shut up like a telescope! I think I\n",
        "could, if I only know how to begin.' For, you see, so many out-of-the-way things had\n",
        "happened lately, that Alice had begun to think that very few things indeed were really\n",
        "impossible.\n",
        "There seemed to be no use in waiting by the little door, so she went back to the table, half\n",
        "hoping she might find another key on it, or at any rate a book of rules for shutting people up\n",
        "like telescopes: this time she found a little bottle on it, ('which certainly was not here \n",
        "before,' said Alice,) and round the neck of the bottle was a paper label, with the words\n",
        "'DRINK ME' beautifully printed on it in large letters.\n",
        "It was all very well to say 'Drink me,' but the wise little Alice was not going to do THAT\n",
        "in a hurry. 'No, I'll look first,' she said, 'and see whether it's marked \"poison\" or not'; for she\n",
        "had read several nice little histories about children who had got burnt, and eaten up by wild\n",
        "beasts and other unpleasant things, all because they WOULD not remember the simple rules\n",
        "their friends had taught them: such as, that a red-hot poker will burn you if you hold it too\n",
        "long; and that if you cut your finger VERY deeply with a knife, it usually bleeds; and she\n",
        "had never forgotten that, if you drink much from a bottle marked 'poison,' it is almost\n",
        "certain to disagree with you, sooner or later.\n",
        "However, this bottle was NOT marked 'poison,' so Alice ventured to taste it, and finding\n",
        "it very nice, (it had, in fact, a sort of mixed flavour of cherry-tart, custard, pine-apple, roast\n",
        "turkey, toffee, and hot buttered toast,) she very soon finished it off.\n",
        "'What a curious feeling!' said Alice; 'I must be shutting up like a telescope.'\n",
        "And so it was indeed: she was now only ten inches high, and her face brightened up at the\n",
        "thought that she was now the right size for going through the little door into that lovely\n",
        "garden. First, however, she waited for a few minutes to see if she was going to shrink any\n",
        "further: she felt a little nervous about this; 'for it might end, you know,' said Alice to herself,\n",
        "'in my going out altogether, like a candle. I wonder what I should be like then?' And she\n",
        "tried to fancy what the flame of a candle is like after the candle is blown out, for she could\n",
        "not remember ever having seen such a thing.\n",
        "After a while, finding that nothing more happened, she decided on going into the garden\n",
        "at once; but, alas for poor Alice! when she got to the door, she found she had forgotten the\n",
        "little golden key, and when she went back to the table for it, she found she could not\n",
        "possibly reach it: she could see it quite plainly through the glass, and she tried her best to\n",
        "climb up one of the legs of the table, but it was too slippery; and when she had tired herself\n",
        "out with trying, the poor little thing sat down and cried.\n",
        "'Come, there's no use in crying like that!' said Alice to herself, rather sharply; 'I advise\n",
        "you to leave off this minute!' She generally gave herself very good advice, (though she very\n",
        "seldom followed it), and sometimes she scolded herself so severely as to bring tears into her\n",
        "eyes; and once she remembered trying to box her own ears for having cheated herself in a\n",
        "game of croquet she was playing against herself, for this curious child was very fond of\n",
        "pretending to be two people. 'But it's no use now,' thought poor Alice, 'to pretend to be two\n",
        "people! Why, there's hardly enough of me left to make ONE respectable person!'\n",
        "Soon her eye fell on a little glass box that was lying under the table: she opened it, and\n",
        "found in it a very small cake, on which the words 'EAT ME' were beautifully marked in \n",
        "currants. 'Well, I'll eat it,' said Alice, 'and if it makes me grow larger, I can reach the key;\n",
        "and if it makes me grow smaller, I can creep under the door; so either way I'll get into the\n",
        "garden, and I don't care which happens!'\n",
        "She ate a little bit, and said anxiously to herself, 'Which way? Which way?', holding her\n",
        "hand on the top of her head to feel which way it was growing, and she was quite surprised\n",
        "to find that she remained the same size: to be sure, this generally happens when one eats\n",
        "cake, but Alice had got so much into the way of expecting nothing but out-of-the-way\n",
        "things to happen, that it seemed quite dull and stupid for life to go on in the common way.\n",
        "So she set to work, and very soon finished off the cake. \"\"\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6H0vtiDYuoSw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "punctuations = '''!()-[]{};:'\"\\,<>./?@#$%^&*_~'''\n",
        "\n",
        "# Removes punctuation from the string\n",
        "no_punct = \"\"\n",
        "for char in alice_chapter_one:\n",
        "   if char not in punctuations:\n",
        "       no_punct = no_punct + char\n",
        "\n",
        "alice_chapter_one = no_punct\n",
        "\n",
        "print(alice_chapter_one)\n",
        "# Splits the string into a list of strings\n",
        "alice_chapter_one = alice_chapter_one.split()\n",
        "\n",
        "print(len(alice_chapter_one))"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}