[10_Questions]_QUIZ_Dictionary.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [10 Questions] QUIZ - Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 1:**\n",
    "\n",
    "Define a function named **words_dict**.\n",
    "\n",
    "It will read `en_words.txt` file and will create a dictionary from these words.\n",
    "\n",
    "It will only take the words that have more than or equal to 19 letters.\n",
    "\n",
    "The Key of the dictionary will be the word itself and the Value will be number of letters in the word.\n",
    "\n",
    "The function will return this dictionary.\n",
    "\n",
    "**Hints:**\n",
    "* open()\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "\n",
    "{\n",
    " 'anticonservationist': 19, \n",
    " 'comprehensivenesses': 19, \n",
    " 'counterdemonstration': 20,\n",
    " 'counterdemonstrations': 21,\n",
    " ...\n",
    "}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'anticonservationist': 19,\n",
       " 'comprehensivenesses': 19,\n",
       " 'counterdemonstration': 20,\n",
       " 'counterdemonstrations': 21,\n",
       " 'counterdemonstrator': 19,\n",
       " 'counterdemonstrators': 20,\n",
       " 'counterinflationary': 19,\n",
       " 'counterpropagations': 19,\n",
       " 'counterretaliations': 19,\n",
       " 'disinterestednesses': 19,\n",
       " 'electrocardiographs': 19,\n",
       " 'extraconstitutional': 19,\n",
       " 'hyperaggressiveness': 19,\n",
       " 'hyperaggressivenesses': 21,\n",
       " 'hypersensitivenesses': 20,\n",
       " 'inappropriatenesses': 19,\n",
       " 'inconsideratenesses': 19,\n",
       " 'interdenominational': 19,\n",
       " 'irreconcilabilities': 19,\n",
       " 'microminiaturization': 20,\n",
       " 'microminiaturizations': 21,\n",
       " 'miscellaneousnesses': 19,\n",
       " 'multidenominational': 19,\n",
       " 'representativenesses': 20}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 1:\n",
    "\n",
    "\n",
    "MIN_CHAR_LENGTH = 19\n",
    "\n",
    "\n",
    "def words_dict():\n",
    "    \n",
    "    # an empty dict\n",
    "    dictionary = dict()\n",
    "    \n",
    "    # read the words\n",
    "    file = open('en_words.txt')\n",
    "    \n",
    "    # iterate over file -> line by line\n",
    "    for i, line in enumerate(file):\n",
    "        \n",
    "        # line -> \\n, ' '\n",
    "        line_list = line.split()\n",
    "        \n",
    "        word = line_list[0]\n",
    "          \n",
    "        # if i < 20:\n",
    "          # print(word)\n",
    "                \n",
    "        # check for lenth\n",
    "        if len(word) >= MIN_CHAR_LENGTH:\n",
    "            # print(word)\n",
    "            \n",
    "            # check if it has not been added already\n",
    "            if not word in dictionary:\n",
    "                # add the word into dict\n",
    "                dictionary[word] = len(word)\n",
    "    \n",
    "    return dictionary\n",
    "words_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'anticonservationist': 19,\n",
       " 'comprehensivenesses': 19,\n",
       " 'counterdemonstration': 20,\n",
       " 'counterdemonstrations': 21,\n",
       " 'counterdemonstrator': 19,\n",
       " 'counterdemonstrators': 20,\n",
       " 'counterinflationary': 19,\n",
       " 'counterpropagations': 19,\n",
       " 'counterretaliations': 19,\n",
       " 'disinterestednesses': 19,\n",
       " 'electrocardiographs': 19,\n",
       " 'extraconstitutional': 19,\n",
       " 'hyperaggressiveness': 19,\n",
       " 'hyperaggressivenesses': 21,\n",
       " 'hypersensitivenesses': 20,\n",
       " 'inappropriatenesses': 19,\n",
       " 'inconsideratenesses': 19,\n",
       " 'interdenominational': 19,\n",
       " 'irreconcilabilities': 19,\n",
       " 'microminiaturization': 20,\n",
       " 'microminiaturizations': 21,\n",
       " 'miscellaneousnesses': 19,\n",
       " 'multidenominational': 19,\n",
       " 'representativenesses': 20}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words_dictionary = words_dict()\n",
    "words_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 2:**\n",
    "\n",
    "Define a function named **words_length_dict**.\n",
    "\n",
    "It will read `en_words.txt` file and will create a dictionary from these words.\n",
    "\n",
    "It will only take the words that have more than or equal to 19 letters.\n",
    "\n",
    "The Key will be the length (number of characters in word) and the Value will be a List of words which have that length.\n",
    "\n",
    "The function will return this dictionary.\n",
    "\n",
    "**Hints:**\n",
    "* open()\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "\n",
    "{19: ['anticonservationist', 'comprehensivenesses', 'counterdemonstrator', ...], \n",
    " 20: ['counterdemonstration', 'counterdemonstrators', 'hypersensitivenesses', ...],\n",
    " 21: ['counterdemonstrations', 'hyperaggressivenesses', 'microminiaturizations']}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{19: ['anticonservationist',\n",
       "  'comprehensivenesses',\n",
       "  'counterdemonstrator',\n",
       "  'counterinflationary',\n",
       "  'counterpropagations',\n",
       "  'counterretaliations',\n",
       "  'disinterestednesses',\n",
       "  'electrocardiographs',\n",
       "  'extraconstitutional',\n",
       "  'hyperaggressiveness',\n",
       "  'inappropriatenesses',\n",
       "  'inconsideratenesses',\n",
       "  'interdenominational',\n",
       "  'irreconcilabilities',\n",
       "  'miscellaneousnesses',\n",
       "  'multidenominational'],\n",
       " 20: ['counterdemonstration',\n",
       "  'counterdemonstrators',\n",
       "  'hypersensitivenesses',\n",
       "  'microminiaturization',\n",
       "  'representativenesses'],\n",
       " 21: ['counterdemonstrations',\n",
       "  'hyperaggressivenesses',\n",
       "  'microminiaturizations']}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 2:\n",
    "\n",
    "# global constant\n",
    "MIN_CHAR_LENGTH = 19\n",
    "\n",
    "\n",
    "def words_length_dict():\n",
    "    \n",
    "    # an empty dict\n",
    "    dictionary = dict()\n",
    "    \n",
    "    # read the words\n",
    "    file = open('en_words.txt')\n",
    "    \n",
    "    # iterate over file -> line by line\n",
    "    for i, line in enumerate(file):\n",
    "        \n",
    "        # line -> \\n, ' '\n",
    "        line_list = line.split()\n",
    "        \n",
    "        word = line_list[0]\n",
    "          \n",
    "        # get the length\n",
    "        length = len(word)\n",
    "                \n",
    "        # check for lenth\n",
    "        if len(word) >= MIN_CHAR_LENGTH:\n",
    "            \n",
    "            # first time -> [word]\n",
    "            if not length in dictionary:\n",
    "                dictionary[length] = [word]\n",
    "            else:\n",
    "                dictionary[length].append(word)\n",
    "     \n",
    "    return dictionary\n",
    " \n",
    "dictionary = words_length_dict()  \n",
    "dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{19: ['anticonservationist',\n",
       "  'comprehensivenesses',\n",
       "  'counterdemonstrator',\n",
       "  'counterinflationary',\n",
       "  'counterpropagations',\n",
       "  'counterretaliations',\n",
       "  'disinterestednesses',\n",
       "  'electrocardiographs',\n",
       "  'extraconstitutional',\n",
       "  'hyperaggressiveness',\n",
       "  'inappropriatenesses',\n",
       "  'inconsideratenesses',\n",
       "  'interdenominational',\n",
       "  'irreconcilabilities',\n",
       "  'miscellaneousnesses',\n",
       "  'multidenominational'],\n",
       " 20: ['counterdemonstration',\n",
       "  'counterdemonstrators',\n",
       "  'hypersensitivenesses',\n",
       "  'microminiaturization',\n",
       "  'representativenesses'],\n",
       " 21: ['counterdemonstrations',\n",
       "  'hyperaggressivenesses',\n",
       "  'microminiaturizations']}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length_words = words_length_dict()\n",
    "length_words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 3:**\n",
    "\n",
    "Define 4 functions named **car_1, car_2, car_3, car_4**.\n",
    "\n",
    "These functions will create dictionaries as below (name of the dictionary will be car):\n",
    "\n",
    "<pre>\n",
    "{'brand': 'Ford',\n",
    " 'model': 'Mustang',\n",
    " 'year': 1964,\n",
    " 'color': 'Red',\n",
    " 'price': 30000,\n",
    " 'km': 89000,\n",
    " 'motor': 1.6}\n",
    "</pre>\n",
    "\n",
    "Functions will create the dictionary by different ways and return the dictionary.\n",
    "\n",
    "**Hints:**\n",
    "* { }\n",
    "* dict()\n",
    "* update()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 3:\n",
    "\n",
    "# Way 1\n",
    "def car_1():\n",
    "    car=dict(\n",
    "    {'brand': 'Ford',\n",
    " 'model': 'Mustang',\n",
    " 'year': 1964,\n",
    " 'color': 'Red',\n",
    " 'price': 30000,\n",
    " 'km': 89000,\n",
    " 'motor': 1.6})\n",
    "    return car  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brand': 'Ford',\n",
       " 'model': 'Mustang',\n",
       " 'year': 1964,\n",
       " 'color': 'Red',\n",
       " 'price': 30000,\n",
       " 'km': 89000,\n",
       " 'motor': 1.6}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Way 2\n",
    "def car_2():\n",
    "    car = {'brand': 'Ford',\n",
    " 'model': 'Mustang',\n",
    " 'year': 1964,\n",
    " 'color': 'Red',\n",
    " 'price': 30000,\n",
    " 'km': 89000,\n",
    " 'motor': 1.6}\n",
    "    return car\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brand': 'Ford',\n",
       " 'model': 'Mustang',\n",
       " 'year': 1964,\n",
       " 'color': 'Red',\n",
       " 'price': 30000,\n",
       " 'km': 89000,\n",
       " 'motor': 1.6}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Way 3\n",
    "def car_3():\n",
    "    car={}\n",
    "    element_update={'brand': 'Ford',\n",
    " 'model': 'Mustang',\n",
    " 'year': 1964,\n",
    " 'color': 'Red',\n",
    " 'price': 30000,\n",
    " 'km': 89000,\n",
    " 'motor': 1.6}\n",
    "    car.update(element_update)\n",
    "    return car\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brand': 'Ford',\n",
       " 'model': 'Mustang',\n",
       " 'year': 1964,\n",
       " 'color': 'Red',\n",
       " 'price': 30000,\n",
       " 'km': 89000,\n",
       " 'motor': 1.6}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_3()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Way 4\n",
    "def car_4():\n",
    "    car = dict()\n",
    "    car['brand'] = 'Ford'\n",
    "    car['model'] = 'Mustang'\n",
    "    car['year'] = 1964\n",
    "    car['color'] = 'Red'\n",
    "    car['price']= 30000\n",
    "    car['km']= 89000\n",
    "    car['motor']=1.6\n",
    "    return car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brand': 'Ford',\n",
       " 'model': 'Mustang',\n",
       " 'year': 1964,\n",
       " 'color': 'Red',\n",
       " 'price': 30000,\n",
       " 'km': 89000,\n",
       " 'motor': 1.6}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_4()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 4:**\n",
    "\n",
    "Define a function named **create_a_new_car**.\n",
    "\n",
    "It will call one of the functions defined in Q3 and will get the car dictionary.\n",
    "\n",
    "Then it will copy the items of this car dictionary into another dictionary via a loop.\n",
    "\n",
    "It will first copy all the elements in car dictionary, then create new keys via appendin \"_2\" at the end of existing key, and create a new element.\n",
    "\n",
    "Values will be the same.\n",
    "\n",
    "It will return the new dictionary.\n",
    "\n",
    "**Hint:**\n",
    "* copy()\n",
    "* update()\n",
    "* items()\n",
    "\n",
    "<pre>\n",
    "Expected Output:\n",
    "\n",
    "{\n",
    " 'brand': 'Ford',\n",
    " 'model': 'Mustang',\n",
    " 'year': 1964,\n",
    " 'color': 'Red',\n",
    " 'price': 30000,\n",
    " 'km': 89000,\n",
    " 'motor': 1.6\n",
    " 'brand_2': 'Ford',\n",
    " 'model_2': 'Mustang',\n",
    " 'year_2': 1964,\n",
    " 'color_2': 'Red',\n",
    " 'price_2': 30000,\n",
    " 'km_2': 89000,\n",
    " 'motor_2': 1.6\n",
    " }\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 4:\n",
    "def create_a_new_car():\n",
    "    \n",
    "    # first get the car dictionary\n",
    "    car = car_2()\n",
    "    \n",
    "    # add this car dict into a new dict\n",
    "    car_double = car.copy()\n",
    "    # loop over items\n",
    "    for item in car.items():\n",
    "        \n",
    "        # print(item)\n",
    "        \n",
    "        key = item[0]\n",
    "        value = item[1]\n",
    "        \n",
    "        key += '_2'\n",
    "        \n",
    "        car_double[key] = value\n",
    "    return car_double\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'brand': 'Ford',\n",
       " 'model': 'Mustang',\n",
       " 'year': 1964,\n",
       " 'color': 'Red',\n",
       " 'price': 30000,\n",
       " 'km': 89000,\n",
       " 'motor': 1.6,\n",
       " 'brand_2': 'Ford',\n",
       " 'model_2': 'Mustang',\n",
       " 'year_2': 1964,\n",
       " 'color_2': 'Red',\n",
       " 'price_2': 30000,\n",
       " 'km_2': 89000,\n",
       " 'motor_2': 1.6}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "create_a_new_car()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 5:**\n",
    "\n",
    "Define a function named **concat_dicts**.\n",
    "\n",
    "It will concatenate the dictionaries below and return the resulting dict.\n",
    "\n",
    "The function will take these dictionaries as parameters.\n",
    "\n",
    "**Hints**\n",
    "* use only one for loop\n",
    "* search for looping on multiple dictionaries\n",
    "    * for x in (d1, d2, .... ):\n",
    "* update()\n",
    "\n",
    "<pre>\n",
    "Dictionaries to concat:\n",
    "\n",
    "d1={4:120, 7:60}\n",
    "d2={'A': 300, 'B':400}\n",
    "d3={True: 'Correct', False: 'Incorrect'}\n",
    "\n",
    "Expected Output:\n",
    "{4: 120, 7: 60, 'A': 300, 'B': 400, True: 'Correct', False: 'Incorrect'}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4: 120, 7: 60, 'A': 300, 'B': 400, True: 'Correct', False: 'Incorrect'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 5:\n",
    "def concat_dicts(d1,d2,d3):\n",
    "    result = {} \n",
    "    for d in d1,d2,d3: \n",
    "        result.update(d) \n",
    "    return result  \n",
    "\n",
    "d1={4:120, 7:60}\n",
    "d2={'A': 300, 'B':400}\n",
    "d3={True: 'Correct', False: 'Incorrect'}\n",
    "d=concat_dicts(d1,d2,d3) \n",
    "d\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4: 120, 7: 60, 'A': 'AAA', 'B': 'BBB', True: 'Correct', False: 'Incorrect'}"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1={4:120, 7:60}\n",
    "d2={'A': 'AAA', 'B':'BBB'}\n",
    "d3={True: 'Correct', False: 'Incorrect'}\n",
    "\n",
    "d = concat_dicts(d1, d2, d3)\n",
    "d\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 6:**\n",
    "\n",
    "Define a function named **sum_of_same_keys**.\n",
    "\n",
    "It will take two dictionaries (d1, d2) as parameters.\n",
    "\n",
    "And it will sum the values of items having the same key in both dicts.\n",
    "\n",
    "It will not take distinct keys. So it will return a new dictionary with only common keys.\n",
    "\n",
    "**Hints:**\n",
    "* Check if both parameters are dictionary (dict)\n",
    "    * if not raise an error -> 'Both parameters must be dictionary type!'\n",
    "    * to check -> use isinstance() instead of type().\n",
    "    * isinstance(<variable>, <type>)\n",
    "* Check if both dictionaries have the same length\n",
    "    * if not raise an error -> 'Dictionaries must be the same length!'\n",
    "\n",
    "<pre>\n",
    "Parameters:\n",
    "d1 = {'a': 10, 'b': 30, 'c':50}\n",
    "d2 = {'a': 40, 'b': 60, 'd':90}\n",
    "\n",
    "Expected Output:\n",
    "{'a': 50, 'b': 90}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 50, 'b': 90}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 6:\n",
    "def sum_of_same_keys(d1,d2):\n",
    "    result = {key: d1.get(key, 0) + d2.get(key, 0) for key in set(d1) & set(d2)}\n",
    "    return result\n",
    "                    \n",
    "\n",
    "d1 = {'a': 10, 'b': 30, 'c':50}\n",
    "d2 = {'a': 40, 'b': 60, 'd':90}\n",
    "sum_of_same_keys(d1,d2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 50, 'd': 190, 'b': 90}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {'a': 10, 'b': 30, 'c':50, 'd': 100}\n",
    "d2 = {'a': 40, 'b': 60, 'd':90, 'e': 50}\n",
    "sum_of_same_keys(d1, d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 7:**\n",
    "\n",
    "Let'e improve the function in Q6.\n",
    "\n",
    "It will work the same for the same keys.\n",
    "\n",
    "But this time we will also include the different keys.\n",
    "\n",
    "Function name will be **sum_of_same_keys_value_of_distinct_ones**.\n",
    "\n",
    "**Hints:**\n",
    "* Check if both parameters are dictionary (dict)\n",
    "    * if not raise an error -> 'Both parameters must be dictionary type!'\n",
    "    * to check -> use isinstance() instead of type().\n",
    "    * isinstance(<variable>, <type>)\n",
    "* Check if both dictionaries have the same length\n",
    "    * if not raise an error -> 'Dictionaries must be the same length!'\n",
    "\n",
    "<pre>\n",
    "Parameters:\n",
    "d1 = {'a': 10, 'b': 30, 'c':50}\n",
    "d2 = {'a': 40, 'b': 60, 'd':90}\n",
    "\n",
    "Expected Output:\n",
    "{'a': 50, 'b': 90, 'c': 50, 'd': 90}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 50, 'b': 90, 'c': 50, 'd': 90}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 7:\n",
    "def sum_of_same_keys_value_of_distinct_ones(d1,d2):\n",
    "    result = {}\n",
    "\n",
    "    for d in d1,d2:\n",
    "        \n",
    "            for keys, values in d.items():\n",
    "                result[keys] = result.get(keys,0) + values\n",
    "\n",
    "    return result\n",
    "\n",
    "d1 = {'a': 10, 'b': 30, 'c':50}\n",
    "d2 = {'a': 40, 'b': 60, 'd':90}\n",
    "sum_of_same_keys_value_of_distinct_ones(d1,d2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 50, 'b': 90, 'c': 50, 'd': 90}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {'a': 10, 'b': 30, 'c':50}\n",
    "d2 = {'a': 40, 'b': 60, 'd':90}\n",
    "sum_of_same_keys_value_of_distinct_ones(d1,d2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 90, 'b': 100, 'c': 50, 'e': 100, 'f': 50, 'd': 90}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1 = {'a': 50, 'b': 30, 'c':50, 'e':10, 'f':50}\n",
    "d2 = {'a': 40, 'b': 70, 'd':90, 'e':90}\n",
    "sum_of_same_keys_value_of_distinct_ones(d1, d2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 8:**\n",
    "\n",
    "Define a function named **delete_odds**.\n",
    "\n",
    "It will take a dictionary as parameter.\n",
    "\n",
    "It will delete the items with odd indices from the dictionary and return a new dictionary with remaining items.\n",
    "\n",
    "**Hints:**\n",
    "* Do not change original dictionary (parameter)\n",
    "* `items()` for the loop\n",
    "* `enumerate()` for the index\n",
    "    \n",
    "<pre>\n",
    "Parameter Dictionary:\n",
    "dictionary = {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D', 'e': 'E', 'f': 'F'}\n",
    "\n",
    "Exptected Output:\n",
    " {'a': 'A', 'c': 'C', 'e': 'E'}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# S 8:\n",
    "\n",
    "# Way 1\n",
    "def delete_odds(dictionary):\n",
    "    \n",
    "    d = {}\n",
    "    \n",
    "    for index, item in enumerate(dictionary.items()):\n",
    "        \n",
    "        key = item[0]\n",
    "        value = item[1]\n",
    "        \n",
    "        if index % 2 == 0:\n",
    "            d[key] = value\n",
    "        \n",
    "    return d\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'A', 'c': 'C', 'e': 'E'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dictionary = {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D', 'e': 'E', 'f': 'F'}\n",
    "\n",
    "evens = delete_odds(dictionary)\n",
    "\n",
    "evens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Way 2\n",
    "def delete_odds(dictionary):\n",
    "    \n",
    "    d = {}\n",
    "    \n",
    "    for index, item in enumerate(dictionary.items()):\n",
    "        \n",
    "        if index % 2 == 0:\n",
    "            # print({item})\n",
    "            d.update({item})\n",
    "\n",
    "    return d\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'A', 'c': 'C', 'e': 'E'}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dictionary = {'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D', 'e': 'E', 'f': 'F'}\n",
    "\n",
    "evens = delete_odds(dictionary)\n",
    "\n",
    "evens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 9:**\n",
    "\n",
    "Define a function named **convert_lists_into_dict**.\n",
    "\n",
    "It will take two lists as parameters.\n",
    "\n",
    "The function will use the first list elements as Keys and second list elements as Values and it will create a dictionary.\n",
    "\n",
    "Then it will return this dictionary.\n",
    "\n",
    "**Hints:**\n",
    "* enumerate()\n",
    "\n",
    "<pre>\n",
    "Parameters:\n",
    "l_1 = ['name', 'lastname', 'age', 'gender']\n",
    "l_2 = ['John', 'Doe', 100, 'Male']\n",
    "\n",
    "Expected Output:\n",
    "{'name': 'John', 'lastname': 'Doe', 'age': 100, 'gender': 'Male'}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'John', 'lastname': 'Doe', 'age': 100, 'gender': 'Male'}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# S 9:\n",
    "def convert_lists_into_dict(l_1, l_2):\n",
    "    d=zip(l_1,l_2)\n",
    "    employee = dict(d)\n",
    "    return employee\n",
    "\n",
    "\n",
    "l_1 = ['name', 'lastname', 'age', 'gender']\n",
    "l_2 = ['John', 'Doe', 100, 'Male']\n",
    "convert_lists_into_dict(l_1, l_2) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'John', 'lastname': 'Doe', 'age': 100, 'gender': 'Male'}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l_1 = ['name', 'lastname', 'age', 'gender']\n",
    "l_2 = ['John', 'Doe', 100, 'Male']\n",
    "\n",
    "convert_lists_into_dict(l_1, l_2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q 10:**\n",
    "\n",
    "Let's consider a function with keys being both numbers and letters.\n",
    "\n",
    "Example: {'a': 'A', 'b': 'B', 2: 200, 'd': 'D', 5: 300, 'f': 'F', 1: 50}\n",
    "\n",
    "Define a function named **alphabetical**.\n",
    "\n",
    "It will delete the elements with keys being number.\n",
    "\n",
    "And it will return the final dictionary which has only alphabetical keys.\n",
    "\n",
    "**Hints:**\n",
    "* Mutate the original dictionary that is the parameter\n",
    "* use two loops\n",
    "* `keys()` for loops\n",
    "* `pop()` for delete\n",
    "* to check if alphabetical -> `isalpha()`\n",
    "* keep in mind `isalpha()` is a string (str) function\n",
    "\n",
    "<pre>\n",
    "Parameter Dictionary:\n",
    "dictionary = {'a': 'A', 'b': 'B', 2: 200, 'd': 'D', 5: 300, 'f': 'F', 1: 50}\n",
    "\n",
    "Expected Output:\n",
    "dictionary before calling alphabetical: {'a': 'A', 'b': 'B', 2: 200, 'd': 'D', 5: 300, 'f': 'F', 1: 50}\n",
    "dictionary after calling alphabetical: {'a': 'A', 'b': 'B', 'd': 'D', 'f': 'F'}\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dictionary before calling alphabetical :  {'a': 'A', 'b': 'B', 2: 200, 'd': 'D', 5: 300, 'f': 'F', 1: 50}\n",
      "dictionary after calling alphabetical :  {'a': 'A', 'b': 'B', 'd': 'D', 'f': 'F'}\n"
     ]
    }
   ],
   "source": [
    "# S 10:\n",
    "\n",
    "\n",
    "dictionary = {'a': 'A', 'b': 'B', 2: 200, 'd': 'D', 5: 300, 'f': 'F', 1: 50}\n",
    "\n",
    "\n",
    "# Printing dictionary before removal\n",
    "print (\"dictionary before calling alphabetical : \",dictionary)\n",
    "new_dictionary = dict()\n",
    "def alphabetical(dictionary):\n",
    "    \n",
    "    new_dictionary = []\n",
    "    for key in dictionary.keys():\n",
    "        if not str(key).isalpha():\n",
    "            new_dictionary.append(key)\n",
    "    \n",
    "    \n",
    "    for key in new_dictionary:\n",
    "        if key in dictionary.keys():\n",
    "            dictionary.pop(key)\n",
    "    \n",
    "    return new_dictionary \n",
    "        \n",
    "alphabetical(dictionary)        \n",
    "# Printing dictionary after removal        \n",
    "print (\"dictionary after calling alphabetical : \" ,dictionary)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dictionary before calling alphabetical: {'a': 'A', 'b': 'B', 2: 200, 'd': 'D', 5: 300, 'f': 'F', 1: 50}\n",
      "dictionary after calling alphabetical: {'a': 'A', 'b': 'B', 'd': 'D', 'f': 'F'}\n"
     ]
    }
   ],
   "source": [
    "dictionary = {'a': 'A', 'b': 'B', 2: 200, 'd': 'D', 5: 300, 'f': 'F', 1: 50}\n",
    "print(\"dictionary before calling alphabetical:\", dictionary)\n",
    "\n",
    "alphabetical(dictionary)\n",
    "\n",
    "print(\"dictionary after calling alphabetical:\", dictionary)"
   ]
  }
 ],
 "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.9.12"
  },
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}