Strings, Lists and Dictionaries.ipynb

{
  "metadata": {
    "language_info": {
      "codemirror_mode": {
        "name": "python",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8"
    },
    "kernelspec": {
      "name": "python",
      "display_name": "Python (Pyodide)",
      "language": "python"
    }
  },
  "nbformat_minor": 4,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "source": "# Strings",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The is_palindrome function checks if a string is a palindrome. A palindrome is a string that can be equally read from left to right or right to left, omitting blank spaces, and ignoring capitalization. Examples of palindromes are words like kayak and radar, and phrases like \"Never Odd or Even\". Fill in the blanks in this function to return True if the passed string is a palindrome, False if not.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def is_palindrome(input_string):\n    \n    # We'll create two strings, to compare them\n    new_string = \"\"\n    reverse_string = \"\"\n    \n    # Traverse through each letter of the input string\n    for string in input_string.lower():\n        \n        # Add any non-blank letters to the end of one string, and to the front of the other string. \n        if string.replace(\" \",\"\"):\n            new_string = string + new_string\n            reverse_string = string + reverse_string\n    \n    # Compare the strings\n    if new_string[::-1]==reverse_string:\n        return True\n    return False\n\nprint(is_palindrome(\"Never Odd or Even\")) # Should be True\nprint(is_palindrome(\"abc\")) # Should be False\nprint(is_palindrome(\"kayak\")) # Should be True",
      "metadata": {
        "trusted": true
      },
      "execution_count": 1,
      "outputs": [
        {
          "name": "stdout",
          "text": "True\nFalse\nTrue\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Using the format method, fill in the gaps in the convert_distance function so that it returns the phrase \"X miles equals Y km\", with Y having only 1 decimal place. For example, convert_distance(12) should return \"12 miles equals 19.2 km\".",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def convert_distance(miles):\n    km = miles * 1.6 \n    result = \"{} miles equals {:.1f} km\".format(miles,km)\n    return result\n\nprint(convert_distance(12)) # Should be: 12 miles equals 19.2 km\nprint(convert_distance(5.5)) # Should be: 5.5 miles equals 8.8 km\nprint(convert_distance(11)) # Should be: 11 miles equals 17.6 km",
      "metadata": {
        "trusted": true
      },
      "execution_count": 2,
      "outputs": [
        {
          "name": "stdout",
          "text": "12 miles equals 19.2 km\n5.5 miles equals 8.8 km\n11 miles equals 17.6 km\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "If we have a string variable named Weather = \"Rainfall\", which of the following will print the substring or all characters before the \"f\"?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "# print(Weather[:4])",
      "metadata": {
        "trusted": true
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Fill in the gaps in the nametag function so that it uses the format method to return first_name and the first initial of last_name followed by a period. For example, nametag(\"Jane\", \"Smith\") should return \"Jane S.\"",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def nametag(first_name, last_name):\n    return(\"{} {[0]}.\".format(first_name,last_name))\n\nprint(nametag(\"Jane\", \"Smith\")) #Should display \"Jane S.\" \nprint(nametag(\"Francesco\", \"Rinaldi\")) #Should display \"Francesco R.\" \nprint(nametag(\"Jean-Luc\", \"Grand-Pierre\")) #Should display \"Jean-Luc G.\" ",
      "metadata": {
        "trusted": true
      },
      "execution_count": 4,
      "outputs": [
        {
          "name": "stdout",
          "text": "Jane S.\nFrancesco R.\nJean-Luc G.\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The replace_ending function replaces the old string in a sentence with the new string, but only if the sentence ends with the old string. If there is more than one occurrence of the old string in the sentence, only the one at the end is replaced, not all of them. For example, replace_ending(\"abcabc\", \"abc\", \"xyz\") should return abcxyz, not xyzxyz or xyzabc. The string comparison is case-sensitive, so replace_ending(\"abcabc\", \"ABC\", \"xyz\") should return abcabc (no changes made).",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def replace_ending(sentence, old, new):\n    \n    # Check if the old string is at the end of the sentence \n    if sentence.endswith(old):\n        \n        # Using i as the slicing index, combine the part of the sentence up to the matched string at the end with the new string\n        i = sentence.rindex(old)\n        new_sentence = sentence[:i]+new\n        return new_sentence\n\n    #Return the original sentence if there is no match \n    return sentence\n\nprint(replace_ending(\"It's raining cats and cats\", \"cats\", \"dogs\")) #Should display \"It's raining cats and dogs\"\nprint(replace_ending(\"She sells seashells by the seashore\", \"seashells\", \"donuts\")) #Should display \"She sells seashells by the seashore\"\nprint(replace_ending(\"The weather is nice in May\", \"may\", \"april\")) #Should display \"The weather is nice in May\"\nprint(replace_ending(\"The weather is nice in May\", \"May\", \"April\")) #Should display \"The weather is nice in April\"",
      "metadata": {
        "trusted": true
      },
      "execution_count": 5,
      "outputs": [
        {
          "name": "stdout",
          "text": "It's raining cats and dogs\nShe sells seashells by the seashore\nThe weather is nice in May\nThe weather is nice in April\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "# Lists",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Given a list of filenames, we want to rename all the files with extension hpp to the extension h. To do this, we would like to generate a new list called newfilenames, consisting of the new filenames. Fill in the blanks in the code using any of the methods you’ve learned thus far, like a for loop or a list comprehension.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "filenames = [\"program.c\", \"stdio.hpp\", \"sample.hpp\", \"a.out\", \"math.hpp\", \"hpp.out\"]\n\n# Generate newfilenames as a list containing the new filenames using as many lines of code as your chosen method requires.\nnewfilenames=[]  \nfor filename in filenames:\n    if filename.endswith(\".hpp\"):\n        filename=filename.replace(\".hpp\",\".h\")\n        newfilenames.append(filename)\n    else:\n        newfilenames.append(filename)\n\nprint(newfilenames) #Should be [\"program.c\", \"stdio.h\", \"sample.h\", \"a.out\", \"math.h\", \"hpp.out\"]",
      "metadata": {
        "trusted": true
      },
      "execution_count": 6,
      "outputs": [
        {
          "name": "stdout",
          "text": "['program.c', 'stdio.h', 'sample.h', 'a.out', 'math.h', 'hpp.out']\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Let's create a function that turns text into pig latin: a simple text transformation that modifies each word moving the first character to the end and appending \"ay\" to the end. For example, python ends up as ythonpay.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def pig_latin(text):\n    say = \"\"\n    \n    #Separate the text into words\n    words = text.split()\n    for word in words:\n    \n        #Create the pig latin word and add it to the list\n        say += word[1:]+word[0]+'ay'\n        if word != words[len(words)-1]:\n            say +=' '\n    \n    #Turn the list back into a phrase\n    return say\n\nprint(pig_latin(\"hello how are you\")) #Should be \"ellohay owhay reaay ouyay\"\nprint(pig_latin(\"programming in python is fun\")) #Should be \"rogrammingpay niay ythonpay siay unfay\"",
      "metadata": {
        "trusted": true
      },
      "execution_count": 7,
      "outputs": [
        {
          "name": "stdout",
          "text": "ellohay owhay reaay ouyay\nrogrammingpay niay ythonpay siay unfay\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The permissions of a file in a Linux system are split into three sets of three permissions: read, write, and execute for the owner, group, and others. Each of the three values can be expressed as an octal number summing each permission, with 4 corresponding to read, 2 to write, and 1 to execute. Or it can be written with a string using the letters r, w, and x or - when the permission is not granted.\nFor example: \n640 is read/write for the owner, read for the group, and no permissions for the others; converted to a string, it would be: \"rw-r-----\"\n755 is read/write/execute for the owner, and read/execute for group and others; converted to a string, it would be: \"rwxr-xr-x\"\nFill in the blanks to make the code convert a permission in octal format into a string format.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def octal_to_string(octal):\n    result = \"\"\n    value_letters = [(4,\"r\"),(2,\"w\"),(1,\"x\")]\n    \n    # Iterate over each of the digits in octal\n    for digit in [int(n) for n in str(octal)]:\n        \n        # Check for each of the permissions values\n        for value, letter in value_letters:\n            if digit >= value:\n                result += letter\n                digit -= value\n            else:\n                result += '-'\n    return result\n    \nprint(octal_to_string(755)) # Should be rwxr-xr-x\nprint(octal_to_string(644)) # Should be rw-r--r--\nprint(octal_to_string(750)) # Should be rwxr-x---\nprint(octal_to_string(600)) # Should be rw-------",
      "metadata": {
        "trusted": true
      },
      "execution_count": 8,
      "outputs": [
        {
          "name": "stdout",
          "text": "rwxr-xr-x\nrw-r--r--\nrwxr-x---\nrw-------\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Tuples and lists are very similar types of sequences. What is the main thing that makes a tuple different from a list?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "# A tuple is immutable",
      "metadata": {
        "trusted": true
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The group_list function accepts a group name and a list of members, and returns a string with the format: group_name: member1, member2, … For example, group_list(\"g\", [\"a\",\"b\",\"c\"]) returns \"g: a, b, c\". Fill in the gaps in this function to do that.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def group_list(group, users):\n    members = group + \": \" + \", \".join(users)\n    return members \n\nprint(group_list(\"Marketing\", [\"Mike\", \"Karen\", \"Jake\", \"Tasha\"])) # Should be \"Marketing: Mike, Karen, Jake, Tasha\"\nprint(group_list(\"Engineering\", [\"Kim\", \"Jay\", \"Tom\"])) # Should be \"Engineering: Kim, Jay, Tom\"\nprint(group_list(\"Users\", \"\")) # Should be \"Users:\"",
      "metadata": {
        "trusted": true
      },
      "execution_count": 10,
      "outputs": [
        {
          "name": "stdout",
          "text": "Marketing: Mike, Karen, Jake, Tasha\nEngineering: Kim, Jay, Tom\nUsers: \n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The guest_list function reads in a list of tuples with the name, age, and profession of each party guest, and prints the sentence \"Guest is X years old and works as __.\" for each one. For example, guest_list(('Ken', 30, \"Chef\"), (\"Pat\", 35, 'Lawyer'), ('Amanda', 25, \"Engineer\")) should print out: Ken is 30 years old and works as Chef. Pat is 35 years old and works as Lawyer. Amanda is 25 years old and works as Engineer. Fill in the gaps in this function to do that.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def guest_list(guests):\n    for guest in guests:\n        name, age, job = guest\n        print(\"{} is {} years old and works as {}\".format(name, age, job))\n\nguest_list([('Ken', 30, \"Chef\"), (\"Pat\", 35, 'Lawyer'), ('Amanda', 25, \"Engineer\")])\n\n#Output should match:\n#Ken is 30 years old and works as Chef\n#Pat is 35 years old and works as Lawyer\n#Amanda is 25 years old and works as Engineer",
      "metadata": {
        "trusted": true
      },
      "execution_count": 11,
      "outputs": [
        {
          "name": "stdout",
          "text": "Ken is 30 years old and works as Chef\nPat is 35 years old and works as Lawyer\nAmanda is 25 years old and works as Engineer\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "# Dictionaries",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The email_list function receives a dictionary, which contains domain names as keys, and a list of users as values. Fill in the blanks to generate a list that contains complete email addresses (e.g. diana.prince@gmail.com).",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def email_list(domains):\n    emails = []\n    for domain, users in domains.items():\n        for user in users:\n            emails.append(user+'@'+domain)\n    return(emails)\n\nprint(email_list({\"gmail.com\": [\"clark.kent\", \"diana.prince\", \"peter.parker\"], \n                  \"yahoo.com\": [\"barbara.gordon\", \"jean.grey\"], \n                  \"hotmail.com\": [\"bruce.wayne\"]}))",
      "metadata": {
        "trusted": true
      },
      "execution_count": 12,
      "outputs": [
        {
          "name": "stdout",
          "text": "['clark.kent@gmail.com', 'diana.prince@gmail.com', 'peter.parker@gmail.com', 'barbara.gordon@yahoo.com', 'jean.grey@yahoo.com', 'bruce.wayne@hotmail.com']\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The groups_per_user function receives a dictionary, which contains group names with the list of users. Users can belong to multiple groups. Fill in the blanks to return a dictionary with the users as keys and a list of their groups as values. ",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def groups_per_user(group_dictionary):\n    user_groups = {}\n    # Go through group_dictionary\n    for group, users in group_dictionary.items():\n        # Now go through the users in the group\n        for user in users:\n            user_groups[user] = user_groups.get(user,[]) + [group]\n            # Now add the group to the the list of groups for this user, creating the entry in the dictionary if necessary\n    return(user_groups)\n\nprint(groups_per_user({\"local\": [\"admin\", \"userA\"],\n        \"public\":  [\"admin\", \"userB\"],\n        \"administrator\": [\"admin\"] }))",
      "metadata": {
        "trusted": true
      },
      "execution_count": 13,
      "outputs": [
        {
          "name": "stdout",
          "text": "{'admin': ['local', 'public', 'administrator'], 'userA': ['local'], 'userB': ['public']}\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The dict.update method updates one dictionary with the items coming from the other dictionary, so that existing entries are replaced and new entries are added. What is the content of the dictionary “wardrobe“ at the end of the following code?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "wardrobe = {'shirt': ['red', 'blue', 'white'], 'jeans': ['blue', 'black']}\nnew_items = {'jeans': ['white'], 'scarf': ['yellow'], 'socks': ['black', 'brown']}\nwardrobe.update(new_items)\n\n#{'shirt': ['red', 'blue', 'white'], 'jeans': ['white'], 'scarf': ['yellow'], 'socks': ['black', 'brown']}",
      "metadata": {
        "trusted": true
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "What’s a major advantage of using dictionaries over lists?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "#It’s quicker and easier to find a specific element in a dictionary",
      "metadata": {
        "trusted": true
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The add_prices function returns the total price of all of the groceries in the  dictionary. Fill in the blanks to complete this function.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def add_prices(basket):\n    # Initialize the variable that will be used for the calculation\n    total = 0\n    # Iterate through the dictionary items\n    for items in basket.values():\n        # Add each price to the total calculation\n        # Hint: how do you access the values of dictionary items?\n        total += items\n    # Limit the return value to 2 decimal places\n    return round(total, 2)  \n\ngroceries = {\"bananas\": 1.56, \"apples\": 2.50, \"oranges\": 0.99, \"bread\": 4.59, \n    \"coffee\": 6.99, \"milk\": 3.39, \"eggs\": 2.98, \"cheese\": 5.44}\n\nprint(add_prices(groceries)) # Should print 28.44",
      "metadata": {
        "trusted": true
      },
      "execution_count": 16,
      "outputs": [
        {
          "name": "stdout",
          "text": "28.44\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "# Quiz",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The format_address function separates out parts of the address string into new strings: house_number and street_name, and returns: \"house number X on street named Y\". The format of the input string is: numeric house number, followed by the street name which may contain numbers, but never by themselves, and could be several words long. For example, \"123 Main Street\", \"1001 1st Ave\", or \"55 North Center Drive\". Fill in the gaps to complete this function.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def format_address(address_string):\n    # Declare variables\n    house_number = \"\"\n    street_name = \"\"\n    # Separate the address string into parts\n    address_string = address_string.split()\n    # Traverse through the address parts\n    for number in address_string:\n    # Determine if the address part is the house number or part of the street name\n        if number.isdigit():\n            house_number = number\n        else:\n            street_name += number\n            street_name += \" \"  \n    # Does anything else need to be done before returning the result?\n  \n    # Return the formatted string  \n    return \"house number {} on street named {}\".format(house_number, street_name)\n\nprint(format_address(\"123 Main Street\")) # Should print: \"house number 123 on street named Main Street\"\nprint(format_address(\"1001 1st Ave\")) # Should print: \"house number 1001 on street named 1st Ave\"\nprint(format_address(\"55 North Center Drive\")) # Should print \"house number 55 on street named North Center Drive\"",
      "metadata": {
        "trusted": true
      },
      "execution_count": 17,
      "outputs": [
        {
          "name": "stdout",
          "text": "house number 123 on street named Main Street \nhouse number 1001 on street named 1st Ave \nhouse number 55 on street named North Center Drive \n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "The highlight_word function changes the given word in a sentence to its upper-case version. For example, highlight_word(\"Have a nice day\", \"nice\") returns \"Have a NICE day\". Can you write this function in just one line?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def highlight_word(sentence, word):\n    return(sentence.replace(word, word.upper()))\n\nprint(highlight_word(\"Have a nice day\", \"nice\"))\nprint(highlight_word(\"Shhh, don't be so loud!\", \"loud\"))\nprint(highlight_word(\"Automating with Python is fun\", \"fun\"))",
      "metadata": {
        "trusted": true
      },
      "execution_count": 18,
      "outputs": [
        {
          "name": "stdout",
          "text": "Have a NICE day\nShhh, don't be so LOUD!\nAutomating with Python is FUN\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "A professor with two assistants, Jamie and Drew, wants an attendance list of the students, in the order that they arrived in the classroom. Drew was the first one to note which students arrived, and then Jamie took over. After the class, they each entered their lists into the computer and emailed them to the professor, who needs to combine them into one, in the order of each student's arrival. Jamie emailed a follow-up, saying that her list is in reverse order. Complete the steps to combine them into one list as follows: the contents of Drew's list, followed by Jamie's list in reverse order, to get an accurate list of the students as they arrived.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def combine_lists(list1, list2):\n  # Generate a new list containing the elements of list2\n  # Followed by the elements of list1 in reverse order\n    new_list = list2\n    for names in reversed(range(len(list1))):\n        new_list.append(list1[names])\n    return new_list \n\nJamies_list = [\"Alice\", \"Cindy\", \"Bobby\", \"Jan\", \"Peter\"]\nDrews_list = [\"Mike\", \"Carol\", \"Greg\", \"Marcia\"]\n\nprint(combine_lists(Jamies_list, Drews_list))",
      "metadata": {
        "trusted": true
      },
      "execution_count": 19,
      "outputs": [
        {
          "name": "stdout",
          "text": "['Mike', 'Carol', 'Greg', 'Marcia', 'Peter', 'Jan', 'Bobby', 'Cindy', 'Alice']\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Use a list comprehension to create a list of squared numbers (n*n). The function receives the variables start and end, and returns a list of squares of consecutive numbers between start and end inclusively.\nFor example, squares(2, 3) should return [4, 9].",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def squares(start, end):\n    return [ (i*i) for i in range(start, end+1) ]\n\nprint(squares(2, 3)) # Should be [4, 9]\nprint(squares(1, 5)) # Should be [1, 4, 9, 16, 25]\nprint(squares(0, 10)) # Should be [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]",
      "metadata": {
        "trusted": true
      },
      "execution_count": 20,
      "outputs": [
        {
          "name": "stdout",
          "text": "[4, 9]\n[1, 4, 9, 16, 25]\n[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Complete the code to iterate through the keys and values of the car_prices dictionary, printing out some information about each one.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def car_listing(car_prices):\n    result = \"\"\n    for cars in car_prices:\n        result += \"{} costs {} dollars\".format(cars, car_prices[cars]) + \"\\n\"\n    return result\n\nprint(car_listing({\"Kia Soul\":19000, \"Lamborghini Diablo\":55000, \"Ford Fiesta\":13000, \"Toyota Prius\":24000}))",
      "metadata": {
        "trusted": true
      },
      "execution_count": 21,
      "outputs": [
        {
          "name": "stdout",
          "text": "Kia Soul costs 19000 dollars\nLamborghini Diablo costs 55000 dollars\nFord Fiesta costs 13000 dollars\nToyota Prius costs 24000 dollars\n\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Taylor and Rory are hosting a party. They sent out invitations, and each one collected responses into dictionaries, with names of their friends and how many guests each friend is bringing. Each dictionary is a partial list, but Rory's list has more current information about the number of guests. Fill in the blanks to combine both dictionaries into one, with each friend listed only once, and the number of guests from Rory's dictionary taking precedence, if a name is included in both dictionaries. Then print the resulting dictionary.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def combine_guests(guests1, guests2):\n    # Combine both dictionaries into one, with each key listed only once, and the value from guests1 taking precedence\n    guests2.update(guests1)\n    return guests2\n\nRorys_guests = { \"Adam\":2, \"Brenda\":3, \"David\":1, \"Jose\":3, \"Charlotte\":2, \"Terry\":1, \"Robert\":4}\nTaylors_guests = { \"David\":4, \"Nancy\":1, \"Robert\":2, \"Adam\":1, \"Samantha\":3, \"Chris\":5}\n\nprint(combine_guests(Rorys_guests, Taylors_guests))",
      "metadata": {
        "trusted": true
      },
      "execution_count": 22,
      "outputs": [
        {
          "name": "stdout",
          "text": "{'David': 1, 'Nancy': 1, 'Robert': 4, 'Adam': 2, 'Samantha': 3, 'Chris': 5, 'Brenda': 3, 'Jose': 3, 'Charlotte': 2, 'Terry': 1}\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "Use a dictionary to count the frequency of letters in the input string. Only letters should be counted, not blank spaces, numbers, or punctuation. Upper case should be considered the same as lower case. For example, count_letters(\"This is a sentence.\") should return {'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}.",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "def count_letters(text):\n    result = {}\n    text = text.lower()\n    # Go through each letter in the text\n    for letter in text.lower():\n    # Check if the letter needs to be counted or not\n        if letter .isalpha() and letter not in result:\n            result[letter] = text.lower().count(letter)\n    # Add or increment the value in the dictionary\n    return result\n\nprint(count_letters(\"AaBbCc\")) # Should be {'a': 2, 'b': 2, 'c': 2}\nprint(count_letters(\"Math is fun! 2+2=4\")) # Should be {'m': 1, 'a': 1, 't': 1, 'h': 1, 'i': 1, 's': 1, 'f': 1, 'u': 1, 'n': 1}\nprint(count_letters(\"This is a sentence.\")) # Should be {'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}",
      "metadata": {
        "trusted": true
      },
      "execution_count": 23,
      "outputs": [
        {
          "name": "stdout",
          "text": "{'a': 2, 'b': 2, 'c': 2}\n{'m': 1, 'a': 1, 't': 1, 'h': 1, 'i': 1, 's': 1, 'f': 1, 'u': 1, 'n': 1}\n{'t': 2, 'h': 1, 'i': 2, 's': 3, 'a': 1, 'e': 3, 'n': 2, 'c': 1}\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "What do the following commands return when animal = \"Hippopotamus\"?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "animal = \"Hippopotamus\"    \n    \nprint(animal[3:6])\nprint(animal[-5])\nprint(animal[10:])\n\n\n# pop, t, us",
      "metadata": {
        "trusted": true
      },
      "execution_count": 24,
      "outputs": [
        {
          "name": "stdout",
          "text": "pop\nt\nus\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "What does the list \"colors\" contain after these commands are executed?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "colors = [\"red\", \"white\", \"blue\"]\ncolors.insert(2, \"yellow\")\n\n\n# ['red', 'white', 'yellow', 'blue']",
      "metadata": {
        "trusted": true
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    },
    {
      "cell_type": "markdown",
      "source": "What do the following commands return?",
      "metadata": {}
    },
    {
      "cell_type": "code",
      "source": "host_addresses = {\"router\": \"192.168.1.1\", \"localhost\": \"127.0.0.1\", \"google\": \"8.8.8.8\"}\nhost_addresses.keys()\n\n\n# ['router', 'localhost', 'google']",
      "metadata": {
        "trusted": true
      },
      "execution_count": 26,
      "outputs": [
        {
          "execution_count": 26,
          "output_type": "execute_result",
          "data": {
            "text/plain": "dict_keys(['router', 'localhost', 'google'])"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": "...",
      "metadata": {}
    }
  ]
}