04_ordered_array.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QyAn0v3QF15O"
   },
   "source": [
    "# Python Sequences Are Ordered Arrays\n",
    "Python Sequences come in two flavors - list and tuple.\n",
    "\n",
    "- List: sequential array (fexible). `my_list = [1, 2, 3]`\n",
    "- Tuple: fixed sequential array (hashable). `my_tuple = (1, 2, 3)`\n",
    "\n",
    "### Tuples are like Lists:\n",
    "1. They both hold an ordered sequence of object references. As such both are fast and efficient to copy and pass around.\n",
    "2. The values inside each can be retrieved with brackets. This is known as \"indexing into\" it. `first = some_group[0]` The first item is always index 0. `last = some_group[-1]` The last item is always index -1. See Slicing for advanced indexing features.\n",
    "3. The values in both can be visited or viewed in turn with a simple loop.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mwrlg-M4TXdR"
   },
   "source": [
    "### Sequence Slicing\n",
    "\n",
    "A slice is like a view into a sequence, but it produces a new sequence of the same type. Both of the following examples work on any type of sequence. The author will leave it to the reader to determine which is more Pythonic. The first example is far more common, but don't let that persuade you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "kvrkWLcLSqVD",
    "outputId": "1c66282a-b5bf-4484-d3f9-2ab674a3f881"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "some_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "by_two = some_list[0:9:2]\n",
    "print(by_two)  # slice of 0-8 by strides of 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ePrmjcsmWfLq",
    "outputId": "42437957-3add-4451-b237-d859b1290131"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 3, 6, 9)\n"
     ]
    }
   ],
   "source": [
    "some_tuple = tuple(some_list)\n",
    "\n",
    "my_slice = slice(0, 10, 3)\n",
    "by_three = some_tuple[my_slice]\n",
    "print(by_three)  # slice of 0-9 by strides of 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ch44Ui-ok7ph"
   },
   "source": [
    "### Lists and Tuples are Heterogeneous\n",
    "In some languages - tuples are used to hold heterogeneous data, as opposed to lists which are used to hold homogeneous data. In Python, both can do both and there is no technical reason to make this distinction. That said, generally speaking - for any type of sequence: homogeneous data is always preferred. One of the best containers for heterogeneous data is the dictionary, but there are other options aswell. Heterogeneous sequences are gross, don't do it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "ouwMUZcZjGoD",
    "outputId": "b7541a8e-c6fd-4ca1-ab3e-fb4e4f41393b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['this', 42, 3.14, (6+7j), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]\n",
      "('this', 42, 3.14, (6+7j), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n"
     ]
    }
   ],
   "source": [
    "pythonic_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]        # homogeneous\n",
    "ugly_list = [\"this\", 42, 3.14, 6+7j, pythonic_list]    # heterogeneous\n",
    "\n",
    "pythonic_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)       # homogeneous\n",
    "ugly_tuple = (\"this\", 42, 3.14, 6+7j, pythonic_tuple)  # heterogeneous\n",
    "\n",
    "print(ugly_list)\n",
    "print(ugly_tuple)\n",
    "\n",
    "print(pythonic_list)\n",
    "print(pythonic_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PVTi7buwjCmk"
   },
   "source": [
    "## Python Lists\n",
    "\n",
    "### Looping A List\n",
    "Pure For Each Loop - very Pythonic. This works the same with any iterable object, not just sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "5QEkY8tdi-El",
    "outputId": "37fccd17-41f0-4b9f-befd-fe76e6247731"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "for value in my_list:\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EqnKzQ7DPZZf"
   },
   "source": [
    "### List Operations: Builtin Methods\n",
    "\n",
    "[List Methods | python.org](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "3MvQhljOOx4t",
    "outputId": "c0d5f538-05c0-4cde-8841-affbbd4e1c63"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 0]\n"
     ]
    }
   ],
   "source": [
    "my_list.append(0)\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "BLqYGIXAOejA",
    "outputId": "f7c3754a-6e28-43af-bf2a-844cf443db5a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "my_list.reverse()\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "K0ctIkOCOqyU",
    "outputId": "4ee9d68d-aef8-49a6-f788-9a52b3f1adc8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "my_list.sort()\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "9ySBI9lhO8cY",
    "outputId": "711a7b60-4e3c-4df4-fe02-a5b2ec756d7c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "my_var = my_list.pop()\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "wjGNV8fDPGzE",
    "outputId": "1a40ecb3-4ad2-4d8a-ffd1-7ec1d698f50a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "my_other_var = my_list.pop(0)\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Yu7h7P03hCLY"
   },
   "source": [
    "## Python Tuple\n",
    "Tuples have a cool name. It is pronounced \"_too-pul_\", not \"_tup-pel_\". The later would be spelled 'tupple'. \n",
    "\n",
    "Tuples are similar to lists, but with some key differences. The literal tuple is created with parens instead of brackets, but the values inside are indexed with brackets - just like lists. The other way to make a tuple is to cast it from a list.\n",
    "\n",
    "In some cases, Tuples can be hashable. This ability comes at the cost of flexiblity. Tuples are fixed in size and order. You cannot append, pop, sort or shuffle a tuple directly. But you can always convert a tuple to a list and then back again. If you find yourself doing this a lot, please consider why it is that you're not using a list in the first place. Lists are good.\n",
    "\n",
    "The one time where only a tuple will do, is when you want to use a sequence as a key. For this to work - it needs to be hashable, and thereby contain no mutable values.\n",
    "\n",
    "[Python Tuple | python.org](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "v641wGkZ_Rqd",
    "outputId": "12fb218d-2db1-4f16-bcef-06edaf2ddc82"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "(1, 2, 3, 4, 5)\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Starting with a list\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Casting (Transforming) a list to a tuple\n",
    "my_tuple = tuple(my_list)\n",
    "\n",
    "# And back again\n",
    "another_list = list(my_tuple)\n",
    "\n",
    "print(my_list)\n",
    "print(my_tuple)\n",
    "print(another_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "afHJ4CBw8ZSy"
   },
   "source": [
    "### Complex Iteration\n",
    "\n",
    "The `zip()` function takes an arbitrary number of sequences and transposes them. Rows -> Columns. Zip then returns a container of tuples that is niether a list nor a tuple itself, but it is iterable.\n",
    "\n",
    "[Zip function | python.org](https://docs.python.org/3.3/library/functions.html#zip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "id": "nwnO_nqmg8ao",
    "outputId": "60a45bfc-f0c0-41fc-9c1a-bc47173fd5fc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BMI Data:\n",
      "John:\t 24.959\n",
      "Paul:\t 26.110\n",
      "George:\t 23.850\n",
      "Ringo:\t 26.086\n"
     ]
    }
   ],
   "source": [
    "names   = (\"John\", \"Paul\", \"George\", \"Ringo\")\n",
    "weights = ( 84.5,   81.8,   86.1,     92.2  )\n",
    "heights = ( 1.84,   1.77,   1.90,     1.88  )\n",
    "\n",
    "data = zip(names, weights, heights)\n",
    "\n",
    "print(\"BMI Data:\")\n",
    "\n",
    "for n, w, h in data:\n",
    "    print(f\"{n}:\\t{w / h**2 : .3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unpacking vs. Indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice in the for loop above that we have multiple loop variables `for n, w, h in data...`. This is known as unpacking. You can unpack any sequence like this so long as you declare the correct number of variables. Unpacking can be a more pythonic alternative to indexing, consider the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Indexing\n",
    "print(some_list[0])\n",
    "print(some_list[1])\n",
    "print(some_list[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Unpacking\n",
    "a, b, c = some_list\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DZlkYw2dg6qy"
   },
   "source": [
    "### Tuple Performance is a Misnomer\n",
    "In previous versions of Python - tuples were measurably faster than lists in almost every way. Today, lists have nearly the same performance as tuples. What tiny performance difference there is should not be a concern to the modern Pythonista. If speed is really important: use a library (Numpy) with faster containers, design a Python Extension, or use something other than Python. Python is not about computational performance, it's about **developer performance**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "biR-NmxFbhAn"
   },
   "source": [
    "### Tuple Immutablity is a Misnomer\n",
    "In a dark alley, late at night, you might hear something like the following...\n",
    "> _\"Your code will be safer if you use a tuple rather than a list. Tuples enforce immutability, so they are better. Always use a tuple!\"_\n",
    "\n",
    "Unfortunately, this is bad advice. While the first sentence is true to some extent, the supporting argument is false and the whole idea is very misleading. Consider the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "Gn-cctQvbiCd",
    "outputId": "c28230fe-f7e1-4755-efd5-719f8f526c85"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tup => ([], [], [])\n",
      "tup => ([1], [2], [3])\n"
     ]
    }
   ],
   "source": [
    "a, b, c = [], [], []\n",
    "tup = (a, b, c)\n",
    "print(f\"tup => {tup}\")\n",
    "a.append(1)\n",
    "b.append(2)\n",
    "c.append(3)\n",
    "print(f\"tup => {tup}\")  # The tuple has been changed without error!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ws3iG5EkGkLe"
   },
   "source": [
    "Tuples are not strictly immutable. It is far better to think of tuples as fixed in size and order. The values inside them are not necessarily immutable. Tuples are hashable, but only if they contain hashable values exclusively. Mutable objects are never hashable - even when stored inside a tuple.\n",
    "\n",
    "The main point here should be the fact that tuples are *potentially* hashable and therefore can *sometimes* be used as keys in a dictionary. This may seem pointless now, but it's actually one of the most powerful tools in Python. It is for this reason alone that we have the tuple container type in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FG5fhtcpplJC"
   },
   "source": [
    "### List or Tuple: Rule of Thumb\n",
    "__If the flexiblity of a list *might* be handy, use a list.__ On the other hand, if your team lead says \"use a tuple unless you can't\" - you should do that instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "04_ordered_array.ipynb",
   "provenance": []
  },
  "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}