Sequences.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "Tuples hold records: each item in the tuple holds the data for one field and the position of the item gives its meaning.\n",
    "If you think of a tuple just as an immutable list, the quantity and the order of the items may or may not be important, depending on the context. But when using a tuple as a collection of fields, the number of items is often fixed and their order is always vital."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "USA/31195855\n",
      "BRA/CE342567\n",
      "ESP/XDA205856\n",
      "\n",
      "sorted\n",
      "USA\n",
      "BRA\n",
      "ESP\n"
     ]
    }
   ],
   "source": [
    "# tuples used as record\n",
    "lax_coordinates = (33.9425, -118.408056)\n",
    "city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)\n",
    "traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]\n",
    "\n",
    "# The % formatting operator understands tuples and treats each item as a separate field.\n",
    "for passport in traveler_ids:\n",
    "    print('%s/%s' % passport)\n",
    "    \n",
    "# The for loop knows how to retrieve the items of a tuple\n",
    "# separately—this is called “unpacking.” Here we are not\n",
    "# interested in the second item, so it’s assigned to _, a dummy variable.\n",
    "print(\"\\nsorted\")\n",
    "for country, _ in traveler_ids:\n",
    "    print(country)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(33.9425, -118.408056)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The most visible form of tuple unpacking is parallel assignment;\n",
    "# that is, assigning items from an iterable to a tuple of variables,\n",
    "# as you can see in this example:\n",
    "\n",
    "lax_coordinates = (33.9425, -118.408056)\n",
    "latitude, longitude = lax_coordinates\n",
    "\n",
    "latitude, longitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-118.408056, 33.9425)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An elegant application of tuple unpacking is swapping \n",
    "# the values of variables without using a temporary variable:\n",
    "latitude, longitude = longitude, latitude\n",
    "\n",
    "latitude, longitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another example of tuple unpacking is prefixing an argument with a star when calling\n",
    "# a function:\n",
    "t = (20, 8)\n",
    "quotient, remainder = divmod(*t)\n",
    "quotient, remainder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using * to grab excess items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, [2, 3, 4])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Defining function parameters with *args to grab \n",
    "# arbitrary excess arguments is a classic Python feature.\n",
    "a, b, *rest = range(5)\n",
    "a, b, rest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, [2])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a, b, *rest = range(3)\n",
    "a, b, rest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1, [2, 3, 4, 5, 6, 7], 8, 9)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In the context of parallel assignment, \n",
    "# the * prefix can be applied to exactly one variable,\n",
    "# but it can appear in any position:\n",
    "a, b, *rest, c, d = range(10)\n",
    "a, b, rest, c, d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested tuple unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                |   lat.    |   long.  \n",
      "Mexico City     |   19.4333 |  -99.1333\n",
      "New York-Newark |   40.8086 |  -74.0204\n",
      "Sao Paulo       |  -23.5478 |  -46.6358\n"
     ]
    }
   ],
   "source": [
    "# Unpacking nested tuples to access the longitude\n",
    "metro_areas = [('Tokyo','JP',36.933,(35.689722,139.691667)), \n",
    "               ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),\n",
    "               ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),\n",
    "               ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),\n",
    "               ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),\n",
    "]\n",
    "print('{:15} | {:^9} | {:^9}'.format('', 'lat.', 'long.'))\n",
    "fmt = '{:15} | {:9.4f} | {:9.4f}'\n",
    "\n",
    "for name, cc, pop, (lat, long) in metro_areas:\n",
    "    if long <=0:\n",
    "        print(fmt.format(name, lat, long))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Named Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Defining and using a named tuple type\n",
    "# Two parameters are required to create a named tuple:\n",
    "# a class name and a list of field names, which can be given as an \n",
    "# iterable of strings or as a single space- delimited string.\n",
    "from collections import namedtuple\n",
    "\n",
    "City = namedtuple('City', 'name country population coordinates')\n",
    "tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))\n",
    "tokyo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "city --> Tokyo\n",
      "Population --> 36.933\n",
      "country --> JP\n",
      "coordinates --> (35.689722, 139.691667)\n"
     ]
    }
   ],
   "source": [
    "print(\"city --> {}\".format(tokyo.name))\n",
    "print(\"Population --> {}\".format(tokyo.population))\n",
    "print(\"country --> {}\".format(tokyo.country))\n",
    "print(\"coordinates --> {}\".format(tokyo.coordinates))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('name', 'country', 'population', 'coordinates')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Named tuple attriute and methods\n",
    "City._fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "LatLong = namedtuple('LatLong', 'lat long')\n",
    "delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "City(name='Delhi NCR', country='IN', population=21.935, coordinates=LatLong(lat=28.613889, long=77.208889))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delhi = City._make(delhi_data)\n",
    "delhi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('name', 'Delhi NCR'),\n",
       "             ('country', 'IN'),\n",
       "             ('population', 21.935),\n",
       "             ('coordinates', LatLong(lat=28.613889, long=77.208889))])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delhi._asdict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Delhi NCR\n",
      "country: IN\n",
      "population: 21.935\n",
      "coordinates: LatLong(lat=28.613889, long=77.208889)\n"
     ]
    }
   ],
   "source": [
    "for key, value in delhi._asdict().items():\n",
    "    print(key + ':' , value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slicing\n",
    "\n",
    "A common feature of list, tuple, str, and all sequence types in Python is the support of slicing operations, which are more powerful than most people realize.\n",
    "The Pythonic convention of excluding the last item in slices and ranges works well with the zero-based indexing used in Python, C, and many other languages.\n",
    "\n",
    "• It’s easy to see the length of a slice or range when only the stop position is given: range(3) and my_list[:3] both produce three items.\n",
    "\n",
    "• It’s easy to compute the length of a slice or range when start and stop are given: just subtract stop - start."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20]\n",
      "[30, 40, 50, 60]\n"
     ]
    }
   ],
   "source": [
    "# It’s easy to split a sequence in two parts at any index x,\n",
    "# without overlapping: simply get my_list[:x] and my_list[x:].\n",
    "# For example:\n",
    "l=[10,20,30,40,50,60]\n",
    "\n",
    "# split at 2\n",
    "_x = l[:2]\n",
    "x_ = l[2:]\n",
    "print(_x)\n",
    "print(x_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30]\n",
      "[40, 50, 60]\n"
     ]
    }
   ],
   "source": [
    "# split at 3\n",
    "_x3 = l[:3]\n",
    "x3_ = l[3:]\n",
    "print(_x3)\n",
    "print(x3_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slice Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gmy\n",
      "ynamreg\n",
      "yarg\n"
     ]
    }
   ],
   "source": [
    "# This is no secret, but worth repeating just in case:\n",
    "# s[a:b:c] can be used to specify a stride or step c, \n",
    "# causing the resulting slice to skip items. \\\n",
    "# The stride can also be negative, returning items in reverse.\n",
    "# Three examples make this clear:\n",
    "s_ex = 'germany'\n",
    "print(s_ex[::3])\n",
    "print(s_ex[::-1])\n",
    "print(s_ex[::-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multidimensional Slicing and Ellipsis\n",
    "\n",
    "The ellipsis—written with three full stops (...) and not ... (Unicode U+2026)—is rec‐ ognized as a token by the Python parser. It is an alias to the Ellipsis object, the single instance of the ellipsis class.2 As such, it can be passed as an argument to functions and as part of a slice specification, as in f(a, ..., z) or a[i:...]. NumPy uses ... as a shortcut when slicing arrays of many dimensions; for example, if x is a four- dimensional array, x[i, ...] is a shortcut for x[i, :, :, :,]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assigning to slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      "\n",
      "Updated l[2:5]\n",
      "[0, 1, 20, 30, 5, 6, 7, 8, 9]\n",
      "\n",
      "\n",
      "deleted l[5:7]\n",
      "[0, 1, 20, 30, 5, 8, 9]\n",
      "\n",
      "\n",
      "[0, 1, 20, 11, 5, 22, 9]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "l = list(range(10))\n",
    "print('l = {}'.format(l))\n",
    "print('\\n')\n",
    "\n",
    "l[2:5] = [20, 30]\n",
    "print(\"Updated l[2:5]\")\n",
    "print(l)\n",
    "print('\\n')\n",
    "\n",
    "del l[5:7]\n",
    "print(\"deleted l[5:7]\")\n",
    "print(l)\n",
    "print('\\n')\n",
    "\n",
    "l[3::2] = [11, 22]\n",
    "print(l)\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only assign an iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-da8b10461280>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ml\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only assign an iterable"
     ]
    }
   ],
   "source": [
    "# When the target of the assignment is a slice,\n",
    "# the right side must be an iterable object, \n",
    "# even if it has just one item.\n",
    "l[2:5] = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 100, 22, 9]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "l[2:5] = [100]\n",
    "print(l)\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building list of Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a tic tac toe board game\n",
    "b_game = [['_'] * 3 for i in range(3)]\n",
    "b_game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['_', '_', '_'], ['_', '_', 'X'], ['_', '_', '_']]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_game[1][2] = 'X'\n",
    "b_game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a list with three references to the same list is useless\n",
    "# The outer list is made of three references to the same inner list.\n",
    "# While it is unchanged, all seems right.\n",
    "weird_bgame = [['_'] * 3] * 3\n",
    "weird_bgame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['_', '_', '0'], ['_', '_', '0'], ['_', '_', '0']]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Placing a mark in row 1, column 2, reveals that all \n",
    "# rows are aliases referring to the same object.\n",
    "weird_bgame[1][2] = '0'\n",
    "weird_bgame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# weird_bgame behaves like this\n",
    "# same row is appended three times to the board\n",
    "row=['_']*3 \n",
    "board = []\n",
    "for i in range(3):\n",
    "    board.append(row)\n",
    "board"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# b_game is equivalent to this\n",
    "b_game = []\n",
    "for i in range(3):\n",
    "    row=['_'] * 3\n",
    "    b_game.append(row)\n",
    "b_game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['_', '_', '_'], ['_', '_', '_'], ['X', '_', '_']]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Only row 3 is changed, as expected\n",
    "b_game[2][0]='X'\n",
    "b_game"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Augmented Assignment with Sequences\n",
    "\n",
    "The augmented assignment operators += and *= behave very differently depending on the first operand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "address --> 4549335816\n",
      "[1, 2, 3, 1, 2, 3]\n",
      "address --> 4549335816\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "print(l)\n",
    "\n",
    "# ID of the initial list\n",
    "print(\"address --> {}\".format(id(l)))\n",
    "\n",
    "l *= 2\n",
    "print(l)\n",
    "\n",
    "# After multiplication, the list is the same object, with new items appended.\n",
    "print(\"address --> {}\".format(id(l)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "address --> 4549533984\n",
      "(1, 2, 3, 1, 2, 3)\n",
      "address --> 4527583496\n"
     ]
    }
   ],
   "source": [
    "t = (1, 2, 3)\n",
    "print(t)\n",
    "\n",
    "# ID of initial tuple\n",
    "print(\"address --> {}\".format(id(t)))\n",
    "\n",
    "t *= 2\n",
    "print(t)\n",
    "\n",
    "# After multiplication, a new tuple was created\n",
    "print(\"address --> {}\".format(id(t)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repeated concatenation of immutable sequences is inefficient, because instead of just appending new items, the interpreter has to copy the whole target sequence to create a new one with the new items concatenated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-606c6dcd668c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m30\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m40\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# A += assignment puzzle\n",
    "t = (1, 2, [20, 30])\n",
    "t[2] += [50, 40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, [20, 30, 50, 40])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'dis' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-aa7f2bba65b9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m's[a] += b'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'dis' is not defined"
     ]
    }
   ],
   "source": [
    "dis.dis('s[a] += b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# list.sort and the sorted Built-In Function\n",
    "\n",
    "The list.sort method sorts a list in place—that is, without making a copy. It returns None to remind us that it changes the target object, and does not create a new list.\n",
    "\n",
    "### reverse\n",
    "If True, the items are returned in descending order (i.e., by reversing the comparison of the items). The default is False.\n",
    "### key\n",
    " A one-argument function that will be applied to each item to produce its sorting key. For example, when sorting a list of strings, key=str.lower can be used to perform a case-insensitive sort, and key=len will sort the strings by character length. The default is the identity function (i.e., the items themselves are compared)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'grape', 'raspberry']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# examples to clarify\n",
    "fruits = ['grape', 'raspberry', 'apple', 'banana']\n",
    "sorted(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['grape', 'raspberry', 'apple', 'banana']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['raspberry', 'grape', 'banana', 'apple']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is simply reverse alphabetical ordering.\n",
    "sorted(fruits, reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'grape', 'banana', 'raspberry']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A new list of strings, now sorted by length. \n",
    "# Because the sorting algorithm is stable, \n",
    "# “grape” and “apple,” both of length 5, are in the original order.\n",
    "sorted(fruits, key=len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['raspberry', 'banana', 'grape', 'apple']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# These are the strings sorted in descending order of length. \n",
    "# It is not the reverse of the previous result because the \n",
    "# sorting is stable, so again “grape” appears before “apple.”\n",
    "sorted(fruits, reverse=True, key=len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This sorts the list in place, \n",
    "# and returns None (which the console omits).\n",
    "fruits.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'grape', 'raspberry']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Managing Ordered Sequences with bisect\n",
    "\n",
    "The bisect module offers two main functions—bisect and insort—that use the bi‐ nary search algorithm to quickly find and insert items in any sorted sequence.\n",
    "\n",
    "\n",
    "### Searching with bisect\n",
    "bisect(haystack, needle) does a binary search for needle in haystack—which must be a sorted sequence—to locate the position where needle can be inserted while main ‐ taining haystack in ascending order.\n",
    "\n",
    "We could use the result of bisect(haystack, needle) as the index argument to haystack.insert(index, needle)—however, using insort does both steps, and is faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import bisect\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]\n",
    "NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "ROW_FMT = '{0:2d} @ {1:2d}    {2}{0:<2d}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def demo(bisect_fn):\n",
    "    for needle in reversed(NEEDLES):\n",
    "        position = bisect_fn(HAYSTACK, needle)\n",
    "        offset = position * ' |'\n",
    "        print(ROW_FMT.format(needle, position, offset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DEMO: bisect_left\n",
      "haystack ->  1  4  5  6  8 12 15 20 21 23 23 26 29 30\n",
      "31 @ 14     | | | | | | | | | | | | | |31\n",
      "30 @ 13     | | | | | | | | | | | | |30\n",
      "29 @ 12     | | | | | | | | | | | |29\n",
      "23 @  9     | | | | | | | | |23\n",
      "22 @  9     | | | | | | | | |22\n",
      "10 @  5     | | | | |10\n",
      " 8 @  4     | | | |8 \n",
      " 5 @  2     | |5 \n",
      " 2 @  1     |2 \n",
      " 1 @  0    1 \n",
      " 0 @  0    0 \n"
     ]
    }
   ],
   "source": [
    "bisect_fn = bisect.bisect_left\n",
    "print('DEMO:', bisect_fn.__name__)\n",
    "print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))\n",
    "demo(bisect_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# An interesting application of bisect is to perform \n",
    "# table lookups by numeric values— for example,\n",
    "# to convert test scores to letter grades\n",
    "# Given a test score, grade returns the corresponding letter grade\n",
    "def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):\n",
    "    i = bisect.bisect(breakpoints, score)\n",
    "    return grades[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['F', 'A', 'C', 'C', 'B', 'A', 'A']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inserting with bisect.insort\n",
    "\n",
    "Sorting is expensive, so once you have a sorted sequence, it’s good to keep it that way. That is why bisect.insort was created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Insort keeps a sequence sorted even after insertion\n",
    "import bisect\n",
    "import random\n",
    "SIZE=7 \n",
    "random.seed(1729)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 -> [10]\n",
      " 0 -> [0, 10]\n",
      " 6 -> [0, 6, 10]\n",
      " 8 -> [0, 6, 8, 10]\n",
      " 7 -> [0, 6, 7, 8, 10]\n",
      " 2 -> [0, 2, 6, 7, 8, 10]\n",
      "10 -> [0, 2, 6, 7, 8, 10, 10]\n"
     ]
    }
   ],
   "source": [
    "my_list = []\n",
    "for i in range(SIZE):\n",
    "    new_item = random.randrange(SIZE*2)\n",
    "    bisect.insort(my_list, new_item)\n",
    "    print('%2d ->' % new_item, my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays\n",
    "\n",
    "If the list will only contain numbers, an array.array is more efficient than a list: it supports all mutable sequence operations (including .pop, .insert, and .extend), and additional methods for fast loading and saving such as .frombytes and .tofile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4747253388768794"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from array import array\n",
    "from random import random\n",
    "floats = array('d', (random() for i in range(10**7)))\n",
    "floats[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write array to file\n",
    "fp = open('floats.bin', 'wb')\n",
    "floats.tofile(fp)\n",
    "fp.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4747253388768794"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create new empty array\n",
    "floats2 = array('d')\n",
    "\n",
    "# open file in read mode\n",
    "fp = open('floats.bin', 'rb')\n",
    "\n",
    "# import data into floats2 array from file\n",
    "floats2.fromfile(fp, 10**7)\n",
    "\n",
    "floats2[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "floats2 == floats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving with array.tofile is about 7 times faster than writing one float per line in a text file. while loading from array.fromfile is 60 times faster than reading from a text file\n",
    "\n",
    "Another fast and more flexible way of saving numeric data is the pickle module for object serialization. Saving an array of floats with pickle.dump is almost as fast as with array.tofile however, pickle handles almost all built-in types, including complex numbers, nested collections, and even instances of user-defined classes automatically (if they are not too tricky in their implementation).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Memory Views\n",
    "\n",
    "A memory view is a generalized NumPy array structure in Python itself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Changing the value of an array item by poking one of its bytes\n",
    "from array import array\n",
    "\n",
    "# Build memoryview from array of 5 short signed integers (typecode 'h')\n",
    "numbers = array('h', [-2, -1, 0, 1, 2])\n",
    "memv = memoryview(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# memv sees the same 5 items in the array.\n",
    "len(memv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "memv[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create memv_oct by casting the elements of memv to typecode 'B' (unsigned char).\n",
    "memv_oct = memv.cast('B')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[254, 255, 255, 255, 0, 0, 1, 0, 2, 0]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Export elements of memv_oct as a list, for inspection.\n",
    "memv_oct.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign value 4 to byte offset 5.\n",
    "memv_oct[5] = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array('h', [-2, -1, 1024, 1, 2])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note change to numbers: a 4 in the most significant byte of a 2-byte unsigned integer is 1024.\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy and SciPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(12)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12,)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can reshape the array be passing (rows, columns) to reshape function\n",
    "a.reshape(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape=12,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or we can directly reshape by assigning new values\n",
    "# to the property shape\n",
    "a.shape = 3,4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  8],\n",
       "       [ 1,  5,  9],\n",
       "       [ 2,  6, 10],\n",
       "       [ 3,  7, 11]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deque and other queues\n",
    "\n",
    "The .append and .pop method makes lists suitable to be used as a stak \n",
    "or a queue. But when it comes to inserting in left, it woudl be time \n",
    "consuming as the whole list needs to shifted right. So, we have\n",
    "#### deque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dq = deque(range(10), maxlen=10)\n",
    "dq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dq.rotate(3)\n",
    "dq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dq.rotate(-4)\n",
    "dq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dq.appendleft(-1)\n",
    "dq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([3, 4, 5, 6, 7, 8, 9, 11, 12, 13])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dq.extend([11, 12,13])\n",
    "dq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque([40, 30, 20, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dq.extendleft([20,30,40])\n",
    "dq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import heapq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 6, 7, 8, 9, 20, 30, 40]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def heapsort(iterable):\n",
    "    h = []\n",
    "    for value in iterable:\n",
    "        heapq.heappush(h, value)\n",
    "    return [heapq.heappop(h) for i in range(len(h))]\n",
    "\n",
    "hdq = heapsort(dq)\n",
    "hdq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}