basic_collections.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Motivation\n",
    "\n",
    "Correct usage of built-in types best matching the task:\n",
    "- Increases code readability.\n",
    "- Makes it easier to use connected existing Python features.\n",
    "- Makes it easier to test.\n",
    "- Reduces \"re-invention of wheel\".\n",
    "\n",
    "# Collection data types\n",
    "Following will be discussed: list, tuple, set, dictionary\n",
    "\n",
    "## Common features\n",
    "### Length:\n",
    "https://docs.python.org/3.10/reference/datamodel.html#object.__len__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of (1, 2) is 2\n",
      "Length of [1, 2, 3] is 3\n",
      "Length of {1, 2, 3, 4} is 4\n",
      "Length of {'1': 1, '2': 2, 3: 3, 4: 4, 5: 5} is 5\n"
     ]
    }
   ],
   "source": [
    "collections = [(1,2),[1,2,3], {1,2,3,4}, {\"1\":1,\"2\":2,3:3,4:4,5:5}]\n",
    "for collection in collections:\n",
    "    print(f\"Length of {collection} is {len(collection)}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "They implement __ len__() method\n",
    "\n",
    "### Iterables\n",
    "https://docs.python.org/3.10/reference/datamodel.html#object.__iter__  \n",
    "( https://docs.python.org/3.10/library/stdtypes.html#iterator.__next__ )\n",
    "\n",
    "**You can call:**\n",
    "\n",
    "    iter(specific_collection_insatnce)\n",
    "\n",
    "They implement __ iter__() method, which return iterator (which implements __ next__() ).  \n",
    "This allows them to be used in for loop - which can be imagined like this:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterate through (1, 2)\n",
      "1\n",
      "2\n",
      "Iterate through [1, 2, 3]\n",
      "1\n",
      "2\n",
      "3\n",
      "Iterate through {1, 2, 3, 4}\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Iterate through {'1': 1, '2': 2, 3: 3, 4: 4, 5: 5}\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for collection in collections:\n",
    "    iterator = iter(collection)\n",
    "    print(f\"Iterate through {collection}\")\n",
    "    while True:\n",
    "        try:\n",
    "            item_from_collection = next(iterator)\n",
    "\n",
    "        except StopIteration:\n",
    "            break\n",
    "        print(item_from_collection)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Which is the same as:**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterate through (1, 2)\n",
      "1\n",
      "2\n",
      "Iterate through [1, 2, 3]\n",
      "1\n",
      "2\n",
      "3\n",
      "Iterate through {1, 2, 3, 4}\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Iterate through {'1': 1, '2': 2, 3: 3, 4: 4, 5: 5}\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for collection in collections:\n",
    "    print(f\"Iterate through {collection}\")\n",
    "    for item_from_collection in collection:\n",
    "        print(item_from_collection)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Membership tests\n",
    "https://docs.python.org/3.10/reference/expressions.html#membership-test-details  \n",
    "https://docs.python.org/3.10/reference/datamodel.html#object.__contains__\n",
    "\n",
    "Can be used in membership tests:"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is 1 in (1, 2)?\n",
      "True\n",
      "Is 1 in [1, 2, 3]?\n",
      "True\n",
      "Is 1 in {1, 2, 3, 4}?\n",
      "True\n",
      "Is 1 in {'1': 1, '2': 2, 3: 3, 4: 4, 5: 5}?\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "tested_value = 1\n",
    "for collection in collections:\n",
    "    result = tested_value in collection\n",
    "    print(f\"Is {tested_value} in {collection}?\")\n",
    "    print(result)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Each collection in detail:\n",
    "\n",
    "### List\n",
    "https://docs.python.org/3/library/stdtypes.html#list\n",
    "- mutable\n",
    "- ordered\n",
    "- allows duplicate values"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "my_list1 = [1,2,3]\n",
    "my_list2 = list((1,2,3))\n",
    "my_list3 = [x+1 for x in (0,1,2)]\n",
    "print(my_list1, my_list2, my_list3, sep=\"\\n\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### (Short detour)\n",
    "#### **Mutable**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "data": {
      "text/plain": "2280553840880"
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=1\n",
    "id(a)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "2280553840912"
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a+=1\n",
    "id(a)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "data": {
      "text/plain": "2278489437568"
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[0,1,2]\n",
    "id(a)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "data": {
      "text/plain": "2278489437568"
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0]=6\n",
    "id(a)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Odered"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "data": {
      "text/plain": "False"
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[0,1,2] == [2,1,0]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[0,1,2] == [0,1,2]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### allows duplicate values"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "data": {
      "text/plain": "[1, 1, 1]"
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,1,1]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Tuple\n",
    "https://docs.python.org/3/library/stdtypes.html#tuple\n",
    "- immutable\n",
    "- ordered\n",
    "- allows duplicate values"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "(1, 2, 3)\n",
      "(1, 2, 3)\n",
      "(1, 2, 3)\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "my_tuple1 = (1,2,3)\n",
    "my_tuple2 = 1,2,3\n",
    "my_tuple3 = tuple([1,2,3])\n",
    "my_tuple4 = tuple(x+1 for x in range(3))\n",
    "my_tuple5 = *(x+1 for x in range(3)),\n",
    "\n",
    "print(my_tuple1, my_tuple2, my_tuple3, my_tuple4, my_tuple5, sep=\"\\n\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Dict (and specialized OrderedDict, DeafultDict, Counter)\n",
    "https://docs.python.org/3/library/stdtypes.html#dict\n",
    "\n",
    "**key**:value pairs\n",
    "\n",
    "- mutable\n",
    "- preserve insertion order (guaranteed since Python3.7.)\n",
    "- not ordered\n",
    "- does not allow duplicate keys  (allows duplicate values)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n",
      "{}\n",
      "{'a': 1}\n",
      "{'a': 1, 'b': 2}\n",
      "{'a': 1, 'b': 2}\n"
     ]
    }
   ],
   "source": [
    "my_dict1 = {}\n",
    "my_dict2 = dict()\n",
    "my_dict3 = {\"a\":1}\n",
    "my_dict4 = {a:b for a,b in ((\"a\",1), (\"b\",2))}\n",
    "my_dict5 = dict(((\"a\",1), (\"b\",2)))\n",
    "\n",
    "print(my_dict1, my_dict2 , my_dict3, my_dict4, my_dict5, sep=\"\\n\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Order:**"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"a\":1, \"b\":2} == {\"b\":2, \"a\":1} # True -> not ordered."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "data": {
      "text/plain": "{'a': 1, 'b': 2}"
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"a\":1, \"b\":2}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "{'b': 2, 'a': 1}"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"b\":2, \"a\":1}"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "False"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "OrderedDict({\"a\":1, \"b\":2}) == OrderedDict({\"b\":2, \"a\":1}) # False -> ordered"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict = {\"a\":1, \"b\":2}\n",
    "list(my_dict) == [\"a\", \"b\"] # But preserves insertion order."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Does not allow duplicate keys**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [
    {
     "data": {
      "text/plain": "{'a': 2}"
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{\"a\":1, \"a\":2} # Later value overwrites earlier value"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Composing dicts**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "outputs": [
    {
     "data": {
      "text/plain": "{'a': 1, 'b': 3, 'c': 4}"
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a={\"a\":1, \"b\":2}\n",
    "b={\"a\":1, \"b\":3, \"c\": 4}\n",
    "c={**a, **b}\n",
    "c"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Iterating over dicts:**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "for key in c:\n",
    "    print(key)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": 22,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for value in c.values():\n",
    "    print(value)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1\n",
      "b 3\n",
      "c 4\n"
     ]
    }
   ],
   "source": [
    "for key, value in c.items():\n",
    "    print(key, value)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Non pythonic:**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for key in c:\n",
    "    print(c[key])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Specialized variants:\n",
    "\n",
    "- **OrderedDict**  \n",
    "https://docs.python.org/3/library/collections.html#collections.OrderedDict\n",
    "  - mutable\n",
    "  - ordered\n",
    "  - does not allow duplicate values\n",
    "\n",
    "- **others**  \n",
    "https://docs.python.org/3/library/collections.html#collections.defaultdict  \n",
    "https://docs.python.org/3/library/collections.html#collections.Counter"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "outputs": [],
   "source": [
    "from collections import Counter"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "outputs": [
    {
     "data": {
      "text/plain": "Counter({1: 3, 2: 2, 3: 1, 5: 1, 6: 1, 7: 1, 8: 1})"
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter([1,2,3,1,5,6,7,8,1,2])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "outputs": [
    {
     "data": {
      "text/plain": "Counter({'C': 1,\n         'o': 1,\n         'u': 1,\n         'n': 1,\n         't': 3,\n         ' ': 1,\n         'l': 1,\n         'e': 2,\n         'r': 1,\n         's': 1})"
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(\"Count letters\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "outputs": [],
   "source": [
    "from collections import defaultdict"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "defaultdict(<function <lambda> at 0x0000021280924CA0>, {})\n"
     ]
    }
   ],
   "source": [
    "my_default_dict = defaultdict(lambda: \"DefaultValue\")\n",
    "print(my_default_dict)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "data": {
      "text/plain": "'DefaultValue'"
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_default_dict[5]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "outputs": [
    {
     "data": {
      "text/plain": "defaultdict(<function __main__.<lambda>()>, {5: 'DefaultValue'})"
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_default_dict"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Set\n",
    "https://docs.python.org/3/library/stdtypes.html#set  \n",
    "**Very fast in membership tests.**\n",
    "\n",
    "- mutable (but can contain only hashable items)\n",
    "- not ordered\n",
    "- does not allow duplicate values"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n",
      "{1, 2}\n"
     ]
    }
   ],
   "source": [
    "my_set1 = set()\n",
    "my_set2 = {1, 2}\n",
    "print(my_set1, my_set2, sep=\"\\n\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Fast membership tests**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "data": {
      "text/plain": "(100000, 100000)"
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "example_set = set(random.sample(range(1_000_000), 100_000))\n",
    "example_list = list(example_set)\n",
    "(len(example_set),len(example_list))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32.7 ns ± 0.0912 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "1 in example_set"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.17 ms ± 241 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "1 in example_list"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Set operations examples:**"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "outputs": [
    {
     "data": {
      "text/plain": "{1, 2}"
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1= {1,2,3}\n",
    "set2= {1,2,4,5}\n",
    "set1 & set2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "outputs": [
    {
     "data": {
      "text/plain": "{1, 2, 3, 4, 5}"
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 | set2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "outputs": [
    {
     "data": {
      "text/plain": "{3}"
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 - set2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "outputs": [
    {
     "data": {
      "text/plain": "{3, 4, 5}"
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 ^ set2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "outputs": [
    {
     "data": {
      "text/plain": "False"
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 < set2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "outputs": [
    {
     "data": {
      "text/plain": "False"
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 > set2"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1 < (set1 | set2)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "outputs": [
    {
     "data": {
      "text/plain": "False"
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set1.isdisjoint(set2)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "- **frozenset**  \n",
    "https://docs.python.org/3/library/stdtypes.html#frozenset\n",
    "  - immutable\n",
    "  - not ordered\n",
    "  - does not allow duplicate values\n",
    "\n",
    "\n",
    "# Proper usage of built-in types communicates purpose!\n",
    "\n",
    "Using correct collection reduces required knowledge of the context information! (You do not need to remember that a particular list contains only unique and not ordered items if you use set directly.)\n",
    "\n",
    "You can use lists almost everywhere instead of sets or tuples, but using lists communicates to the reader: **mutable, ordered, with duplicates.**\n",
    "\n",
    "For example using list in place of frozenset will work in most cases, but it will communicate completely wrong message.\n",
    "\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}