17. Type Conversions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Type Conversion\n",
    "1. To int\n",
    "\n",
    "2. To str\n",
    "\n",
    "3. To list\n",
    "\n",
    "4. To dict\n",
    "\n",
    "5. To tuple\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X : 12\n",
      "Y : 12\n"
     ]
    }
   ],
   "source": [
    "x = input(\"X : \")\n",
    "#print(type(x))\n",
    "y = input(\"Y : \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1212\n"
     ]
    }
   ],
   "source": [
    "print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "x = int(x)\n",
    "y = int(y)\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "x = input()\n",
    "x = int(x,16) # base 16\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43981\n"
     ]
    }
   ],
   "source": [
    "x = \"             ABCD        \"\n",
    "y = int(x,16)  # we passing the base of given string\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44177065300\n"
     ]
    }
   ],
   "source": [
    "y = \"101001001001001010001000010101010100\"\n",
    "x = int(y,2)  # here we passing the base of given input like it is in binary format so we pass 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "124374539524\n"
     ]
    }
   ],
   "source": [
    "y = \"124374539524\"\n",
    "print(int(y,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0b1111\n",
      "0xf\n",
      "0o17\n"
     ]
    }
   ],
   "source": [
    "x = 15\n",
    "y = bin(x)\n",
    "z = hex(x)\n",
    "p = oct(x)\n",
    "print(y)\n",
    "print(z)\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anythi\n",
      "[1, 23, 4, 5, 46, 45] <class 'str'>\n",
      "(12454, 'hello', 'hi', 1, 23) <class 'str'>\n",
      "{'one': 1, 'two': 2, 'three': 3, 'asas': 7845}\n",
      "ne': \n",
      "},2:'owt',1:'eno'{\n"
     ]
    }
   ],
   "source": [
    "x = str('anythi')\n",
    "a = str([1,23,4,5,46,45])\n",
    "b = str((12454,'hello','hi',1,23))\n",
    "c = str({ 'one' : 1,'two':2,'three':3,\"asas\":7845})\n",
    "print(x)\n",
    "print(a,type(a))\n",
    "print(b,type(b))\n",
    "print(c)\n",
    "print(c[3:8])\n",
    "s = \"{'one':1,'two':2,}\"\n",
    "print(s[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#list(seqqence)\n",
    "t = (1,2,3,5,'hello','hi')\n",
    "s = 'hello world'\n",
    "d = { 'one':1,'two':2,'hello':'hi'}\n",
    "s1 = { 1,2,3,'hello' }\n",
    "a = list(t)\n",
    "b = list(s)\n",
    "c = list(d)\n",
    "d = list(s1)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 1, 'name': 'python', 'version': 3.6}\n",
      "{12: 10}\n",
      "{'h': 'i', 'b': 'y', '1': '2', '3': '4'}\n",
      "{'one': 1, 'name': [1, 2, 3], 'version': 3.6, 'p': 'y'}\n"
     ]
    }
   ],
   "source": [
    "#list tuple only can be converted to dictionary\n",
    "#list() ()\n",
    "#tuple() []\n",
    "l = [ ('one',1), ('name','python'), ('version',3.6) ]\n",
    "d = dict(l)\n",
    "print(d)\n",
    "s=(('he','sq'),[1,5],{4:5,8:3})#dict\n",
    "s=(('he','sq'),[1,5],{4,8})#set\n",
    "s=[(12,10)] #correct\n",
    "s2=[12,10] #wrong\n",
    "#those elements are iterable only that can be converted to dictionary \n",
    "#like 'str' list tuple not a digit numbers\n",
    "\n",
    "print(dict(s))\n",
    "l2 =  dict(( ['one',1], ('name',[1,2,3]), ('version',3.6), 'py' ))\n",
    "l = [ 'hi','by','12','34']\n",
    "k = dict(l)\n",
    "print(k)\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'h', 'p', 'o', 'y', 'n', 't'}\n",
      "{1, 2, 3, 4, 5}\n",
      "{1, 2, 'three'}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "k = set('python')\n",
    "l = set([1,2,3,4,5,1])\n",
    "p = set({1:'one',2:'two','three':3})\n",
    "print(k)\n",
    "print(l)\n",
    "print(p)\n",
    "print(type(p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['name', 'version', 'module', 'father', 'key1', 'hello', 'one', 2]\n",
      "['Monty Python', 3.6, ['numpy', 'scipy', 'matplotlib', 'pandas'], 'Guido Van Rossum', 'value1', 'hi', 1, 'two']\n",
      "[('name', 'Monty Python'), ('version', 3.6), ('module', ['numpy', 'scipy', 'matplotlib', 'pandas']), ('father', 'Guido Van Rossum'), ('key1', 'value1'), ('hello', 'hi'), ('one', 1), (2, 'two')]\n"
     ]
    }
   ],
   "source": [
    "data = {'name': 'Monty Python',\n",
    " 'version': 3.6,\n",
    " 'module': ['numpy', 'scipy', 'matplotlib', 'pandas'],\n",
    " 'father': 'Guido Van Rossum',\n",
    " 'key1': 'value1',\n",
    " 'hello': 'hi',\n",
    " 'one': 1,\n",
    " 2: 'two'}\n",
    "\n",
    "l1 = list(data.keys()) #keys\n",
    "l2 = list(data.values()) #values\n",
    "l3 = list(data.items()) #key-value pair\n",
    "print(l1)\n",
    "print(l2)\n",
    "print(l3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#swapping two numbers\n",
    "x = 5\n",
    "y = 6\n",
    "x,y = y,x\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Sets Practice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "s = set(map(int, input().split()))\n",
    "for i in range(n):\n",
    "    x = input().split()\n",
    "    if x[0]=='discard':\n",
    "        s.discard(int(x[1]))\n",
    "    elif x[0] == 'remove':\n",
    "        s.remove(int(x[1]))\n",
    "    elif x[0] == 'pop':\n",
    "        s.pop()\n",
    "print(sum(s))\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Enumerate it return indexes\n",
    "print(list(enumerate([1,2,3,4,5,6,5,5,5,5])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=set('Rank')\n",
    "b=set('HackerRank')\n",
    "print(a.intersection({'Rank':1}))\n",
    "\n",
    "d={'Rank':1}\n",
    "for i in d:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Intersection\n",
    "\n",
    "a=int(input())\n",
    "ar=set(map(int,input().split()))\n",
    "b=int(input())\n",
    "br=set(map(int,input().split()))\n",
    "print(len(ar.intersection(br)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# symmetric metrix\n",
    "# a.symmetric_difference(b) = (A U B ) - (A intersection B)\n",
    "#Intersection\n",
    "\n",
    "a=int(input())\n",
    "ar=set(map(int,input().split()))\n",
    "b=int(input())\n",
    "br=set(map(int,input().split()))\n",
    "print(len(ar.symmetric_difference(br)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q={1,2,9,3}\n",
    "a={9,9}\n",
    "#q.update(a)  # it update q to union of 'a' and 'q'\n",
    "#q.intersection_update(a) # it update 'q' to only elements which are common between them\n",
    "#q.difference_update(a) # except common all elements updates to q\n",
    "q.symmetric_difference_update(a)\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "a = set(map(int,input().split()))\n",
    "n = int(input())\n",
    "for i in range(n):\n",
    "    f = list(input().split())\n",
    "    s = set(map(int,input().split()))\n",
    "    if f[0]=='symmetric_difference_update':\n",
    "        a.symmetric_difference_update(s)\n",
    "    elif f[0]=='difference_update':\n",
    "        a.difference_update(s)\n",
    "    elif f[0]=='update':\n",
    "        a.update(s)\n",
    "    elif f[0]=='intersection_update':\n",
    "        a.intersection_update(s)\n",
    "print(sum(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a={1,2,3,1,2,3}\n",
    "print(enmurate(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "#Captain room\n",
    "n=int(input())\n",
    "l=list(map(int,input().split()))\n",
    "s=set(l)\n",
    "d={}\n",
    "for i in s:\n",
    "     d[l.count(i)] = i         \n",
    "print(d[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81\n",
      "70\n",
      "71\n",
      "72\n",
      "73\n",
      "74\n",
      "75\n",
      "76\n",
      "77\n",
      "78\n",
      "79\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "a = 'a'  # F\n",
    "print(ord('Q'))\n",
    "for i in range(ord('F'),ord('Q')):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "420\n"
     ]
    }
   ],
   "source": [
    "chr(100) #d  #100*4+20\n",
    "chr(4) #\\x04\n",
    "chr(20) # \\x14\n",
    "ord('d')*ord('\\x04')+ord('\\x14')\n",
    "a = (int((ord(\"d\") * ord(\"\\x04\")) + ord(\"\\x14\")))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "420\n",
      "100\n",
      "100\n",
      "100\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "print(sum(ord(x) for x in 'dddx'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object saving using pickle "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "class Company(object):\n",
    "    def __init__(self, name, value):\n",
    "        self.name = name\n",
    "        self.value = value\n",
    "\n",
    "with open('company_data.pkl', 'wb') as output:\n",
    "    company1 = Company('banana', 40)\n",
    "    pickle.dump(company1, output, pickle.HIGHEST_PROTOCOL)\n",
    "\n",
    "    company2 = Company('spam', 42)\n",
    "    pickle.dump(company2, output, pickle.HIGHEST_PROTOCOL)\n",
    "\n",
    "del company1\n",
    "del company2\n",
    "\n",
    "with open('company_data.pkl', 'rb') as input:\n",
    "    company1 = pickle.load(input)\n",
    "    print(company1.name)  # -> banana\n",
    "    print(company1.value)  # -> 40\n",
    "\n",
    "    company2 = pickle.load(input)\n",
    "    print(company2.name) # -> spam\n",
    "    print(company2.value)  # -> 42"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}