1.Python_Basics_Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tutorial\n",
    "\n",
    "Prof. Bin Shan(bshan@mail.hust.edu.cn), Huazhong University of Science and Technology\n",
    "\n",
    "Nano Materials Design and Manufacturing research center at HUST (www.materialssimulation.com)\n",
    "\n",
    "[Python](https://www.python.org) is an easy to learn, powerful programming language. It has efficient high-level data structures and a simple but effective approach to object-oriented programming. Python’s elegant syntax and dynamic typing, together with its interpreted nature, make it an ideal language for scripting and rapid application development in many areas on most platforms.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hello, Python!\n",
    "Here is a simple Python program demonstrates many important aspects of what Python code looks like and how it works. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coin_amount = 0\n",
    "print(coin_amount)\n",
    "\n",
    "# get one more coin\n",
    "coin_amount = coin_amount + 1\n",
    "\n",
    "if coin_amount > 0:\n",
    "    print(\"Hello Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variable assignment**: Here we create a variable called `coin_amount` and assign it the value of `0` using `=`, which is called the assignment operator. Unlike the other languages (like Java or C++):\n",
    "- we don't need to \"declare\" `coin_amount` before assigning to it\n",
    "- we don't need to tell Python what type of value `coin_amount` is going to refer to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coin_amount = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Function calls**: `print` is a Python function that displays the value passed to it on the screen. We call functions by putting parentheses after their name, and putting the inputs (or arguments) to the function in those parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(coin_amount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comment**: comments begin with the `#` symbol in Python.  \n",
    "**Reassignment**: reassigning the value of an existing variable still uses the `=` assignment operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get one more coin\n",
    "coin_amount = coin_amount + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The colon `:` at the end of the if line indicates that a new \"code block\" is starting. Subsequent lines which are **indented** are part of that code block. Some other languages use {} to mark the beginning and end of code blocks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if coin_amount > 0:\n",
    "    print(\"Hello Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise 1 (Numbers and arithmetic)\n",
    "\n",
    "Python supports both integers and floating point numbers. There’s no type declaration to distinguish them; Python tells them apart by the presence or absence of a decimal point. And you can do all kinds of things with numbers.\n",
    "\n",
    "|Operator|Name|Description|\n",
    "|:-----|:-----|:-----|\n",
    "|a + b|Addition|Sum of a and b|\n",
    "|a - b|Subtraction|Difference of a and b|\n",
    "|a * b|Multiplication|Product of a and b|\n",
    "|a / b|True division|Quotient of a and b|\n",
    "|a // b|Floor division|Quotient of a and b, removing fractional parts|\n",
    "|a % b|Modulus|Integer remainder after division of a by b|\n",
    "|a ** b|Exponentiation|a raised to the power of b|\n",
    "|-a|Negation|The negative of a|\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- use the `type()` function to check the type of any value or variable\n",
    "- add an int to an int\n",
    "- add an int to a float\n",
    "- coercing integers to floats and Vice-Versa\n",
    "- do some basic arithmetic by the above operator\n",
    "\n",
    "#### Questions\n",
    "\n",
    "1.1 What is type(11/2), int or float?\n",
    "\n",
    "1.2 What is the value of 15%4?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Integer numbers & Float numbers \n",
    "print(type(1))\n",
    "print(type(1.0))\n",
    "\n",
    "# int + int & int + float\n",
    "a = 1 + 2\n",
    "print(a)\n",
    "b = 1 + 2.0\n",
    "print(b)\n",
    "\n",
    "# coercing integers to floats\n",
    "i2f = float(2)\n",
    "print(i2f)\n",
    "f2i = int(2.0)\n",
    "print(f2i)\n",
    "# The int() function will truncate, not round\n",
    "f_trun = int(2.5)\n",
    "# The int() function truncates negative numbers towards 0\n",
    "nf_trun = int(-2.5)\n",
    "\n",
    "# arithmetic\n",
    "print(11 / 2)\n",
    "print(11 // 2)\n",
    "print(-11 // 2)\n",
    "print(11 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When integer-dividing negative numbers, the `//` operator rounds “up” to the nearest integer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise 2 (Basic Math Operations)\n",
    "\n",
    "You can also do basic math operations like trigonometry in Python. You will need to import the **math** module for this task.\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- get the value of sin(π/2)\n",
    "- get the value of tan(π/4)\n",
    "- pow(x,y,z) can be used to find the power xy also the mod of the resulting value with the third specified number can be found i.e. : (xy % z)\n",
    "- `range()` function outputs the integers of the specified range. It can also be used to generate a series by specifying the difference between the two numbers within a particular range. The elements are returned in a list (will be discussing in detail later.)\n",
    "\n",
    "#### Questions\n",
    "\n",
    "2.1 What is the value of `round(math.pi, 4)`\n",
    "\n",
    "2.2 What is the value of the last element in `range(2,11)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.pi)\n",
    "val_1 = math.sin(math.pi / 2)\n",
    "print(val_1)\n",
    "val_2 = math.tan(math.pi / 4)\n",
    "print(val_2)\n",
    "print(pow(3,3))\n",
    "print(pow(3,3,5))\n",
    "\n",
    "list(range(2,11))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise 3 (Booleans and Conditionals)\n",
    "Booleans are either true or false. Python has two constants, cleverly named `True` and `False`, which can be used to assign boolean values directly. We usually get boolean values from **boolean operators**. These are operators that answer yes/no questions. We'll go through some of these operators below.\n",
    "\n",
    "|Operation|Description|Operation|Description|\n",
    "|:-----|:-----|:-----|:-----|\n",
    "|a == b|a equal to b|a != b|a not equal to b|\n",
    "|a < b|a less than b|a > b|a greater than b|\n",
    "|a <= b|a less than or equal to b|a >= b|a greater than or equal to b|\n",
    "\n",
    "Booleans really start to shine when combined with conditional statements, using the keywords `if`, `elif`, and `else`. Conditional statements, often referred to as **if-then** statements, allow the programmer to execute certain pieces of code depending on some Boolean condition.\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- define a function called `inspect` which takes a numerical argument x\n",
    "- use conditional statements to judge whether they are **positive**, **negative** or **0**, the function:\n",
    "$$inspect(x) = \\begin{cases}  \n",
    "\"is&zero\" & x > 0 \\\\\n",
    "\"is&positive\" & x  = 0 \\\\\n",
    "\"is&negative\" & x < 0\n",
    "\\end{cases}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def inspect(x):\n",
    "    if x == 0:\n",
    "        return(\"is zero\")\n",
    "    elif x > 0:\n",
    "        return(\"is positive\")\n",
    "    elif x < 0:\n",
    "        return(\"is negative\")\n",
    "    else:\n",
    "        return(\"is unlike anything I've ever seen...\")\n",
    "\n",
    "print(0, inspect(0))\n",
    "print(10, inspect(10))\n",
    "print(-1, inspect(-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For loops\n",
    "\n",
    "for variable in something:\n",
    "\n",
    "    algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While loops\n",
    "\n",
    "while some_condition:\n",
    "\n",
    "    algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 4:\n",
    "    print(i ** 2)\n",
    "    i += 1\n",
    "print('Bye')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Break\n",
    "\n",
    "As the name says. It is used to break out of a loop when a condition becomes true when executing the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)\n",
    "    if i==5:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Continue\n",
    "\n",
    "The keyword \"continue\" tells Python to skip the remaining commands of the current step and move on to the next steps of this loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    if i%2 == 0:\n",
    "        print(\"the number is even\")\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise 4 (Lists)\n",
    "\n",
    "Lists in Python represent ordered sequences of values. Lists might contain items of different types, but usually the items all have the same type.\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- create a list contains several integers\n",
    "- create a list of lists\n",
    "- create a list contains a mix of different types of variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-20T16:35:28.569555Z",
     "start_time": "2019-02-20T16:35:28.566928Z"
    }
   },
   "outputs": [],
   "source": [
    "# Enter your code here\n",
    "numbers = [2,3,4,5]\n",
    "hands = [\n",
    "    ['A', 'A', 'A'],\n",
    "    ['J', 'Q', 'K'],\n",
    "    ['8', 'Q', 'K'],\n",
    "]\n",
    "info = [20, 'Jason', 'MSE']\n",
    "print(numbers)\n",
    "print(hands)\n",
    "print(info)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and slicing of lists\n",
    "\n",
    "You can access individual list elements with square brackets.\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- create a list containing the names of all the planets in our solar system, arranged in order from near to far from the sun\n",
    "- find the closest planet to the sun\n",
    "- find the second closest planet\n",
    "- find the furthest planet\n",
    "\n",
    "#### Questions\n",
    "\n",
    "4.1 What is the value of `planets[-1]`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-20T16:35:28.581665Z",
     "start_time": "2019-02-20T16:35:28.577506Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Enter your code here\n",
    "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
    "print('The closest planet to the sun is',planets[0])\n",
    "print('The second closest planet to the sun is',planets[1])\n",
    "print('The furthest planet to the sun is',planets[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-20T16:35:28.591506Z",
     "start_time": "2019-02-20T16:35:28.587586Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Enter your code here\n",
    "print(planets[:])\n",
    "print(planets[0:3])\n",
    "print(planets[1:-1])\n",
    "print(planets[:3])\n",
    "print(planets[3:])\n",
    "print(planets[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List functions\n",
    "\n",
    "Python has several useful functions for working with lists. All the built-in functions of Python are listed [here](https://docs.python.org/3/library/functions.html) in alphabetical order.\n",
    "\n",
    "#### Instructions\n",
    "- create a list contains several integers and use function `len` to get the length of it\n",
    "- use `sorted` to sort the list\n",
    "- use `max` to get the maximum interger in the list \n",
    "- use `sum` to get the sum of the elements in the list\n",
    "\n",
    "#### Questions\n",
    "4.2 What are the results if we replace the list `numbers` with `planets`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-20T16:35:28.617215Z",
     "start_time": "2019-02-20T16:35:28.613422Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for 'numbers':\n",
      "4\n",
      "[1, 3, 8, 9]\n",
      "9\n",
      "21\n",
      "for 'planets':\n"
     ]
    }
   ],
   "source": [
    "numbers = [9, 3, 8, 1]\n",
    "\n",
    "\n",
    "print(\"for 'numbers':\")\n",
    "print(len(numbers))\n",
    "print(sorted(numbers))\n",
    "print(max(numbers))\n",
    "print(sum(numbers))\n",
    "\n",
    "# Enter your code here\n",
    "print(\"for 'planets':\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop over list\n",
    "Loops are a way to repeatedly execute some code. The for loop specifies:\n",
    "\n",
    "- the variable name to use\n",
    "- the set of values to loop over\n",
    "\n",
    "We use the word `in` to link them together.\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- use the for loop to print the names of all elements in the list `planet`\n",
    "- use the for loop to get the result of $5!$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
    "for planet in planets:\n",
    "    print(planet)\n",
    "\n",
    "factorial = 1\n",
    "for i in range(5):\n",
    "    factorial = factorial * (i+1)\n",
    "print(\"5! = \", factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List methods\n",
    "\n",
    "Python has a set of built-in methods that you can use on lists.\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- use `list.append` to modify `planets` by adding an item to the end\n",
    "- use `list.pop` to remove the last element of `planets`\n",
    "- use `list.index` to find the index of `Earth`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-20T16:35:28.630303Z",
     "start_time": "2019-02-20T16:35:28.626019Z"
    }
   },
   "outputs": [],
   "source": [
    "# Enter your code here\n",
    "planets.append('Pluto')\n",
    "print(planets)\n",
    "planets.pop()\n",
    "print(planets)\n",
    "planets.index('Earth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise 5 (Tuples)\n",
    "Tuples are almost exactly the same as lists. They differ in just two ways.\n",
    "1. The syntax for creating them uses parentheses instead of square brackets.\n",
    "2. They cannot be modified (they are immutable).\n",
    "\n",
    "#### Instructions\n",
    "\n",
    "- create a tuple `t`\n",
    "- try to index `t` and assign a new value to it\n",
    "\n",
    "#### Questions\n",
    "\n",
    "5.1 Why Python would complain TypeError? What is the error message?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-20T16:35:28.634813Z",
     "start_time": "2019-02-20T16:35:28.632236Z"
    }
   },
   "outputs": [],
   "source": [
    "t = (1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-88963aa635fa>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  },
  "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": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "164px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}