Python_overview.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e8ec8d6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import h5py\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9452885a",
   "metadata": {},
   "source": [
    "## 1. Basic elements\n",
    "\n",
    "### 1.1. Comments and variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0e683a83",
   "metadata": {},
   "outputs": [],
   "source": [
    "#   here are some comments\n",
    "a = 1  # a is a constant i use\n",
    "b = 1.2  # float \n",
    "c = \"this is a string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "30dacfa5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one of the A's elements =  3\n",
      "1 1.2\n"
     ]
    }
   ],
   "source": [
    "# Casting and data types\n",
    "indx = 2.0\n",
    "A = [1, 2, 3]\n",
    "print(\"one of the A's elements = \", A[int(indx)])\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88265571",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1.2 5 1.0\n",
      "1/2 =  0.5 0.5 0.5\n"
     ]
    }
   ],
   "source": [
    "c = int(5.0)\n",
    "d = float(a)\n",
    "print(a, b, c, d)\n",
    "\n",
    "z = 1.0+2.0j\n",
    "print(\"1/2 = \", 1/2, 1/float(2), 1/2.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a25a25bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=====\"======\n",
      "====\t===\n"
     ]
    }
   ],
   "source": [
    "# Escape characters examples \n",
    "print(\"=====\\\"======\\n====\\t===\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "75b0401a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HF energy is = -0.5Ha\n",
      "HF ENERGY IS = -0.5HA\n",
      "hf energy is = -0.5ha\n",
      "['HF', 'energy', 'is', '=', '-0.5Ha']\n",
      "-0.5\n",
      "hellohellohellohellohellohellohellohellohellohello\n",
      "The energy for 2 molecules will be =  0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Some fun with strings and data type conversion\n",
    "a = \"HF energy is = -0.5Ha\"\n",
    "print(a)\n",
    "print(a.upper())\n",
    "print(a.lower())\n",
    "\n",
    "A = a.split()\n",
    "print(A)\n",
    "\n",
    "\n",
    "E = A[4][0:4]\n",
    "print(E)\n",
    "\n",
    "print(\"hello\" * 10)\n",
    "print(\"The energy for 2 molecules will be = \", 2*int( float(E) ) )\n",
    "\n",
    "print( int(1.99))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0a9d431",
   "metadata": {},
   "source": [
    "### 1.2. Dictionaries and lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2a04f8df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries\n",
    "d = { \"key\":\"value\", \"my_name\":\"Alexey\", \"my_age\":35, \"the_number_of_cats_i_have\":0.0 }\n",
    "d[\"my_age\"], d[\"my_name\"] = 40.0, \"Nic\"\n",
    "#print( d )\n",
    "d.update({\"my_name\":\"Nicolas\", \"my_age\":60})\n",
    "#print( d )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8b6a9742",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_cart = {}\n",
    "my_cart_list = []\n",
    "item1 = { \"food\":\"meat\", \"cost\":7.0 };     my_cart_list.append(item1); my_cart[\"item1\"] = item1\n",
    "item2 = { \"food\":\"milk\", \"cost\":3.0 };     my_cart_list.append(item2); my_cart.update( {\"item2\": item2} )\n",
    "item3 = { \"food\":\"tortilla\", \"cost\":2.0 }; my_cart_list.append(item3); my_cart[\"item3\"] = item3\n",
    "\n",
    "#print(my_cart)\n",
    "#print(my_cart_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5dfa08a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.0, 2.0], [-2.0, 1.0]]\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "# A list\n",
    "my_list_1 = [ 1, 2, 3, 4]\n",
    "my_list_2 = [ 1.0, 2.0, 3.0]\n",
    "my_list_3 = [\"a\", \"b\", \"c\"]\n",
    "my_list_4 = [1, \"a\", 1.02]\n",
    "\n",
    "list_2D = [ [1.0, 2.0], [-2.0, 1.0] ]\n",
    "#print( my_list_4[1] )\n",
    "print(list_2D)\n",
    "print(list_2D[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08b2cc57",
   "metadata": {},
   "source": [
    "### 1.3. Printing and formatted printing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5743579f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing element 0 1 of my 2D list, the value is 2.000\n",
      "Printing pi =  3.14\n",
      "Printing pi = 3.1415926\n",
      "Here is pi = 3.14      Here is the end\n",
      "Here is pi = 3.14      Here is the end-3.141593E+00\n"
     ]
    }
   ],
   "source": [
    "i, j = 0, 1\n",
    "val = list_2D[i][j]\n",
    "print(\"Printing element %i %i of my 2D list, the value is %5.3f\" % (i, j, val) )\n",
    "\n",
    "pi = 3.1415926\n",
    "print(\"Printing pi = %5.2f\" % (pi) )\n",
    "print(F\"Printing pi = {pi}\")\n",
    "\n",
    "pi = 3.1415926\n",
    "print(\"Here is pi = {0:<10.2f}Here is the end\".format(pi))\n",
    "print(\"Here is pi = {0:<10.2f}Here is the end{1:+E}\".format(pi, -pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efa5babe",
   "metadata": {},
   "source": [
    "### 1.4. Reading-writing files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4978c59b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Printing pi =  3.14\\n', 'Printing pi = 3.1415926\\n']\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data.txt\", \"a\")\n",
    "f.write(\"Printing pi = %5.2f\\n\" % (pi))\n",
    "f.write(F\"Printing pi = {pi}\\n\")\n",
    "f.close()\n",
    "\n",
    "f = open(\"data.txt\", \"r\")\n",
    "my_file_content = f.readlines()\n",
    "f.close()\n",
    "\n",
    "print(my_file_content)\n",
    "\n",
    "#print(a, b, c, d)\n",
    "#print(my_list_1, my_list_2, my_list_3, my_list_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f62ddf0",
   "metadata": {},
   "source": [
    "## 1.5. Advanced: HDF5 files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ab6ba0cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create():\n",
    "    with h5py.File(\"myfile.dat\", \"w\") as f:\n",
    "        g = f.create_group(\"my_data\")\n",
    "        g.create_dataset(\"data\", data = np.array([1,2,3], dtype=int))\n",
    "\n",
    "def read():\n",
    "    with h5py.File(\"myfile.dat\", \"r\") as f:\n",
    "        print(f[\"my_data/data\"][:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d8019322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "create()\n",
    "read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c6322e39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n",
      "[-1. -2. -3.]\n"
     ]
    }
   ],
   "source": [
    "def create2():\n",
    "    with h5py.File(\"myfile.hdf5\", \"w\") as f:\n",
    "        g = f.create_group(\"my_data\")\n",
    "        bg1 = g.create_group(\"exp\")\n",
    "        bg2 = g.create_group(\"theo\")\n",
    "        bg1.create_dataset(\"data\", data = np.array([[1,2,3], [0.1, 0.2, 0.3]], dtype=float), compression=\"gzip\")\n",
    "        bg2.create_dataset(\"data\", data = np.array([[-1,-2,-3], [-0.1, -0.2, -0.3]], dtype=float), compression=\"gzip\")\n",
    "\n",
    "\n",
    "def read2():\n",
    "    with h5py.File(\"myfile.hdf5\", \"r\") as f:\n",
    "        x = f[\"my_data/exp/data\"][0, :]\n",
    "        print(x)\n",
    "        y = f[\"my_data/theo/data\"][0, :]\n",
    "        print(y)\n",
    "\n",
    "\n",
    "create2()\n",
    "read2()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2ad3812",
   "metadata": {},
   "source": [
    "# 2. Flow control\n",
    "\n",
    "## 2.1. If - else\n",
    "\n",
    "Conditions - a Boolean variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "86ca4be1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#======== IF ELSE ======\n",
    "a = \"B\"\n",
    "b =     ( a == \"A\" )\n",
    "print(b)\n",
    "print(a == \"A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "695e543c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x < 1\n",
      "x >= 1\n"
     ]
    }
   ],
   "source": [
    "x = -1\n",
    "if(x < 1):\n",
    "    print(\"x < 1\")\n",
    "else:\n",
    "    print(\"x >= 1\")\n",
    "\n",
    "x = 2\n",
    "if(x<1):\n",
    "    print(\"x < 1\")\n",
    "else:\n",
    "    print(\"x >= 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "eee2a5ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x >= 1\n"
     ]
    }
   ],
   "source": [
    "if(0):\n",
    "    print(\"x < 1\")\n",
    "else:\n",
    "    print(\"x >= 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9923c1e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n"
     ]
    }
   ],
   "source": [
    "a = \"Abrr\"\n",
    "if(a == \"A\"):\n",
    "    print(\"A\")\n",
    "elif(a == \"B\"):\n",
    "    print(\"B\")\n",
    "elif(a == \"C\" or a == \"Abrr\"):\n",
    "    print(\"C\")\n",
    "else:\n",
    "    print(\"something else\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10f44dc4",
   "metadata": {},
   "source": [
    "## 2.2. For and while loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8962f0e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "hi\n",
      "class\n"
     ]
    }
   ],
   "source": [
    "#======== FOR ======\n",
    "for a in [1, 2, 3, \"hi\", \"class\"]:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccc8eec9",
   "metadata": {},
   "source": [
    "Can be nested - indentation is the key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "35948375",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 3\n",
      "5 4\n",
      "5 5\n",
      "6 3\n",
      "6 4\n",
      "6 5\n",
      "7 3\n",
      "7 4\n",
      "7 5\n",
      "8 3\n",
      "8 4\n",
      "8 5\n",
      "9 3\n",
      "9 4\n",
      "9 5\n"
     ]
    }
   ],
   "source": [
    "for a in range(5,10):\n",
    "    for b in range(3,6):\n",
    "        print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d1308f",
   "metadata": {},
   "source": [
    "For the \"while\" loop - make sure to explicitly advance the state, to not fall into an infinite loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0793870a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.1\n",
      "0.2\n",
      "0.30000000000000004\n",
      "0.4\n",
      "0.5\n",
      "0.6\n",
      "0.7\n",
      "0.7999999999999999\n",
      "0.8999999999999999\n"
     ]
    }
   ],
   "source": [
    "#======= WHILE ========\n",
    "x, counter = 0.0, 0\n",
    "while(x < 20 and counter<10):\n",
    "    print(x)\n",
    "    x = x + 0.1\n",
    "    counter += 1  #  counter = counter + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c0b102c",
   "metadata": {},
   "source": [
    "## 3. Functions\n",
    "\n",
    "### 3.1. Definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e57b1cdf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "1.0\n",
      "125.0\n"
     ]
    }
   ],
   "source": [
    "#========== FUNCTIONS =============\n",
    "def my_pow(x, n):\n",
    "    \"\"\"\n",
    "    Computes x^n , for non-negative n values \n",
    "    \"\"\"\n",
    "\n",
    "    res = x**n\n",
    "\n",
    "    return res \n",
    "\n",
    "\n",
    "my_res = my_pow(0.0, 3); print(my_res)  # 0.0\n",
    "my_res = my_pow(5.0, 0); print(my_res)  # 1.0\n",
    "my_res = my_pow(5.0, 3); print(my_res)  # 125.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d66cead8",
   "metadata": {},
   "source": [
    "## Exercise 1\n",
    "\n",
    "Write a code to compute $$A x^n$$ using either `for` or `while` loops\n",
    "\n",
    "Pass all the parameters as a dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3cf3a47",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "\n",
    "Write a code to compute `exp(x)` function using Taylor series:\n",
    "\n",
    "$$exp(x) \\approx 1 + x + \\frac{x^2}{2!} + \\frac{x^3}{3!} + ... + \\frac{x^n}{n!}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69c15608",
   "metadata": {},
   "source": [
    "### 3.2. Functions as arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "570941bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1e-06\n",
      "0.0\n",
      "75.0000010000278\n"
     ]
    }
   ],
   "source": [
    "def my_derivative(func, x, n):\n",
    "    \n",
    "    dx = 0.001\n",
    "    df = func(x+dx, n) - func(x-dx, n)\n",
    "    deriv = df / (2.0*dx)\n",
    "    \n",
    "    return deriv\n",
    "\n",
    "res = my_derivative(my_pow, 0.0, 3); print(res) # ( x^3 )'  at x=  0\n",
    "res = my_derivative(my_pow, 5.0, 0); print(res) # ( x^0 )'  at x=  5\n",
    "res = my_derivative(my_pow, 5.0, 3); print(res) # ( x^3 )'  at x=  5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ae13667",
   "metadata": {},
   "source": [
    "## Homework 1\n",
    "\n",
    "Write a function to compute a definite integral of an aribtrary function (also taking an arbitrary number of  parameters) on a given interval according to one of the known quadrature rules, such as Simpson rule: https://en.wikipedia.org/wiki/Simpson%27s_rule. \n",
    "\n",
    "The more general the function (e.g. for functions of multiple dimensions), the better. \n",
    "\n",
    "Don't use the known solutions - write your own code. Never plagiarize.\n",
    "\n",
    "Test it (e.g. see below)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0e01a72",
   "metadata": {},
   "source": [
    "## 4. Classes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8191c465",
   "metadata": {},
   "outputs": [],
   "source": [
    "class vector:\n",
    "    \"\"\"\n",
    "    This is a class to represent a 2D vector\n",
    "\n",
    "    Warning:\n",
    "        You can add up objects of this class using the :func:`my_math.functions.sum_vectors` functions\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, _x, _y):\n",
    "        \"\"\"\n",
    "        Constructor of the 2D vector object\n",
    "\n",
    "        Args:\n",
    "            _X ( double ): x-component of a vector\n",
    "            _y ( double ): y-component of a vector\n",
    "\n",
    "        Returns:\n",
    "            None: but an object is initialized\n",
    "        \"\"\"\n",
    "\n",
    "        self.x = _x\n",
    "        self.y = _y\n",
    "\n",
    "\n",
    "    def print(self):\n",
    "        \"\"\" \n",
    "        Prints out the x and y components of the vector\n",
    "\n",
    "        Args:\n",
    "            None:\n",
    "\n",
    "        Returns:\n",
    "            None: but outputs the component \n",
    "\n",
    "        Note:\n",
    "            Here is some note about this function\n",
    "        \"\"\"\n",
    "        print(self.x, self.y)\n",
    "\n",
    "\n",
    "def sum_vectors(v1, v2):\n",
    "    \"\"\"\n",
    "    This functions adds up two vectors\n",
    "\n",
    "    Args:\n",
    "        v1 (vector): first operand\n",
    "        v2 (vector): second operand\n",
    " \n",
    "    Returns:\n",
    "        vector: sum of the two\n",
    "    \"\"\"\n",
    "   \n",
    "    return vector(v1.x + v2.x, v1.y + v2.y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "05b52a8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 0.0\n",
      "2.0 -1.0\n"
     ]
    }
   ],
   "source": [
    "v1 = vector(1.0, 0.0)\n",
    "v2 = vector(2.0, -1.0)\n",
    "v1.print()\n",
    "v2.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "38c7e700",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0 -1.0\n"
     ]
    }
   ],
   "source": [
    "v3 = sum_vectors(v1, v2)\n",
    "v3.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b476540",
   "metadata": {},
   "source": [
    "A better version of the above class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2488d850",
   "metadata": {},
   "outputs": [],
   "source": [
    "class vector2D:\n",
    "    \"\"\"\n",
    "    This is a class to represent a 2D vector\n",
    "\n",
    "    Warning:\n",
    "        You can add up objects of this class using the :func:`my_math.functions.sum_vectors` functions\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, _x, _y):\n",
    "        \"\"\"\n",
    "        Constructor of the 2D vector object\n",
    "\n",
    "        Args:\n",
    "            _X ( double ): x-component of a vector\n",
    "            _y ( double ): y-component of a vector\n",
    "\n",
    "        Returns:\n",
    "            None: but an object is initialized\n",
    "        \"\"\"\n",
    "\n",
    "        self.x = _x\n",
    "        self.y = _y\n",
    "        \n",
    "\n",
    "\n",
    "    def print(self):\n",
    "        \"\"\" \n",
    "        Prints out the x and y components of the vector\n",
    "\n",
    "        Args:\n",
    "            None:\n",
    "\n",
    "        Returns:\n",
    "            None: but outputs the component \n",
    "\n",
    "        Note:\n",
    "            Here is some note about this function\n",
    "        \"\"\"\n",
    "        print(self.x, self.y)\n",
    "        \n",
    "        \n",
    "    def __add__(self, v):\n",
    "        \"\"\" \n",
    "        Prints out the x and y components of the vector\n",
    "\n",
    "        Args:\n",
    "            None:\n",
    "\n",
    "        Returns:\n",
    "            None: but outputs the component \n",
    "\n",
    "        Note:\n",
    "            Here is some note about this function\n",
    "        \"\"\"\n",
    "        \n",
    "        res = vector2D(0.0, 0.0)\n",
    "        res.x = self.x + v.x\n",
    "        res.y = self.y + v.y\n",
    "        return res\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "29dce936",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 0.0\n",
      "2.0 -1.0\n"
     ]
    }
   ],
   "source": [
    "v1 = vector2D(1.0, 0.0)\n",
    "v2 = vector2D(2.0, -1.0)\n",
    "v1.print()\n",
    "v2.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "b1cb53bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0 -1.0\n"
     ]
    }
   ],
   "source": [
    "v3 = v1 + v2\n",
    "v3.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6034557a",
   "metadata": {},
   "source": [
    "## Caution - assignment by references"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "66103895",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n"
     ]
    }
   ],
   "source": [
    "v1 = vector2D(1, 1)\n",
    "v2 = v1 \n",
    "v2.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "3d9b789f",
   "metadata": {},
   "outputs": [],
   "source": [
    "v1.x, v1.y = 2, 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "668590b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2\n"
     ]
    }
   ],
   "source": [
    "v2.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db1035d6",
   "metadata": {},
   "source": [
    "### Correct way is to use constructors \n",
    "\n",
    "But there is no overloading (same method name but with different number and type of arguments)in Python, so we can use `deepcopy` instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3667caf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "v1 = vector2D(1, 1)\n",
    "v2 = copy.deepcopy(v1)\n",
    "v1.x, v1.y = 2, 2\n",
    "v2.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3523533d",
   "metadata": {},
   "source": [
    "Same for lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "e10992a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "list_A = [1, 1, 1]\n",
    "list_B = list_A\n",
    "print(list_B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "dccc759c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 2]\n"
     ]
    }
   ],
   "source": [
    "list_A[0] = 2\n",
    "list_A[1] = 2\n",
    "list_A[2] = 2\n",
    "\n",
    "print(list_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5a03d7f",
   "metadata": {},
   "source": [
    "but"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3fc5dfb8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 1]\n",
      "[1, 1, 1]\n"
     ]
    }
   ],
   "source": [
    "list_A = [1, 1, 1]\n",
    "list_B = list(list_A)\n",
    "print(list_B)\n",
    "\n",
    "list_A[0] = 2\n",
    "list_A[1] = 2\n",
    "list_A[2] = 2\n",
    "\n",
    "print(list_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ccae7f8",
   "metadata": {},
   "source": [
    "## 5. Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8b455f32",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "test_1 (__main__.Test_vector2D)\n",
      "Test constructors ... ok\n",
      "test_2 (__main__.Test_vector2D)\n",
      "Test additions ... ok\n",
      "test_3 (__main__.Test_vector2D)\n",
      "Test additions, another one ... ok\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 3 tests in 0.007s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x2ba6406580b8>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class Test_vector2D(unittest.TestCase):\n",
    "\n",
    "    def test_1(self):\n",
    "        \"\"\"Test constructors\"\"\"\n",
    "        \n",
    "        v = vector2D(0, 1)\n",
    "        \n",
    "        self.assertEqual(v.x, 0)\n",
    "        self.assertEqual(v.y, 1)\n",
    "\n",
    "    def test_2(self):\n",
    "        \"\"\"Test additions\"\"\"\n",
    "        \n",
    "        v1 = vector2D(0, 1) \n",
    "        v2 = vector2D(-1, 1) \n",
    "        v3 = v1 + v2\n",
    "        \n",
    "        self.assertAlmostEqual( v3.x, -1.0 )\n",
    "        self.assertAlmostEqual( v3.y, 2.0 )\n",
    "        \n",
    "    def test_3(self):\n",
    "        \"\"\"Test additions, another one\"\"\"\n",
    "        \n",
    "        v1 = vector2D(1, 3) \n",
    "        v2 = vector2D(-2, -1) \n",
    "        v3 = v1 + v2\n",
    "        \n",
    "        self.assertAlmostEqual( v3.x, -1.0 )\n",
    "        self.assertAlmostEqual( v3.y, 2.0 )\n",
    "        \n",
    "        \n",
    "unittest.main(argv=[''], verbosity=2, exit=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce058a6e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6 (libra-latest)",
   "language": "python",
   "name": "libra-plus"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}