ComPhy-1-Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "celltoolbar": "Raw Cell Format",
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.8"
    },
    "colab": {
      "name": "ComPhy-1-Python.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/monttj/computational-physics/blob/2021/ComPhy-1-Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mpy9lYDaiK-T"
      },
      "source": [
        "We need to mount the google drive in order to use the existing material."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FW10RxXQhz36"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f_mDf_1kmtrg"
      },
      "source": [
        "cd /content/drive/My Drive/computational-physics"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i85dJwm9hBBL"
      },
      "source": [
        "# Introudction to Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mgaakkcdhBBL"
      },
      "source": [
        "In this exercise, you will learn the basics of python computer language. You can either login to the dedicated server and run the jupyter or just click the button above to switch to Colab. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YE9HCeq-hBBM"
      },
      "source": [
        "### Excute"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "poMrLUcwhBBM"
      },
      "source": [
        "ls *.py"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D0JxvRT5hBBN"
      },
      "source": [
        "cat hello_python.py"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "52sdb_yvhBBN"
      },
      "source": [
        "##### answer:\n",
        "```\n",
        "#!/usr/bin/env python\n",
        "\n",
        "print \"Hello world!\"\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "18rW8WFLhBBN"
      },
      "source": [
        "!python hello_python.py"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KSRb5Rg4hBBO"
      },
      "source": [
        "##### answer:\n",
        "```\n",
        "Hello world!\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yqz2fEj3hBBO"
      },
      "source": [
        "### Print"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9NhGty5shBBO"
      },
      "source": [
        "a = \"Hello World!\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qqyELF2NhBBO"
      },
      "source": [
        "print (a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GJbRWyQ6hBBP"
      },
      "source": [
        "myname = \"Computational Physics\"\n",
        "print (\"My name is = \", myname)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6fEM7_JThBBP"
      },
      "source": [
        "### Indent"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ci_uJquGhBBP"
      },
      "source": [
        "#this is not correct\n",
        "#CORRECT ME!\n",
        "  x = 3\n",
        "  y = 4\n",
        "  z = x + y \n",
        "print \"3 + 4 is\", z"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bY8y79B0hBBP"
      },
      "source": [
        "##### answer:\n",
        "```\n",
        "3 + 4 is 7\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MHldt3ObhBBP"
      },
      "source": [
        "### Assignment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sFdbM12chBBQ"
      },
      "source": [
        "In python which is a dynamically typed language, we don't need to specify the type of a variable. This is one of the main difference compared to c++. \n",
        "\n",
        "We will create a variable by assigning a value to the variable below and will check the type:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DkRZbGSWhBBQ"
      },
      "source": [
        "# variable assignments\n",
        "x = 1.0\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eQzc30ZAhBBQ"
      },
      "source": [
        "#fix this and make the output true\n",
        "type(x) is str"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KZPu7myrhBBQ"
      },
      "source": [
        "##### answer:\n",
        "```\n",
        "True\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3OBHgRdahBBQ"
      },
      "source": [
        "#can use the function\n",
        "isinstance(x, float)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U70f1jkhhBBR"
      },
      "source": [
        "##### answer:\n",
        "```\n",
        "True\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bK8_DdLRhBBR"
      },
      "source": [
        "x = 1\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gkD2qp0ihBBR"
      },
      "source": [
        "x = \"hello\"\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GXAn0T_GhBBR"
      },
      "source": [
        "x = True #can also be False\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GXdmno2ghBBR"
      },
      "source": [
        "x = 1.0 - 1.0j\n",
        "type(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_K7L8tXfhBBR"
      },
      "source": [
        "print (x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a9TSsCcjhBBS"
      },
      "source": [
        "print(x.real, x.imag)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b7eEuQY1hBBS"
      },
      "source": [
        "y = bool(x.real)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N-s_yNxIhBBS"
      },
      "source": [
        "print (x.real, \":\", y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HfFvp4CbhBBS"
      },
      "source": [
        "y = bool(x.imag)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fbHjVVDVhBBS"
      },
      "source": [
        "print (x.imag, \":\", y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l3AusYQshBBS"
      },
      "source": [
        "import types\n",
        "\n",
        "# print all types defined in the `types` module\n",
        "print(dir(types))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uGEzl-8qhBBS"
      },
      "source": [
        "### Math operator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w4ncJ-Y_hBBT"
      },
      "source": [
        "This code will give the sum of x and y. The answer should be 7. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "2MTlQhZvhBBT"
      },
      "source": [
        "#summation\n",
        "x = 3\n",
        "y = 4\n",
        "z = x + y\n",
        "print (\"sum =\", z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sHr3PZ0bhBBT"
      },
      "source": [
        "#subtraction\n",
        "z = x - y\n",
        "print (\"subtraction = \", z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UZK7N8EehBBT"
      },
      "source": [
        "#multiplication\n",
        "z = x*y\n",
        "print (\"multiplication = \", z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Umbi58MdhBBT"
      },
      "source": [
        "#division\n",
        "z = x/y\n",
        "print (\"z = \", z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RPYjT5b7hBBT"
      },
      "source": [
        "#division\n",
        "x = 3.0\n",
        "y = 4.0\n",
        "z = x/y\n",
        "print (\"z = \", z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4I5rGHNVhBBT"
      },
      "source": [
        "#modulus\n",
        "x = 3.0\n",
        "y = 1.1\n",
        "reminder = x%y\n",
        "print (\"reminder = \", reminder)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XE-URAvFhBBU"
      },
      "source": [
        "quotient = x//y\n",
        "print (\"quotient = \", quotient)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PjQV410HhBBU"
      },
      "source": [
        "#exponent\n",
        "z = x**3\n",
        "print (\"z = \", z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FZRGWl00hBBU"
      },
      "source": [
        "#import math to be able to use the math function\n",
        "import math\n",
        "x = math.cos(2 * math.pi) #math.pi = 3.14159265359\n",
        "print (\"cos(2*3.14159265359) = \", x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6zshDzxDhBBU"
      },
      "source": [
        "We can choose to import all symbols to the current namespace. In this way, we can use the math modules without using the prefix \"math\":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "92Z0KD5hhBBU"
      },
      "source": [
        "#import math to be able to use the math function\n",
        "from math import *\n",
        "x = cos(2 * pi) #math.pi = 3.14159265359\n",
        "print (\"cos(2*3.14159265359) = \", x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SU9eFDpLhBBU"
      },
      "source": [
        "\n",
        "This is very convenent but sometimes it can be confusing with the symbols as it can also be used in other places. Usually it is better to keep the namespaces. This would elimate the cofusing problems with the name space collisions. \n",
        "This pattern can be very convenient, but in large programs that include many modules it is often a good idea to keep \n",
        "\n",
        "Otherwise, we can chose to import only a few selected symbols from a module by explicitly listing which ones we want to import instead of using the wildcard character *:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ei-IRCMPhBBV"
      },
      "source": [
        "\n",
        "from math import cos, pi\n",
        "x = cos(2 * pi) #math.pi = 3.14159265359\n",
        "print (\"cos(2*3.14159265359) = \", x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HGB92o5ehBBV"
      },
      "source": [
        "You can check what is available in math library with following lines:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c4_RLhtThBBV"
      },
      "source": [
        "a = log(10)\n",
        "print (\"log(10) = \", a)\n",
        "b = log(10,2)\n",
        "print (\"log(10,2) = \", b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "i40_e5QNhBBV"
      },
      "source": [
        "import math\n",
        "\n",
        "print(dir(math))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ykm7JcQ9hBBV"
      },
      "source": [
        "### Strings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kb7D8RoVhBBV"
      },
      "source": [
        "s = \"Hello world\"\n",
        "type(s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ahhgoYUhBBW"
      },
      "source": [
        "# length of the string: the number of characters# length \n",
        "len(s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GwtSZMq7hBBW"
      },
      "source": [
        "# replace a substring in a string with something else\n",
        "s2 = s.replace(\"world\", \"Physics\")\n",
        "print(s2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "myHL6ka0hBBW"
      },
      "source": [
        "s[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6Ctcf26mhBBW"
      },
      "source": [
        "s[0:5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T4PkakdChBBW"
      },
      "source": [
        "s[4:5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y5716hjZhBBW"
      },
      "source": [
        "s[:5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q03V65zMhBBW"
      },
      "source": [
        "s[6:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0IjyaugbhBBX"
      },
      "source": [
        "s[:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2ED2nsyqhBBX"
      },
      "source": [
        "We can also define the step size [start:end:step]:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oEZrF2jchBBX"
      },
      "source": [
        "s[::1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iw1jF9q1hBBX"
      },
      "source": [
        "s[::3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "73ILCxgchBBX"
      },
      "source": [
        "a = \"Computational\"\n",
        "b = \"Physics\"\n",
        "print (a,b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tHTRbnd1hBBX"
      },
      "source": [
        "print (a, b, 2, \"is\", True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OEH5_tlXhBBX"
      },
      "source": [
        "print (a+b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sMJWg52hhBBY"
      },
      "source": [
        "print (\"value = %f\" % 1.0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RBH9vDEyhBBY"
      },
      "source": [
        "s = \"value1 = %.2f. value2 = %d\" % (3.1415, 1.5)\n",
        "print (s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LV5gMigZhBBY"
      },
      "source": [
        "### List"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ujXIwPxhBBY"
      },
      "source": [
        "l = [1,2,3,4]\n",
        "\n",
        "print (type(l))\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kYklOzKPhBBY"
      },
      "source": [
        "print (l[1:3])\n",
        "print (l[::2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tWDd3J7XhBBY"
      },
      "source": [
        "l[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sjDmNjlQhBBY"
      },
      "source": [
        "nested_list = [[1,2], [3,4]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z1al4Zw4hBBZ"
      },
      "source": [
        "print (nested_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k7Ne2kUghBBZ"
      },
      "source": [
        "start = 0\n",
        "stop = 10\n",
        "step = 1\n",
        "l = range(0,10,1)\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i5zjLq3ghBBZ"
      },
      "source": [
        "l = range(-10,10)\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qt7AiA-uhBBZ"
      },
      "source": [
        "# sorting lists\n",
        "l = [9,1,10,3,4,6,2,5,7,8]\n",
        "print (l)\n",
        "l.sort()\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kgqy1Uo1hBBZ"
      },
      "source": [
        "# create a new empty list\n",
        "l = []\n",
        "\n",
        "# add an elements using `append`\n",
        "l.append(\"P\")\n",
        "l.append(\"H\")\n",
        "l.append(\"Y\")\n",
        "\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4XHCzsSHhBBZ"
      },
      "source": [
        "l[0] = \"H\"\n",
        "l[1] = \"Y\"\n",
        "l[2] = \"U\"\n",
        "\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AdkLXE9qhBBa"
      },
      "source": [
        "l.insert(3, \"P\")\n",
        "l.insert(4, \"H\")\n",
        "l.insert(5, \"Y\")\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SUoczlqqhBBa"
      },
      "source": [
        "l.remove(\"H\")\n",
        "print (l) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7TkyvfAbhBBa"
      },
      "source": [
        "del l[1]\n",
        "print (l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PI4DEN1qhBBa"
      },
      "source": [
        "### Dictionaries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oc1lcLRDhBBa"
      },
      "source": [
        "params = {\"mass\" : 3,\n",
        "          \"distance\" : 2.0,\n",
        "          \"gravity\" : 9,}\n",
        "\n",
        "print (type(params))\n",
        "print (params)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lpJXMfCehBBa"
      },
      "source": [
        "print(\"mass = \" + str(params[\"mass\"]))\n",
        "print(\"distance = \" + str(params[\"distance\"]))\n",
        "print(\"gravity = \" + str(params[\"gravity\"]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i20oIHNShBBa"
      },
      "source": [
        "params[\"mass\"] = 10\n",
        "params[\"distance\"] = 5\n",
        "\n",
        "# add a new entry\n",
        "params[\"force\"] = params[\"mass\"]*params[\"gravity\"]\n",
        "\n",
        "print(\"mass = \" + str(params[\"mass\"]))\n",
        "print(\"distance = \" + str(params[\"distance\"]))\n",
        "print(\"gravity = \" + str(params[\"gravity\"]))\n",
        "print(\"force = \" + str(params[\"force\"]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CIJDTC5dhBBb"
      },
      "source": [
        "### Conditional statement"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y3x0JJKOhBBb"
      },
      "source": [
        "# equality\n",
        "2 == 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZKiabGKLhBBb"
      },
      "source": [
        "2 > 1, 2 < 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "hbBDmJi5hBBb"
      },
      "source": [
        "# objects identical?\n",
        "a = b = 3\n",
        "\n",
        "a is b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1-Lchm_LhBBb"
      },
      "source": [
        "Program blocks are defined by their indentation level."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rabzSPAIhBBb"
      },
      "source": [
        "if sum == 55:\n",
        "    print (\"Correct answer!\")\n",
        "else:\n",
        "    print (\"Wrong answer!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "Qmnwe8kwhBBb"
      },
      "source": [
        "if True and False:\n",
        "    print (\"True and False = True\")\n",
        "else:\n",
        "    print (\"True and False = False\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "lTY5CAJlhBBc"
      },
      "source": [
        "if True or False:\n",
        "    print (\"True or False = True\")\n",
        "else:\n",
        "    print (\"True or False = False\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j3XqQYrphBBc"
      },
      "source": [
        "if not False:\n",
        "    print (\"not False = True\")\n",
        "else:\n",
        "    print (\"not False = False\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WOHzN7IAhBBc"
      },
      "source": [
        "### Loops"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C038VTgxhBBc"
      },
      "source": [
        "for x in [1,2,3]:\n",
        "    print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ghCDFbIFhBBc"
      },
      "source": [
        "#print from 0, 1, 2, 3\n",
        "y = 4\n",
        "for x in range(y): # by default range start at 0\n",
        "    print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "puHdEsVNhBBd"
      },
      "source": [
        "##### output should be \n",
        "```    \n",
        "    0\n",
        "    1\n",
        "    2\n",
        "    3\n",
        "```    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FdOwKBAEhBBd"
      },
      "source": [
        "for word in [\"scientific\", \"computing\", \"with\", \"python\"]:\n",
        "    print(word)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5NmVoGDYhBBd"
      },
      "source": [
        "Sometimes it is useful to have access to the indices of the values when iterating over a list. We can use the enumerate function for this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TubCxhc6hBBd"
      },
      "source": [
        "for idx, x in enumerate(range(-3,3)):\n",
        "    print(idx, x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QlmmmXx5hBBd"
      },
      "source": [
        "Now, we will calculate the sum from 1 to 10"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "LZfknfjphBBe"
      },
      "source": [
        "#set global variable ~1 line\n",
        "#calculate the sum from 1 to 10, use global variable: 2 lines\n",
        "for i in range(0,11):\n",
        "    sum = sum + i\n",
        "print (\"sum from 1 to 10 = \", sum)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pONC2ioNhBBe"
      },
      "source": [
        "##### output should be:\n",
        "```\n",
        "sum from 1 to 10 =  55\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ISVEgfMhBBe"
      },
      "source": [
        "A convenient and compact way to initialize lists:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LyrVsjsLhBBe"
      },
      "source": [
        "l1 = [x**2 for x in range(0,5)]\n",
        "\n",
        "print(l1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4w4_6CnJhBBe"
      },
      "source": [
        "i = 0\n",
        "\n",
        "while i < 5:\n",
        "    print(i)\n",
        "    \n",
        "    i = i + 1\n",
        "    \n",
        "print (\"sum = \", i)\n",
        "print (\"done\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MuNd9yb8hBBe"
      },
      "source": [
        "### Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wKJxQs-MhBBe"
      },
      "source": [
        "def func0():  \n",
        "    #print out the \"test\": line 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lBajBomGhBBf"
      },
      "source": [
        "func0()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AMyLv-6PhBBf"
      },
      "source": [
        "##### output should be:\n",
        "```\n",
        "test\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UWKSp0dZhBBf"
      },
      "source": [
        "def func1(s):\n",
        "    \"\"\"\n",
        "    Print a string 's' and tell how many characters it has    \n",
        "    \"\"\"\n",
        "    \n",
        "    print(s + \" has \" + str(len(s)) + \" characters\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mXs3h8WLhBBf"
      },
      "source": [
        "help(func1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PsmoM8AChBBf"
      },
      "source": [
        "func1(\"test\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ToAhVf6uhBBf"
      },
      "source": [
        "def square(x):\n",
        "    \"\"\"\n",
        "    Return the square of x.\n",
        "    \"\"\"\n",
        "    return x ** 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mxTHn9gphBBf"
      },
      "source": [
        "square(4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uaPHKyhHhBBg"
      },
      "source": [
        "def powers(x):\n",
        "    \"\"\"\n",
        "    Return a few powers of x.\n",
        "    \"\"\"\n",
        "    return x ** 2, x ** 3, x ** 4"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xQJMOO-HhBBg"
      },
      "source": [
        "powers(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mEwiPDY1hBBg"
      },
      "source": [
        "x2, x3, x4 = powers(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aCMjU4dThBBg"
      },
      "source": [
        "print(x3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t3Uwoi_6hBBg"
      },
      "source": [
        "def myfunc(x, p=2, debug=False):\n",
        "    if debug:\n",
        "        print(\"evaluating myfunc for x = \" + str(x) + \" using exponent p = \" + str(p))\n",
        "    return x**p"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-HPFWELMhBBg"
      },
      "source": [
        "If we don't provide a value of the debug argument when calling the the function myfunc it defaults to the value provided in the function definition:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WG_UWLAMhBBg"
      },
      "source": [
        "myfunc(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K81tWftDhBBg"
      },
      "source": [
        "myfunc(5, debug=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dxGbDp3ehBBh"
      },
      "source": [
        "If we explicitly list the name of the arguments in the function calls, they do not need to come in the same order as in the function definition. This is called keyword arguments, and is often very useful in functions that takes a lot of optional arguments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RGg9Xt4AhBBh"
      },
      "source": [
        "myfunc(p=3, debug=True, x=7)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XPlxow3chBBh"
      },
      "source": [
        "### Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1QiDEV5FhBBh"
      },
      "source": [
        "Python is also object-oriented programming. Like c++, understanding class is important in object-oriented programming. \n",
        "You can think of a class as a template. With the template, many objects can be created. An object is an instance of a class. The class contains attributes (variables) and methods (functions).\n",
        "\n",
        "Each method should have an argument self as its first argument.\n",
        "Example:\n",
        "\n",
        "    def speed(self, dx, dy, dz):"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9KnQZe9vhBBh"
      },
      "source": [
        "Some method names have special meaning.    \n",
        "Example:\n",
        "\n",
        "    __init__: The name of the method that is invoked when the object is first created.\n",
        "\n",
        "    __str__ : A method that is invoked when a simple string representation of the class is needed, as for example when printed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oBMoZoPmhBBh"
      },
      "source": [
        "class Particle:\n",
        "    \"\"\"\n",
        "    Simple class for representing a particle in a Cartesian coordinate system.\n",
        "    \"\"\"\n",
        "    \n",
        "    def __init__(self, x, y, z, m):\n",
        "        \"\"\"\n",
        "        Create a new Point at x, y.\n",
        "        \"\"\"\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "        self.z = z\n",
        "        self.m = m \n",
        "        \n",
        "        \n",
        "    def speed(self, dx, dy, dz):\n",
        "        \"\"\"\n",
        "        speed up the particle by dx and dy and dz in the x and y and z direction.\n",
        "        \"\"\"\n",
        "        ## increase the speed of the particle: 3 lines \n",
        "        self.x += dx\n",
        "        self.y += dy\n",
        "        self.z += dz\n",
        "    \n",
        "    def mass(self, dm):\n",
        "        \"\"\"\n",
        "        increase the mass of the particle \n",
        "        \"\"\"\n",
        "        self.m += dm\n",
        "        \n",
        "    def __str__(self):\n",
        "        return(\"particle with [%f, %f, %f, %f]\" % (self.x, self.y, self.z, self.m))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aVmOm5EphBBi"
      },
      "source": [
        "To create an object (a new instance of a class):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0OpYOOsWhBBi"
      },
      "source": [
        "p1 = Particle(0, 0, 0, 0) # this will invoke the __init__ method in the Point class\n",
        "\n",
        "print (p1)          # this will invoke the __str__ method"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jj9iOqbchBBi"
      },
      "source": [
        "Now you have to create a second particle with the speed of 1,1,1 and the mass of 1:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "U7kZC89FhBBi"
      },
      "source": [
        "#create a second particle\n",
        "p2 = Particle(1, 1, 1, 1)\n",
        "\n",
        "#increase the speed of the particle 1 by 0.25 in x, 1.5 in y and 3.5 in z\n",
        "\n",
        "print(p1)\n",
        "print(p2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qc8eoOqmhBBj"
      },
      "source": [
        "##### output should be:\n",
        "```\n",
        "particle with [0.250000, 1.500000, 3.500000, 0.000000] \n",
        "particle with [1.000000, 1.000000, 1.000000, 1.000000] \n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N3JocH2ohBBj"
      },
      "source": [
        "%%file myParticle.py\n",
        "\"\"\"\n",
        "Example of a python module. Contains a variable called myMass,\n",
        "a function called Mass, and a class called Particle.\n",
        "\"\"\"\n",
        "\n",
        "mymass = 0\n",
        "\n",
        "def Mass():\n",
        "    \"\"\"\n",
        "    Example function\n",
        "    \"\"\"\n",
        "    return mymass\n",
        "    \n",
        "class Particle:\n",
        "    \"\"\"\n",
        "    Example class.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        self.variable = mymass\n",
        "        \n",
        "    def setMass(self, new_value):\n",
        "        \"\"\"\n",
        "        Set self.variable to a new value\n",
        "        \"\"\"\n",
        "        self.variable = new_value\n",
        "        \n",
        "    def getMass(self):\n",
        "        return self.variable\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eYM-ocZuhBBj"
      },
      "source": [
        "#check what is created\n",
        "!ls"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RG5t8uMQhBBj"
      },
      "source": [
        "import myParticle"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bSLOzywwhBBj"
      },
      "source": [
        "#for exercise, compare the values from variable and function:\n",
        "#print \"mass value from global variable (myParticle.mymass) = \", \n",
        "#print \"mass value from the function (myParticle.Mass()) = \", "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RYN7pdaIhBBj"
      },
      "source": [
        "##### output should be:\n",
        "```\n",
        "mass value from global variable (myParticle.mymass) =  0\n",
        "mass value from the function (myParticle.Mass()) =  0\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fj9XQPudhBBk"
      },
      "source": [
        "help(myParticle)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y-uXrAslhBBk"
      },
      "source": [
        "Can you set the mass of 10 and print out?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zupdqL1nhBBk"
      },
      "source": [
        "#set the particle mass as 10 \n",
        "my_class = myParticle.Particle() \n",
        "#hint\n",
        "#you need to set the mass and get the mass: 2 lines"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TBuyH5pUhBBk"
      },
      "source": [
        "##### output should be:\n",
        "```\n",
        "10\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S6rxPhI5hBBk"
      },
      "source": [
        "##### examples to raise error message"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9FSKm6TEhBBk"
      },
      "source": [
        "raise Exception(\"description of the error\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wMrLGH2dhBBk"
      },
      "source": [
        "try:\n",
        "    print(\"test\")\n",
        "         # generate an error: the variable test is not defined# generat \n",
        "    print(test)\n",
        "except:\n",
        "    print(\"Caught an exception\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qVyYjCxPhBBk"
      },
      "source": [
        "try:\n",
        "    print(\"test\")\n",
        "    # generate an error: the variable test is not defined\n",
        "    print(test)\n",
        "except Exception as e:\n",
        "    print(\"Caught an exception:\" + str(e))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iRL6xNYzhBBl"
      },
      "source": [
        "### Task 1 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IU1Bjjj6hBBl"
      },
      "source": [
        "There are 26 students. Use the code below to read out the score for 10 students. \n",
        "Can you write a code to print out the average and the list of students with the highest score of 20% and also the list of 50%?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fDR4AzFHhBBl"
      },
      "source": [
        "average = 0\n",
        "high20 = []\n",
        "high50 = []\n",
        "with open(\"score.txt\") as fp:  \n",
        "   line = fp.readline()\n",
        "   while line:\n",
        "        print line\n",
        "        line = fp.readline()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AklJYiwuhBBl"
      },
      "source": [
        "### Numpy\n",
        "\n",
        "Numpy is the library package for scientific computing with Python. Basically, it deals with a N-dimensional array object.\n",
        "In deep learning which we will cover later, matrix is essential so numpy will be used extensively throughout the course later. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a1ZJXl4AhBBl"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "61UctugyhBBl"
      },
      "source": [
        "x = np.array([1,2,3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ABtoDhHxhBBm"
      },
      "source": [
        "x.__class__"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tmg5R7pxhBBm"
      },
      "source": [
        "#### shape\n",
        "\n",
        "It is of importance to check the shape of the matrix to perform any operators "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GMPS5WuqhBBm"
      },
      "source": [
        "x.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YisrLzwHhBBm"
      },
      "source": [
        "x.ndim"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_5gb9usuhBBm"
      },
      "source": [
        "W = np.array([[1,2,3],[4,5,6]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZnHypHR8hBBm"
      },
      "source": [
        "### Task 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PvMhXGiLhBBn"
      },
      "source": [
        "W.shape == (3,2) # make the answer True"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QqB6PH8LhBBn"
      },
      "source": [
        "##### answer:\n",
        "```\n",
        "True \n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z8oZCNYrhBBn"
      },
      "source": [
        "W.ndim # check the dimension of the tensor"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mvSxeiKOhBBn"
      },
      "source": [
        "#### element wise operator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WEWOiR71hBBn"
      },
      "source": [
        "W = np.array([[1,2,3],[3,4,5]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hygB_ENhhBBn"
      },
      "source": [
        "X = np.array([[0,1,2],[3,4,5]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dKrNqZTPhBBn"
      },
      "source": [
        "W+X"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FBEUEepZhBBn"
      },
      "source": [
        "W*X"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgUwqyb0hBBo"
      },
      "source": [
        "#### broadcast\n",
        "\n",
        "With this broadcast, it becomes possible to calculate betweent two matrices with different shapes. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hGs01d3ohBBo"
      },
      "source": [
        "A = np.array([[1,2],[3,4]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JriJH7BThBBo"
      },
      "source": [
        "A*10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cEzceBg1hBBo"
      },
      "source": [
        "Below, two matrices A and b have different shapes. A is $2 \\times 2$ and b is $1 \\times 2$. In the broadcast, b can be extended to $2 \\times 2$. \n",
        "\n",
        "A is \n",
        "$\n",
        "\\begin{pmatrix}\n",
        "1 & 2 \\\\\n",
        "3 & 4\n",
        "\\end{pmatrix}\n",
        "$\n",
        "\n",
        "b becomes \n",
        "$\n",
        "\\begin{pmatrix}\n",
        "10 & 20 \\\\\n",
        "10 & 20\n",
        "\\end{pmatrix}\n",
        "$\n",
        "\n",
        "A*b =\n",
        "$\n",
        "\\begin{pmatrix}\n",
        "1 \\times 10 & 2 \\times 20 \\\\\n",
        "3 \\times 10 & 4 \\times 20\n",
        "\\end{pmatrix}\n",
        "$ =\n",
        "$\n",
        "\\begin{pmatrix}\n",
        "10 & 40 \\\\\n",
        "40 & 80\n",
        "\\end{pmatrix}\n",
        "$\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qk24p9u0hBBo"
      },
      "source": [
        "A = np.array([[1,2],[3,4]])\n",
        "b = np.array([10,20])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oexoieMKhBBo"
      },
      "source": [
        "A*b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uw1ZiDdihBBo"
      },
      "source": [
        "#### dot product"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JdfCWemMhBBp"
      },
      "source": [
        "a = np.array([1,2,3])\n",
        "b = np.array([4,5,6])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dB5jZG7xhBBp"
      },
      "source": [
        "np.dot(a,b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9gMgic0bhBBp"
      },
      "source": [
        "### Task 3\n",
        "\n",
        "A particle moving in the xy plane undergoes a displacement given by $\\Delta \\vec{r} = (2.0 \\hat{i} + 3.0 \\hat{j} + 5.0 \\hat{k}) $ m as a constant force $ \\vec{F} = (5.0 \\hat{i} + 2.0 \\hat{j})$ N acts on the particle. Calculate the workdone by $ \\vec{F}$ on the particle. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S2TcavCGhBBp"
      },
      "source": [
        "r = # Displacement \n",
        "F = # Force\n",
        "W = # Work"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5sf4zoG7hBBp"
      },
      "source": [
        "#### Matrix multiplocation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-5U0gL8FhBBp"
      },
      "source": [
        "A = np.array([[1,2],[3,4]])\n",
        "B = np.array([[5,6],[7,8]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gm_e4RilhBBp"
      },
      "source": [
        "np.matmul(A,B)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gob-AtMkhBBp"
      },
      "source": [
        "### Task 4\n",
        "What would be the shape of the matrix x and b to run the code in following example?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GdgHs6HKhBBq"
      },
      "source": [
        "x = np.array() ## correct and fill in the blank\n",
        "A = np.array([[1,2],[2,4],[3,6]])\n",
        "b = np.array() ## fill in the blank \n",
        "y = np.matmul(x, A) + b\n",
        "\n",
        "#check if the shape is correct\n",
        "y.shape == (2,2)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GfbP4jVyhBBq"
      },
      "source": [
        "##### answer:\n",
        "```\n",
        "True \n",
        "```"
      ]
    }
  ]
}