Dictionary, Tuple, Set.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Crash Course Assignment: Dictionary, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best way we learn anything is by practice and exercise questions. We have started this section for those (beginner to intermediate) who may or maynot familiar with Python.\n",
    "\n",
    "There are multiple ways to solve any given problem. Best way to learn is to come up with every possible way. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary\n",
    "\n",
    "Python dictionary is a container of the unordered set of objects like lists. The objects are surrounded by curly braces { }. The items in a dictionary are a comma-separated list of key:value pairs where keys and values are Python data type.\n",
    "\n",
    "Each object or value accessed by key and keys are unique in the dictionary. As keys are used for indexing, they must be the immutable type (string, number, or tuple). You can create an empty dictionary using empty curly braces.\n",
    "\n",
    "**Syntax: dictionary = {key:value}**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Write a Python program to convert the given list to dictionary such that all the odd elements have the key, and even number elements have the value.**\n",
    "\n",
    "**Sample list : ['a', 1, 'b', 2, 'c', 3]**\n",
    "\n",
    "**Output : {'a': 1, 'b': 2, 'c': 3}**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def d(l):\n",
    "    di = {}\n",
    "    for i in range(0,len(l),2):\n",
    "        di[l[i]] = l[i+1]\n",
    "    return di"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "l = ['a', 1, 'b', 2, 'c', 3]\n",
    "print(d(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Write a above Python program for same inputs using zip().**\n",
    "\n",
    "* Zip(): zip(iter1  [,iter2  [...]]) --> zip object\n",
    "\n",
    "Return a zip object whose .__next__() method returns a tuple where\n",
    "the i-th element comes from the i-th iterable argument.\n",
    "\n",
    "**Sample list : ['a', 1, 'b', 2, 'c', 3]**\n",
    "\n",
    "**Output : {'a': 1, 'b': 2, 'c': 3}**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def di(l):\n",
    "    d = zip(l[::2],l[1::2])\n",
    "    di = dict(d)\n",
    "    return di"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 2, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "print(di(['a', 1, 'b', 2, 'c', 3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Write a Python program to iterate over dictionaries using for loops.**\n",
    "\n",
    "**Sample list:{'x': 10, 'y': 20, 'z': 30} **\n",
    "\n",
    "**Output list:**\n",
    "* x -> 10\n",
    "* y -> 20\n",
    "* z -> 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x -> 10\n",
      "y -> 20\n",
      "z -> 30\n"
     ]
    }
   ],
   "source": [
    "d = {'x': 10, 'y': 20, 'z': 30} \n",
    "\n",
    "for i in d:\n",
    "    print(f\"{i} -> {d[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Write a Python program to merge two Python dictionaries..**\n",
    "\n",
    "**Sample List:**\n",
    "* d1 = {'a': 100, 'b': 200}\n",
    "* d2 = {'x': 300, 'y': 200}\n",
    "\n",
    "\n",
    "**Sample Output:**\n",
    "* {'a': 100, 'b': 200, 'x': 300, 'y': 200}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 100, 'b': 200, 'x': 300, 'y': 200}\n"
     ]
    }
   ],
   "source": [
    "d1 = {'a': 100, 'b': 200}\n",
    "d2 = {'x': 300, 'y': 200}\n",
    "\n",
    "d3 = {}\n",
    "d3.update(d1)\n",
    "d3.update(d2)\n",
    "\n",
    "print(d3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple\n",
    "\n",
    "A tuple is a collection of objects which ordered and immutable. Tuples are sequences, just like lists. The differences between tuples and lists are, the tuples cannot be changed unlike lists and tuples use parentheses, whereas lists use square brackets\n",
    "\n",
    "**Syntax: tuple = (value1,value2,....,valuen)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. Write a Python program to add all the elements in a tuple.**\n",
    "\n",
    "**Sample tuple: (2,55,10)**\n",
    "\n",
    "**Sample Output: 67**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67\n"
     ]
    }
   ],
   "source": [
    "t = (2,55,10)\n",
    "print(sum(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6. Write a Python program to convert tuple to string.**\n",
    "\n",
    "**Sample tuple: ('E','U','C','L','I','D')**\n",
    "\n",
    "**Sample Output: 'EUCLID'**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EUCLID\n"
     ]
    }
   ],
   "source": [
    "t  = ('E','U','C','L','I','D')\n",
    "s = \"\"\n",
    "for i in t:\n",
    "    s += i\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7. Write a Python program to slice a tuple.**\n",
    "\n",
    "**Sample tuple: ('E','U','C','L','I','D','L','A','B','S')**\n",
    "\n",
    "**Sample Output: 'EUCLID LAB'**\n",
    "\n",
    "* Hint:\n",
    "\n",
    "#step specify an increment between the elements to cut of the tuple = tuple[start:stop:step]\n",
    "\n",
    "By default step = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EUCLID LABS\n"
     ]
    }
   ],
   "source": [
    "t = ('E','U','C','L','I','D','L','A','B','S')\n",
    "s = \"\"\n",
    "for i in t[:6]:\n",
    "    s += i\n",
    "s += \" \"\n",
    "for i in t[6:]:\n",
    "    s += i\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**8. Write a Python program to slice a above tuple in reverse order.**\n",
    "\n",
    "**Sample tuple: ('E','U','C','L','I','D','L','A','B','S')**\n",
    "\n",
    "**Sample Output: 'DILCUE SBAL'**\n",
    "\n",
    "* Hint:\n",
    "\n",
    "#step specify an increment between the elements to cut of the tuple = tuple[start:stop:step]\n",
    "\n",
    "By default step = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DILCUE SBAL\n"
     ]
    }
   ],
   "source": [
    "t = ('E','U','C','L','I','D','L','A','B','S')\n",
    "s = \"\"\n",
    "for i in t[5::-1]:\n",
    "    s += i\n",
    "s += \" \"\n",
    "for i in t[:5:-1]:\n",
    "    s += i\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set\n",
    "\n",
    "A set object is an unordered collection of distinct hashable objects. It is commonly used in membership testing, removing duplicates from a sequence, and computing mathematical operations such as intersection, union, difference, and symmetric difference.\n",
    "\n",
    "**Syntex: Set()**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**9. Write a Python program to add and update member() in a set.**\n",
    "\n",
    "1. Create empty animal set\n",
    "2. Add \"Horse\"\n",
    "3. Update animal set with [\"Mouse\",\"Lion\"]\n",
    "\n",
    "**Sample Output:** \n",
    "\n",
    "* adding Set: {'Horse'}\n",
    "* Updateing Set: {'Lion', 'Mouse', 'Horse'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adding set {'Horse'}\n",
      "Updateing Set: {'Mouse', 'Lion', 'Horse'}\n"
     ]
    }
   ],
   "source": [
    "s = set()\n",
    "print(\"adding set \",end = \"\")\n",
    "s.add(\"Horse\")\n",
    "print(s)\n",
    "print(\"Updateing Set: \",end = \"\")\n",
    "s.update([\"Mouse\",\"Lion\"])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**10. Write a Python program to get the intersection and Union in a set.**\n",
    "\n",
    "**Sample Input:**\n",
    "* color_set1 = set([\"green\", \"blue\"])\n",
    "* color_set2 = set([\"blue\", \"yellow\"])\n",
    "\n",
    "**Sample Output:** \n",
    "* blue\n",
    "* 'blue', 'yellow', 'green'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection  {'blue'}\n",
      "Union:  {'blue', 'green', 'yellow'}\n"
     ]
    }
   ],
   "source": [
    "set1 = set([\"green\", \"blue\"])\n",
    "set2 = set([\"blue\", \"yellow\"])\n",
    "\n",
    "print(\"Intersection \", set1 & set2)\n",
    "print(\"Union: \",set1 | set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}