python-data-structures-list.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# List in Python\n",
    "\n",
    "This is a companion notebook to the [Data Science Solutions](https://startupsci.com) book.\n",
    "\n",
    "List is one of the fundamental and powerful data structures natively available in Python. Understanding how List works, will help us understand rest of the Python data structures.\n",
    "\n",
    "Learning goals in this notebook.\n",
    "\n",
    "- Defining a list\n",
    "- Traversing a list\n",
    "- Changing items in a list\n",
    "- Functional programming with lists\n",
    "- Stacks as lists\n",
    "- Create lists using comprehensions\n",
    "- Packing and unpacking lists\n",
    "- Sequences in Python\n",
    "- Performance of lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a list\n",
    "\n",
    "You can easily define a list as a comma-separated set of values within square [ ] brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1, 3, 5, 9, 6, 3, 9]"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a list of integers\n",
    "number_list = [3, 2, 1, 3, 5, 9, 6, 3, 9]\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Jan', 'Feb', 'Mar', 'Apr']"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List can contain strings\n",
    "word_list = ['Jan', 'Feb', 'Mar', 'Apr']\n",
    "word_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'Jan', 2, 'Feb', 3, 'Mar']"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List can contain mixed data types\n",
    "mixed_list = [1, 'Jan', 2, 'Feb', 3, 'Mar']\n",
    "mixed_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'Jan'], [2, 'Feb'], [3, 'Mar']]"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Lists can be n-dimensional or list of lists of...\n",
    "matrix_list = [[1, 'Jan'], [2, 'Feb'], [3, 'Mar']]\n",
    "matrix_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'Jan', ['Mon', 'Tue']],\n",
       " [2, 'Feb', ['Wed', 'Thu']],\n",
       " [3, 'Mar', ['Fri', 'Sat']]]"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_3d = [[1, 'Jan', ['Mon', 'Tue']], \n",
    "           [2, 'Feb', ['Wed', 'Thu']], \n",
    "           [3, 'Mar', ['Fri', 'Sat']]]\n",
    "list_3d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Traversing a list\n",
    "\n",
    "List traversal includes syntax to learn more about, find, and slice items in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First item on the list starts at 0 index\n",
    "number_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Last item on the list starts at -1 index\n",
    "number_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fri'"
      ]
     },
     "execution_count": 247,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Refer list of lists items using index\n",
    "list_3d[2][2][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Feb', 'e')\n"
     ]
    }
   ],
   "source": [
    "# String is a list of characters, can refer using index\n",
    "print(word_list[1], word_list[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1, 3, 5, 9]"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing first 6 items in the list\n",
    "number_list[:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 6, 3, 9]"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Last 4 items in the list\n",
    "number_list[-4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3 items (5-2) starting from 2 index\n",
    "number_list[2:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find first index of an item\n",
    "number_list.index(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Length of list\n",
    "len(number_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count of items in the list\n",
    "number_list.count(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Max item in list\n",
    "max(number_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Min item in list\n",
    "min(number_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing items in a list\n",
    "\n",
    "Python List is mutable. Python provides methods on List objects for changing the items within the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 1, 3, 5, 9, 6, 3, 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[3, 2, 1, 3, 5, 9, 6, 3, 9, 10]"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Append an item to the list\n",
    "print(number_list)\n",
    "number_list.append(10)\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1, 3, 5, 9, 6, 3, 9, 10, 13, 15, 15, 12]"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Extend list with another list\n",
    "number_list.extend([13, 15, 15, 12])\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1, 3, 5, 19, 9, 6, 3, 9, 10, 13, 15, 15, 12]"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Insert at index i, an item n to the list (i, n)\n",
    "number_list.insert(5, 19)\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 1, 3, 5, 19, 6, 3, 9, 10, 13, 15, 15, 12]"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Remove first occurance of an item from the list\n",
    "number_list.remove(9)\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 2, 1, 3, 5, 6, 3, 9, 10, 13, 15, 15, 12]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Remove at index, an item from the list, return removed item\n",
    "last_item = number_list.pop(5)\n",
    "print(number_list)\n",
    "last_item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 3, 5, 6, 3, 9, 10, 13, 15, 15, 12]"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Delete a slice from the list\n",
    "del number_list[1:3]\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 3, 5, 6, 3, 9, 10, 13, 15, 15, 12]"
      ]
     },
     "execution_count": 263,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Replace an item in the list\n",
    "number_list[0] = 7\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[31, 42, 91, 6, 3, 9, 10, 13, 15, 15, 12]"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Replace a slice in the list\n",
    "number_list[:3] = [31, 42, 91]\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 6, 9, 10, 12, 13, 15, 15, 31, 42, 91]"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sort list\n",
    "number_list.sort()\n",
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[91, 42, 31, 15, 15, 13, 12, 10, 9, 6, 3]"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reverse list\n",
    "number_list.reverse()\n",
    "number_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functional programming with lists\n",
    "\n",
    "Using `filter`, `map`, and `reduce` functional programming methods with List can be a powerful and concise coding technique for list operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[91, 42, 31, 15, 15, 13, 12, 10, 9, 6, 3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[91, 31, 15, 15, 13, 9, 3]"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Filter list to apply functional checks on all list items\n",
    "def odds(x): return (x % 2) != 0\n",
    "odds_list = filter(odds, number_list)\n",
    "print(number_list)\n",
    "odds_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8281, 1764, 961, 225, 225, 169, 144, 100, 81, 36, 9]"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Map list to apply operations on all list items\n",
    "def squares(x): return (x ** 2)\n",
    "squares_list = map(squares, number_list)\n",
    "squares_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[91, 42, 31, 15, 15, 13, 12, 10, 9, 6, 3]"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Map multiple lists to combine into one\n",
    "def divide(x, y): return (x / y)\n",
    "original_list = map(divide, squares_list, number_list)\n",
    "original_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "247"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reduce list to one item\n",
    "def total(x, y): return (x + y)\n",
    "totalled = reduce(total, number_list)\n",
    "totalled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacks as lists\n",
    "\n",
    "Using the List methods `append()` and `pop()` you can easily implement a *last-in, first-out* Stack data structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[91, 42, 31, 15, 15, 13, 12, 10, 9, 6, 3, 21, 23]"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stack = number_list\n",
    "\n",
    "# Push two items at the end or top of the stack\n",
    "stack.append(21)\n",
    "stack.append(23)\n",
    "stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[91, 42, 31, 15, 15, 13, 12, 10, 9, 6, 3, 21]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pop one item from the end or top of the stack\n",
    "popped_item = stack.pop()\n",
    "print(stack)\n",
    "popped_item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create lists using comprehensions\n",
    "\n",
    "List comprehensions are concise way to create new lists where items of the new list are a result of applying an operation, method, or function on all list items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 273,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create new list of squares for first n integers\n",
    "n = 10\n",
    "squares_n = [x**2 for x in range(n)]\n",
    "squares_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 9, 25, 49, 81]"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create new list of squares for first n odd integers\n",
    "n = 10\n",
    "squares_odd_n = [x**2 for x in range(n) if (x % 2) != 0]\n",
    "squares_odd_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['jan', 'feb', 'mar', 'apr']"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create new list by applying a method on items from another\n",
    "smaller_words = [x.lower() for x in word_list]\n",
    "smaller_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 1, 4, 7]"
      ]
     },
     "execution_count": 276,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create new list by applying a function on items from another\n",
    "absolute_list = [abs(x) for x in [-3, -5, 1, 4, 7]]\n",
    "absolute_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Jan', 'JAN'], ['Feb', 'FEB'], ['Mar', 'MAR'], ['Apr', 'APR']]"
      ]
     },
     "execution_count": 277,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a list of lists with original and new item\n",
    "capitalize_words = [[x, x.upper()] for x in word_list]\n",
    "capitalize_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 4, 6, 2, 8, 9, 3, 12]"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return list applying operation on each item combination from two lists\n",
    "combine_list = [x * y for x in [1, 2, 3] for y in [3, 1, 4]]\n",
    "combine_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 3], [1, 4], [2, 3], [2, 1], [2, 4], [3, 1], [3, 4]]"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return list of lists for matching criteria between two lists\n",
    "match_list = [[x, y] for x in [1, 2, 3] for y in [3, 1, 4] if x != y]\n",
    "match_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packing and unpacking lists\n",
    "\n",
    "Lists can be packed and unpacked into tuples using the `zip()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Mon', '9:30'),\n",
       " ('Tue', '8:30'),\n",
       " ('Wed', '8:30'),\n",
       " ('Thu', '10:30'),\n",
       " ('Fri', '11:00')]"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pack and then unpack two lists\n",
    "days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri']\n",
    "open_times = ['9:30', '8:30', '8:30', '10:30', '11:00']\n",
    "packed = zip(days, open_times)\n",
    "packed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mon', 'Tue', 'Wed', 'Thu', 'Fri')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('9:30', '8:30', '8:30', '10:30', '11:00')"
      ]
     },
     "execution_count": 285,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unpacked_days, unpacked_times = zip(*packed)\n",
    "print(unpacked_days)\n",
    "unpacked_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 'Jan'], [2, 'Feb'], [3, 'Mar']]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(1, 2, 3), ('Jan', 'Feb', 'Mar')]"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transpose a matrix of lists\n",
    "print(matrix_list)\n",
    "zip(*matrix_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequences in Python\n",
    "\n",
    "Sequence types in Python include strings, Unicode strings, lists, tuples, bytearrays, buffers, and xrange objects. Sequence types share many operations in common, so knowing one can ease the understanding of how to work with others.\n",
    "\n",
    "Many operations shared by sequences.\n",
    "\n",
    "- operations `x in seq` and `y not in seq`.\n",
    "- concat `seq1 + seq2` and multiply `seq1 * n`.\n",
    "- sequence traversal operations including return item by index, slicing.\n",
    "- len, max, min, count methods.\n",
    "\n",
    "There are some notable differences among various sequence types.\n",
    "\n",
    "- List is mutable, Tuple is immutable.\n",
    "- List is denoted with square [ ] brackets, Tuple with round ( ) brackets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance of lists\n",
    "\n",
    "Lists are generally very fast considering they are native data structure within Python, however certain operations are not recommended on lists. Instead you may want to use other Python or vendor provided specialised libraries for these operations.\n",
    "\n",
    "- **DO** Mutable operations at end of the list are fast. So using `pop()` works well.\n",
    "- **DO** Implementing Stack data structure as a List works well.\n",
    "- **NOT** Mutable operations at start or middle of the list are slow as these require shifting entire contents of the list. Use Python collections library instead.\n",
    "- **NOT** Operations on entire list contents are slow. Use NumPy to perform operations on entire list.\n",
    "- **NOT** Matrices or tables using list of lists is not optimal. Use Pandas to create Dataframe data structure instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "- [Official Python Data Structures Tutorial](https://docs.python.org/2/tutorial/datastructures.html)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}