3-Python-Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "Earlier when discussing strings we introduced the concept of a *sequence* in Python. Lists can be thought of the most general version of a *sequence* in Python. Unlike strings, they are mutable, meaning the elements inside a list can be changed!\n",
    "\n",
    "In this section we will learn about:\n",
    "    \n",
    "    1.) Creating lists\n",
    "    2.) Indexing and Slicing Lists\n",
    "    3.) Basic List Methods\n",
    "    4.) Nesting Lists\n",
    "    5.) Introduction to List Comprehensions\n",
    "    6.) Unpacking Lists\n",
    "\n",
    "Lists are constructed with brackets [ ] and commas separating every element in the list.\n",
    "\n",
    "Let's go ahead and see how we can construct lists!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Assign a list to an variable named numbers\n",
    "numbers = [1,2,3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We just created a list of integers, but lists can actually hold different object types. For example:\n",
    "Below is the list of student details with scholar_number,enrollment_number,cgpa,sgpa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stu_details = [1094,'0114CS151038',7.8,8.2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Just like strings, the len() function will tell you how many items are in the sequence of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(stu_details)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Lists are mutable whereas strings and tuples are immutable. Wait! , let me prove it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory address of list before changing  0x7fc3a17f0048\n",
      "List before:  1 2 3 4\n",
      "Memory address of list after changing   0x7fc3a17f0048\n",
      "List after:  1 2 3 4 5\n",
      "Memory address of string: 'string is immmutable.'                         before changing  0x7fc3a17d8ed0\n",
      "Memory address of string: 'string is immmutable.Told ya! It's immutable.' after  changing  0x7fc3a17bb390\n"
     ]
    }
   ],
   "source": [
    "li = [1,2,3,4]\n",
    "print(\"Memory address of list before changing \",hex(id(li)))\n",
    "print(\"List before: \",*li)\n",
    "li.append(5)\n",
    "print(\"Memory address of list after changing  \",hex(id(li)))\n",
    "print(\"List after: \",*li)\n",
    "st = \"string is immmutable.\"\n",
    "print(\"Memory address of string: '{0}'{1} before changing \".format(st,\" \"*24),hex(id(st)))\n",
    "# st[11]='' TypeError: 'str' object does not support item assignment\n",
    "st = st+\"Told ya! It's immutable.\"\n",
    "print(\"Memory address of string: '{0}' after  changing \".format(st),hex(id(st)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing and Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's lists support slicing and indexing. Lists are 0 indexed in python and slicing is very much similar to string slicing(refer previous notebook). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Syntax for list slicing: list_name[start:stop:step]. Remember that stop is not inclusive that is it'll stop the iteration one element before the stop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From index 2 to index 5:   [36, 45, 54, 63]\n",
      "For first three elements:  [18, 27, 36]\n",
      "For every second element from index 1 to index 6: [27, 45, 63]\n",
      "For element at even position: [27, 45, 63, 81]\n",
      "For element at odd position:  [18, 36, 54, 72]\n",
      "For reversing the list:  [81, 72, 63, 54, 45, 36, 27, 18]\n"
     ]
    }
   ],
   "source": [
    "num_li = [18,27,36,45,54,63,72,81]\n",
    "# index:  0  1  2  3  4  5  6  7\n",
    "print(\"From index 2 to index 5:  \",num_li[2:6])\n",
    "print(\"For first three elements: \",num_li[:3])\n",
    "print(\"For every second element from index 1 to index 6:\",num_li[1:7:2])\n",
    "print(\"For element at even position:\",num_li[1::2])\n",
    "print(\"For element at odd position: \",num_li[::2])\n",
    "print(\"For reversing the list: \",num_li[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_li.index(27) # params: value,start,stop returns: integer, first index of value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic List Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let L be List.\n",
    "\n",
    "        L.__reversed__()\n",
    "        L.reverse()\n",
    "        L.append()\n",
    "        L.insert()\n",
    "        L.extend()\n",
    "        L.pop()\n",
    "        L.remove()        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterable for two lists.\n",
    "\n",
    "    zip(list1,list2)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 1)\n",
      "('b', 2)\n",
      "('c', 3)\n",
      "('d', 4)\n",
      "a 1\n",
      "b 2\n",
      "c 3\n",
      "d 4\n"
     ]
    }
   ],
   "source": [
    "list1 = ['a','b','c','d']\n",
    "list2 = [1,2,3,4]\n",
    "\n",
    "# zip returns a tuple for both the iterables.\n",
    "for i in zip(list1,list2):\n",
    "    print(i)\n",
    "\n",
    "# looping through both items \n",
    "\n",
    "for i,j in zip(list1,list2):\n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Taking input in list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bharat rajani\n",
      "['bharat', 'rajani']\n",
      "1 2 3 4 5\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "str_a = input().split()\n",
    "print(str_a)\n",
    "\n",
    "int_a = list(map(int,input().split()))\n",
    "print(int_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nesting Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cube_li = [[6,216],[3,9],[2,8],[4,64],[5,125]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 3, 2, 4, 5]\n",
      "[216, 9, 8, 64, 125]\n"
     ]
    }
   ],
   "source": [
    "## Snippet: How to get two lists as 6,3,2,4,5 and 216,9,8,64,125\n",
    "## See unpacking for understanding this.\n",
    "a,b = map(list,zip(*cube_li))\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 8], [3, 9], [4, 64], [5, 125], [6, 216]]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Snippet: How to sort nested lists according to first element of nested list.\n",
    "sorted(cube_li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "li:    [16, 25, 36, 49, 64, 81, 100, 121, 144]\n",
      "sq_li: [[4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81], [10, 100], [11, 121], [12, 144]]\n"
     ]
    }
   ],
   "source": [
    "## Get list of squares of number from 4 to 12\n",
    "\n",
    "li = [x*x for x in range(4,13)]\n",
    "print(\"li:   \",li)\n",
    "## Get nested list of squares of number from 4 to 12\n",
    "sq_li = [[i,j] for i,j in zip(range(4,13),li)]\n",
    "print(\"sq_li:\",sq_li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example one..\n",
      "a 2\n",
      "b 3\n",
      "\n",
      "Example two..\n",
      "a 1\n",
      "b 2\n",
      "c 3\n",
      "\n",
      "Example three (starred expression)..\n",
      "1\n",
      "[2, 3, 4, 5, 6, 7]\n",
      "\n",
      "Example four (starred expression)..\n",
      "1\n",
      "[2, 3, 4, 5, 6]\n",
      "7\n",
      "\n",
      "Example five (starred expression)..\n",
      "Without Unpacking:  [34, 234, 56, 234, 23, 45, 34, 234, 2314]\n",
      "Unpacking:           34 234 56 234 23 45 34 234 2314\n"
     ]
    }
   ],
   "source": [
    "print(\"Example one..\")\n",
    "a,b = [2,3]\n",
    "print(\"a\",a)\n",
    "print(\"b\",b)\n",
    "\n",
    "print(\"\\nExample two..\")\n",
    "a,b,c = [1,2,3]\n",
    "print(\"a\",a)\n",
    "print(\"b\",b)\n",
    "print(\"c\",c)\n",
    "\n",
    "print(\"\\nExample three (starred expression)..\")\n",
    "a,*b = [1,2,3,4,5,6,7]\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "print(\"\\nExample four (starred expression)..\")\n",
    "a,*b,c = [1,2,3,4,5,6,7]\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "print(\"\\nExample five (starred expression)..\")\n",
    "li = [34,234,56,234,23,45,34,234,2314]\n",
    "print(\"Without Unpacking: \",li)\n",
    "print(\"Unpacking:          \",*li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced : How arrays are implemented as list in python? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Referential Arrays in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python the list items are stored as references to different objects.\n",
    "\n",
    "=> Consider a list of strings as\n",
    "\n",
    "    [ Rene , Joseph , Janet , Jonas , Helen , Virginia , ... ]\n",
    "        \n",
    "To represent such a list with an array, Python must adhere to the requirement that\n",
    "each cell of the array use the same number of bytes. Yet the elements are strings,\n",
    "and strings naturally have different lengths. Python could attempt to reserve enough\n",
    "space for each cell to hold the maximum length string (not just of currently stored\n",
    "strings, but of any string we might ever want to store), but that would be wasteful.\n",
    "\n",
    "Instead, Python represents a list or tuple instance using an internal storage\n",
    "mechanism of an array of object references. At the lowest level, what is stored\n",
    "is a consecutive sequence of memory addresses at which the elements of the sequence\n",
    "reside."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/referential_arrays_1.png\" alt=\"Drawing\" style=\"width: 60%;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "=> A single list instance may include multiple references\n",
    "to the same object as elements of the list, and it is possible for a single object to\n",
    "be an element of two or more lists, as those lists simply store references back to\n",
    "that object. As an example, when you compute a slice of a list, the result is a new\n",
    "list instance, but that new list has references to the same elements that are in the\n",
    "original list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory address of primes:  0x7f7ec8aa0d48\n",
      "Memory address of 3rd,4th,5th elements of primes.\n",
      "0x55607abb5d00\n",
      "0x55607abb5d20\n",
      "0x55607abb5d60\n",
      "Memory address of temp:  0x7f7ec8aa0d08\n",
      "Memory address of first three elements of temp.\n",
      "0x55607abb5da0\n",
      "0x55607abb5e20\n",
      "0x55607abb5e60\n"
     ]
    }
   ],
   "source": [
    "primes = [2,3,5,7,11,13,17,19]\n",
    "temp = primes[3:6]\n",
    "print(\"Memory address of primes: \",hex(id(primes)))\n",
    "print(\"Memory address of 3rd,4th,5th elements of primes.\")\n",
    "for i in range(3):\n",
    "    print(hex(id(primes[i])))\n",
    "    \n",
    "print(\"Memory address of temp: \",hex(id(temp)))\n",
    "print(\"Memory address of first three elements of temp.\")\n",
    "for i in range(3):\n",
    "    print(hex(id(temp[i])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/referential_arrays_2.png\" alt=\"Drawing\" style=\"width: 50%;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A question arrises after observing above figure. What happens if we replace an object of \"temp\" at any location with a different number.\n",
    "Let's visualize it.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "temp[2]=15\n",
    "print(temp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/referential_arrays_3.png\" alt=\"Drawing\" style=\"width: 65%;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another striking example is of creating a list with all elements same.\n",
    "This is heavily used in competitive programming and mainly for bit manipulation.\n",
    "A similar c++ function is memset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "counters = [0]*8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/referential_arrays_4.png\" alt=\"Drawing\" style=\"width: 70%;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compact Arrays in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we saw above that python lists contain a reference to multiple objects. But is that the case with every object? Well the answer is NO. I will illustrate this argument with below example."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "string = \"python is the best language\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are represented using array of characters. So do we need to store reference of each character?. Clearly No.\n",
    "Because that would lead to wastage of memory and it will decrease the computing performance.\n",
    "Therefore python implements a compact array internally that is an array storing the bits that represent data (characters in case of string)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well now by this time a question must have arrised in your brain. What if we need to explicitly make a compact array like we do in C++,C,Java ? Brace yourself, cause there is nothing that we can't do with python.\n",
    "Primary support for compact arrays is in a module named array. That module defines a class, also named array, providing compact storage for arrays of primitive data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import array # for \n",
    "primes_arr = array.array( 'i' , [2, 3, 5, 7, 11, 13, 17, 19])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The type is specified at object creation time by using a type code, which is a single character."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/arrays.png\" alt=\"Drawing\" style=\"width: 70%;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Size of array class and elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "96\n",
      "Why 96? It should be 32. getsizeof() also calculates the size of normal array class.\n",
      "Size of empty array:  64\n",
      "Net size of elements inside array:  32\n"
     ]
    }
   ],
   "source": [
    "print(sys.getsizeof(primes_arr))\n",
    "print(\"Why 96? It should be 32. getsizeof() also calculates the size of normal array class.\")\n",
    "empty_arr = array.array( 'i' , [])\n",
    "print(\"Size of empty array: \",sys.getsizeof(empty_arr))\n",
    "print(\"Net size of elements inside array: \",sys.getsizeof(primes_arr)-sys.getsizeof(empty_arr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dynamic arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a great and easy to use sequence known as list. Since lists allow us to do all sort of magic like append at last, slicing etc. But under the hood there is lot more going on than just simply adding and traversing. In a computer system the precise size of a sequence(or array) must be explicitly declared in order for the system to properly allocate a consecutive piece of memory for its storage.\n",
    "\n",
    "So how do lists actually work in a fashion that they expand dynamically according to the need?\n",
    "How do they magically know that what size list must be created?\n",
    "\n",
    "Well the answer is not much magical but obvious. They expand as we append. But at what rate they expand?\n",
    "\n",
    "Python’s list class presents a more interesting abstraction. Although a list has a particular length when constructed, the class allows us to add elements to the list, with no apparent limit on the overall capacity of the list. To provide this abstraction, Python relies on an algorithmic sleight of hand known as a ```dynamic array```.\n",
    "\n",
    "The first key to providing the semantics of a dynamic array is that a list instance\n",
    "maintains an underlying array that often has greater capacity than the current length\n",
    "of the list. For example, while a user may have created a list with five elements,\n",
    "the system may have reserved an underlying array capable of storing eight object\n",
    "references (rather than only five). This extra capacity makes it easy to append a\n",
    "new element to the list by using the next available cell of the array.\n",
    "If a user continues to append elements to a list, any reserved capacity will\n",
    "eventually be exhausted. In that case, the class requests a new, larger array from the\n",
    "system, and initializes the new array so that its prefix matches that of the existing\n",
    "smaller array. At that point in time, the old array is no longer needed, so it is\n",
    "reclaimed by the system. Intuitively, this strategy is much like that of the hermit\n",
    "crab, which moves into a larger shell when it outgrows its previous one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Experiment Length: 15\n",
      "Length:   0; | Size in bytes:   64; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   1; | Size in bytes:   96; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   2; | Size in bytes:   96; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   3; | Size in bytes:   96; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   4; | Size in bytes:   96; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   5; | Size in bytes:  128; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   6; | Size in bytes:  128; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   7; | Size in bytes:  128; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   8; | Size in bytes:  128; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:   9; | Size in bytes:  192; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:  10; | Size in bytes:  192; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:  11; | Size in bytes:  192; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:  12; | Size in bytes:  192; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:  13; | Size in bytes:  192; | Memory Address:  0x7f7ec8ad8fc8\n",
      "Length:  14; | Size in bytes:  192; | Memory Address:  0x7f7ec8ad8fc8\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "li = []\n",
    "for i in range(int(input(\"Experiment Length: \"))):\n",
    "    a = len(li)\n",
    "    b = sys.getsizeof(li)\n",
    "    print(\"Length: {0:3d}; | Size in bytes: {1:4d}; | Memory Address:  {2}\".format(a,b,hex(id(li))))\n",
    "    li.append(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dynamic array implementation in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First an array(list A) is declared with four elements in it.\n",
    "List elements from small list(a) are copied into a bigger __(by the factor of 2X)__ list(b).\n",
    "Then reassign reference A to the new array.List B is old array hence destructed or collected in garbage collector."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/dynamic_array.png\" alt=\"Drawing\" style=\"width: 70%;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Amortized Analysis of Dynamic Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.634429931640625e-07\n"
     ]
    }
   ],
   "source": [
    "from time import time # import time function from time module\n",
    "def compute_average(n):\n",
    "    '''\n",
    "    Perform n appends to an empty list and return average time elapsed.\n",
    "    '''\n",
    "    data = [ ]\n",
    "    start = time( ) # record the start time (in seconds)\n",
    "    for k in range(n):\n",
    "        data.append(None)\n",
    "        end = time( ) # record the end time (in seconds)\n",
    "    return (end - start) / n\n",
    "\n",
    "\n",
    "if __name__=='__main__':\n",
    "    print(compute_average(100000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stay Tuned for more content in this notebook. Remember that these notebooks are updated as I learn something new and commit it."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}