1.3_week3_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 3: Data Structures, Functions and Loops\n",
    "\n",
    "In this week's exercise, you'll learn how to:\n",
    "\n",
    "1. write functions that manipulate data structures such as lists and dictionaries\n",
    "2. master list comprehension and dict comprehension\n",
    "3. compute operations on matrices represented as lists of lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Write a Python function to sum all the numbers in a list.\n",
    "\n",
    "Write a function to sum all number in a list without using the `sum()` built-in method. Hint: use a `for..in` cycle instead.\n",
    "\n",
    "Sample list: `[9, 12, 7, 19]`\n",
    "\n",
    "Expected output: 47"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your function here:\n",
    "# Hint: do not use the name `sum` for your function because it would overwrite the built-in sum() method\n",
    "def total_numbers(input):\n",
    "    return sum(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test your function here\n",
    "list_1 = [9, 12, 7, 19]\n",
    "total_numbers(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Write a Python program to count the number of elements in a list within a specified range.\n",
    "\n",
    "Sample list: `[10,20,30,40,40,40,70,80,99]`\n",
    "\n",
    "Sample min: `15`\n",
    "\n",
    "Sample max: `50`\n",
    "\n",
    "Expected output: `5`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your function here:\n",
    "def list_info(list_1, min_range_val, max_range_val):\n",
    "    count = 0\n",
    "    for item in list_1:\n",
    "        if item > min_range_val and item < max_range_val:\n",
    "            count = count + 1\n",
    "    return(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test your function here\n",
    "list_1 = [10,20,30,40,40,40,70,80,99]\n",
    "list_info(list_1, 15, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 List Manipulation\n",
    "\n",
    "From the given list:\n",
    "\n",
    "```\n",
    "gadgets = [“Mobile”, “Laptop”, 100, “Camera”, 310.28, “Speakers”, 27.00,\n",
    "“Television”, 1000, “Laptop Case”, “Camera Lens”]\n",
    "```\n",
    "\n",
    "a)create separate lists of strings and numbers.\n",
    " \n",
    "b)Sort the strings list in ascending order\n",
    " \n",
    "c)Sort the strings list in descending order\n",
    " \n",
    "d)Sort the number list from lowest to highest\n",
    " \n",
    "e)Sort the number list from highest to lowest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original list: ['Mobile', 'Laptop', 100, 'Camera', 310.28, 'Speakers', 27.0, 'Television', 1000, 'Laptop Case', 'Camera Lens']\n",
      "The cleaned list: [100.0, 310.28, 27.0, 1000.0]\n",
      "['Camera', 'Camera Lens', 'Laptop', 'Laptop Case', 'Mobile', 'Speakers', 'Television']\n",
      "['Television', 'Speakers', 'Mobile', 'Laptop Case', 'Laptop', 'Camera Lens', 'Camera']\n",
      "[27.0, 100.0, 310.28, 1000.0]\n",
      "[1000.0, 310.28, 100.0, 27.0]\n"
     ]
    }
   ],
   "source": [
    "# Write your solution here:\n",
    "\n",
    "gadgets = [\"Mobile\", \"Laptop\", 100, \"Camera\", 310.28, \"Speakers\", 27.00, \n",
    "           \"Television\", 1000, \"Laptop Case\", \"Camera Lens\"]\n",
    " \n",
    "\n",
    "# Write your solutions here \n",
    " \n",
    "# a)creating separate lists\n",
    " \n",
    "int_list = []\n",
    "str_list = []\n",
    "\n",
    "for item in gadgets:\n",
    "    try:\n",
    "        i = float(item)\n",
    "        int_list.append(i)\n",
    "    except ValueError:\n",
    "        str_list.append(item)\n",
    " \n",
    "print(\"The original list:\", gadgets)\n",
    "print(\"The cleaned list:\", int_list)\n",
    "\n",
    "\n",
    "# b)sorting strings list in ascending order, a-z\n",
    "print(sorted(str_list))\n",
    "# c)sorting strings list in descending order z-a\n",
    "print(sorted(str_list, reverse=True))\n",
    "\n",
    "# d)sorting number list from lowest to highest\n",
    "print(sorted(int_list))\n",
    "# e)sorting number list from highest to lowest\n",
    "print(sorted(int_list, reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 Dictionary manipulation\n",
    "\n",
    "Write a function that takes a dictionary as input and retuns the mean (i.e. average value) of the values stored in the dictionary\n",
    "\n",
    "```\n",
    "Sample Dictionary = Life expectancy by country = {\n",
    "    'Japan': 83.7,\n",
    "    'Switzerland': 83.4,\n",
    "    'Singapore': 83.1,\n",
    "    'Italy': 82.7,\n",
    "    'Israel': 82.5,\n",
    "    'Netherlands': 81.9,\n",
    "    'United Kingdom': 81.2,\n",
    "    'Cyprus': 80.5,\n",
    "    'Chile': 80.5,\n",
    "    'United States: 79.3,\n",
    "    'Argentina': 76.3,\n",
    "    'Iran': 75.5,\n",
    "    'Jordan': 74.1,\n",
    "    'Russia': 70.5,\n",
    "    'Philippines': 68.5,\n",
    "    'India': 68.3\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your function here:\n",
    "def dict_average(input):\n",
    "    num_list = []\n",
    "    for item in input:\n",
    "        num_list.append(input[item])\n",
    "    return sum(num_list)/len(num_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78.25"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test your code here:\n",
    "\n",
    "Life_expectancy_country = {\n",
    "    'Japan': 83.7,\n",
    "    'Switzerland': 83.4,\n",
    "    'Singapore': 83.1,\n",
    "    'Italy': 82.7,\n",
    "    'Israel': 82.5,\n",
    "    'Netherlands': 81.9,\n",
    "    'United Kingdom': 81.2,\n",
    "    'Cyprus': 80.5,\n",
    "    'Chile': 80.5,\n",
    "    'United States': 79.3,\n",
    "    'Argentina': 76.3,\n",
    "    'Iran': 75.5,\n",
    "    'Jordan': 74.1,\n",
    "    'Russia': 70.5,\n",
    "    'Philippines': 68.5,\n",
    "    'India': 68.3\n",
    "}\n",
    "\n",
    "dict_average(Life_expectancy_country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5 Dictionary sorting\n",
    "\n",
    "Write a program that sorts by key in descending order (from Z to A) the dictionary of **exercise 3.4**. \n",
    "\n",
    "Hint: inspect the Python built-in functions (https://docs.python.org/3.7/library/functions.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['United States',\n",
       " 'United Kingdom',\n",
       " 'Switzerland',\n",
       " 'Singapore',\n",
       " 'Russia',\n",
       " 'Philippines',\n",
       " 'Netherlands',\n",
       " 'Jordan',\n",
       " 'Japan',\n",
       " 'Italy',\n",
       " 'Israel',\n",
       " 'Iran',\n",
       " 'India',\n",
       " 'Cyprus',\n",
       " 'Chile',\n",
       " 'Argentina']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your program here\n",
    "sorted(Life_expectancy_country.keys(), reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6 Lists to Dictionary\n",
    "\n",
    "Write a program (or function) that maps two lists into a dictionary\n",
    "\n",
    "Sample first list: ```['Japan', 'Italy', 'United Kingdom', 'Russia']```\n",
    "\n",
    "Sample second list: ```[83.7, 82.7, 81.2, 70.5]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Japan': 83.7, 'Italy': 82.7, 'United Kingdom': 81.2, 'Russia': 70.5}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your program here\n",
    "key_list = ['Japan', 'Italy', 'United Kingdom', 'Russia']\n",
    "value_list = [83.7, 82.7, 81.2, 70.5]\n",
    "dictionary = {}\n",
    "\n",
    "if len(key_list) == len(value_list):\n",
    "    for x in range(0,len(key_list)):\n",
    "        key_name = key_list[x]\n",
    "        key_value = value_list[x]\n",
    "        dictionary[key_name] = key_value\n",
    "else:\n",
    "    print('make sure both list lengths are equal')\n",
    "\n",
    "dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.7 Write a Python program to get the 4th element and 4th element from last of a tuple.\n",
    "\n",
    "Sample input\n",
    "\n",
    "```\n",
    "tuplex = (\"we\", 3, \"are\", \"left\", 4.8, \"our\", \"u\", \"www.ox.ac.uk\", \"core\", \"empty\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4th tuple element 4.8 \n",
      " last 4th tuple element u\n"
     ]
    }
   ],
   "source": [
    "# Write your solution here \n",
    "tuplex = (\"we\", 3, \"are\", \"left\", 4.8, \"our\", \"u\", \"www.ox.ac.uk\", \"core\", \"empty\")\n",
    "print('4th tuple element',tuplex[4], '\\n', 'last 4th tuple element', tuplex[-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.8  Write a Python program to convert a list of tuples to a dictionary.\n",
    "\n",
    "Sample input: ```[(28, 'February'), (30, 'April'), (31, 'July'), (31, 'August'), (30, 'November')]```\n",
    "\n",
    "Sample output ```{'February': 28, 'April': 30, 'July': 31, 'August': 31, 'November': 30}```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'February': 28, 'April': 30, 'July': 31, 'August': 31, 'November': 30}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write your program here\n",
    "tuple_list = [(28, 'February'), (30, 'April'), (31, 'July'), (31, 'August'), (30, 'November')]\n",
    "dict_output = {}\n",
    "\n",
    "for x in tuple_list:\n",
    "    key_name = x[1]\n",
    "    key_value = x[0]\n",
    "    dict_output[key_name] = key_value\n",
    "\n",
    "dict_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loops, list comprehension, dict comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.9 List comprehension\n",
    "\n",
    "Rewrite the following code using list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['the', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']\n",
      "[5, 5, 3, 5, 4, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "# Code to be rewritten\n",
    "\n",
    "sentence = \"the quick brown fox jumps over the lazy dog\"\n",
    "words = sentence.split()\n",
    "word_lengths = []\n",
    "for word in words:\n",
    "      if word != \"the\":\n",
    "          word_lengths.append(len(word))\n",
    "print(words)\n",
    "print(word_lengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 5, 3, 5, 4, 4, 3]\n"
     ]
    }
   ],
   "source": [
    "# Write your solution here\n",
    "words\n",
    "word_lengths = [len(item) for item in words if item != 'the']\n",
    "print(word_lengths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.10 List filtering\n",
    "\n",
    "Using a list comprehension, create a new list called \"newlist\" out of the list \"numbers\", which contains only the positive numbers from the list, as integers rounded to the closest integer value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[35, 45, 68, 45, 13]\n"
     ]
    }
   ],
   "source": [
    "### Input\n",
    "\n",
    "numbers = [34.6, -203.4, 44.9, 68.3, -12.2, 44.6, 12.7]\n",
    "\n",
    "### Write your solution here\n",
    "pos_int_list = [round(integer) for integer in numbers if integer > 0]\n",
    "print(pos_int_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.11 Matrix Element Wise-multiplication\n",
    "\n",
    "Matrices can be encoded as numerical two-dimensional lists\n",
    "Consider the two following matrices \n",
    "\n",
    "```\n",
    "mat_00 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "```\n",
    "and\n",
    "```\n",
    "mat_01 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n",
    "```\n",
    "\n",
    "Compute the element-wise multiplication of the two matrices, i.e.\n",
    "\n",
    "```\n",
    "mat_02 = [[1, 0, 0], [0, 5, 0], [0, 0, 9]]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "[[1, 0, 0], [0, 5, 0], [0, 0, 9]]\n"
     ]
    }
   ],
   "source": [
    "mat_00 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "mat_01 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n",
    "\n",
    "## Write your solution here:\n",
    "mat_02 = []\n",
    "for i, row in enumerate(mat_00):\n",
    "    print(i)\n",
    "    mat_02.append([matrix_val * mat_01[i][list_pos] for list_pos, matrix_val in enumerate(row)])\n",
    "print(mat_02)                  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.12 Matrix-Matrix Multiplication\n",
    "\n",
    "Consider the following two matrices\n",
    "\n",
    "```\n",
    "mat_00 = [[2, 1, 3], [1, 1, 2]]\n",
    "```\n",
    "and\n",
    "```\n",
    "A = [[1, 2], [5, 6], [7, 9]]\n",
    "```\n",
    "\n",
    "Compute the matrix multiplication, i.e.:\n",
    "```\n",
    "B = [[28 37] [20 26]]\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[28, 37], [20, 26]]\n"
     ]
    }
   ],
   "source": [
    "A = [[2, 1, 3], [1, 1, 2]]\n",
    "B = [[1, 2], [5, 6], [7, 9]]\n",
    "\n",
    "# Write your solution here\n",
    "\n",
    "final_list = []\n",
    "for x in A:\n",
    "    semi_final_list = []\n",
    "    #print(x)\n",
    "    for first_matrix_row_count in range(0,len(A)):\n",
    "        matrix2_col_count = -1\n",
    "        count = 0\n",
    "        cell_sum_list = []\n",
    "        \n",
    "        for y in B:\n",
    "            count = count + 1\n",
    "\n",
    "            matrix2_col_count = matrix2_col_count + 1\n",
    "\n",
    "            cell_sum_list.append(x[matrix2_col_count] * y[first_matrix_row_count])\n",
    "\n",
    "        semi_final_list.append(sum(cell_sum_list))\n",
    "         \n",
    "    final_list.append(semi_final_list)\n",
    "\n",
    "print(final_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.13 Dict comprehension\n",
    "\n",
    "Consider these four lists:\n",
    "```\n",
    "fellowship_names = ['gandalf', 'frodo', 'samwise', 'merry', 'aragorn', 'legolas', 'boromir', 'gimli', 'pippin']\n",
    "```\n",
    "```\n",
    "fellowship_surnames = [\n",
    "    'mithrandir', 'baggins', 'gamgee', 'brandybuck', 'elessar', \n",
    "    'greenleaf', 'son of denethor', 'son of gloin', 'took'\n",
    "]\n",
    "```\n",
    "```\n",
    "fellowship_species = ['maia', 'hobbit', 'hobbit', 'hobbit', 'man', 'elf', 'man', 'dwarf', 'hobbit']\n",
    "```\n",
    "```\n",
    "fellowship_ages = [inf, 51, 36, 37, 88, 800, 41, 140, 29]\n",
    "```\n",
    "\n",
    "1) Produce a dictionary with the mapping `fellowship_name` -> `fellowship_age`, pairing each element with the same index in the two lists\n",
    "\n",
    "2) Produce a dictionary with the mapping `(fellowship_name, fellowship_surname)` -> `fellowship_species`, pairing each element with the same index in the three lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'gandalf': 'mithrandir', 'frodo': 'baggins', 'samwise': 'gamgee', 'merry': 'brandybuck', 'aragorn': 'elessar', 'legolas': 'greenleaf', 'boromir': 'son of denethor', 'gimli': 'son of gloin', 'pippin': 'took'}\n",
      "{('gandalf', 'mithrandir'): inf, ('frodo', 'baggins'): 51, ('samwise', 'gamgee'): 36, ('merry', 'brandybuck'): 37, ('aragorn', 'elessar'): 88, ('legolas', 'greenleaf'): 800, ('boromir', 'son of denethor'): 41, ('gimli', 'son of gloin'): 140, ('pippin', 'took'): 29}\n"
     ]
    }
   ],
   "source": [
    "from math import inf\n",
    "\n",
    "fellowship_names = ['gandalf', 'frodo', 'samwise', 'merry', 'aragorn', \n",
    "                    'legolas', 'boromir', 'gimli', 'pippin']\n",
    "fellowship_surnames = [\n",
    "    'mithrandir', 'baggins', 'gamgee', 'brandybuck', 'elessar', \n",
    "    'greenleaf', 'son of denethor', 'son of gloin', 'took'\n",
    "]\n",
    "fellowship_species = ['maia', 'hobbit', 'hobbit', 'hobbit', 'man', 'elf', 'man', 'dwarf', 'hobbit']\n",
    "\n",
    "fellowship_ages = [inf, 51, 36, 37, 88, 800, 41, 140, 29]\n",
    "\n",
    "# Write your solution here\n",
    "fellowship_tuples = tuple(zip(fellowship_names, fellowship_surnames))\n",
    "fellowship_tuples\n",
    "\n",
    "fellowship_age_dict = {member: age for member, age in fellowship_tuples}\n",
    "\n",
    "fellowship_age_dict = {member: age for member, age in fellowship_tuples}\n",
    "print(fellowship_age_dict)\n",
    "\n",
    "fellowship_age_species_dict = {member: age for member, age in zip(fellowship_tuples, fellowship_ages)}\n",
    "print(fellowship_age_species_dict)"
   ]
  }
 ],
 "metadata": {
  "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}