Dictionary_Assignment_by_kiran.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b6394548",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'email': 'kathy_abram897@gmail.com', 'Phone': 1887654321, 'City': 'New York'}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initialize a dictionary \"emp_info\" with below details\n",
    "# In - emp_info['Tom']\n",
    "# Out - {'email':'tom_latham019@gmail.com', 'Phone': +1987654321, 'City': 'California'}\n",
    "emp_info= {'Tom':{'email':'tom_latham019@gmail.com', 'Phone': +1987654321, 'City': 'California'},\n",
    "           'Kathy':{'email':'kathy_abram897@gmail.com', 'Phone': +1887654321, 'City': 'New York'}}\n",
    "emp_info['Tom']\n",
    "\n",
    "# In - emp_info['Kathy']\n",
    "# Out - {'email':'kathy_abram897@gmail.com', 'Phone': +1887654321, 'City': 'New York'}\n",
    "\n",
    "emp_info['Kathy']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1094e51b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'emp1': {'e_name': 'John', 'e_id': 'SG101', 'e_sal': '$10,000'},\n",
       " 'emp2': {'e_name': 'Smith', 'e_id': 'SG102', 'e_sal': '$9,000'},\n",
       " 'emp3': {'e_name': 'Peter', 'e_id': 'SG103', 'e_sal': '$9,500'}}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a dictionary out of below inputs\n",
    "lst1 = ['emp1', 'emp2', 'emp3']\n",
    "emp_key = ['e_name', 'e_id', 'e_sal']\n",
    "emp1_val = ['John', 'SG101', '$10,000']\n",
    "emp2_val = ['Smith', 'SG102', '$9,000']\n",
    "emp3_val = ['Peter', 'SG103', '$9,500']\n",
    "\n",
    "\n",
    "# Expected Output:- {'emp1':{'e_name':'John', 'e_id':'SG101', 'e_sal':$10,000}, \n",
    "#                    'emp2':{'e_name':'Smith', 'e_id':'SG102', 'e_sal':$9,000}, \n",
    "#                    'emp3':{'e_name':'Peter', 'e_id':'SG103', 'e_sal':$9,500}}\n",
    "\n",
    "d1= dict(zip(emp_key,emp1_val))\n",
    "d2= dict(zip(emp_key,emp2_val))\n",
    "d3= dict(zip(emp_key,emp3_val))\n",
    "\n",
    "d= [d1,d2,d3]\n",
    "dl= dict(zip(lst1,d))\n",
    "dl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fc6e0c9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "80"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Acess the value of key 'history'\n",
    "\n",
    "sampleDict = { \n",
    "   \"class\":{ \n",
    "      \"student\":{ \n",
    "         \"name\":\"Mike\",\n",
    "         \"marks\":{ \n",
    "            \"physics\":70,\n",
    "            \"history\":80\n",
    "         }\n",
    "      }\n",
    "   }\n",
    "}\n",
    "\n",
    "\n",
    "sampleDict['class']['student']['marks']['history']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d1c35411",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Kelly': {'designation': 'Application Developer', 'salary': 8000},\n",
       " 'Emma': {'designation': 'Application Developer', 'salary': 8000},\n",
       " 'John': {'designation': 'Application Developer', 'salary': 8000}}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initialize dictionary with default values. Inputs are:-\n",
    "employees = ['Kelly', 'Emma', 'John']\n",
    "defaults = {\"designation\": 'Application Developer', \"salary\": 8000}\n",
    "\n",
    "#Expected output:- {'Kelly': {'designation': 'Application Developer', 'salary': 8000}, \n",
    "#                   'Emma': {'designation': 'Application Developer', 'salary': 8000}, \n",
    "#                   'John': {'designation': 'Application Developer', 'salary': 8000}}\n",
    "defaults= defaults.fromkeys(employees,defaults)   \n",
    "defaults"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f66e1bc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'g': 2, 'o': 3, 'l': 1, 'e': 1, '.': 1, 'c': 1, 'm': 1}\n"
     ]
    }
   ],
   "source": [
    "# Write a function which takes a word as input and returns a dictionary with letters as key and no of time letters are repeated as value.\n",
    "# In - count_letter('google.com')\n",
    "# Out - {'g': 2, 'o': 3, 'l': 1, 'e': 1, '.': 1, 'c': 1, 'm': 1}\n",
    "\n",
    "def fun(x):\n",
    "    g = [x.count(i) for i in x]\n",
    "    return print(dict(zip(x,g)))\n",
    "\n",
    "fun('google.com')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a312c88f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1, 'C': 0, 'T': 1, 'G': 1}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A DNA strand consisting of the 4 nucleotide bases is usually represented with a string of letters: A,T, C, G. \n",
    "# Write a function that computes the base composition of a given DNA sequence.\n",
    "\n",
    "# In - baseComposition(\"CTATCGGCACCCTTTCAGCA\")\n",
    "# Out - {'A': 4, 'C': 8, 'T': 5,  'G': 3 }\n",
    "\n",
    "# basecomposition(\"CTATCGGCACCCTTTCAGCA\")\n",
    "    \n",
    "# In - baseComposition(\"AGT\")\n",
    "# Out - {'A': 1, 'C': 0, 'T': 1,  'G': 1 }\n",
    "\n",
    "k='AGT'\n",
    "l=list(\"CTATCGGCACCCTTTCAGCA\")\n",
    "dna= ['A','C','T','G']\n",
    "\n",
    "\n",
    "def dnar(l):\n",
    "    dd=[l.count(i) for i in dna]\n",
    "    return dict(zip(dna,dd))\n",
    "\n",
    "dnar(l)\n",
    "dnar(k)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b050bb1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 8, 'T': 5, 'A': 4, 'G': 3}\n"
     ]
    }
   ],
   "source": [
    "# In - baseComposition(\"CTATCGGCACCCTTTCAGCA\")\n",
    "# Out - {'A': 4, 'C': 8, 'T': 5,  'G': 3 }\n",
    "\n",
    "def basecomposition(d):\n",
    "    g=[d.count(i) for i in d ]\n",
    "    f=(dict(zip(d,g)))\n",
    "    print(f)\n",
    "    \n",
    "\n",
    "basecomposition(\"CTATCGGCACCCTTTCAGCA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "05834112",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [MCQ] Suppose \"d\" is an empty dictionary, which statement does not assign \"d\" with {\"Name\":\"Tom\"}? \n",
    "# 1. d = {\"Name\": \"Tom\" }\n",
    "# 2. d[\"Name\"] = \"Tom\"\n",
    "# 3. d.update({\"Name\": \"Tom\" })\n",
    "# 4. d.setdefault(\"Name\", \"Tom\")\n",
    "# 5. None of the above.\n",
    "\n",
    "# 5.None of the above\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e68c3f82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [MCQ] d = {\"a\":1, \"b\":2}. Which of the statements returns [1,2]? \n",
    "# 1. d.keys()\n",
    "# 2. d.values()\n",
    "# 3. d.items()\n",
    "# 4. d.popitem()\n",
    "# 5. None of the above.\n",
    "\n",
    "# 2. d.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "60a13d8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [MCQ] Which of the following declarations is not valid for 'dict' type?\n",
    "# 1. d = {\"Name\": \"Tom\" }\n",
    "# 2. d = { (1,3,4): 4.5 }\n",
    "# 3. d = { [\"First\", \"Last\"]: (1,3) }\n",
    "# 4. d = { 1: 0.4 }\n",
    "# 5. None of the above\n",
    "\n",
    "\n",
    "# 3. d= {['First','Last']: (1,3)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5e29b864",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['b', 'c']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a function reverseLookup(dictionary, value) that takes in a dictionary \n",
    "# and a value as arguments and returns a sorted list of all keys that contains the value. \n",
    "# The function will return an empty list if no match is found.\n",
    "\n",
    "# In - reverseLookup({'a':1, 'b':2, 'c':2}, 1)\n",
    "# Out - ['a']\n",
    "# In - reverseLookup({'a':1, 'b':2, 'c':2}, 2)\n",
    "# Out - ['b', 'c']\n",
    "# In - reverseLookup({'a':1, 'b':2, 'c':2}, 3)\n",
    "# Out - []\n",
    "\n",
    "def reverseLookup(dic,val):\n",
    "    all_keys = []\n",
    "    for key, value in dic.items():\n",
    "        if(value == val):\n",
    "            all_keys.append(key)\n",
    "        else:\n",
    "            all_keys\n",
    "\n",
    "#     print(all_keys)\n",
    "    \n",
    "    return(all_keys)\n",
    "    \n",
    "    \n",
    "reverseLookup({'a':1, 'b':2, 'c':2},2)\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6eb62f83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['a'], 2: ['b', 'd'], 3: ['c']}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a function invertDictionary(d) that takes in a dictionary as argument and return a dictionary that inverts the keys and the values of the original dictionary.\n",
    "# In - invertDictionary({'a':1, 'b':2, 'c':3, 'd':2})\n",
    "# Out - {1: ['a'], 2: ['b', 'd'], 3: ['c']}\n",
    "# In - invertDictionary({'a':3, 'b':3, 'c':3})\n",
    "# Out - {3: ['a', 'c', 'b']}\n",
    "# In - invertDictionary({'a':2, 'b':1, 'c':2, 'd':1})\n",
    "# Out - {1: ['b', 'd'], 2: ['a', 'c']}\n",
    "\n",
    "\n",
    "ls= {'a':1, 'b':2, 'c':3, 'd':2}\n",
    " \n",
    "def Inverted_ls(ls):\n",
    "    from collections import defaultdict\n",
    "    ls_invert = defaultdict(list)\n",
    "    {ls_invert[v].append(k) for k,v in ls.items()}\n",
    "    \n",
    "    return(dict(ls_invert))\n",
    "    \n",
    "Inverted_ls({'a':1, 'b':2, 'c':3, 'd':2})\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3d51eb9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a function that converts a sparse vector into a dictionary as described above.\n",
    "# In - convertVector([1, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 4])\n",
    "# Out - {0: 1, 3: 2, 7: 3, 12: 4}\n",
    "# In - convertVector([1, 0, 1 , 0, 2, 0, 1, 0, 0, 1, 0])\n",
    "# Out - {0: 1, 2: 1, 4: 2, 6: 1, 9: 1}\n",
    "# In - convertVector([0, 0, 0, 0, 0])\n",
    "# Out - {}\n",
    "\n",
    "\n",
    "def convertVector(numbers):\n",
    "    d = {}\n",
    "    for k, c in enumerate(numbers):\n",
    "        if c:\n",
    "            d[k] = c  \n",
    "    return d\n",
    "\n",
    "convertVector([1, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 4])\n",
    "convertVector([1, 0, 1 , 0, 2, 0, 1, 0, 0, 1, 0])\n",
    "convertVector([0, 0, 0, 0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7de09131",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 1, 0, 2, 0, 1, 0, 0, 1]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write a function that converts a dictionary back to its sparse vector representation.\n",
    "# In - convertDictionary({0: 1, 3: 2, 7: 3, 12: 4})\n",
    "# Out - [1, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 4]\n",
    "# In - convertDictionary({0: 1, 2: 1, 4: 2, 6: 1, 9: 1})\n",
    "# Out - [1, 0, 1, 0, 2, 0, 1, 0, 0, 1]\n",
    "# In - convertDictionary({})\n",
    "# Out - []\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "def makeA(d):\n",
    "    dd = defaultdict(int, d)\n",
    "    return [dd[n] for n in range(10)]\n",
    "\n",
    "\n",
    "makeA({0: 1, 3: 2, 7: 3, 12: 4})\n",
    "makeA({})\n",
    "makeA({0: 1, 2: 1, 4: 2, 6: 1, 9: 1})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "62434a76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'emp1': {'name': 'Jhon', 'salary': 7500},\n",
       " 'emp2': {'name': 'Emma', 'salary': 8000},\n",
       " 'emp3': {'name': 'Brad', 'salary': 8500}}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Given a Python dictionary, Change Brad’s salary to 8500\n",
    "sampleDict = {\n",
    "     'emp1': {'name': 'Jhon', 'salary': 7500},\n",
    "     'emp2': {'name': 'Emma', 'salary': 8000},\n",
    "     'emp3': {'name': 'Brad', 'salary': 6500}\n",
    "}\n",
    "\n",
    "# Expected Output\n",
    "# sampleDict = {\n",
    "#      'emp1': {'name': 'Jhon', 'salary': 7500},\n",
    "#      'emp2': {'name': 'Emma', 'salary': 8000},\n",
    "#      'emp3': {'name': 'Brad', 'salary': 8500}\n",
    "# }\n",
    "\n",
    "sampleDict['emp3']['salary']= 8500\n",
    "sampleDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e7edcad8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Math']\n"
     ]
    }
   ],
   "source": [
    "# Get the key corresponding to the minimum value from the following dictionary\n",
    "sampleDict = {\n",
    "  'Physics': 82,\n",
    "  'Math': 65,\n",
    "  'history': 75\n",
    "}\n",
    "\n",
    "# Expected Output\n",
    "# Math\n",
    "\n",
    "temp = min(sampleDict.values())\n",
    "res = [key for key in sampleDict if sampleDict[key] == temp]\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c799662f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Kelly', 'age': 25, 'salary': 8000, 'city': 'New york'}\n"
     ]
    }
   ],
   "source": [
    "# Rename key city to location in the following dictionary\n",
    "sampleDict = {\n",
    "  \"name\": \"Kelly\",\n",
    "  \"age\":25,\n",
    "  \"salary\": 8000,\n",
    "  \"city\": \"New york\"\n",
    "}\n",
    "\n",
    "# Expected Output\n",
    "# {\n",
    "#   \"name\": \"Kelly\",\n",
    "#   \"age\":25,\n",
    "#   \"salary\": 8000,\n",
    "#   \"location\": \"New york\"\n",
    "# }\n",
    "\n",
    "old_k = 'cityi'\n",
    "new_k = 'location'\n",
    "# new_v = 4  # optional\n",
    "\n",
    "print(dict((new_k, new_v) if k == old_k else (k, v) for k, v in sampleDict.items()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8e6da635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Check if a value 200 exists in a dictionary\n",
    "# sampleDict = {'a': 100, 'b': 200, 'c': 300}\n",
    "\n",
    "# Expected Output: True\n",
    "\n",
    "\n",
    "def val(di,x_val):\n",
    "    \n",
    "    if x_val in di.values():\n",
    "        print('True')\n",
    "    else:\n",
    "        return di.values()\n",
    "    \n",
    "    return None\n",
    "\n",
    "        \n",
    "val({'a': 100, 'b': 200, 'c': 300},200)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "28597399",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'age': 25, 'city': 'New york'}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Delete set of keys from Python Dictionary\n",
    "sampleDict = {\n",
    "  \"name\": \"Kelly\",\n",
    "  \"age\":25,\n",
    "  \"salary\": 8000,\n",
    "  \"city\": \"New york\"\n",
    "  \n",
    "}\n",
    "keysToRemove = [\"name\", \"salary\"]\n",
    "\n",
    "# Expected Output:\n",
    "# {'city': 'New york', 'age': 25}\n",
    "\n",
    "\n",
    "def delete_key(sampleDict,keysToRemove):\n",
    "    keysToRemove = [\"name\", \"salary\"]\n",
    "    {sampleDict.pop(key) for key in keysToRemove}\n",
    "    return(sampleDict)\n",
    "\n",
    "delete_key(sampleDict,keysToRemove)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61e81226",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}