ch02-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": "ch02-Copy1.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "2Pvm8yYybPkP"
      },
      "source": [
        "# Python Language Basics\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "j-gBMOy6bPkR"
      },
      "source": [
        "### About Magic Commands"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "d4XEPic4bPkS"
      },
      "source": [
        "IPython’s special commands (which are not built into Python itself) are known as “magic” commands. These are designed to facilitate common tasks and enable you to easily control the behavior of the IPython system.\n",
        "A magic command is any command prefixed by the percent symbol %. For example, you can check the execution time of any Python statement, such as a matrix multiplication, using the %timeit magic function "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SZXeDLzZbPkT"
      },
      "source": [
        "```python\n",
        "In [20]: a = np.random.randn(100, 100)\n",
        "\n",
        "In [20]: %timeit np.dot(a, a)\n",
        "10000 loops, best of 3: 20.9 µs per loop\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cVArjRepbPkU"
      },
      "source": [
        "%magic :Display detailed documentation for all of the available magic commands"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tlA5Bc9MbPkV"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6WJgA1wGbPkW"
      },
      "source": [
        "### Matplotlib Integration"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JwE2ADFGbPkX"
      },
      "source": [
        "if you want to see the graphics in your jupiter notebook use the %matplotlib magic command\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "YfyB1E2fbPkY"
      },
      "source": [
        "```python\n",
        "In [26]: %matplotlib inline\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "e884hytFbPkZ"
      },
      "source": [
        "## Python Language Basics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "gdZLlKaibPkb"
      },
      "source": [
        "### Language Semantics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "VrHBR8dBbPkc"
      },
      "source": [
        "#### Indentation, not braces"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_dBh-kIpbPkd"
      },
      "source": [
        "```python\n",
        "for x in array:\n",
        "    if x < pivot:\n",
        "        less.append(x)\n",
        "    else:\n",
        "        greater.append(x)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v2lJKn0hbPke"
      },
      "source": [
        "for mulitple statements in a single line (discouraged)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FRTlGf6DbPkg"
      },
      "source": [
        "```python\n",
        "a = 5; b = 6; c = 7\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YqD0NoB0bTnJ",
        "outputId": "ed6702db-1d7a-4fa6-bf5a-ebfb91273a70",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "variablename=5\n",
        "variablename"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B-vwKOSDbtPm",
        "outputId": "8423c448-4d0d-4ecc-d276-9374ab56bd90",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "variablename=5.0\n",
        "\n",
        "variablename"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l2DbrKpfb_oD"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "weLRZWmucBVf",
        "outputId": "3e1699ef-d35a-412b-c035-556d0556c981",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "def foo(x,y=4):\n",
        "   a=3\n",
        "   b=4\n",
        "   return x+y\n",
        "print(\"hello world\") \n",
        "print(foo(5,4)) \n",
        "print(foo(4))"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello world\n",
            "9\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "xHskfdiVbPkm"
      },
      "source": [
        "#### Everything is an object"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tg-h6sThbPkp"
      },
      "source": [
        "#### Comments"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "W-KjyB6ebPkq"
      },
      "source": [
        "```python\n",
        "results = []\n",
        "for line in file_handle:\n",
        "    # keep the empty lines for now\n",
        "    # if len(line) == 0:\n",
        "    #   continue\n",
        "    results.append(line.replace('foo', 'bar'))\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Kp-9fNUgbPkr"
      },
      "source": [
        "```python\n",
        "print(\"Reached this line\")  # Simple status report\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dgUWEan1bPks"
      },
      "source": [
        "#### Function and object method calls"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "5V98narlbPks"
      },
      "source": [
        "```\n",
        "result = f(x, y, z)\n",
        "g()\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "DwarfuOJbPku"
      },
      "source": [
        "```\n",
        "obj.some_method(x, y, z)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PYz8AwVhbPkw"
      },
      "source": [
        "Functions can take both positional and keyword arguments:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "AN-OKiWubPkx"
      },
      "source": [
        "```python\n",
        "result = f(a, b, c, d=5, e='foo')\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "AXShU7ctbPky"
      },
      "source": [
        "#### Variables and argument passing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H1Qbvv92bPkz"
      },
      "source": [
        "When assigning a variable (or name) in Python, you are creating a reference to the object on the righthand side of the equals sign."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wxoyXEnlbPk0"
      },
      "source": [
        "a = [1, 2, 3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yDlN_bMMbPk7"
      },
      "source": [
        "b = a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "HalG8BYqbPlB",
        "outputId": "6565fc59-d0e3-4410-e586-3d92e06fa458"
      },
      "source": [
        "a.append(2)# dot operation, append() method belongs to class of lists\n",
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 2]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ITZSX8l8bPlI"
      },
      "source": [
        "Assignment is also referred to as binding, as we are binding a name to an object. \n",
        "<p>\n",
        "When you pass objects as arguments to a function, new local variables are created referencing the original objects without any copying.\n",
        "</p>\n",
        "If you bind a new object to a variable inside a function, that change will not be reflected in the parent scope. It is therefore possible to alter the internals of a <b>mutable</b> argument. Suppose we had the following function:</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "_DNEqGKKbPlK"
      },
      "source": [
        "```python\n",
        "def append_element(some_list, element):\n",
        "    some_list.append(element)\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "QvqjN49ubPlL"
      },
      "source": [
        "```python\n",
        "In [27]: data = [1, 2, 3]\n",
        "\n",
        "In [28]: append_element(data, 4)\n",
        "\n",
        "In [29]: data\n",
        "Out[29]: [1, 2, 3, 4]\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-pw6C0DgbPlM"
      },
      "source": [
        "#### Dynamic references, strong types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xIL2d2KzbPlN"
      },
      "source": [
        "Object references in Python have no type associated with them"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CoACaTFubPlO",
        "outputId": "10840345-8e2f-4f6f-a2c2-c7af21822272",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = 5\n",
        "type(a)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "w28r59xIbPlV",
        "outputId": "8b4d9a0e-de2c-4cac-c017-fb1119e1bd63"
      },
      "source": [
        "a = 'foo'\n",
        "type(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9r5Pg40DbPla"
      },
      "source": [
        "Python is considered a strongly typed"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "E3sHMW82bPlb",
        "outputId": "503c9880-76b9-4840-8c0f-ba4110d6d388"
      },
      "source": [
        "'5' + 5 # in some scripting languages this statement will output 55"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "can only concatenate str (not \"int\") to str",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-4dd8efb5fac1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'5'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "2nv3PZvsbPlh"
      },
      "source": [
        "a = 4.5\n",
        "b = 2\n",
        "# String formatting, to be visited later\n",
        "print('a is {0}, b is {1}'.format(type(a), type(b)))\n",
        "a / b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "DDzopQ6UbPlm"
      },
      "source": [
        "a = 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kmcCeTCgbPlu"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "A7pt7-BybPl1",
        "outputId": "31b21c23-9575-4a4d-8b2b-e9fc37931d92"
      },
      "source": [
        "isinstance(a, int)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "jvjwmfstbPl5",
        "outputId": "cba11732-3be6-427e-9a45-2a717edacb68"
      },
      "source": [
        "a=\"a string\"\n",
        "isinstance(a, str)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CLq8KcR6bPl-",
        "outputId": "9b8cbe9c-36f1-406d-d1b6-5a0b35662fbe",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = 5; b = 4.5\n",
        "isinstance(a, (int, float))\n",
        "isinstance(b, (int, float))"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "LfcU5oVUbPmD"
      },
      "source": [
        "#### Imports"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LDMcW3CXbPmF"
      },
      "source": [
        "In Python a module is simply a file with the .py extension containing Python code. Suppose that we had the following module:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6xoQQeF7bPmF"
      },
      "source": [
        "```python\n",
        "# some_module.py\n",
        "PI = 3.14159\n",
        "\n",
        "def f(x):\n",
        "    return x + 2\n",
        "\n",
        "def g(a, b):\n",
        "    return a + b\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UwWyZvU7bPmG"
      },
      "source": [
        "If we wanted to access the variables and functions defined in some_module.py, from\n",
        "another file in the same directory"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gpDhi4dCbPmH"
      },
      "source": [
        "import some_module \n",
        "result = some_module.f(5) \n",
        "pi = some_module.PI"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lMQ6UFMmbPmK"
      },
      "source": [
        "#Or equivalently:\n",
        "from some_module import f, g, PI result = g(5, PI)\n",
        "#By using the as keyword you can give imports different variable names: import some_module as sm\n",
        "from some_module import PI as pi, g as gf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "PgsnZW54bPmP"
      },
      "source": [
        "#### Binary operators and comparisons"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "dpHy8TDubPmQ"
      },
      "source": [
        "5 - 7\n",
        "12 + 21.5\n",
        "5 <= 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wDYj_ypPbPmT"
      },
      "source": [
        "To check if two references refer to the same object, use the is keyword"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "je5m6dnRbPmU",
        "outputId": "880c3b9b-cb07-407c-82a6-3af549c24124",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = [1, 2, 3]\n",
        "b = a\n",
        "c = list(a)\n",
        "a is b\n",
        "a is not c"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hP0UkkGjbPmc",
        "outputId": "c258172c-bb99-4b76-b553-aa2abd3047da"
      },
      "source": [
        "a == c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "u36KCBgSbPmh"
      },
      "source": [
        "a = None\n",
        "a is None"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8e2RKirLbPmn"
      },
      "source": [
        "For list of binary operations see Page 37 in book \"Python for data science\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "hzrvG6h4bPmo"
      },
      "source": [
        "#### Mutable and immutable objects"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZaBBhyIbPmq"
      },
      "source": [
        "Mutable: lists,dicts numpyarrays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FGEC-SkRbPmr",
        "outputId": "1fc76167-59e0-4407-e7bd-b26a6897705a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a_list = ['foo', 2, [4, 5]] # lists are mutable\n",
        "a_list[2] = (3, 4)\n",
        "a_list"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 2, (3, 4)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qbE6XSr0bPnD"
      },
      "source": [
        "immutable: strings and tuples"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yBIe-6GmbPnI",
        "outputId": "f1a26bab-1e31-454e-800b-99341a05055d"
      },
      "source": [
        "a_tuple = (3, 5, (4, 5))# tuples they are inmutable\n",
        "a_tuple[1] = 'four'"
      ],
      "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-23-2c9bddc8679c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma_tuple\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'four'\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": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9RCEhsxGbPna"
      },
      "source": [
        "### Scalar Types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mmer18o5bPnb"
      },
      "source": [
        " built-in types for handling numerical data, strings, boolean (True or False) values, and dates and time. These <b>“single value”</b> types are also called scalar types "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "GXUlNEE9bPnc"
      },
      "source": [
        "#### Numeric types"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MIfZMZWqbPnd"
      },
      "source": [
        "Float and int mainly. An int can store arbitrarily large numbers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vCRxXBfXbPnd",
        "outputId": "afb6f554-f876-4969-e83f-4fc8f070dc44"
      },
      "source": [
        "ival = 17239871\n",
        "ival ** 6"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "26254519291092456596965462913230729701102721"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CndNfYBObPni"
      },
      "source": [
        "fval = 7.243\n",
        "fval2 = 6.78e-5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "q_KhRoftbPnt",
        "outputId": "0744f222-0b93-4911-e303-44b8725ecffe"
      },
      "source": [
        "3 / 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.5"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "J9m_KNc9bPnx",
        "outputId": "cd6f3b5e-11b9-410e-8722-66404aa36d7d"
      },
      "source": [
        "3 // 2 # in case you want to use integer division //"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "L77iSV1dbPn2"
      },
      "source": [
        "#### Strings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "LKzDGRfFbPn2"
      },
      "source": [
        "a = 'one way of writing a string'<br>\n",
        "b = \"another way\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "OcBM51hobPn3"
      },
      "source": [
        "c = \"\"\"\n",
        "This is a longer string that\n",
        "spans multiple lines\n",
        "\"\"\""
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "4SVlbShQbPn9",
        "outputId": "8ba026c0-2a43-4f2e-add6-f659044a1698",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "\n",
        "c.count('\\n')"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "AKcw6y3tbPoH",
        "outputId": "42c389ea-0114-4693-ed93-4b8e0294b7d3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 232
        }
      },
      "source": [
        "alist=[1,2,3]\n",
        "print(alist[1])\n",
        "a = 'this is a string'\n",
        "print(a[10])\n",
        "a[10] = 'f'#string are inmutable"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "s\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-22-6b84e5ad646c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'this is a string'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'f'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "9ofawiF2bPoO",
        "outputId": "e5f6cb62-c1c3-4b33-8066-6c521ff5ae77",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "b = a.replace('string', 'longer string')\n",
        "b\n",
        "b is a"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "zvVc49mobPoT",
        "outputId": "adb42f7e-0d3b-4641-a26d-b95d76970cac"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'this is a string'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "48lUxQRCbPoX",
        "outputId": "6a78abc9-0ed2-4ce0-9700-255ef7f48cd0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = 5.6\n",
        "s = str(a)# s will be char 5 char. char 6\n",
        "print(s)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5.6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FwH9VKZUbPod",
        "outputId": "dbff4e4e-9e3e-457f-ad01-cdcb28941835"
      },
      "source": [
        "s = 'python'\n",
        "#Strings are a sequence of \n",
        "#Unicode characters and therefore can be treated like other sequences, such as lists and tuples\n",
        "list(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['p', 'y', 't', 'h', 'o', 'n']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "mjN3x0tmbPom",
        "outputId": "b22a44e3-a2e8-42b8-efc7-98951038e7b6"
      },
      "source": [
        "s[:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'pyt'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wLGUD7bzbPox",
        "outputId": "4702ed93-826f-490f-e53f-239f004f7ccb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "s = '12\\\\n34'# \\ is escape sequence\n",
        "print(s)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12\\n34\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6djzo3acbPo_",
        "outputId": "8b488052-8bc5-44c3-9703-7ad39d170ff9"
      },
      "source": [
        "s = r'this\\has\\no\\special\\characters'\n",
        "#The r stands for raw.\n",
        "#preface the leading quote of the string with r=the characters should be interpreted as is:\n",
        "s"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'this\\\\has\\\\no\\\\special\\\\characters'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "W4hO16S2bPpO",
        "outputId": "635e774b-534a-4363-da2b-f0e345f5a6d1"
      },
      "source": [
        "a = 'this is the first half '\n",
        "b = 'and this is the second half'\n",
        "a + b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'this is the first half and this is the second half'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HGhH2TPKbPpY",
        "outputId": "9ec4386e-4cde-49b5-8cca-7daffbad0454"
      },
      "source": [
        "a*3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'this is the first half this is the first half this is the first half '"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yA_B1MCfbPpj"
      },
      "source": [
        "template = '{0:.2f} {1:s} are worth US${2:d}'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "uYvji2cobPpt",
        "outputId": "122eb2c9-5a3a-418c-b9af-50b4dbd09430"
      },
      "source": [
        "template.format(4.5560, 'Argentine Pesos', 1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'4.56 Argentine Pesos are worth US$1'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "w4H2XnP9bPp2"
      },
      "source": [
        "#### Bytes and Unicode"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "QvjuLo57bPp3"
      },
      "source": [
        "val = \"español\"\n",
        "val"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "I21UJNSSbPp8"
      },
      "source": [
        "val_utf8 = val.encode('utf-8')\n",
        "val_utf8\n",
        "type(val_utf8)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yRJpzndEbPqD"
      },
      "source": [
        "val_utf8.decode('utf-8')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ZI6B4YmLbPqI"
      },
      "source": [
        "val.encode('latin1')\n",
        "val.encode('utf-16')\n",
        "val.encode('utf-16le')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Y75QF74gbPqM"
      },
      "source": [
        "bytes_val = b'this is bytes'\n",
        "bytes_val\n",
        "decoded = bytes_val.decode('utf8')\n",
        "decoded  # this is str (Unicode) now"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "yrX0uCr3bPqS"
      },
      "source": [
        "#### Booleans"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "J2iWDATtbPqS",
        "outputId": "21334150-6ecd-4107-84ee-da413ffdf982",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "True and True\n",
        "False or True"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "586aLHrHbPqW"
      },
      "source": [
        "#### Type casting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "sTaqWU8RbPqa",
        "outputId": "4f95b53e-6980-4291-e959-8b8fbc6c8c23",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "s = '3.14159'\n",
        "fval = float(s) # casttype(thethingcasted)\n",
        "type(fval)\n",
        "int(fval)\n"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Aqsgg4jWbPqf"
      },
      "source": [
        "#### None"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dg2DExzDbPqg"
      },
      "source": [
        "None is the Python null value type"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "4MdGDEbibPqh"
      },
      "source": [
        "a = None\n",
        "a is None\n",
        "b = 5\n",
        "b is not None"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "lIRUUGcxbPqk"
      },
      "source": [
        "a technical point: None is not only a reserved keyword but also a unique instance of NoneType:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "f46-2HbfbPql"
      },
      "source": [
        "type(None)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FPsR3spebPqo"
      },
      "source": [
        "#### Dates and times"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WF8L3nUlbPqp"
      },
      "source": [
        "The built-in Python datetime module provides <b>datetime, date, and time types</b>. The datetime type,  combines the information stored in date and time and is the most commonly used:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "fyRGwztGbPqq",
        "outputId": "f7bdecfc-2d60-4b6e-d336-b15e017f96de"
      },
      "source": [
        "from datetime import datetime, date, time\n",
        "dt = datetime(2011, 10, 29, 20, 30, 21)\n",
        "dt.day\n",
        "dt.minute"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "30"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "lYM_88xqbPqv",
        "outputId": "ae70fdf8-5c59-4565-cc26-3e5f80bc4d77"
      },
      "source": [
        "dt.date()\n",
        "dt.time()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "datetime.time(20, 30, 21)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "FL0yy2UXbPqz",
        "outputId": "b1af43b7-d7a8-4977-a6b3-08e0054df5af"
      },
      "source": [
        "dt.strftime('%m/%d/%Y %H:%M')#The strftime method formats a datetime as a string."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'10/29/2011 20:30'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Ek1DSz-1bPq3"
      },
      "source": [
        "#Strings can be converted (parsed) into datetime objects with the strptime function:\n",
        "datetime.strptime('20091031', '%Y%m%d')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "PKFbqSTYbPq_",
        "outputId": "b43f9ea2-18c8-43cc-d2da-83c06f3c1cab"
      },
      "source": [
        "dt.replace(minute=0, second=0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "datetime.datetime(2011, 10, 29, 20, 0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "45UeV7yRbPrG",
        "outputId": "9ba096f6-dccc-416f-c196-429a9c13bf83"
      },
      "source": [
        "datetime.now()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "datetime.datetime(2019, 2, 20, 12, 6, 0, 31777)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0-Vkt-tDbPrL"
      },
      "source": [
        "#datetime.datetime is an immutable type, methods like these always produce new objects.\n",
        "dt2 = datetime(2011, 11, 15, 22, 30)\n",
        "delta = dt2 - dt\n",
        "delta\n",
        "type(delta)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "85sf6f0TbPrO"
      },
      "source": [
        "dt\n",
        "dt + delta"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "HUCIZnuCbPrQ"
      },
      "source": [
        "### Control Flow"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "iS0PbOQcbPrR"
      },
      "source": [
        "#### if, elif, and else"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "wcskN28KbPrS"
      },
      "source": [
        "x=7\n",
        "if x < 0:\n",
        "    print('It\\'s negative')"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "kH8QeAu5bPrU",
        "outputId": "b114175b-bdab-456a-bb55-2894db72d90a"
      },
      "source": [
        "if x < 0:\n",
        "    print(r\"It's negative\")\n",
        "elif x == 0:#== checks for equilty not assignment\n",
        "    print('Equal to zero')\n",
        "elif 0 < x < 5:\n",
        "    print('Positive but smaller than 5')\n",
        "else:\n",
        "    print('Positive and larger than or equal to 5')#catch all else"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Positive and larger than or equal to 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "vMGWe0GNbPrW",
        "outputId": "7033879d-827b-4ce5-e5c4-a2cceaa6a276",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = 5\n",
        "b = 7\n",
        "c = 8\n",
        "d = 4\n",
        "if a < b or c > d:\n",
        "    print('Made it')"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Made it\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "TrBSolQXbPrc",
        "outputId": "5ab576fe-f991-4846-cba1-6d14325ec46e"
      },
      "source": [
        "4 > 3 > 2 > 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "oalLfCqQbPri"
      },
      "source": [
        "#### for loops"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "P9njpNhebPrj"
      },
      "source": [
        "for value in collection:\n",
        "    # do something with value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "tbsmSB4dbPrv",
        "outputId": "270bc5b1-46e9-49f9-fcaf-06d34694056c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        }
      },
      "source": [
        "sequence = [1, 2, None, 4, None, 5]\n",
        "total = 0\n",
        "for value in sequence:\n",
        "    if value is None:\n",
        "        continue\n",
        "    print(value)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "4\n",
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "ayS489CCbPr0",
        "outputId": "732ee9cf-bc3c-4295-8c6e-0da17ea25cd6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 102
        }
      },
      "source": [
        "sequence = [1, 2, 0, 4, 6, 5, 2, 1]\n",
        "total_until_5 = 0\n",
        "for value in sequence:\n",
        "    if value == 5:\n",
        "        break\n",
        "    print(value)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "0\n",
            "4\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pn_eor5esHI4"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pSPPuIDksH6P",
        "outputId": "7575e466-a913-47e2-f188-ace68bab3690",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        }
      },
      "source": [
        "for i in range(10):#creates  list starting 0 upto 10 (10 i snot included)[0,1,2,...9]\n",
        "  print(i)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "-83XvVIObPr4"
      },
      "source": [
        "for i in range(4):\n",
        "    for j in range(4):\n",
        "        if j > i:\n",
        "            break\n",
        "        print((i, j))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VVFyQ4XGbPr8",
        "outputId": "d52d8594-8cdc-4a35-e42b-c497edf30131"
      },
      "source": [
        "range(4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 4)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "SCn1BlDkbPsF"
      },
      "source": [
        "for a, b, c in iterator:\n",
        "    # do something"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "cNpBvbcRbPsI"
      },
      "source": [
        "#### while loops"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0ma1BRhcbPsK"
      },
      "source": [
        "x = 256\n",
        "total = 0\n",
        "while x > 0:\n",
        "    if total > 500:\n",
        "        break\n",
        "    total += x\n",
        "    x = x // 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "0M9zbaYPbPsN"
      },
      "source": [
        "#### pass"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "I5YZhEqmbPsQ"
      },
      "source": [
        "if x < 0:\n",
        "    print('negative!')\n",
        "elif x == 0:\n",
        "    # TODO: put something smart here\n",
        "    pass\n",
        "else:\n",
        "    print('positive!')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Sy9ljl9mbPsU"
      },
      "source": [
        "#### range"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "Fc2xa0TnbPsV",
        "outputId": "ac34f7f7-e120-4ca7-db8b-c85f1f3dbb9d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "range(10)\n",
        "list(range(10))"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "6scKOlK5bPsY",
        "outputId": "5ba24af6-f243-4a9e-c8e3-bf0fab7ca7bf"
      },
      "source": [
        "list(range(0, 20, 2))# starts from 0 goes upto 20 by increasing in steps of 2 [0,2,4....,18]\n",
        "list(range(5, 0, -1))# 5,4,,,,,1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 4, 3, 2, 1]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "1f5ymywwbPsd"
      },
      "source": [
        "#A common use of range is for iterating through sequences by index:\n",
        "seq = [\"a\", \"b\", 3, 4]\n",
        "for i in range(len(seq)):\n",
        "    val = seq[i]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "CES1IQnSbPsj"
      },
      "source": [
        "#While you can use functions like list to store all the integers generated by range in some other data\n",
        "#structure, often the default iterator form will be what you want.\n",
        "#This snippet sums all numbers from 0 to 99,999 that are multiples of 3 or 5:\n",
        "#While the range generated can be arbitrarily large, the memory use at any given time may be very small.\n",
        "sum = 0\n",
        "for i in range(100000):\n",
        "    # % is the modulo operator\n",
        "    if i % 3 == 0 or i % 5 == 0:\n",
        "        sum += i"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "RlAwRTN2bPsr"
      },
      "source": [
        "#### Ternary expressions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "2IE0N5wkbPss"
      },
      "source": [
        "<p>A ternary expression in Python allows you to combine an if-else block that pro‐ duces a value into a single line or expression. The syntax for this in Python is:</p>\n",
        "value = true-expr if condition else false-expr"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "deletable": true,
        "editable": true,
        "id": "LifHWbewbPss",
        "outputId": "27432822-4f2c-4621-c9a4-8f7ac0336b2f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "x = 5\n",
        "b='Non-negative' if x >= 0 else 'Negative'"
      ],
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Non-negative'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    }
  ]
}