ch03-Copy1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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"
    },
    "colab": {
      "name": "ch03-Copy1.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qC4kP-h3t2aI"
      },
      "source": [
        "# Built-in Data Structures, Functions, "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "KmVbIjs4t2aK"
      },
      "source": [
        "## Data Structures and Sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "RxoOibHzt2aP"
      },
      "source": [
        "### Tuple"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Bx9PFOkt2aQ"
      },
      "source": [
        "A tuple is a fixed-length, immutable sequence of Python objects. \n",
        "The easiest way to create one is with a comma-separated sequence of values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "OpQPq5_bt2aR",
        "outputId": "1b841031-c18c-4632-f3af-9f59df916f0f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "tup =( 4, 5, 6)\n",
        "tup"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4, 5, 6)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "biNmapQXt2ab",
        "outputId": "5082eb93-8b3c-468a-a06d-00bbd72fbb6c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#must use paranthesis for complicated tuples: a tuple of tuples\n",
        "\n",
        "nested_tup = ((4, 5, 6), (7, 8))\n",
        "nested_tup"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((4, 5, 6), (7, 8))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yLuYdD2bt2al",
        "outputId": "4b3eb00f-8bfb-477b-81cb-a45857fcf92a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#You can convert any sequence or iterator to a tuple by invoking tuple:\n",
        "\n",
        "t=tuple([4, 0, 2])\n",
        "t2=tuple(\"string\")\n",
        "tup = tuple(['foo', [1, 2], True])\n",
        "tup\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('foo', [1, 2], True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Qt-YPGnxt2at",
        "outputId": "f2adec98-44a2-4c13-a4f6-48decb079170",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#tup[1]=[2,4]#can  be accessed with C like indexes\n",
        "print (tup[1])"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "W8RiG2Mat2a1",
        "outputId": "de3edb2e-6de9-4072-84c2-9f4767a9d18a"
      },
      "source": [
        "tup = tuple(['foo', [1, 2], True])#even if the elements are mutable once in a tuple \n",
        "#once the tuple is cre‐ ated it’s not possible to modify which object is stored in each slot:\n",
        "tup[2] = False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'tuple' object does not support item assignment",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-7765830289ac>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtup\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'foo'\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;32mTrue\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m#even if the elements are mutable once in a tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m#once the tuple is cre‐ ated it’s not possible to modify which object is stored in each slot:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "W2I62JoBt2a-",
        "outputId": "737ee405-7756-43f0-f8c7-85880554f98f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#If an object inside a tuple is mutable, such as a list, you can modify it in-place:\n",
        "tup[1].append(3)\n",
        "tup"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('foo', [1, 2, 3], True)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FtDC4Y4ht2bL",
        "outputId": "4c71df98-9568-4f69-b803-8f269a87b5ed"
      },
      "source": [
        "(4, None, 'foo') + (6, 0) + ('bar',)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4, None, 'foo', 6, 0, 'bar')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6mytjpi9t2bU",
        "outputId": "32888874-279d-4ff6-9754-f061101e6ef2"
      },
      "source": [
        "('foo', 'bar') * 4"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "XIujgOv7t2bb"
      },
      "source": [
        "#### Unpacking tuples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "d6BLSz0Lt2bc",
        "outputId": "2c575049-0a41-4d40-a1df-156b5d42754b"
      },
      "source": [
        "tup = (4, 5, 6)\n",
        "a, b, c = tup\n",
        "a\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-To4M9AOt2bj",
        "outputId": "084959fb-d7a1-4f6b-ae8f-a13bbca3d290"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "zbB0hD8at2bq"
      },
      "source": [
        "#a funny swap\n",
        "a,b=b,a\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "C_1kplnTt2b1"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "y69SwB7rt2b6"
      },
      "source": [
        "tup = 4, 5, (6, 7)\n",
        "#Even sequences with nested tuples can be unpacked:\n",
        "a, b, (c, d) = tup\n",
        "d"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "pPg3HUI2t2cB"
      },
      "source": [
        "tmp = a\n",
        "a = b\n",
        "b = tmp"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "S-qVpEYBt2cG"
      },
      "source": [
        "a, b = 1, 2\n",
        "a\n",
        "b\n",
        "b, a = a, b\n",
        "a\n",
        "b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kEwh5ysIt2cR",
        "outputId": "1823d00a-ff79-49b2-ff44-1651bec4636c"
      },
      "source": [
        "#A common use of variable unpacking is iterating over sequences of tuples or lists:\n",
        "seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]\n",
        "for a, b, c in seq:\n",
        "    print('a={0}, b={1}, c={2}'.format(a, b, c))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a=1, b=2, c=3\n",
            "a=4, b=5, c=6\n",
            "a=7, b=8, c=9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "53rNhaFIt2cX",
        "outputId": "a8c87f8e-273d-438a-c57c-2ca5a5d26feb"
      },
      "source": [
        "values = 1, 2, 3, 4, 5\n",
        "a,*rest,b = values # beware * wild char\n",
        "a, b\n",
        "(rest)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 3, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Gt1nixIPt2cd"
      },
      "source": [
        "#traditionally _ is used for unwanted variables\n",
        "a, b, *_ = values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "bSCNAnb8t2cj"
      },
      "source": [
        "#### Tuple methods"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ndDd4kJBt2ck",
        "outputId": "502b1f90-9330-455b-a811-0f5d0e1792b8"
      },
      "source": [
        "a = (1, 2, 2, 2, 3, 4, 2)\n",
        "a.count(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "rSvciN1xt2cr"
      },
      "source": [
        "### List"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IiCF6Qq5t2cv"
      },
      "source": [
        "In contrast with tuples, lists are variable-length and their contents can be modified in-place. You can define them using square brackets [] or using the list type funtion:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "lnfXHC7et2cw"
      },
      "source": [
        "a_list = [2, 3, 7, None]\n",
        "tup = ('foo', 'bar', 'baz')\n",
        "b_list = list(tup)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CvUeEW__t2c4",
        "outputId": "d0647658-c685-4203-edf5-f88b9f1b9bee"
      },
      "source": [
        "b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 'bar', 'baz']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6FNPC9U4t2dC",
        "outputId": "5f484463-381b-4a95-ab58-801cc5d4bf70"
      },
      "source": [
        "b_list[1] = 'peekaboo'\n",
        "b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 'peekaboo', 'baz']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "7nk5MLYMt2dY"
      },
      "source": [
        "#The list function is frequently used in data processing as a way to materialize an iterator!\n",
        "#or generator! expression:\n",
        "\n",
        "gen = range(10)\n",
        "gen\n",
        "list(gen)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vf-lp5OSt2dj"
      },
      "source": [
        "#### Adding and removing elements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "sPU-aSh_t2dl",
        "outputId": "d30330b6-1cbe-405f-a9b9-194c0e296af3"
      },
      "source": [
        "b_list.append('dwarf')\n",
        "b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 'peekaboo', 'baz', 'dwarf']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "74eco--Tt2du",
        "outputId": "5b5334d6-b7b2-4521-a99c-037f3f443bcc"
      },
      "source": [
        "b_list.insert(1, 'red')\n",
        "b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 'red', 'peekaboo', 'baz', 'dwarf']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UnJIFXTbt2d3",
        "outputId": "89dbe70f-5126-408e-d3a2-3d7de3911dcd"
      },
      "source": [
        "b_list.pop(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'peekaboo'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "8SVucAtht2d8",
        "outputId": "3829ec35-7c46-4707-d583-2533502bd12d"
      },
      "source": [
        "b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 'red', 'baz', 'dwarf']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "4Z8b1dSQt2eF",
        "outputId": "f5adfa9d-14e2-41a9-c734-e51b36c3f3d9"
      },
      "source": [
        "b_list.append('foo')\n",
        "b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 'red', 'baz', 'dwarf', 'foo']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "WJLp0cbdt2eM",
        "outputId": "f949c08c-de1c-40ce-c262-1973da82c0f3"
      },
      "source": [
        "b_list.remove('foo')\n",
        "b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['red', 'baz', 'dwarf', 'foo']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9hcyt2zst2eT",
        "outputId": "632eb212-9f35-4c39-c187-5ab08830fc8c"
      },
      "source": [
        "'dwarf' in b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "K4QAqn2nt2eZ",
        "outputId": "76de7abb-f0cf-4fd7-8f5b-d09305cf8785"
      },
      "source": [
        "'dwarf' not in b_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JugeTOzZt2ef"
      },
      "source": [
        "Checking whether a list contains a value is a lot slower than doing so with dicts and sets .\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hc-MeSPot2eg"
      },
      "source": [
        "#### Concatenating and combining lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qaNP8jE_t2eh"
      },
      "source": [
        "[4, None, 'foo'] + [7, 8, (2, 3)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hcJhwvzWt2es"
      },
      "source": [
        "x = [4, None, 'foo']\n",
        "x.extend([7, 8, (2, 3)])\n",
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Zo7K0kOKt2ex"
      },
      "source": [
        "everything = []\n",
        "for chunk in list_of_lists:\n",
        "    everything.extend(chunk)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3MZFEZ8Ft2e7"
      },
      "source": [
        "<i>is faster than <i>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "pRUFV4XUt2e8"
      },
      "source": [
        "everything = []\n",
        "for chunk in list_of_lists:\n",
        "    everything = everything + chunk"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kiMx3Y3qt2fD"
      },
      "source": [
        "#### Sorting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "IIgUBe11t2fE"
      },
      "source": [
        "a = [7, 2, 5, 1, 3]\n",
        "a.sort()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xjROpLNzt2fJ"
      },
      "source": [
        "b = ['saw', 'small', 'He', 'foxes', 'six']\n",
        "b.sort(key=len)\n",
        "b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ohbNaijbt2fN"
      },
      "source": [
        "#### Binary search and maintaining a sorted list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tzIiq8kjt2fP"
      },
      "source": [
        "import bisect\n",
        "c = [1, 2, 2, 2, 3, 4, 7]\n",
        "bisect.bisect(c, 2)\n",
        "bisect.bisect(c, 5)\n",
        "bisect.insort(c, 6)\n",
        "c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "WoRF1zQnt2fW"
      },
      "source": [
        "#### Slicing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "RMJqSulHt2fe"
      },
      "source": [
        "seq = [7, 2, 3, 7, 5, 6, 0, 1]\n",
        "seq[1:5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QaKXzpzht2fm"
      },
      "source": [
        "seq[3:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "XYUlD-9tt2fq"
      },
      "source": [
        "#Slices can also be assigned to with a sequence:\n",
        "seq[3:4] = [6, 3]\n",
        "seq"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5FvYO7eGt2fv"
      },
      "source": [
        "While the element at the start index is included, the stop index is not included, so\n",
        "that the number of elements in the result is stop - start."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yJZxUr8jt2fw"
      },
      "source": [
        "seq[:5]\n",
        "seq[3:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "3Sse7nygt2f4"
      },
      "source": [
        "#Negative indices slice the sequence relative to the end:\n",
        "\n",
        "seq[-4:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wa70r09qt2f9"
      },
      "source": [
        "seq[-6:-2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YBU2H0UQt2gD"
      },
      "source": [
        "   see page 59"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xfCQInNUt2gE"
      },
      "source": [
        "#A step can also be used after a second colon to, say, take every other element:\n",
        "seq[::2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "aOYY1q4et2gI"
      },
      "source": [
        "#reverse alistor tuple\n",
        "seq[::-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ua9SNOmBt2gP"
      },
      "source": [
        "### Built-in Sequence Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tFuuAolPt2gQ"
      },
      "source": [
        "#### enumerate"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "EgwVb3Ult2gR"
      },
      "source": [
        "# enumerate returns asequence of (i, value) tuples:\n",
        "for i, value in enumerate(collection):\n",
        "   # do something with value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oQWe3suOt2gb"
      },
      "source": [
        "When you are indexing data, a helpful pattern that uses enumerate is computing a dict mapping the values of a sequence (which are assumed to be unique) to their locations in the sequence:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qesuRXJYt2gb"
      },
      "source": [
        "some_list = ['foo', 'bar', 'baz']\n",
        "mapping = {}\n",
        "type(mapping)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m0CH9ySRt2gg"
      },
      "source": [
        "for i, v in enumerate(some_list):\n",
        "    print(i,v)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "liPpsAAht2g0"
      },
      "source": [
        "for i, v in enumerate(some_list):\n",
        "    mapping[v] = i\n",
        "mapping"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9t86lGyUt2g-"
      },
      "source": [
        "#### sorted"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x3pQOF4jt2hB"
      },
      "source": [
        "The sorted function returns a new sorted list from the elements of any sequence:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "LHAmJg6at2hC"
      },
      "source": [
        "sorted([7, 1, 2, 6, 0, 3, 2])\n",
        "sorted('horse race')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1zY_7c-pt2hS"
      },
      "source": [
        "#### zip"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "omI_rTqit2hS"
      },
      "source": [
        "zip “pairs” up the elements of a number of lists, tuples, or other sequences to create a list of tuples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "r8bILheTt2hY"
      },
      "source": [
        "seq1 = ['foo', 'bar', 'baz']\n",
        "seq2 = ['one', 'two', 'three']\n",
        "zipped = zip(seq1, seq2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "r6B1uA-It2hh"
      },
      "source": [
        "list(zipped)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "02xDmoVtt2hl"
      },
      "source": [
        "seq3 = [False, True]\n",
        "list(zip(seq1, seq2, seq3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sihfWYoFt2ht"
      },
      "source": [
        "A very common use of zip is simultaneously iterating over multiple sequences, possi‐\n",
        "bly also combined with enumerate:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kX_7iRRmt2hu"
      },
      "source": [
        "for i, (a, b) in enumerate(zip(seq1, seq2)):\n",
        "    print('{0}: {1}, {2}'.format(i, a, b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GXKBUkCWt2h1"
      },
      "source": [
        "Given a “zipped” sequence, zip can be applied in a clever way to “unzip” the sequence. Another way to think about this is converting a list of rows into a list of columns. The syntax, which looks a bit magical, is:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "v2lYX1aOt2h1"
      },
      "source": [
        "pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),\n",
        "            ('Schilling', 'Curt')]\n",
        "first_names, last_names = zip(*pitchers)\n",
        "first_names\n",
        "last_names"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wAIspiwUt2h6"
      },
      "source": [
        "#### reversed"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XtlXKdqmt2h7"
      },
      "source": [
        " reversed is a <b>generator</b> , so it does not create the reversed sequence until materialized"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "MQ_9LO-8t2h8"
      },
      "source": [
        "list(reversed(range(10)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "jlYruuvit2iF"
      },
      "source": [
        "### dict (aka hash map or associative array)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nJy3Gggbt2iG"
      },
      "source": [
        "dict is a flexibly sized collection of key-value pairs, where key and value are Python objects. One approach for creating one is to use curly braces {} and colons to separate keys and values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "fJVf64qRt2iG"
      },
      "source": [
        "empty_dict = {}\n",
        "d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]}\n",
        "d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9sT0UpqOt2iN"
      },
      "source": [
        "#You can access, insert, or set elements using the same syntax as for accessing elements of a list :\n",
        "d1[7] = 'an integer'\n",
        "d1\n",
        "d1[7]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "COSRuk4tt2iS"
      },
      "source": [
        "#You can check if a dict contains a !key!  with in keyword\n",
        "'b' in d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ipHmMsRvt2iV"
      },
      "source": [
        "d1[5] = 'some value'\n",
        "d1\n",
        "d1['dummy'] = 'another value'\n",
        "d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "MfwdRoo0t2iY"
      },
      "source": [
        "#You can delete values either using the del keyword \n",
        "#or the pop method (which simul‐ taneously returns the value and deletes the key):\n",
        "del d1[5]\n",
        "d1\n",
        "ret = d1.pop('dummy')\n",
        "ret"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "sXhmMk1-t2ic"
      },
      "source": [
        "d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UqfhC7Gzt2if"
      },
      "source": [
        "list(d1.keys())\n",
        "list(d1.values())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X9yrIYkmt2ik"
      },
      "source": [
        "d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "uJUcNaght2iq"
      },
      "source": [
        "#You can merge one dict into another using \n",
        "d1.update({'b' : 'foo', 'c' : 12})\n",
        "d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "M4wzf-Q4t2iw"
      },
      "source": [
        "#### Creating dicts from sequences"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xzCNr9I8t2ix"
      },
      "source": [
        "mapping = {}\n",
        "mapping[\"yeni\"]=2\n",
        "mapping"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "WgOxOu7Ot2i2"
      },
      "source": [
        "for key, value in zip(key_list, value_list):\n",
        "    mapping[key] = value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "rlXGwnG5t2jB"
      },
      "source": [
        "#Since a dict is essentially a collection of 2-tuples, the dict function accepts a list of 2-tuples:\n",
        "mapping = dict(zip(range(5), reversed(range(5))))\n",
        "mapping\n",
        "ls=[1,2]\n",
        "ls2=[\"a\",\"b\"]\n",
        "dict(zip(ls,ls2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "mjIX_MiNt2jH"
      },
      "source": [
        "#### Default values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9tFRgiegt2jH"
      },
      "source": [
        "#this is equivalent\n",
        "if key in some_dict:\n",
        "    value = some_dict[key]\n",
        "else:\n",
        "    value = default_value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CTPrg6P1t2jK"
      },
      "source": [
        "#to this\n",
        "value = some_dict.get(key, default_value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "BeegKmdWt2jT",
        "outputId": "7a7c81c5-da58-4a96-a074-fe996896fe06"
      },
      "source": [
        "words = ['apple', 'bat', 'bar', 'atom', 'book']\n",
        "by_letter = {}\n",
        "for word in words:\n",
        "    letter = word[0]\n",
        "    if letter not in by_letter:\n",
        "        by_letter[letter] = [word]\n",
        "    else:\n",
        "        by_letter[letter].append(word)\n",
        "by_letter\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "z_lIsaAGt2jX"
      },
      "source": [
        "for word in words:\n",
        "    letter = word[0]\n",
        "    by_letter.setdefault(letter, []).append(word)\n",
        "by_letter    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDIg2c-gt2ja"
      },
      "source": [
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "7HjLun4Yt2ja"
      },
      "source": [
        "\n",
        "for word in words:\n",
        "    letter = word[0]\n",
        "    by_letter.setdefault(letter, []).append(word)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dOfPQKWQt2jg"
      },
      "source": [
        "The built-in collections module has a useful class, defaultdict, which makes this even easier. To create one, you pass a type or function for generating the default value for each slot in the dict:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "VJ7WHVt_t2jg"
      },
      "source": [
        "from collections import defaultdict\n",
        "by_letter = defaultdict(list)\n",
        "for word in words:\n",
        "    by_letter[word[0]].append(word)\n",
        "by_letter\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "bdEcehBBt2jj"
      },
      "source": [
        "#### Valid dict key types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "shUtcFXHt2jj"
      },
      "source": [
        "While the values of a dict can be any Python object, the keys generally have to be immutable objects like scalar types (int, float, string) or tuples (all the objects in the tuple need to be immutable, too). The technical term here is hashability. You can check whether an object is hashable (can be used as a key in a dict) with the hash function:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Vwto_not2jk"
      },
      "source": [
        "To use a list as a key, one option is to convert it to a tuple, which can be hashed as long as its elements also can:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "MaIlXxePt2jl"
      },
      "source": [
        "d = {}\n",
        "d[tuple([1, 2, 3])] = 5\n",
        "d"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "8UgrOKLQt2jt"
      },
      "source": [
        "### set"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fOGrvk2pt2jt"
      },
      "source": [
        "A set is an unordered collection of unique elements.  A set can be created in two ways: via the set function or via a set literal with curly braces:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "26HAy4ftt2ju"
      },
      "source": [
        "set([2, 2, 2, 1, 3, 3])\n",
        "{2, 2, 2, 1, 3, 3}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kV817qnAt2j0"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "U06vUYb_t2j7"
      },
      "source": [
        "a = {1, 2, 3, 4, 5}\n",
        "b = {3, 4, 5, 6, 7, 8}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GtIQ2v3ct2kB"
      },
      "source": [
        "Sets support mathematical set operations like union, intersection, difference, and symmetric difference."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "5QnxxMPUt2kC"
      },
      "source": [
        "a.union(b)\n",
        "a | b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ZPZqPM8Nt2kH"
      },
      "source": [
        "a.intersection(b)\n",
        "a & b\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xd4glADPt2kN"
      },
      "source": [
        "All of the logical set operations have <b>in-place</b> counterparts, which enable you to replace the contents of the set on the left side of the operation with the result. For very large sets, this may be more efficient:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1LL4-NE5t2kO"
      },
      "source": [
        "c = a.copy()\n",
        "c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "G1Pre5P_t2kT"
      },
      "source": [
        "c |= b\n",
        "\n",
        "c"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_aaPtYxgt2kk"
      },
      "source": [
        "d = a.copy()\n",
        "d &= b\n",
        "d"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1fF0YS8Zt2kx"
      },
      "source": [
        "Like dicts, set elements generally must be immutable. To have list-like elements, you must convert it to a tuple:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Zkzbemi-t2ky"
      },
      "source": [
        "my_data = [1, 2, 3, 4]\n",
        "my_set = {tuple(my_data)}\n",
        "my_set"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ePB9q-Out2k9"
      },
      "source": [
        "a_set = {1, 2, 3, 4, 5}\n",
        "{1, 2, 3}.issubset(a_set)\n",
        "a_set.issuperset({1, 2, 3})"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oNu7bTTot2lH"
      },
      "source": [
        "Sets are equal if and only if their contents are equal:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UJhu9vc4t2lI"
      },
      "source": [
        "{1, 2, 3} == {3, 2, 1}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "sWX3aHeXt2lX"
      },
      "source": [
        "### List, Set, and Dict Comprehensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "4z1IV--Xt2lZ"
      },
      "source": [
        "[expr for val in collection if condition] \n",
        "#This is equivalent to the following for loop:\n",
        "result = []\n",
        "for val in collection:\n",
        "    if condition: result.append(expr)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LuE0pJ9qt2lf"
      },
      "source": [
        "The filter condition can be omitted, leaving only the expression"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_1Niz0zOt2lu"
      },
      "source": [
        "strings = ['a', 'as', 'bat', 'car', 'dove', 'python']\n",
        "[x.upper() for x in strings if len(x) > 2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "rO--0wY1t2mE"
      },
      "source": [
        "Set and dict comprehensions are a natural extension, producing sets and dicts in an\n",
        "idiomatically similar way instead of lists. A dict comprehension looks like this:<br>\n",
        "<b>dict_comp = {key-expr : value-expr for value in collection if condition}</b>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tkWPWi0dt2mF"
      },
      "source": [
        "sA set comprehension looks like the equivalent list comprehension except with curly braces instead of square brackets:<br>\n",
        "<b>set_comp = {expr for value in collection if condition}</b>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dcnr-WiIt2mF"
      },
      "source": [
        "unique_lengths = {len(x) for x in strings}\n",
        "unique_lengths"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "bjnYe752t2mP"
      },
      "source": [
        "set(map(len, strings))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TvnLP2b7t2mY"
      },
      "source": [
        "As a simple dict comprehension example, we could create a lookup map of these strings to their locations in the list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ktGQwEkSt2mZ"
      },
      "source": [
        "loc_mapping = {val : index for index, val in enumerate(strings)}\n",
        "loc_mapping"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dyOheHipt2mc"
      },
      "source": [
        "#### Nested list comprehensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "20Ag5O-ct2md"
      },
      "source": [
        "all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],\n",
        "            ['Meriae', 'Juan', 'Javier', 'Natalia', 'Pilar']]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "VciNBIrlt2mn"
      },
      "source": [
        "Now, suppose we wanted to get a single list containing all names with two or more e’s in them"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "jaGiGBBnt2mq"
      },
      "source": [
        "names_of_interest = [] \n",
        "for names in all_data:\n",
        "    enough_es = [name for name in names if name.count('e') >= 2]\n",
        "    names_of_interest.extend(enough_es)\n",
        "names_of_interest"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "TFGLacOmt2mv"
      },
      "source": [
        "result = [name for names in all_data \n",
        "          for name in names\n",
        "          if name.count('e') >= 2]\n",
        "result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mhdkRlrmt2mz"
      },
      "source": [
        "The for parts of the list comprehension are arranged according to the order of nesting, and any filter condition is put at the end as before. Here is another example where we “flatten” a list of tuples of integers into a simple list of integers:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f7Qk5hoZt2m1"
      },
      "source": [
        "flattened = []\n",
        "for tup in some_tuples: for x in tup:\n",
        "            flattened.append(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ZeDn8FgQt2m-"
      },
      "source": [
        "some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]\n",
        "flattened = [x for tup in some_tuples \n",
        "             for x in tup]\n",
        "flattened"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_lO3bjRut2nC"
      },
      "source": [
        "fYou can have arbitrarily many levels of nesting, though if you have more than two or three levels of nesting you should probably start to question whether this makes sense from a code readability standpoint. It’s important to distinguish the syntax just shown from a list comprehension inside a list comprehension, which is also perfectly valid:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "eaSWZCO0t2nL"
      },
      "source": [
        "[[x for x in tup] for tup in some_tuples]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kDgGSjFKt2nV"
      },
      "source": [
        "## Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YB7scjmAt2nW"
      },
      "source": [
        "Functions are declared with the def keyword and returned from with the return key‐word:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "qDbrdXwWt2nX"
      },
      "source": [
        "def my_function(x, y, z=1.5):\n",
        "    if z > 1:\n",
        "        return z * (x + y)\n",
        "    else:\n",
        "        return z / (x + y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TIaWfP4-t2nt"
      },
      "source": [
        "Each function can have positional arguments and keyword arguments. Keyword arguments are most commonly used to specify default values or optional arguments. In the preceding function, x and y are positional arguments while z is a keyword argu‐ment. This means that the function can be called in any of these ways:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "fEseEc2Jt2nu"
      },
      "source": [
        "my_function(5, 6, z=0.7)\n",
        "my_function(3.14, 7, 3.5)\n",
        "my_function(10, 20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dBF-PVPJt2oO"
      },
      "source": [
        "<p>The main restriction on function arguments is that the keyword arguments must fol‐ low the positional arguments (if any). You can specify keyword arguments in any order; this frees you from having to remember which order the function arguments were specified in and only what their names are.</p><p>\n",
        "It is possible to use keywords for passing positional arguments as well. In the preceding example, we could also have written:</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8bmn31X9t2ob"
      },
      "source": [
        "my_function(x=5, y=6, z=7)\n",
        "my_function(y=6, x=5, z=7)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "N5glqxKIt2og"
      },
      "source": [
        "### Namespaces, Scope, and Local Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "c2_BZqLNt2ok"
      },
      "source": [
        "def func():\n",
        "    a = []\n",
        "    for i in range(5):\n",
        "        a.append(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "58EvdsMBt2pF"
      },
      "source": [
        "a = []\n",
        "def func():\n",
        "    for i in range(5):\n",
        "        a.append(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sev6gNvht2pI"
      },
      "source": [
        "Assigning variables outside of the function’s scope is possible, but those variables must be declared as global via the global keyword:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dVfYPPXwt2pI"
      },
      "source": [
        "a = None\n",
        "def bind_a_variable():\n",
        "    global a\n",
        "    a = []\n",
        "bind_a_variable()\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "7n1ZDtOTt2pW"
      },
      "source": [
        "### Returning Multiple Values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_yUkOE5xt2pX"
      },
      "source": [
        "def f():\n",
        "    a = 5\n",
        "    b = 6\n",
        "    c = 7\n",
        "    return a, b, c\n",
        "\n",
        "a, b, c = f()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wPqxzsEpt2pr"
      },
      "source": [
        "return_value = f()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tDQMK-NRt2pu"
      },
      "source": [
        "def f():\n",
        "    a = 5\n",
        "    b = 6\n",
        "    c = 7\n",
        "    return {'a' : a, 'b' : b, 'c' : c}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_RlMnGC9t2p8"
      },
      "source": [
        "### Functions Are Objects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "t2CWIL9Xt2qB"
      },
      "source": [
        "states = ['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda',\n",
        "          'south   carolina##', 'W-est virginia?']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "8xLcYUZht2qM"
      },
      "source": [
        "import re\n",
        "\n",
        "def clean_strings(strings):\n",
        "    result = []\n",
        "    for value in strings:\n",
        "        value = value.strip()\n",
        "        value = re.sub('[!#?-]', '', value)\n",
        "        value = value.title()\n",
        "        result.append(value)\n",
        "    return result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "V-edkKRvt2qP",
        "outputId": "149c0de8-8238-4a12-af84-cbc0bb50d246"
      },
      "source": [
        "clean_strings(states)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Alabama',\n",
              " 'Georgia',\n",
              " 'Georgia',\n",
              " 'Georgia',\n",
              " 'Florida',\n",
              " 'South   Carolina',\n",
              " 'West Virginia']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ihllxOZDt2qU"
      },
      "source": [
        "def remove_punctuation(value):\n",
        "    return re.sub('[!#?]', '', value)\n",
        "\n",
        "clean_ops = [str.strip, remove_punctuation, str.title]\n",
        "\n",
        "def clean_strings(strings, ops):\n",
        "    result = []\n",
        "    for value in strings:\n",
        "        for function in ops:\n",
        "            value = function(value)\n",
        "        result.append(value)\n",
        "    return result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "5IfH0oxxt2qY"
      },
      "source": [
        "clean_strings(states, clean_ops)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tE9ja6Wrt2qb"
      },
      "source": [
        "<p>A more functional pattern like this enables you to easily modify how the strings are transformed at a very high level. The clean_strings function is also now more reus‐ able and generic.</p>\n",
        "You can use <i>functions<i > as arguments to other functions like the built-in <b>map</b>:function, which applies a function to a sequence of some kind:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UZVNjykvt2qc"
      },
      "source": [
        "for x in map(remove_punctuation, states):\n",
        "    print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Yqmxu2GOt2qe"
      },
      "source": [
        "### Anonymous (Lambda) Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ee9-_JeDt2qk"
      },
      "source": [
        "lambda functions are a way of writing functions consisting of a single statement, the result of which is the return value. They are defined with the lambda keyword."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "zpRRjc4Ft2qm"
      },
      "source": [
        "def short_function(x):\n",
        "    return x * 2\n",
        "#equivalent \n",
        "equiv_anon = lambda x: x * 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SAuNzFz0t2q0"
      },
      "source": [
        "def apply_to_list(some_list, f):\n",
        "    return [f(x) for x in some_list]\n",
        "\n",
        "ints = [4, 0, 1, 5, 6]\n",
        "apply_to_list(ints, lambda x: x * 2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "fwwiPBJht2q8"
      },
      "source": [
        "As another example, suppose you wanted to sort a collection of strings by the number of distinct letters in each string:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "C1E4zgw_t2q9"
      },
      "source": [
        "strings = ['foo', 'card', 'bar', 'aaaa', 'abab']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6HRFKyqOt2rG"
      },
      "source": [
        "strings.sort(key=lambda x: len(set(list(x))))\n",
        "strings"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "by9w9hArt2rJ"
      },
      "source": [
        "### Currying: Partial Argument Application"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k_75j541t2rK"
      },
      "source": [
        "Currying is computer science jargon (named after the mathematician Haskell Curry) that means deriving new functions from existing ones by partial argument applica‐ tion. For example, suppose we had a trivial function that adds two numbers together:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "p3wQ8rB3t2rL"
      },
      "source": [
        "def add_numbers(x, y):\n",
        "    return x + y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1W9wlgM_t2rV"
      },
      "source": [
        "add_five = lambda y: add_numbers(5, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZJP99mJyt2re"
      },
      "source": [
        "The second argument to add_numbers is said to be curried. There’s nothing very fancy here, as all we’ve really done is define a new function that calls an existing function. The built-in functools module can simplify this process using the partial function:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0NHZC6vYt2ri"
      },
      "source": [
        "from functools import partial\n",
        "add_five = partial(add_numbers, 5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "YrOvJXSQt2r1"
      },
      "source": [
        "### Generators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "oONkuj9dt2r3"
      },
      "source": [
        "some_dict = {'a': 1, 'b': 2, 'c': 3}\n",
        "for key in some_dict:\n",
        "    print(key)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S_7aSxRot2sS"
      },
      "source": [
        "When you write for key in some_dict, the Python interpreter first attempts to cre‐ ate an iterator out of some_dict:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "TE6aPkuGt2sZ"
      },
      "source": [
        "dict_iterator = iter(some_dict)\n",
        "dict_iterator"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SG3jQ4L-t2sj"
      },
      "source": [
        "\n",
        "An iterator is any object that will yield objects to the Python interpreter when used in a context like a for loop. Most methods expecting a list or list-like object will also accept any iterable object. This includes built-in methods such as min, max, and sum, and type constructors like list and tuple:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "HXITrZYat2sk"
      },
      "source": [
        "list(dict_iterator)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GlM12jAmt2sp"
      },
      "source": [
        "A generator is a concise way to construct a new iterable object. Whereas normal func‐ tions execute and return a single result at a time, generators return a sequence of multiple results lazily, pausing after each one until the next one is requested. To create a generator, use the yield keyword instead of return in a function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "LSp33eaIt2sq"
      },
      "source": [
        "def squares(n=10):\n",
        "    print('Generating squares from 1 to {0}'.format(n ** 2))\n",
        "    for i in range(1, n + 1):\n",
        "        yield i ** 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ofh8Vbgrt2te",
        "outputId": "8c7133a4-4c94-4e2a-a407-eb067a20c332"
      },
      "source": [
        "gen = squares()\n",
        "gen"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<generator object squares at 0x10bd584f8>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cMyBwmcst2t2"
      },
      "source": [
        "It is not until you request elements from the generator that it begins executing its code:\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xtVb5t0it2t3",
        "outputId": "a57c5268-0078-4bf3-bbc3-9d2bd577b224"
      },
      "source": [
        "for x in gen:\n",
        "    print(x, end=' ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Generating squares from 1 to 100\n",
            "1 4 9 16 25 36 49 64 81 100 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "WDkRLahHt2uD"
      },
      "source": [
        "#### Generator expresssions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7vscG4ZIt2uE"
      },
      "source": [
        "Another even more concise way to make a generator is by using a generator expres‐ sion. This is a generator analogue to list, dict, and set comprehensions; to create one, enclose what would otherwise be a list comprehension within parentheses instead of brackets:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "TZ1ZXnort2uE",
        "outputId": "c10b1e33-9368-4278-ec01-11af394c7ae5"
      },
      "source": [
        "gen = (x ** 2 for x in range(100))\n",
        "gen"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<generator object <genexpr> at 0x10bd587c8>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wKX86scKt2uG"
      },
      "source": [
        "#which is equivalent to\n",
        "def _make_gen():\n",
        "    for x in range(100):\n",
        "        yield x ** 2\n",
        "gen = _make_gen()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YfQuHoNct2uO"
      },
      "source": [
        "Generator expressions can be used instead of list comprehensions as function argu‐ ments in many cases:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "s-4yGVa1t2uP"
      },
      "source": [
        "sum(x ** 2 for x in range(100))\n",
        "dict((i, i **2) for i in range(5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SwDuJVxtt2uZ"
      },
      "source": [
        "#### itertools module"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "g-lClNCKt2ua",
        "outputId": "cf17f057-50b1-44e7-8728-1040df27e6cc"
      },
      "source": [
        "import itertools\n",
        "first_letter = lambda x: x[0]\n",
        "names = ['Alan', 'Adam', 'Wes', 'Will', 'Albert', 'Steven']\n",
        "for letter, names in itertools.groupby(names, first_letter):\n",
        "    print(letter, list(names)) # names is a generator"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A ['Alan', 'Adam']\n",
            "W ['Wes', 'Will']\n",
            "A ['Albert']\n",
            "S ['Steven']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "seDh0otBt2uj"
      },
      "source": [
        "### Errors and Exception Handling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "UkU0xEWXt2uk"
      },
      "source": [
        "float('1.2345')\n",
        "float('something')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "gP5e6xeqt2um"
      },
      "source": [
        "def attempt_float(x):\n",
        "    try:\n",
        "        return float(x)\n",
        "    except:\n",
        "        return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Q7OkU_SSt2ur"
      },
      "source": [
        "attempt_float('1.2345')\n",
        "attempt_float('something')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "p31_aizgt2uw"
      },
      "source": [
        "float((1, 2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "aPhhHhzat2uy"
      },
      "source": [
        "def attempt_float(x):\n",
        "    try:\n",
        "        return float(x)\n",
        "    except ValueError:\n",
        "        return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dhx0iwtRt2u7"
      },
      "source": [
        "attempt_float((1, 2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "uMt0jTMNt2vA"
      },
      "source": [
        "def attempt_float(x):\n",
        "    try:\n",
        "        return float(x)\n",
        "    except (TypeError, ValueError):\n",
        "        return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SIcWfx81t2vG"
      },
      "source": [
        "f = open(path, 'w')\n",
        "\n",
        "try:\n",
        "    write_to_file(f)\n",
        "finally:\n",
        "    f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "PRMfReySt2vM"
      },
      "source": [
        "f = open(path, 'w')\n",
        "\n",
        "try:\n",
        "    write_to_file(f)\n",
        "except:\n",
        "    print('Failed')\n",
        "else:\n",
        "    print('Succeeded')\n",
        "finally:\n",
        "    f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "QFTUPubEt2vU"
      },
      "source": [
        "#### Exceptions in IPython"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "je8Z6GrOt2vV"
      },
      "source": [
        "In [10]: %run examples/ipython_bug.py\n",
        "---------------------------------------------------------------------------\n",
        "AssertionError                            Traceback (most recent call last)\n",
        "/home/wesm/code/pydata-book/examples/ipython_bug.py in <module>()\n",
        "     13     throws_an_exception()\n",
        "     14\n",
        "---> 15 calling_things()\n",
        "\n",
        "/home/wesm/code/pydata-book/examples/ipython_bug.py in calling_things()\n",
        "     11 def calling_things():\n",
        "     12     works_fine()\n",
        "---> 13     throws_an_exception()\n",
        "     14\n",
        "     15 calling_things()\n",
        "\n",
        "/home/wesm/code/pydata-book/examples/ipython_bug.py in throws_an_exception()\n",
        "      7     a = 5\n",
        "      8     b = 6\n",
        "----> 9     assert(a + b == 10)\n",
        "     10\n",
        "     11 def calling_things():\n",
        "\n",
        "AssertionError:"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vtfV478Bt2vY"
      },
      "source": [
        "## Files and the Operating System"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wmeBTllQt2va"
      },
      "source": [
        "%pushd book-materials"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wZbpNcYyt2vf"
      },
      "source": [
        "path = 'examples/segismundo.txt'\n",
        "f = open(path)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tSpNuCn3t2vi"
      },
      "source": [
        "for line in f:\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O1TqeEJit2vm"
      },
      "source": [
        "The lines come out of the file with the end-of-line (EOL) markers intact, so you’ll often see code to get an EOL-free list of lines in a file like:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "PibYrrnUt2vn"
      },
      "source": [
        "lines = [x.rstrip() for x in open(path)]\n",
        "lines"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "p3FW5llut2vp"
      },
      "source": [
        "f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "mBolliIDt2vr"
      },
      "source": [
        "with open(path) as f:\n",
        "    lines = [x.rstrip() for x in f]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OSVHj4Rct2vw"
      },
      "source": [
        "This will automatically close the file f when exiting the <b>with</b> block."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yuucfv60t2vy"
      },
      "source": [
        "If we had typed f = open(path, 'w'), a new file at examples/segismundo.txt would have been created (be careful!), overwriting any one in its place. There is also the 'x' file mode, which creates a writable file but fails if the file path already exists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "eDvl5whHt2vz"
      },
      "source": [
        "f = open(path)\n",
        "f.read(10)\n",
        "f2 = open(path, 'rb')  # Binary mode\n",
        "f2.read(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "VDMZ-xjEt2v5"
      },
      "source": [
        "f.tell()\n",
        "f2.tell()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6X6vt4MCt2v8"
      },
      "source": [
        "import sys\n",
        "sys.getdefaultencoding()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0q_DZCTtt2wA"
      },
      "source": [
        "f.seek(3)\n",
        "f.read(1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "14Lw22Uot2wF"
      },
      "source": [
        "f.close()\n",
        "f2.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IvpN1Xaot2wO"
      },
      "source": [
        "To write text to a file, you can use the file’s write or writelines methods. For exam‐\n",
        "ple, we could create a version of prof_mod.py with no blank lines like so:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "N31KXhVdt2wP"
      },
      "source": [
        "with open('tmp.txt', 'w') as handle:\n",
        "    handle.writelines(x for x in open(path) if len(x) > 1)\n",
        "with open('tmp.txt') as f:\n",
        "    lines = f.readlines()\n",
        "lines"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "jh96d_Lrt2wS"
      },
      "source": [
        "import os\n",
        "os.remove('tmp.txt')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "S1usTm_Pt2wV"
      },
      "source": [
        "### Bytes and Unicode with Files"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "QXDMAAOHt2wW"
      },
      "source": [
        "with open(path) as f:\n",
        "    chars = f.read(10)\n",
        "chars"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SNuwVRYet2wY"
      },
      "source": [
        "with open(path, 'rb') as f:\n",
        "    data = f.read(10)\n",
        "data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "YQVBPa5ut2wd"
      },
      "source": [
        "data.decode('utf8')\n",
        "data[:4].decode('utf8')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Q4oKPKBGt2wl"
      },
      "source": [
        "sink_path = 'sink.txt'\n",
        "with open(path) as source:\n",
        "    with open(sink_path, 'xt', encoding='iso-8859-1') as sink:\n",
        "        sink.write(source.read())\n",
        "with open(sink_path, encoding='iso-8859-1') as f:\n",
        "    print(f.read(10))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "iljtScgOt2wo"
      },
      "source": [
        "os.remove(sink_path)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "g6JmtA88t2wx"
      },
      "source": [
        "f = open(path)\n",
        "f.read(5)\n",
        "f.seek(4)\n",
        "f.read(1)\n",
        "f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-Qc_afcat2w1"
      },
      "source": [
        "%popd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "VeWigHV_t2w6"
      },
      "source": [
        "## Conclusion"
      ]
    }
  ]
}