python_list_operation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python List Operations\n",
    "\n",
    "**This note summarizes some very useful operations on list. Including:**\n",
    "- Access items from list: `indexing`, `slicing`\n",
    "- Remove duplicated items from list: `set()`, `dict.fromkeys()`\n",
    "- Count number of occurance of item in list: `.count()`\n",
    "- Delete items from list: `.pop()`, `.remove()` \n",
    "- Add items into list: `.insert()`, `.append()`, `.entend()`, `+`, `*` \n",
    "- Sort list in certain order: `.sort()`, `sorted()`\n",
    "- Logical operations between lists: `<`, `<=`, `>`, `>=`, `!=`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slice list by index `list[start:stop:step]`\n",
    "**Note**: Item at the start position is included in the returned list, but he item at the stop position is not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'd', 'e', 'f']"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "lst[2:6:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'e']"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "lst[2:6:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make the list go backward by setting `start > end` index and `step < 0`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['g', 'f', 'e', 'd']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "lst[6:2:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['g', 'f', 'e']"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "lst[-1:-4:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `set()` and `dict.fromkeys()` remove the duplicated items from list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['flowers', 'orange', 'gold', 'metal', 'apple']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'gold', 'metal', 'gold']\n",
    "list(set(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**To maintain the order of items in the list:** use the builtin dictionary (>= Python 3.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'orange', 'gold', 'flowers', 'metal']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(dict.fromkeys(lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.count()` returns count of how many times obj occurs in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'gold', 'metal', 'gold']\n",
    "lst.count('gold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'flowers': 1, 'orange': 1, 'gold': 3, 'metal': 1, 'apple': 2}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['apple', 'orange', \n",
    "       'gold', 'flowers',\n",
    "       'gold', 'metal', \n",
    "       'gold', 'apple']\n",
    "{item: lst.count(item) for item in set(lst)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.index()` finds the index of an item in the list\n",
    "\n",
    "**Note**: it only return the index of the first match: A call to index searches through the list in order until it finds a match, and stops there. <br>\n",
    "If you expect to need indices of more matches, you should use a list comprehension, or generator expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'silver', 'metal']\n",
    "lst.index('gold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'silver', 'metal', 'gold']\n",
    "lst.index('gold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'silver', 'metal', 'gold']\n",
    "[index for index, item in enumerate(lst) if item == 'gold']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.remove()` removes an item from list by value\n",
    "**Note** it only remove the first match and stop there, to remove all occurances of a value, consider using list comprehension or loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'flowers', 'silver', 'metal']\n"
     ]
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'silver', 'metal']\n",
    "lst.remove('gold')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'flowers', 'silver', 'metal', 'gold']\n"
     ]
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'silver', 'metal', 'gold']\n",
    "lst.remove('gold')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'orange', 'flowers', 'silver', 'metal']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'silver', 'metal', 'gold']\n",
    "[item for item in lst if item != 'gold']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'orange', 'flowers', 'silver', 'metal']\n"
     ]
    }
   ],
   "source": [
    "lst = ['apple', 'orange', 'gold', 'flowers', 'silver', 'metal', 'gold']\n",
    "while 'gold' in lst: lst.remove('gold')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.pop()` removes and returns last value from the list or the given index value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Pops and removes the last element by default \n",
    "lst = [ 1, 2, 3, 4, 5, 6 ] \n",
    "print(lst.pop()) \n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "lst = [ 1, 2, 3, 4, 5, 6 ] \n",
    "print(lst.pop(0)) \n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[[4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "lst = [[1, 2, 3], [4, 5, 6]] \n",
    "print(lst.pop(0)) \n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.insert()`: insert an item at a given position (index) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "lst = [ 1, 2, 3, 4, 5, 6 ] \n",
    "lst.insert(0, 0)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'Hi', 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "lst = [ 1, 2, 3, 4, 5, 6 ] \n",
    "lst.insert(3, 'Hi')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.append()`: adds its argument as a single element to the end of a list. \n",
    "The length of the list increases by **one**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Thalia', 'likes', 'lasagna']\n"
     ]
    }
   ],
   "source": [
    "lst = ['Thalia', 'likes']\n",
    "lst.append('lasagna')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Thalia', 'likes', ['lasagna', 'hotpot']]\n"
     ]
    }
   ],
   "source": [
    "lst = ['Thalia', 'likes']\n",
    "lst.append(['lasagna', 'hotpot'])\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.extend()`: iterates over its argument and adding each element to the end of the list\n",
    "The length of the list increases by number of elements in it’s argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Thalia', 'likes', 'lasagna', 'hotpot']\n"
     ]
    }
   ],
   "source": [
    "lst = ['Thalia', 'likes']\n",
    "lst.extend(['lasagna', 'hotpot'])\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We can use `+` sign to concatenate two lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] + [4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Thalia', 'likes', 'lasagna', 'hotpot']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['Thalia', 'likes'] + ['lasagna', 'hotpot']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### We can use `*` sign to replicate list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ha', 'Ha', 'Ha', 'Ha', 'Ha']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['Ha'] * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `.sort()` method sorts the elements of a given list in a specific order - Ascending or Descending\n",
    "\n",
    "**Note**: It modifies the list in-place and returns `None`. It only works on `list` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "lst = [2, 1, 9, 8, 10] \n",
    "print(lst.sort()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "lst = [2, 1, 9, 8, 10] \n",
    "lst.sort()\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings will be sorted in alphabetical order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'e', 'i', 'o', 'u']\n"
     ]
    }
   ],
   "source": [
    "vowels = ['e', 'a', 'u', 'o', 'i']\n",
    "vowels.sort()\n",
    "print(vowels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'cherry', 'guawa', 'peach']\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'peach', 'guawa', 'banana', 'cherry']\n",
    "fruits.sort()\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using `.sort()` method, the list has to have only one data type. A mix of string and numbers will result in `Type error`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-27-a230b900f48c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mfruits\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'apple'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'peach'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'guawa'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'banana'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'cherry'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m17\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m20\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mfruits\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msort\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: '<' not supported between instances of 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'peach', 'guawa', 'banana', 'cherry', 2, 17, 20]\n",
    "fruits.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `sorted()` function returns a new sorted list\n",
    "**Note**: It words accpets any iterable object like list, tuple, dictionary, etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 8, 9, 10]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [2, 1, 9, 8, 10] \n",
    "sorted(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('John', 'CU', 'NY', 19),\n",
       " ('Vivian', 'UCLA', 'CA', 22),\n",
       " ('Thalia', 'UW', 'WA', 26)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "members_tuples = [('Thalia', 'UW', 'WA', 26),\n",
    "                  ('Vivian', 'UCLA', 'CA', 22),\n",
    "                  ('John', 'CU', 'NY', 19)]\n",
    "sorted(members_tuples, key=lambda x: x[3]) # Sort by age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Thalia', 'UW', 'WA', 26),\n",
       " ('Vivian', 'UCLA', 'CA', 22),\n",
       " ('John', 'CU', 'NY', 19)]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(members_tuples, key=lambda x: x[3], reverse=True) # In decending order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You can compare two lists using logical operator\n",
    "- The first value will be compared first, then second,...\n",
    "- For the lists with different length, only the matching ones will be compared.\n",
    "- Still, the string will be compared in alphabetical order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] < [1, 3, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] <= [1, 1, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3] < [2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', 'e', 'f'] < ['b', 'e', 'f']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', 'e', 'f'] < ['b', 'a', 'f']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', 'e', 'f'] < ['b', 'a', 'a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', '2', 'b'] < ['a', '3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', '2', 'b'] != ['a', '3']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The order matters when check for equality**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', '2', 'b'] == ['a', 'b', '2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', '2', 'b'] <= ['a', 'b', '2']"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}