SIT719_Prac01_Python_Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UP2Th8B0LLey"
   },
   "source": [
    "# SIT719: Security and Privacy Issues in Analytics\n",
    "**(Week 01: Programming Python)**\n",
    "\n",
    "---\n",
    "- Materials in this module include resources collected from various open-source online repositories.\n",
    "- You are free to use, change and distribute this package.\n",
    "- Thanks to A/Prof Gang Li for sharing the information \n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "# Session 1A - Jupyter notebook and basic data types\n",
    "\n",
    "\n",
    "In this session, \n",
    "you will learn how to run *Python* code under  **Jupyter notebook** (aka IPython notebook). You have two options for the environment:\n",
    "\n",
    "1. Install the [Anaconda](https://www.anaconda.com/distribution/), and run it locally (recommended for those who want to learn advanced python skills,the unit chair and tutors will use this, once you install successfully, everything is easy but may face some version issue); **OR**\n",
    "1. Use one cloud data science platform such as:\n",
    "    - [Google Colab](https://colab.research.google.com) (recommended for the slow starters) \n",
    "    - [IBM Cloud](https://www.ibm.com/cloud)\n",
    "    - [DataBricks](https://community.cloud.databricks.com)\n",
    "\n",
    "\n",
    "\n",
    "In Jupyter notebook, you will be able to execute and modify your *Python* code more efficiently. \n",
    "\n",
    "- **If you are using Google Colab for SIT719 lab session practicals, you can skip this Part 1 of this Session 1A, and start with Part 2 directly.**\n",
    "\n",
    "\n",
    "\n",
    "In addition, you will be given an introduction on *Python*'s basic data types, \n",
    "getting familiar with **string**, **number**, data conversion, data comparison and \n",
    "data input/output. \n",
    "\n",
    "Hopefully, by using **Python** and the powerful **IPython Notebook** environment, \n",
    "you will find writing programs both fun and easy. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "V0vSWcazLLe3"
   },
   "source": [
    "## Content\n",
    "\n",
    "### Part 1 Create your own Jupyter notebook\n",
    "\n",
    "1.1 [Start a notebook server](#cell_start)\n",
    "\n",
    "1.2 [A tour of Jupyter notebook](#cell_tour)\n",
    "\n",
    "1.3 [IPython notebook interface](#cell_interface)\n",
    "\n",
    "1.4 [Open and close notebooks](#cell_close)\n",
    "\n",
    "### Part 2 Basic data types\n",
    "\n",
    "2.1 [String](#cell_string)\n",
    "\n",
    "2.2 [Number](#cell_number)\n",
    "\n",
    "2.3 [Data conversion and comparison](#cell_conversion)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DAeickflLLe7"
   },
   "source": [
    "# Part 1. Create your own Jupyter notebook\n",
    "\n",
    "- **If you are using Google Colab for SIT719 lab session practicals, you can ignore this Part 1, and start with Part 2.**\n",
    "\n",
    "\n",
    "This notebook will show you how to start an IPython notebook session. It guides you through the process of creating your own notebook. It provides you details on the notebook interface and show you how to navigate with a notebook and manipulate its components. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C6uxTijTLLe_"
   },
   "source": [
    "<a id = \"cell_start\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JO2tcWluLLfB"
   },
   "source": [
    "     \n",
    "## 1. 1 Start a notebook server\n",
    "\n",
    "As described in Part 1, you start the IPython notebook server by keying in the command in a terminal window/command line window.\n",
    "\n",
    "Once you staryt Jupyter notebook, default browser should start (or open a new tab) to the following URL: http://localhost:8888/tree If that port is busy, it looks for the next available port. \n",
    "\n",
    "Note that right now you are not actually running a Notebook, but instead you are just running the Notebook server. Let’s actually create a Notebook now! However,  before you do this, make sure you have created a folder **p01** under the Folder **SIT719** of the deafalt path, download the file **SIT719_Prac01-Python-Intro.ipynb** notebook, and saved it under **../SIT719/p01**.\n",
    "\n",
    "If you are using [Google Colab](https://colab.research.google.com), you can upload this notebook to Google Colab and run it from there. If any difficulty, please ask your tutor, or check the CloudDeakin discussions.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Slhkb9iqLLfM"
   },
   "source": [
    " \n",
    " ## 1.2  A tour of Jupyter notebook \n",
    " \n",
    " ###  Create a new Jupyter notebook\n",
    " \n",
    " \n",
    " To create a new notebook, go to the menu bar and select **File -> New Notebook -> Python 3**\n",
    "\n",
    "By default, the new notebook is named **Untitled**. To give your notebook a meaningful name, click on the notebook name and rename it. We would like to call our new notebook **hello.ipynb**. Therefore, key in the name **hello**. \n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/tuliplab/mds/master/Jupyter/image/emptyNotebook.jpg\">\n",
    "\n",
    "\n",
    "\n",
    "###  Run script in code cells\n",
    "\n",
    "After a new notebook is created, there is an empty box in the notebook, called a **cell**. If you double click on the cell, you enter the **edit** mode of the notebook. Now we can  enter the following code in the cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "raw",
    "id": "KjqBdqFeLLfO"
   },
   "source": [
    "text = \"Hello World\"\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NYDnH3V1LLfR"
   },
   "source": [
    "After this,  press **CTRL + ENTER**, and execute the cell. The result will be shown after the cell. \n",
    "\n",
    "\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/tuliplab/mds/master/Jupyter/image/hello-world.jpg\">\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "After a cell is executed, the notebook is switched to the **Command** mode. In this mode, you can manipulate the notebook and its component. Alternatively, you can  use **ESC** key to switch from **Edit** mode to **Command** mode without executing code. \n",
    "\n",
    "To modify the code you entered in the cell, **double click** the cell again and modify its content. For example, try to change the first line of previous cell into the following code:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "raw",
    "id": "TJQbOFqJLLfU"
   },
   "source": [
    "text = \"Good morning World!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YhgTgof0LLfX"
   },
   "source": [
    "Afterwards,  press **CTRL + ENTER**, and the new output is displayed. \n",
    "\n",
    "As you can see, you are switching between two modes, **Command** and **Edit**, when editing a notebook. We will in later section look into these two operation modes of closely. Now practice  switching between the two modes until you are comfortable with them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N3q3nZrQLLfY"
   },
   "source": [
    "###  Add  new  cells\n",
    "\n",
    "To add a new cell to a notebook, you have to ensure the notebook is in **Command** mode. If not, refer to previous section to switch to **Command** mode. \n",
    "\n",
    "\n",
    "To add cell below the current cell, go to menu bar and click **Insert-> Insert Cell Below**. Alternatively, you can use shortcut i.e. pressing **b** (or **a** to create a cell above).\n",
    "\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/tuliplab/mds/master/Jupyter/image/new-cell.jpg\">\n",
    "\n",
    "###  Add markdown cells\n",
    "\n",
    "By default, a code cell is created when adding a new cell. However, IPython notebook also use a **Markdown** cell for enter normal text. We use markdown cell to display the text in specific format and to provide structure for a notebook.  \n",
    "\n",
    "Try to copy the text in the cell below and paste it into your new notebook. Then from toolbar(**Cell->Cell Type**), change cell type from **Code** to **Markdown**. \n",
    "\n",
    "Please note in the following cell, there is a space between the leading **-, #, 0** and the text that follows. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "raw",
    "id": "yE7_3iNPLLfa"
   },
   "source": [
    "## Heading 2\n",
    "Normal text here!\n",
    "\n",
    "### Heading 3\n",
    "ordered list here\n",
    "\n",
    "0. Fruits\n",
    "  0. Banana\n",
    "  0. Grapes\n",
    "0. Veggies\n",
    "  0. Tomato\n",
    "  0. Broccoli\n",
    " \n",
    "Unordered list here\n",
    "- Fruits\n",
    "     - Banana\n",
    "     - Grapes\n",
    "- Veggies\n",
    "     - Tomato\n",
    "     - Broccoli"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "slcY8TkgLLfc"
   },
   "source": [
    "Now execute the cell by press **CTRL+ ENTER**. You notebook should look like this:\n",
    "    \n",
    "<img src=\"https://raw.githubusercontent.com/tuliplab/mds/master/Jupyter/image/new-markdown.jpg\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Wvfjy1AALLff"
   },
   "source": [
    "Here is what the formatted Markdown cell looks like:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dPvd8QuFLLfh"
   },
   "source": [
    "### Exercise:\n",
    "Click this cell, and practice writing markdown language here..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FNzxurYjLLfj"
   },
   "source": [
    "<a id = \"cell_interface\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "R0RQeVQlLLfn"
   },
   "source": [
    " \n",
    "### 1.3 Jupyter notebook interface\n",
    "\n",
    "Now you have created your first notebook, let us have a close look at the user interface of IPython notebook.\n",
    "\n",
    "\n",
    "\n",
    "### Notebook component\n",
    "When you create a new notebook document, you will be presented with the notebook name, a menu bar, a toolbar and an empty code cell.\n",
    "\n",
    "We can see the following components in a notebook:\n",
    "\n",
    "- **Title bar** is at the top of the page and  contains the name of the notebook. Clicking on the notebook name brings up a dialog which allows you to rename it.  Please renaming your notebook name from “Untitled0” to “hello”. This change the file name from **Untitled0.ipynb**  to  **hello.ipynb**.\n",
    "\n",
    "- **Menu bar** presents different options that can be used to manipulate the way the notebook functions.\n",
    "\n",
    "- **Toolbar** gives a quick way of performing the most-used operations within the notebook.\n",
    "\n",
    "- An empty computational cell is show in a new notebook where you can key in your code.\n",
    "\n",
    "The notebook has two modes of operation:\n",
    "\n",
    "- **Edit**: In this mode, a single cell comes into focus and you can enter text or execute code. You activate the **Edit mode** by **clicking on a cell** or **selecting a cell and then pressing Enter key**.\n",
    "\n",
    "- **Command**: In this mode, you can perform tasks that is related to the whole notebook structure. For example, you can move, copy, cut and paste cells. A series of keyboard shortcuts are also available to enable you to perform these tasks more efficient. One easiest way of activating the command mode by pressing the **Esc** key to exit editing mode. \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### Get help and interrupting\n",
    "\n",
    "\n",
    "To get help on the use of different commands, shortcuts, you can go to the **Help** menu, which provides links to relevant documentation.\n",
    "\n",
    "It is also easy to get help on any objects(including functions and methods). For example, to access help on the sum() function, enter the following line in a cell:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "raw",
    "id": "TGoAeYhYLLfp"
   },
   "source": [
    "sum?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tbgcq5bXLLfu"
   },
   "source": [
    "The other important thing to know is how to interrupt a computation. This can be done through the menu **Kernel->Interrupt** or **Kernel->Restart**, depending on what works on the situation. We will have chance to try this in later session. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C0Ra6R3PLLfw"
   },
   "source": [
    "\n",
    "### Notebook cell types\n",
    "\n",
    "\n",
    "There are basically three types of cells in a IPython notebook: Code Cells, Markdown Cells, Raw Cells.\n",
    "\n",
    "\n",
    "**Code cells** : Code cell can be used to enter code and will be executed by Python interpreter. Although we will not use other language in this unit, it is good to know that Jupyter Notebooks  also support JavaScript,  HTML, and Bash commands.\n",
    "\n",
    "*** Markdown cells***: You have created markdown cell in the previous section. Markdown Cells are the easiest way to write and format text. It is also give structure to the notebook. Markdown language is used in this type of cell. Follow this link https://daringfireball.net/projects/markdown/basics  for the basics of the syntax.  \n",
    "\n",
    "This is a  Markdown Cells example notebook sourced from : https://ipython.org/ipython-doc/3/notebook/notebook.html\n",
    "This markdown cheat sheet can also be good reference to the main markdowns you might need to use in our pracs http://nestacms.com/docs/creating-content/markdown-cheat-sheet\n",
    "\n",
    "\n",
    "**Raw cells** : Raw cells, unlike all other Jupyter Notebook cells, have no input-output distinction. This means that raw Cells cannot be rendered into anything other than what they already are. They are mainly used to create examples.\n",
    "\n",
    "\n",
    "As you have seen, you can use the toolbar to choose between different cell types. In addition, shortcut **M** and **Y** can be used to quickly change a cell to Code cell or Markdown cell under Command mode. \n",
    "\n",
    "\n",
    "### Operation modes of Jupyter notebook\n",
    "\n",
    "**Edit mode**\n",
    "\n",
    "\n",
    "\n",
    "The Edit mode is used to enter text in cells and to execute code. As you have seen, after typing some code in the notebook and pressing **CTRL+Enter**, the notebook executes the cell and diplays output. The other two shortcuts used to run code in a cell are **Shift +Enter** and **Alt + Enter**. \n",
    "\n",
    "These three ways to run the the code in a cells are summarized as follows:\n",
    "\n",
    "\n",
    "- Pressing Shift + Enter: This runs the cell and select the next cell(A new cell is created if at the end of the notebook). This is the most usual way to execute a cell.\n",
    "\n",
    "- Pressing Ctrl + Enter: This runs the cell and keep the same cell selected. \n",
    "\n",
    "- Pressing Alt + Enter: This runs the cell and insert a new cell below it. \n",
    "\n",
    "\n",
    "**Command mode**\n",
    "\n",
    "In Command mode, you can edit the notebook as a whole, but not type into individual cells.\n",
    "\n",
    "You can use keyboard shortcut in this mode to perform the notebook and cell actions efficiently. For example, if you are in command mode and press **c**, you will copy the current cell. \n",
    "\n",
    "\n",
    "\n",
    " There are a large amount of shortcuts available in the command mode. However, you do not have to remember all of them, since most actions in the command mode are available in the menu. \n",
    " \n",
    " Here is a list of the most useful shortcuts. They are arranged by the \n",
    " order we recommend you learn so that you can edit the cells efficiently.\n",
    "\n",
    "\n",
    "1. Basic navigation: \n",
    "\n",
    "   - Enter: switch to Edit mode\n",
    "   \n",
    "   - Esc: switch to Command mode\n",
    "   \n",
    "   - Shift+Enter: Execute a cell\n",
    "   \n",
    "   - Up, down: Move to the cell above or below\n",
    "\n",
    "2. Cell types: \n",
    "  - y: switch to code cell)\n",
    "  - m: switch to markdown cell) \n",
    "\n",
    "3. Cell creation: \n",
    "    - a: insert new sell above\n",
    "    - b: insert new cell  below\n",
    "\n",
    "4. Cell deleting:\n",
    "    - press D twice.\n",
    "\n",
    "Note that one of the most common (and frustrating) mistakes when using the\n",
    "notebook is to type something in the wrong mode. Remember to use **Esc**\n",
    "to switch to the Command mode and **Enter** to switch to the Edit mode.\n",
    "Also, remember that **clicking** on a cell automatically places it in the Edit\n",
    "mode, so it will be necessary to press **Esc** to go to the Command mode.\n",
    "\n",
    "### Exercise\n",
    "Please go ahead and try these shortcuts. For example, try to insert new cell, modify and delete an existing cell. You can also switch cells between code type and markdown type, and practice different kinds of formatting in a markdown cell.\n",
    " \n",
    "For a complete list of shortcut in **Command** mode, go to menu bar **Help->Keyboard Shortcuts**. Feel free to explore the other shortcuts. \n",
    " \n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M2sk2y0ILLfy"
   },
   "source": [
    "<a id = \"cell_close\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "W0JXgsqELLf0"
   },
   "source": [
    " \n",
    " ## 1.4 open and close notebooks\n",
    " \n",
    " You can open multiple notebooks in a browser windows. Simply go to menu bar and choose **File->open...**, and select one **.ipynb** file. The second notebook will be opened in a seperated tab. \n",
    " \n",
    "Now make sure you still have your **hello.ipynb** open. \n",
    " \n",
    " When you finish your work, you will need to close your notebooks and shutdown the IPython notebook server. Instead of simply close all the tabs in the browser, you need to shutdown each notebook first. To do this, switch to the **Home** tab(**Dashboard page**) and **Running** section(see below). Click on **Shutdown** button to close each notebook. In case  **Dashboard** page is not open,  click on the **Jupyter** icon to reopen it. \n",
    " \n",
    "\n",
    " <img src=\"https://raw.githubusercontent.com/tuliplab/mds/master/Jupyter/image/close-index.jpg\">\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WKEEelJeLLf2"
   },
   "source": [
    "\n",
    "# Part 2  Basic Data Types\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rtm_f4lwLLf4"
   },
   "source": [
    "\n",
    "\n",
    "In this part,  you will get better understanding with Python's basic data type. We will \n",
    "look at **string** and **number** data type in this section. Also covered are:\n",
    "\n",
    "- Data conversion\n",
    "- Data  comparison\n",
    "- Receive  input from users and display results effectively \n",
    "\n",
    "You will be guided through  completing a simple program which receives input from a user,\n",
    " process the information, and display results with specific format. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "THnW6RPgLLf6"
   },
   "source": [
    "## 2.1 String\n",
    "\n",
    "A string is a *sequence of characters*. We are using strings in almost every Python\n",
    "programs. As we can seen in the **”Hello, World!”** example, strings can be specified\n",
    "using single quotes **'**. The **print()** function can be used to display a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CG-9AQrmLLf7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print('Hello, World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZPKAMR6WLLgI"
   },
   "source": [
    "We can also use a variable to store the string value, and use the variable in the\n",
    "**print()** function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5ZsarfIpLLgO"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# Assign a string to a variable \n",
    "text = 'Hello, World!'\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cm9IgbLyLLgU"
   },
   "source": [
    "A *variable* is basically a name that represents (or refers to) some value. We use **=**\n",
    "to assign a value to a variable before we use it. Variable names are given by a programmer\n",
    "in a way that the program is easy to understanding. Variable names are *case sensitive*.\n",
    "It can consist of letters, digits and underscores. However, it can not begin with a digit.\n",
    "For example, **plan9** and **plan_9** are valid names, where **9plan** is not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zilCIz-GLLga"
   },
   "outputs": [],
   "source": [
    "text = 'Hello, World!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cHelVR_8LLgg"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# with print() function, content is displayed without quotation mark\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zshg7IvZLLgp"
   },
   "source": [
    "With variables, we can also display its value without **print()** function. Note that\n",
    "you can not display a variable without **print()** function in Python script(i.e. in a **.py** file). This method only works under interactive mode (i.e. in the notebook).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "A8eOiupBLLgq"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, World!'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# without print() function, quotation mark is displayed together with content\n",
    "text "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "grJ6X6aMLLg8"
   },
   "source": [
    "Back to representation of string, there will be issues if you need to include a quotation\n",
    "mark in the text.\n",
    "We provide a example use a apostrophe mark(’) similar with single quotation mark(').\n",
    "You will find that it will show \"SyntaxError: invalid character in identifier\". Just try to change the apostrophe mark with single quotation mark and run it again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QcxK0VgBLLg9"
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid character in identifier (<ipython-input-6-1d543ff1b17c>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-6-1d543ff1b17c>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    text = ’What’ s your name ’\u001b[0m\n\u001b[1;37m                ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid character in identifier\n"
     ]
    }
   ],
   "source": [
    "text = ’What’ s your name ’"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HHs3pOo7ummI"
   },
   "source": [
    "<details><summary><u><b><font color=\"Blue\">Click here for solution</u></b></summary>\n",
    "```python\n",
    "    text = ' What\\'s your name?'\n",
    "    print(text)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "W3vLIE_bLLhC"
   },
   "source": [
    "Since strings in double quotes **\"** work exactly the same way as string in single quotes.\n",
    "By mixing the two types, it is easy to include quotation mark itself in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kcq185ULLLhD"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What' s your name?\n"
     ]
    }
   ],
   "source": [
    "text = \"What' s your name?\"\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ncHDozPILLhI"
   },
   "source": [
    "Alternatively, you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "X-DGDDQaLLhI"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"What is the problem?\", he asked.\n"
     ]
    }
   ],
   "source": [
    "text = '\"What is the problem?\", he asked.'\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bwoz8VV2LLhS"
   },
   "source": [
    "You can specify multi-line strings using triple quotes  (**\"\"\"** or **'''**). In this way, single\n",
    "quotes and double quotes can be used freely in the text.\n",
    "Here is one example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "q1mgdutELLhU"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a test for multiline. This is the first line. \n",
      "This is the second line. \n",
      "I asked, \"What's your name?\"\n"
     ]
    }
   ],
   "source": [
    "multiline = '''This is a test for multiline. This is the first line. \n",
    "This is the second line. \n",
    "I asked, \"What's your name?\"'''\n",
    "print(multiline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i5Kx0MKLLLhZ"
   },
   "source": [
    "Notice the difference when the variable is displayed without **print()** function in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5j7kVvnnLLhd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a test for multiline. This is the first line. \\nThis is the second line. \\nI asked, \"What\\'s your name?\"'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiline = '''This is a test for multiline. This is the first line. \n",
    "This is the second line. \n",
    "I asked, \"What's your name?\"'''\n",
    "multiline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "glnQnKz6LLhi"
   },
   "source": [
    "Another way of include the special characters, such as single quotes is with help of\n",
    "escape sequences **\\\\**. For example, you can specify the single quote using **\\\\' ** as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DC97cQs2LLhj"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's your name?\n"
     ]
    }
   ],
   "source": [
    "string = 'What\\'s your name?'\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kp8W43nnLLhv"
   },
   "source": [
    "There are many more other escape sequences (See Section 2.4.1 in [Python3.0 official document](https://docs.python.org/3.1/reference/lexical_analysis.html)). But I am going to mention the most useful two examples here. \n",
    "\n",
    "First, use escape sequences to indicate the backslash itself e.g. **\\\\\\\\**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "U5PUlblFLLh3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\windows\\temp\n"
     ]
    }
   ],
   "source": [
    "path = 'c:\\\\windows\\\\temp'\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cm0OdobTLLh9"
   },
   "source": [
    "Second,  used escape sequences to specify a two-line string. Apart from using a triple-quoted\n",
    "string as shown previously, you can use **\\n** to indicate the start of a new line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6Hx7whpWLLh9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a test for multiline. This is the first line.\n",
      "This is the second line.\n"
     ]
    }
   ],
   "source": [
    "multiline = 'This is a test for multiline. This is the first line.\\nThis is the second line.'\n",
    "print(multiline)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SxYdplr7LLiB"
   },
   "source": [
    "To manipulate strings, the following two operators are most useful: \n",
    "* ** + ** is use to concatenate two strings or string variables; \n",
    "* ** * ** is used for concatenating several copies of the same string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "atOH5kwTLLiC"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, WorldWorldWorld\n"
     ]
    }
   ],
   "source": [
    "print('Hello, ' + 'World' * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3e2FhseULLiE"
   },
   "source": [
    "Below is another example of string concatenation based on  variables that store strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "b4rw4CjPLLiG"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "name = 'World'\n",
    "greeting = 'Hello'\n",
    "print(greeting + ', ' + name + '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ggn2lPQMLLiJ"
   },
   "source": [
    "Using variables, change part of the string text is very easy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "i0jfd08dLLiK"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'World'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gDymwzHmLLiN"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-xdxHvZlLLiQ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good morning, World!\n"
     ]
    }
   ],
   "source": [
    "# Change part of the text is easy\n",
    "greeting = 'Good morning' \n",
    "print(greeting + ', ' + name + '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aUcMPHTMLLiS"
   },
   "source": [
    " ## 2.2 Number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NTaPssJ_LLiT"
   },
   "source": [
    "There are two types of numbers that are used most frequently: integers and floats. As we\n",
    "expect, the standard mathematical operation can be applied to these two types. Please\n",
    "try the following expressions. Note that **\\*\\*** is exponent operator, which indicates\n",
    "exponentiation exponential(power) calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4bJEQg_MLLiU"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "p6bV4vC9LLiX"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-Rs_u_qnLLia"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#3 to the power of 4\n",
    "3 ** 4 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XTDUWNsPLLie"
   },
   "source": [
    "Among the number operations, we need to look at division closely. In Python 3.0, classic division is performed using  **/**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "l5ee7L9mLLif"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "15 / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZtobUWNcLLij"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.8"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "14 / 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6ID6qNctLLil"
   },
   "source": [
    "*//* is used to perform floor division. It truncates the fraction and rounds it to the next smallest whole number toward the left on the number line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hT18fhA8LLim"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "14 // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Jj02iHTpLLip"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Negatives move left on number line. The result is -3 instead of  -2\n",
    "-14 // 5 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z-YaXqCSLLir"
   },
   "source": [
    "Modulus operator **%** can be used to obtain remainder. Pay attention when negative number is involved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WIZ3IGCILLis"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "14 % 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4Ao-du3_LLix"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Hint:  −14 // 5 equal to −3\n",
    "#        (-3) * 5 +  ? = -14\n",
    "\n",
    "-14 % 5 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I0sASGehLLiz"
   },
   "source": [
    "*Operator precedence* is a rule that affects how an expression is evaluated. As we learned in high school, the multiplication is done first than the addition. e.g. **2 + 3 * 4**. This means multiplication operator has higher precedence than the addition operator.\n",
    "\n",
    "For your reference, a precedence table from the python reference manual is used to indicate the evaluation order in Python.  For a complete precedence table, check the heading \"Python Operators Precedence\" in this [Python tutorial](http://www.tutorialspoint.com/python/python_basic_operators.htm)\n",
    "\n",
    "\n",
    "However, When things get confused, it is far better to use parentheses **()** to explicitly\n",
    "specify the precedence. This makes the program more readable.\n",
    "\n",
    "Here are some examples on operator precedence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q8-htgKSLLi0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MTstkwWoLLi2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 + 3) * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "X5zqw9gQLLi6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2J5jmyrALLi8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 + 3) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4c0ohRKmLLi-"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-(4+3)+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6QklYZFXLLjB"
   },
   "source": [
    "Similarly as string, variables can be used to store a number so that it is easy to manipulate them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TsmyIIe0LLjC"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3\n",
    "y = 2\n",
    "x + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "joZHkCbELLjJ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum = x + y\n",
    "sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2lzP8lYMLLjU"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1gsMSLAgLLjW"
   },
   "source": [
    "One common expression is to run a math operation on a variable and then assign the result of the operation back to the variable. Therefore, there is a shortcut for such a expression. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "D1hxyg1mLLjX"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "x = x * 3\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M5b_TPipLLjZ"
   },
   "source": [
    "This is equivalent to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qb0BdkZ9LLja"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "# Note there is no space between '*' and '+'\n",
    "x *= 3\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mk39mzf8LLjd"
   },
   "source": [
    "## 2.3 Data conversion and comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DI609niBLLje"
   },
   "source": [
    "So far, we have seen three types of data: integer, float, and string. With various data type, Python can define the operations possible on them and the storage method for each of them. In the later pracs, we will further introduce more data types, such as tuple, list and dictionary. \n",
    "\n",
    "To obtain the data type of a variable or a value, we can use built-in function **type()**;\n",
    "whereas functions, such as **str()**, **int()**, **float()**, are used to convert data one  type to another. Check the following examples on the usage of these functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V62kYzxKLLjf"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('Hello, world!)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Boe-ivfiLLjh"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_Value = '45.6'\n",
    "type(input_Value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4wGHArWZLLji"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weight = float(input_Value)\n",
    "weight\n",
    "type(weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "T7mJiYNiLLjk"
   },
   "source": [
    "Note the system will report error message when the conversion function is not compatible with the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "i9bnxwLRLLjk"
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "could not convert string to float: 'David'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-41-d2e5d8c88ee0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0minput_Value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'David'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mweight\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput_Value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: could not convert string to float: 'David'"
     ]
    }
   ],
   "source": [
    "input_Value = 'David'\n",
    "weight = float(input_Value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s_NS6zzbLLjl"
   },
   "source": [
    "Comparison between two values can help make decision in a program. The result of the comparison is either **True** or **False**. They are the two values of *Boolean* type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hpz8oajsLLjp"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vZnUQd69LLjx"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5 > 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Zfw9EfrqLLj0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Double equal sign is also used for comparison\n",
    "10.0 == 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_rZvY3UlLLj1"
   },
   "source": [
    "Check the following examples on comparison of two strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "l4dFT7CYLLj1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'cat' < 'dog'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EzfdIp6XLLj3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# All uppercases are smaller than low cases in terms of ASCII code. It will compare each character from the beginning to the end between two words based on their ACSII code value.\n",
    "'cat' < 'Dog'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s88N5oeRLLj4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'apple' < 'apricot'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SRn9iUKrLLj8"
   },
   "source": [
    "There are three logical operators, *not*, *and* and *or*, which can  be applied to the boolean values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TJOHXNYOLLj8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Both condition #1 and condition #2 are True?\n",
    "3 < 4  and 7 < 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "e3678xUuLLj9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Either condition 1 or condition 2 are True?\n",
    "3 < 4  or 7 > 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AgVnOhigLLj-"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Both conditional #1 and conditional #2 are False?\n",
    "not ((3 > 4) or (7 > 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "B3ClkWDGLLkG"
   },
   "source": [
    "## 2. 4. Symbols and meanings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MZQSERheLLkl"
   },
   "source": [
    "With the quotation mark,  **%s** and **%d** are used to specify formatting for string and integer respectively. \n",
    "The following table shows a selected set of symbols which can be used along with %. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1wKLT4k4LLkl"
   },
   "source": [
    "<table width=\"304\" border=\"1\">\n",
    "  <tr>\n",
    "    <th width=\"112\" scope=\"col\">Format symbol</th>\n",
    "    <th width=\"176\" scope=\"col\">Conversion</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>%s</td>\n",
    "    <td>String</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>%d</td>\n",
    "    <td>Signed decimal integer</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>%f</td>\n",
    "    <td>Floating point real number</td>\n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q0_RdlHALLkm"
   },
   "source": [
    "There are extra characters that are used together with above symbols:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iaQEU8mCLLkm"
   },
   "source": [
    "<table width=\"400\" border=\"1\">\n",
    "  <tr>\n",
    "    <th width=\"100\" scope=\"col\">Symbol</th>\n",
    "    <th width=\"3000\" scope=\"col\">Functionality</th>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>-</td>\n",
    "    <td>Left justification</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>+</td>\n",
    "    <td>Display the sign</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>m.n</td>\n",
    "    <td>m is the minimum total width; n is the number of digits to display after the decimal point</td>\n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jfsOdi7pLLkn"
   },
   "source": [
    "Here are  more examples that use above specifiers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9CSC_2NOLLkn"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output a float number:     3.5000\n"
     ]
    }
   ],
   "source": [
    "# With %f, the format is right justification by default. \n",
    "# As a result, white spaces are added to the left of the number\n",
    "# 10.4 means minimal width 10 with 4 decimal points\n",
    "print('Output a float number: %10.4f' % (3.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FeXQfC1OLLkq"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output an integer: +0023\n"
     ]
    }
   ],
   "source": [
    "# plus sign after % means to show positive sign\n",
    "# Zero after plus sign means using leading zero to fill width of 5\n",
    "print('Output an integer: %+05d' % (23))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tlMQpvLnLLkt"
   },
   "source": [
    "### 2.5 Notes on *Python 2*\n",
    "\n",
    "You need to pay attention if you test examples in this prac under *Python* 2.  \n",
    "\n",
    "1. In *Python 3,  * **/** is float division, and  **//** is integer division; while in Python 2, \n",
    "\tboth **/** and **//**\n",
    "\tperform *integer division*.  \n",
    "\tHowever, if you stick to using **float(3)/2** for *float division*, \n",
    "\tand **3/2** for *integer division*, \n",
    "\tyou will have no problem in both version. \n",
    "    \n",
    "2. Instead using function **input()**,  \n",
    "\t**raw_input()** is used in Python 2. \n",
    "\tBoth functions have the same functionality,\n",
    "\ti.e. take what the user typed and passes it back as a string.\n",
    "    \n",
    "3. Although both versions support **print()** function with same format, \n",
    "\tPython 2 also allows  the print statement (e.g. **print \"Hello, World!\"**), \n",
    "\twhich is not valid in Python 3. \n",
    "\tHowever, if you stick to our examples and using **print()** function with parentheses, \n",
    "\tyour programs should works fine in both versions.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "SIT742P01A-Python.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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": 4
}