{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Introduction\n",
    "\n",
    "Python is a very simple language. It is an interpreted language, which means that code can be executed as soon as it is written. This facilitates to do very quick prototyping. It is open-source and works in multiple platforms (Windows, Mac, Linux, Raspberry Pi, etc).\n",
    "\n",
    "Some highlights:\n",
    "- Was designed to for **readability**, and has some similarities to the English language with influence from mathematics.\n",
    "- Uses new lines to complete a command, as opposed to other programming languages which often use semicolons or parentheses.\n",
    "- Relies on **indentation**, using whitespace, to define scope; such as the scope of loops, functions and classes. Other programming languages often use curly-brackets for this purpose.\n",
    "\n",
    "Now we will make a very short introduction to the Python's syntax and its main data structures. We will also see how to work with vector and matrices to make math operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "Declaring a veriable is as easy as writting `a = 5`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "35\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 10\n",
    "print(a+b)\n",
    "c = 20\n",
    "print(a+b+c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic data structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# tuples\n",
    "t = (1, 2, 3)\n",
    "print(t)\n",
    "print(t[0])\n",
    "print(t[1])\n",
    "print(t[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 2, 1, 3]\n",
      "[4, 2, 1, 3, 5]\n",
      "[4, 2, 1, 3, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# creating a list\n",
    "x = [4, 2, 1, 3]\n",
    "print(x)\n",
    "x.append(5)\n",
    "print(x)\n",
    "x += [6]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(4, 1), (1, 2), (7, 3), (1, 4), (10, 4)]\n"
     ]
    }
   ],
   "source": [
    "# creating a list of tuples \n",
    "x = [(1,2), (4,1), (1,4), (7,3), (10, 4)]\n",
    "\n",
    "# sorting\n",
    "x = sorted(x, key=lambda z: z[1])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3}\n",
      "{2, 3, 4}\n",
      "{2}\n"
     ]
    }
   ],
   "source": [
    "# creating a set\n",
    "x = set()\n",
    "x.add(2)\n",
    "x.add(3)\n",
    "x.add(3)\n",
    "print(x)\n",
    "x.add(4)\n",
    "print(x)\n",
    "y = set()\n",
    "y.add(1)\n",
    "y.add(2)\n",
    "print(x & y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Hanoi': 1, 'Ho Chi Minh': 2}\n",
      "1\n",
      "dict_keys(['Hanoi', 'Ho Chi Minh'])\n",
      "dict_values([1, 2])\n"
     ]
    }
   ],
   "source": [
    "# creating a dictionary\n",
    "x = dict()\n",
    "x['Hanoi'] = 1\n",
    "x['Ho Chi Minh'] = 2\n",
    "print(x)\n",
    "print(x['Hanoi'])\n",
    "\n",
    "# dictionary keys and values\n",
    "print(x.keys())\n",
    "print(x.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Hanoi, Vietnam!\n"
     ]
    }
   ],
   "source": [
    "name = 'Hanoi, Vietnam'\n",
    "print(\"Hello, %s!\" % name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hanoi, Vietnam is 1000 years old.\n",
      "Hanoi, Vietnam is 1000 years old.\n"
     ]
    }
   ],
   "source": [
    "age = 1000\n",
    "print(\"%s is %d years old.\" % (name, age))\n",
    "print(\"{} is {} years old.\".format(name, age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A list: [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# This prints out: A list: [1, 2, 3]\n",
    "mylist = [1, 2, 3]\n",
    "print(\"A list: %s\" % mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditions\n",
    "The result of a condition is expressed with a boolean variable. The boolean values **True** and **False** are returned when an expression is compared or evaluated. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "print(x == 2) # prints out True\n",
    "print(x == 3) # prints out False\n",
    "print(x < 3) # prints out True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your name is either Hanoi or Havana.\n"
     ]
    }
   ],
   "source": [
    "name = \"Havana\"\n",
    "age = 1000\n",
    "\n",
    "if name == \"Hanoi\" and age == 1000:\n",
    "    print(\"Your name is Hanoi, and you are 1000 years old.\")\n",
    "\n",
    "if name == \"Hanoi\" or name == \"Havana\":\n",
    "    print(\"Your name is either Hanoi or Havana.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x equals two!\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "if x == 2:\n",
    "    print(\"x equals two!\")\n",
    "else:\n",
    "    print(\"x does not equal to two.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [1, 2, 3]\n",
    "print(x == y) # Prints out True\n",
    "print(x is y) # Prints out False\n",
    "print(x is x) # Prints out True\n",
    "\n",
    "print(not x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not False) # Prints out True\n",
    "print((not False) == (False)) # Prints out False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7]\n",
    "for i in range(4):\n",
    "    print(primes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "\n",
      "3\n",
      "4\n",
      "5\n",
      "\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# Prints out the numbers 0,1,2,3,4\n",
    "for x in range(5):\n",
    "    print(x)\n",
    "\n",
    "print()\n",
    "\n",
    "# Prints out 3,4,5\n",
    "for x in range(3, 6):\n",
    "    print(x)\n",
    "    \n",
    "print()\n",
    "\n",
    "# Prints out 3,5,7\n",
    "for x in range(3, 8, 2):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Prints out 0,1,2,3,4\n",
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count += 1  # This is the same as count = count + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "\n",
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Prints out 0,1,2,3,4\n",
    "count = 0\n",
    "while True:\n",
    "    print(count)\n",
    "    count += 1\n",
    "    if count >= 5:\n",
    "        break\n",
    "\n",
    "print()\n",
    "\n",
    "# Prints out only odd numbers - 1,3,5,7,9\n",
    "for x in range(10):\n",
    "    # Check if x is even\n",
    "    if x % 2 == 0:\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes and Objects\n",
    "Objects are an encapsulation of variables and functions into a single entity. Objects get their variables and functions from classes. Classes are essentially a template to create your objects.\n",
    "A very basic class would look something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    variable = \"xin chào\"\n",
    "    def function(self):\n",
    "        print(\"This is a message inside the class.\")\n",
    "\n",
    "myobject = MyClass()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll explain why you have to include that \"self\" as a parameter a little bit later. First, to assign the above class(template) to an object you would do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xin chào\n",
      "This is a message inside the class.\n"
     ]
    }
   ],
   "source": [
    "print(myobject.variable)\n",
    "myobject.function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xin chào\n",
      "tạm biệt\n"
     ]
    }
   ],
   "source": [
    "myobject2 = MyClass()\n",
    "\n",
    "myobject2.variable = \"tạm biệt\"\n",
    "\n",
    "# Then print out both values\n",
    "print(myobject.variable)\n",
    "print(myobject2.variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a message inside the class.\n"
     ]
    }
   ],
   "source": [
    "myobject.function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "Numpy is a python module for better dealing with matrices and vectors. Some of the key advantages are that it is quite fast, easy to work with, and give users the opportunity to perform calculations across entire arrays.\n",
    "\n",
    "### Numpy Vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [3, 4, 5]\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.5 2.1 3.2 4.3]\n",
      "[0.5 1.9 2.8 3.7]\n",
      "2.5\n"
     ]
    }
   ],
   "source": [
    "# Import the numpy package as np\n",
    "import numpy as np\n",
    "\n",
    "# Create two numpy vectors\n",
    "v1 = np.array([1, 2, 3, 4])\n",
    "v2 = np.array([0.5, 0.1, 0.2, 0.3])\n",
    "\n",
    "print(v1 + v2)\n",
    "print(v1 - v2)\n",
    "print(np.dot(v1, v2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets do some calculations along the vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n",
      "[1, 4, 9, 16]\n",
      "[ 1  4  9 16]\n"
     ]
    }
   ],
   "source": [
    "# Compute a vector with the same elements squared\n",
    "# 1)\n",
    "result = []\n",
    "for i in range(len(v1)):\n",
    "    result += [v1[i] ** 2]\n",
    "print(result)\n",
    "\n",
    "# 2)\n",
    "result = [x**2 for x in v1]\n",
    "print(result)\n",
    "\n",
    "# 3)\n",
    "print(v1 ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False False  True  True]\n",
      "[3 4]\n"
     ]
    }
   ],
   "source": [
    "# Boolean response\n",
    "print(v1 > 2)\n",
    "\n",
    "print(v1[v1 > 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy matrix operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [1 2 3]\n",
      " [2 3 4]]\n",
      "\n",
      "[[1 1]\n",
      " [1 1]\n",
      " [1 1]]\n",
      "\n",
      "[[6 6]\n",
      " [6 6]\n",
      " [9 9]]\n"
     ]
    }
   ],
   "source": [
    "# 3 x 3 matrix\n",
    "A = np.array([[1, 2, 3], [1, 2, 3], [2, 3, 4]])\n",
    "print(A)\n",
    "\n",
    "print()\n",
    "# 3 x 2 matrix\n",
    "B = np.array([[1, 1], [1, 1], [1, 1]])\n",
    "print(B)\n",
    "\n",
    "print()\n",
    "\n",
    "print(np.dot(A, B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "**1)** Solve the following linear system and check the result afterwards\n",
    "\n",
    "$$3a+4b−5c+d =10$$\n",
    "$$2a+2b+2c−d = 5$$\n",
    "$$a−b+5c−5d =7$$\n",
    "$$5a+d =4$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.46768061  1.66159696 -0.8973384  -2.53612167]\n",
      "[10.  5.  7.  4.]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[3, 4, -5, 1], \n",
    "              [2, 2, 2, -1], \n",
    "              [1, -1, 5, -5], \n",
    "              [5, 1, 0, 0]])\n",
    "\n",
    "b = np.array([10, 5, 7, 4])\n",
    "x = np.linalg.solve(A ,b)\n",
    "print(x)\n",
    "print(np.dot(A, x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "\n",
    "The [Matplotlib](https://matplotlib.org/) package is the main plotting package for python. It tries to make easy things easy and hard things possible. You can generate plots, histograms, power spectra, bar charts, errorcharts, scatterplots, etc., with just a few lines of code. For examples, see the sample plots and thumbnail gallery.\n",
    "\n",
    "For simple plotting the `pyplot` module provides a MATLAB-like interface, particularly when combined with IPython. For the power user, you have full control of line styles, font properties, axes properties, etc, via an object oriented interface or via a set of functions familiar to MATLAB users."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "x = np.linspace(0, 10, 100)\n",
    "y = np.sin(x)\n",
    "\n",
    "plt.plot(x, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "1) Create 2 random points. Make a plot with the 2 points and the line that passes through both points.\n",
    "\n",
    "**Hint:** Use the `plt.scatter()` function to plot the points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1 = np.random.rand(2)\n",
    "p2 = np.random.rand(2)\n",
    "plt.scatter([p1[0], p2[0]], [p1[1], p2[1]], color='red')\n",
    "plt.plot([p1[0], p2[0]], [p1[1], p2[1]]);"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}