python_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Python Basics</font>\n",
    "\n",
    "\n",
    "This tutorial teaches you the basic building blocks of Python syntax (variables, expressions, functions, conditional blocks, loops, and classes), so that we can formulate statements of code that the computer can understand.\n",
    "\n",
    "> Check [Python Standard Library](https://docs.python.org/3/library/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Arithmetic Operations</font>\n",
    "\n",
    "Python can be used as a calculator using the same arithmetic operations we have in math and their precedence. Similarly you can use parenthesis to specify the precedence.\n",
    "> - add (`+`), subtract (`-`), multiply (`*`), and divide (`/`) operations\n",
    "> - elevate to power (`**`), integer and remainder part of division (`//` and `%`; floor division and modulo) operations\n",
    "> - Python comments start with `#` character\n",
    "> - From Python Standard Library: [`math` module](https://docs.python.org/3/library/math.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mathematical operations (use parentheses as we do in math problems)\n",
    "\n",
    "12.5 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#129300; Question\n",
    "</span>** \n",
    "\n",
    "> For $L=5$ (box length) and $n=1$ (ground state), compute $\\psi^2$ at $x=\\frac{L}{2}$ (probability of finding am electron in the middle of a 1D-box), where\n",
    "\n",
    "\\begin{equation}\n",
    "\\psi = \\sqrt{\\frac{2}{L}} \\sin\\left(\\frac{n \\times \\pi}{L}x\\right)\n",
    "\\end{equation}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=blue>Comparison and logical Operations</font>\n",
    "\n",
    "The comparison operators can be used to compare values, and the logical operators can be used to combine them.\n",
    "\n",
    "> - **Comparison Operators:** equal to (`==`), not equal to (`!=`), greater/less than (`>` and `<`), greater/less than or equal to (`>=` and `<=`).\n",
    "> - **Logical Operators:** `and` (both sides have to be True for the whole statement to be True), `or` (f either side of the comparison is True, the whole statement is True), `not` (inverse the value of statement)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Built-in Functions</font>\n",
    "\n",
    " The keywords and functions make up the syntax of Python, which we can use to build more complex code:\n",
    "\n",
    "- **Function:** a piece of code that performs a unit of work.\n",
    "- **Keyword:** reserved word that is used to construct instructions (e.g., `and`, `or`).\n",
    "\n",
    "[Click here to see the list of general purpose Python built-in functions](https://docs.python.org/3/library/functions.html); by clicking on each function you will be directed to its documentation where you can learn more about the function. Note that these functions are case-sensitive.\n",
    "\n",
    "> **Example:** The `print()` function is part of the basic Python language (i.e., Python syntax) and can be used to  print something on the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "\n",
      "3.5\n"
     ]
    }
   ],
   "source": [
    "# print a string, empty line, and a number\n",
    "print(\"Hello World\")\n",
    "print()\n",
    "print(3.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#129300; Questions\n",
    "</span>** \n",
    "\n",
    "> - What does the `abs` function do? What happens when you pass it a number or an string?\n",
    "> - What do the `str`, `len`, and `type` functions do?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Variables</font>\n",
    "\n",
    "When we write code, we usually need to store values (i.e., give them names) so that we can refer to them later.\n",
    "\n",
    "- **Variable(s):** are used to temporarily store data in a computer's memory. It is like a container for our which can be accessed later (to read or modify).\n",
    "- **Assignment:** The process of storing a value inside a variable using `=` sign.\n",
    "- **Expression:** A combinations of numbers, symbols, or other variables that produce a result when evaluated (to calculate more complex values)\n",
    "\n",
    "## <font color=blue>Variable Naming Restrictions</font>\n",
    "\n",
    "- Don't use spaces and keywords/functions that Python reserves for its own\n",
    "- Must start with a letter or an underscore and be made up of only letters (preferably lower case), numbers, and underscore\n",
    "- variable names are case-sensitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World\n"
     ]
    }
   ],
   "source": [
    "# define a variable called name and print it\n",
    "name = \"Hello, World!\"\n",
    "print(name)\n",
    "\n",
    "name = \"World\"\n",
    "print(\"Hello, \" + name)  # concatenate strings\n",
    "\n",
    "# define a variable called age and use augmented assignment to change its value\n",
    "age = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#129300; Questions\n",
    "</span>** \n",
    "\n",
    "> - What happens if you violate naming restrictions?\n",
    "> - Assign `2 < 3` to a variable, print its value and its type. \n",
    "> - Can you concatenate a sting and a number?\n",
    "> - What happens if you name your variable `print`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#x270B; HANDS-ON Exercise!\n",
    "</span>** \n",
    "\n",
    "> - Define two variables called `length` and `width` assign them initial values.\n",
    "> - Define anoter variable called `area` and assign the value of rectagle area to it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Data Types</font>\n",
    "\n",
    "> - **string:** text written (sequence of characters) between single/double quotes (textual data)\n",
    "> - **integer:** whole numbers without fraction\n",
    "> - **float:** real numbers (numbers with a fractional part)\n",
    "> - **boolean:** represents one of two possible states: either True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "<class 'str'>\n",
      "\n",
      "True\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# example of data types & use type function\n",
    "name = \"Hello, World!\"\n",
    "print(name)\n",
    "print(type(name))\n",
    "print()\n",
    "\n",
    "var = True\n",
    "print(var)\n",
    "print(type(var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#x270B; HANDS-ON Exercise!\n",
    "</span>** \n",
    "\n",
    "> - Generally your computer doesn't know how to mix different data types, so type conversion is very important. To see this, combine variables with different types using the `+` operator and see whether the combination is allowed or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# combine string with integer, float, or boolean (you will get an error --- type it in the browser)\n",
    "\n",
    "\n",
    "# combine string and integer with an explicit conversion (built-in functions)\n",
    "\n",
    "\n",
    "# combine integer with float (implicit conversion)\n",
    "\n",
    "\n",
    "# combine integer with boolean\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Functions</font>\n",
    "\n",
    "Functions allows you to organize your code into logical blocks (indentation is used to specify a block of code) so that  the code is easier to read and is reusable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# define an area function (function that returns a value)\n",
    "\n",
    "def area(length, width):\n",
    "    value = length * width\n",
    "    return value\n",
    "\n",
    "a = area(4, 5)\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c      =  (0, 8, 20)\n",
      "type c =  <class 'tuple'>\n",
      "\n",
      "h, m, s      =  0 6 0\n",
      "type h, m, s =  <class 'int'> <class 'int'> <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# define convert_seconds function (return many values)\n",
    "\n",
    "def convert_seconds(seconds):\n",
    "    # 1h = 3600s\n",
    "    hours = seconds // 3600\n",
    "    # 1min = 60s\n",
    "    minutes = (seconds - hours * 3600) // 60\n",
    "    # remaining seconds\n",
    "    remaining = seconds - hours * 3600 - minutes * 60\n",
    "    return hours, minutes, remaining\n",
    "\n",
    "c = convert_seconds(500)\n",
    "print(\"c      = \", c)\n",
    "print(\"type c = \", type(c))\n",
    "print()\n",
    "\n",
    "h, m, s = convert_seconds(360)\n",
    "print(\"h, m, s      = \", h, m, s)\n",
    "print(\"type h, m, s = \", type(h), type(m), type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Conditionals: `if/elif/else` Statements</font>\n",
    "\n",
    "These statements use logical operations to branch the execution based on a specific condition being `True` (i.e., alter the execution sequence). The simplest conditional has only an `if` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statement is too long!\n"
     ]
    }
   ],
   "source": [
    "# change the variable value and see how the result changes\n",
    "statement = \"Python\"\n",
    "\n",
    "if len(statement) > 5:\n",
    "    print(\"Statement is too long!\")\n",
    "elif len(statement) < 5:\n",
    "    print(\"Statement in too short!\")\n",
    "elif len(statement) == 5:\n",
    "    print(\"Perfect Statement = \", statement)\n",
    "else:\n",
    "    print(\"Proper Statement = \", statement)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#x270B; HANDS-ON Exercise!\n",
    "</span>** \n",
    "\n",
    "> - Write a function, called `is_even`, to check whether a number is even (use `%` with `if/else` or only `if` statement)\n",
    "> - Write examples to show that it works properly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Loops: `while` and `for`</font>\n",
    "\n",
    "Loops allows us to do repetitive tasks without making mistake (or getting tired!). To automate repetitive tasks, one can use:\n",
    "\n",
    "- **while loops:** Instruct your computer to continuously execute a code block based on the value of a condition.\n",
    "- **for loops:** Iterates over a sequence of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 *****\n",
      "4 ****\n",
      "3 ***\n",
      "2 **\n",
      "1 *\n"
     ]
    }
   ],
   "source": [
    "# initialize x and print it while less than a number\n",
    "x = 5\n",
    "while x > 0:\n",
    "    print(x, \"*\" * x)\n",
    "    x -= 1    # without this line, you will be trapped in an infinite loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 *****\n",
      "4 ****\n",
      "3 ***\n",
      "2 **\n",
      "1 *\n"
     ]
    }
   ],
   "source": [
    "# loop using range function\n",
    "for x in [5, 4, 3, 2, 1]:\n",
    "    print(x, \"*\" * x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# loop over elements of a sequence\n",
    "\n",
    "name = \"Python\"\n",
    "for i in name:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#129300; Questions\n",
    "</span>** \n",
    "\n",
    "> - Use `range` built-in function to print numbers 1 to 10 using a `for` loop. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**<span style=\"color:#A03;font-size:14pt\">\n",
    "&#x270B; HANDS-ON Exercise!\n",
    "</span>** \n",
    "\n",
    "> - Write a function, called `factorial_with_while`, to compute the [factorial](https://en.wikipedia.org/wiki/Factorial) of a given number using `while` loop.\n",
    "> - Write a function, called `factorial_with_for`, to compute the [factorial](https://en.wikipedia.org/wiki/Factorial) of a given number using `for` loop.\n",
    "> - Write examples to show that it works properly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Sequences: `list` and `dict`</font>\n",
    "\n",
    "Example of sequences which are also (complex) data types in Python:\n",
    "\n",
    "- **string:** a data type used for representing a piece of text written between quotes (immutable).\n",
    "- **list:** collection of items (of any type) stored in square brackets (mutable).\n",
    "- **dictionary:** a data type that stores data in the form of pairs of keys and values in curely brakets (data is not accessed with indexing).\n",
    "\n",
    "These sequences share operations, like using `for` loop to iterate over them, indexing, `len`, `+` to concatenate and in. These sequences also have special functions (i.e., methods) that are specific to the sequence and expose certain capabilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=blue>Sting and its Methods</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "H o\n",
      "el\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# example of string with len/index and in\n",
    "s = \"Hello\"\n",
    "\n",
    "print(len(s))         # length of string\n",
    "print(s[0], s[-1])    # example of indexing to get first and last element of the string\n",
    "print(s[1: 3])        # example of indexing a range of elements\n",
    "print(\"e\" in s)       # check whether \"e\" shows up in the string\n",
    "print(\"h\" in s)       # check whether \"h\" shows up in the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n",
      "hello\n",
      "Hillo\n"
     ]
    }
   ],
   "source": [
    "# example of string methods (upper, strip, endswith, isnumeric, ...)\n",
    "print(s.upper())           # make string uppercase\n",
    "print(s.lower())           # make string lowercase\n",
    "print(s.replace('e', 'i')) # replace e with i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "print(s.endswith('lo'))    # check whether string ends with a special character\n",
    "print(s.endswith('e'))     # check whether string ends with a special character\n",
    "print(s)                   # see that original string is intact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=blue>List and its Methods</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "a abc\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# example of list with len/index and in\n",
    "l = [\"a\", 3, 5.5, \"abc\"]\n",
    "\n",
    "print(len(l))      # number of items in list\n",
    "print(l[0], l[3])  # example of indexing to get first and last element of the string\n",
    "print(\"ab\" in l)   # check whether \"ab\" is an item in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 3, 5.5, 'abc', 0]\n",
      "['a', 'c', 3, 5.5, 'abc', 0]\n",
      "['a', 'c', 3, 5.5, 0]\n",
      "['a', 'c', 3, 5.5, 0, 'a', 'c', 3, 5.5, 0]\n"
     ]
    }
   ],
   "source": [
    "# example of list methods append, insert, and remove\n",
    "l.append(0)    # add item to the end of the list\n",
    "print(l)       # notice that the list has changed\n",
    "\n",
    "l.insert(1, \"c\")  # insert item at position 1 in the list\n",
    "print(l)\n",
    "\n",
    "l.remove(\"abc\")   # remove item \"abc\" from list\n",
    "print(l)\n",
    "\n",
    "print(l + l)      # concatenate two lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color=blue>Disctionary and its Methods</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n",
      "\n",
      "dict_keys(['a', 'b', 'c', 3])\n",
      "dict_values([0, 1, 2, 'd'])\n",
      "{'a': 0, 'b': 1, 'c': 2, 3: 'd', 'e': 5}\n"
     ]
    }
   ],
   "source": [
    "# example of dictionary methods (keys, values, update, clear)\n",
    "d = {\"a\": 0, \"b\": 1, \"c\": 2, 3: \"d\"}\n",
    "\n",
    "print(d[\"a\"])       # get value corresponding to a key\n",
    "print(len(d))       # get number of items in dictionary\n",
    "print()\n",
    "\n",
    "print(d.keys())     # get the keys of dictionary\n",
    "print(d.values())   # get the values of dictionary\n",
    "\n",
    "d.update({\"e\": 5})  # update dictionary\n",
    "print(d)            # notice how the dictionary has changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 0\n",
      "b 1\n",
      "c 2\n",
      "3 d\n",
      "e 5\n"
     ]
    }
   ],
   "source": [
    "# loop over dictionary\n",
    "for k, v in d.items():\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <font color=blue>Classes</font>\n",
    "\n",
    "Classes are used to define new types and associated functionality (like list data type and its methods)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length =  4\n",
      "width  =  5.0\n",
      "area   =  20.0\n"
     ]
    }
   ],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.width\n",
    "\n",
    "# make an instance of class\n",
    "r = Rectangle(4, 5.0)\n",
    "print(\"length = \", r.length)\n",
    "print(\"width  = \", r.width)\n",
    "print(\"area   = \", r.area())"
   ]
  }
 ],
 "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.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}