Tasks_t7_collections.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "collections\n",
    "https://www.youtube.com/watch?v=QswQA1lRIQY"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Counter is subclass of dictionary object.\n",
    "It conatains all the methods of dictionary\n",
    "additional methods:\n",
    "Elements\n",
    "Most_common([n])\n",
    "Subtract([interable-or-mapping])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. using counter find the count of numner of 1's from one to 100\n",
    "# (ex: 21,11) no of 1's : 3\n",
    "from collections import Counter\n",
    "c = Counter(''.join(str(x) for x in range(1, 101)))\n",
    "print(c)\n",
    "# also find the top 5 most coomon numbers\n",
    "c.most_common(5)\n",
    "# subtract 9 one time and 8 two times\n",
    "d = Counter({'9': 1, '8': 2})\n",
    "print(c-d)\n",
    "# you can also try in any other ways to do it.."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Have you ever get keyerror when trying to access non existent key in dictionary.\n",
    "If you don't want that try defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. create a dictionary using defaultdict key as name and value as no of times it appears\n",
    "from collections import defaultdict, Counter\n",
    "names_list = \"Mike John Mike Anna Mike John John Mike Mike Britney Smith Anna Smith\"\n",
    "name_count = defaultdict(int)\n",
    "for name in names_list.split():\n",
    "    name_count[name] += 1\n",
    "\n",
    "print(name_count)\n",
    "print(name_count['Ravi']) "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "like lists dictionary can be ordered. wondered how, it's easy just use OrderdDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('a', 4), ('c', 3), ('b', 2), ('e', 2), ('d', 1), ('h', 1), ('ma', 1), ('n', 1), ('hello', 1)]\n",
      "OrderedDict([(1, 'a'), (2, 'c'), (3, 'b'), (4, 'e'), (5, 'd'), (6, 'h'), (7, 'ma'), (8, 'n'), (9, 'hello')])\n"
     ]
    }
   ],
   "source": [
    "# 3. create an Orderddict in the order of most frequent letter\n",
    "from collections import OrderedDict, Counter\n",
    "a_list = [\"a\",\"c\",\"c\",\"a\",\"b\",\"a\",\"a\",\"b\",\"c\", \"d\", \"e\", \"h\", \"e\", \"ma\",\"n\",\"hello\"]\n",
    "c = Counter(a_list)\n",
    "most_common = c.most_common()\n",
    "print(most_common)\n",
    "# print(c.most_common())\n",
    "d = OrderedDict()\n",
    "i = 1\n",
    "for ele, count in most_common:\n",
    "    d[i] = ele\n",
    "    i += 1\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The deque is a list optimized for inserting and removing items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 1, 7, 5, 1, 4, 4, 5, 9, 1, 2, 6]\n",
      "[9, 0, 1, 4, 8, 1, 4, 5, 9, 1, 2, 6]\n",
      "Popped ele-left: 9\n",
      "Popped ele-right: 6\n",
      "Popped ele-left: 0\n",
      "Popped ele-right: 2\n",
      "Popped ele-left: 1\n",
      "Popped ele-right: 1\n",
      "Popped ele-left: 4\n",
      "Popped ele-right: 9\n",
      "Popped ele-left: 8\n",
      "Popped ele-right: 5\n",
      "Popped ele-left: 1\n",
      "Popped ele-right: 4\n",
      "pop from an empty deque! Pop completed!\n"
     ]
    }
   ],
   "source": [
    "# 4. write a function it takes 3 lists as inputs\n",
    "# list 1 items have to add at end of list2\n",
    "# list 3 items have to add at begin of list1\n",
    "# to pop items from left and right alternatively\n",
    "# use try and except block catch indexerror\n",
    "# ex: [1,2,3,4,5,6] the order of items to pop 1,6,2,5,3,4\n",
    "from collections import deque\n",
    "\n",
    "def three_lists(lst_1, lst_2, lst_3):\n",
    "    lst_2 += lst_1\n",
    "    print(lst_2)\n",
    "    lst_1 = lst_3 + lst_1\n",
    "    print(lst_1)\n",
    "    d = deque(lst_1)\n",
    "    for count in range(len(d)):\n",
    "        try:\n",
    "            print(f'Popped ele-left: {d.popleft()}')\n",
    "            print(f'Popped ele-right: {d.pop()}')\n",
    "        except IndexError as error:\n",
    "            print(f'{error}! Pop completed!')\n",
    "            break\n",
    "        \n",
    "three_lists([4,5,9,1,2,6], [2,1,7,5,1,4], [9,0,1,4,8,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 8, 1, 2, 3, 4, 5, 6]\n",
      "[7, 8, 1, 2, 3, 4, 5, 6]\n",
      "[2, 3, 4, 5, 6, 7, 8, 1]\n"
     ]
    }
   ],
   "source": [
    "# 5.\n",
    "from collections import deque\n",
    "l1 = [1,2,3,4,5,6,7,8]\n",
    "# expetected output1 :  [7,8,1,2,3,4,5,6]\n",
    "d1 = deque(l1)\n",
    "d1.rotate(2)\n",
    "print(list(d1)) # using rotate \n",
    "\n",
    "print(l1[-2:]+ l1[:-2]) # using slicing\n",
    "\n",
    "\n",
    "# expetected output2 :  [2,3,4,5,6,7,8,1]\n",
    "l2 = [1,2,3,4,5,6,7,8]\n",
    "d2 = deque(l2)\n",
    "d2.append(d2.popleft())\n",
    "print(list(d2))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "if you wanna see several dictionaries in a single view ChainMap helps..\n",
    "the ouput is a list of dictionaries\n",
    "the last dictionary is parent and remaining all childs\n",
    "parent dict in chainmap never changes\n",
    "new dictinoary can be added using new_child method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'c': 3, 'b': 4}, {'a': 1, 'b': 2}]\n",
      "['c', 'b', 'a']\n",
      "[3, 4, 1]\n",
      "[{'d': 5, 'a': 6}, {'c': 3, 'b': 4}, {'a': 1, 'b': 2}]\n",
      "['b', 'a', 'd', 'c']\n",
      "[4, 6, 5, 3]\n",
      "None\n",
      "[{'d': 5, 'a': 6}, {'c': 3, 'b': 4}, {'a': 1, 'b': 2, 'e': 5}]\n"
     ]
    }
   ],
   "source": [
    "# 6.\n",
    "from collections import ChainMap\n",
    "d1 = {'a':1, 'b':2}\n",
    "d2 = {'c':3, 'b':4}\n",
    "ch = ChainMap(d2, d1)\n",
    "print(ch.maps)\n",
    "print(list(ch.keys()))\n",
    "print(list(ch.values()))\n",
    "# create chainmap using d1 as parent\n",
    "# print keys\n",
    "# print values\n",
    "\n",
    "d3 = {'d':5,'a':6}\n",
    "chain = ch.new_child(d3)\n",
    "print(chain.maps)\n",
    "print(list(chain.keys()))\n",
    "print(list(chain.values()))\n",
    "# print chainmap\n",
    "# print keys\n",
    "# print values\n",
    "\n",
    "# update d1 with \"e\":5\n",
    "print(chain.parents.parents.update({'e': 5}))\n",
    "\n",
    "# print chainmap\n",
    "print(chain.maps)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "One of the biggest problems with ordinary tuples is that you have to remember the index of each field of a tuple object. \n",
    "This is obviously difficult. The namedtuple was introduced to solve this problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "OrderedDict([('red', 20), ('blue', 30), ('green', 40)])\n",
      "OrderedDict([('red', 20), ('blue', 30), ('green', 60)])\n"
     ]
    }
   ],
   "source": [
    "# 7.\n",
    "from collections import namedtuple\n",
    "# create a namedtuple object color with fileds red blue green\n",
    "a = namedtuple('color', 'red blue green')\n",
    "# create an instance of named tuple using 55,100,20 values\n",
    "s = a(55, 100, 20)\n",
    "# access blue color from instance\n",
    "print(s.blue)\n",
    "# [20,30,40] with this list cfreate named tuple instance\n",
    "s1 = a(20, 30, 40)\n",
    "# convert instance to dictinoary\n",
    "ord_dict = s1._asdict()\n",
    "print(ord_dict)\n",
    "# replace the green color value with 60\n",
    "ord_dict['green'] = 60 \n",
    "print(ord_dict)"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}