F0A-00-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FLIP (00): Data Science \n",
    "**(Module （00）: Python Basics)**\n",
    "\n",
    "---\n",
    "- Materials in this module include resources collected from various open-source online repositories.\n",
    "- You are free to use,but NOT allowed to change and distribute this package.\n",
    "\n",
    "Prepared by and for \n",
    "**Student Members** |\n",
    "2006-2023 [TULIP Lab](http://www.tulip.org.au), Australia\n",
    "\n",
    "---\n",
    "\n",
    "# Session 1 IPython notebook and basic data types\n",
    "\n",
    "In this week, \n",
    "you will learn how to run *Python* code under  **IPython notebook**. In IPython notebook, you will be able to execute \n",
    "and modify your *Python* code more efficiently.  \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": {},
   "source": [
    "## Content\n",
    "\n",
    "### Part 1 Create your own IPython notebook\n",
    "\n",
    "1.1 [Start a notebook server](#cell_start)\n",
    "\n",
    "1.2 [A tour of IPython notebook](#cell_tour)\n",
    "\n",
    "1.3 [IPython notebook infterface](#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",
    "2.4 [Input and output](#cell_input)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1. Create your own IPython notebook\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 nevigate with a notebook and manipulate its components. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_start\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "     \n",
    "## 1. 1 Start  a  notebook server\n",
    "\n",
    "As described in Part 1, you start the IPython notebnook server by keying in the command in a terminal window/command line window.\n",
    "\n",
    "However,  before you do this, make sure you have created a folder **p01** under **H:/sit742**,   download the file  **BasicData.ipynb** notebook, and saved it under **H:/sit742/p01**.\n",
    "\n",
    "After you complete this, you can now  switch  working directory to **H:/sit742**,  and start the IPython notebook server. Please enter the following commands:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "ipython notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# You can see the message in the terminal windows as follows:\n",
    "\n",
    "\n",
    "<img src=\"image/start-workspace.jpg\">\n",
    "\n",
    "This will open a new browser window(or a new tab in your browser window). In the browser, there is an **dashboard**  page which shows you all the folders and files under **sit111** folder\n",
    "\n",
    "\n",
    "<img src=\"image/start-index.jpg\">\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_tour\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " ## 1.2  A tour of iPython notebook \n",
    " \n",
    " ###  Create a new ipython 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=\"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": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good morning World\n"
     ]
    }
   ],
   "source": [
    "text = \"Hellow World\"\n",
    "text = \"Good morning World\"\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After this,  press **CTRL + ENTER**, and execute the cell. The result will be shown after the cell. \n",
    "\n",
    "\n",
    "\n",
    "<img src=\"image/hello-world.jpg\">\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "After a cell is executed ,  the notebook is switched to  the **Commmand** mode. In this mode,  you can manipulte the notebook and its commponent. 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 previouse cell into the following code:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "text = \"Good morning World!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afterwards,  press **CTRL + ENTER**, and the new output is displayed. \n",
    "\n",
    "As you can see, you are switching bewteen two  modes,  **Command** and  **Edit**,  when  editing a notebook. We will in  later section look into these two operation modes of closely. Now practise  switching between the two modes until you are comfortable with them. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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 currrent cell, go to menubar 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=\"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": {},
   "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": {},
   "source": [
    "Now execute the cell by press **CTRL+ ENTER**. You notebook should look like this:\n",
    "    \n",
    "<img src=\"image/new-markdown.jpg\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is what the formated Markdown cell looks like:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "Click this cell, and practisc writing markdown language   here...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_interface\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    "### 1.3  IPython 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 operatiopn:\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 performa  these tasks more effiencient. 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 cammands, 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 followsing line in a cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other improtant thing to know is how to interrupt a compuation. 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": {},
   "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 previouse 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 IPython 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 effeciently. 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 avaialbe 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 arrganged by the \n",
    "  order we recommend you learn so that you can edit the cells effienctly.\n",
    "\n",
    "\n",
    "1. Basic navigation: \n",
    "\n",
    "   - Enter: switch to Edit mode\n",
    "   \n",
    "   - Esc: switch to Command mode\n",
    "   \n",
    "   - Shift+enter: Eexecute 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 practics different kinds of formatting  in a markdown cell. \n",
    " \n",
    "For a complete list of shortcut in **Command** mode, go to menu bar **Help->Keyboardshorcut**. Feel free to explore the other shortcuts. \n",
    " \n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_close\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " ## 1.4 open and close notebooks\n",
    " \n",
    " You can open multiple notebooks in a browser windows. Simply go to menubar 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. Also please  download **ControlAdvData.ipynb** from cloudDeakin, and save under **H:/sit742/prac01**. Now go to the manu bar, click on **File->open ...**, locate the file **ControlAdvData.ipynb**, and open this file. \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, swich 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=\"image/close-index.jpg\">\n",
    " \n",
    " After each notebook is shutdown, it is time to showdown the IPython notebook server. To do this, go to the terminal window and press **CTRL + C**, and then enter **Y**. After the notebook server is shut down,  the terminal window is ready for you to enter any new command. \n",
    " \n",
    "\n",
    " <img src=\"image/close-terminal.jpg\">\n",
    " \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Part 2  Basic Data Types\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "source": [
    "<a id = \"cell_string\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello, World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign a string to a variable \n",
    "text = 'Hello, World!'\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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 programer\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'Hello, World!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with print() function, content is displayed without quotation mark\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# without print() function, quotation mark is displayed together with content\n",
    "text "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Back to representation of string, there will be issues if you need to include a quotation\n",
    "mark in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'What's your name'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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 quaotation mark itself in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"What' s your name?\"\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternertively, you can use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = '\"What is the problem?\", he asked.'\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": {},
   "source": [
    "Notice the difference when the variable is displayed without **print()** function in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = 'What\\'s your name?'\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'c:\\\\windows\\\\temp'\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": {},
   "source": [
    "To manipulate strings, the following two operators are most useful: \n",
    "* **+** is use to concatenate\n",
    "two strings or string variables; \n",
    "* ***** is used for concatenating several copies of the same\n",
    "string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello, ' + 'World' * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is another example of string concatenation based on  variables that store strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'World'\n",
    "greeting = 'Hello'\n",
    "print(greeting + ', ' + name + '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using variables, change part of the string text is very easy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change part of the text is easy\n",
    "greeting = 'Good morning' \n",
    "print(greeting + ', ' + name + '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_number\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## 2.2 Number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two types of numbers that are used most frequently: integers and floats. As we\n",
    "expect, the standard mathematic operation can be applied to these two types. Please\n",
    "try the following expressions. Note that **\\*\\*** is exponent operator, which indicates\n",
    "exponentation exponential(power) caluclation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#3 to the power of 4\n",
    "3 ** 4 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "15 / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "14 / 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "14 // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Negatives move left on number line. The result is -3 instead of  -2\n",
    "-14 // 5 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modulus operator **%** can be used to obtain remaider. Pay attention when negative number is involved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "14 % 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hint:  −14 // 5 equal to −3\n",
    "#        (-3) * 5 +  ? = -14\n",
    "\n",
    "-14 % 5 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(2 + 3) * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(2 + 3) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "-(4+3)+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similary as string, variables can be used to store a  number so that it is easy to  manipulate them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "y = 2\n",
    "x + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum = x + y\n",
    "sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x * y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "x = x * 3\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalant to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "# Note there is no space between '*' and '+'\n",
    "x *= 3\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_conversion\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2.3 Data conversion and comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have seen three types of data: interger, 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type('Hello, world!)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input = '45.6'\n",
    "type(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight = float(input)\n",
    "weight\n",
    "type(weight)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the system will report error message when the conversion function is not compatible with the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input = 'David'\n",
    "weight = float(input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 > 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(5 > 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Double equal sign is also used for comparison\n",
    "10.0 == 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the following examples on comparison of two strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'cat' < 'dog'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All uppercases are before low cases. \n",
    "'cat' < 'Dog'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'apple' < 'apricot'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three logical operators, *not*, *and* and *or*, which can  be applied to the boolean values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Both condition #1 and condition #2 are True?\n",
    "3 < 4  and 7 < 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Either condition 1 or condition 2 are True?\n",
    "3 < 4  or 7 > 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Both conditional #1 and conditional #2 are False?\n",
    "not ((3 > 4) or (7 > 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"cell_input\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 4. Input and output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All programing languages provide features to interact with user. Python provide *input()* function to get input. It waits for the user to type some input and press return. We can add some information for the user by putting a message inside the function's brackets. It must be a string or a string variable. The text that was typed can be saved in a variable. Here is one example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nInput  = input('Enter you number here:\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, be aware that the input received from the user are treated as a string, even\n",
    "though a user entered a number. The following **print()** function invokes an error message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(nInput + 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input need to be converted to an integer before the match operation can be performed as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(nInput) + 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After user's input are accepted, the messages need to be displayed to the user accordingly. String concatenation is one way to display messages which incorporate variable values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'David'\n",
    "print('Hello, ' + name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of achieving this is using **print()** funciton with *string formatting*. We need to use the *string formatting operator*, the percent(**%**) sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'David'\n",
    "print('Hello, %s' % name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another example with two variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'David'\n",
    "age = 23\n",
    "print('%s is %d years old.' % (name, age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the two variables, **name**, **age**, that specify the values are included at the end of the statement, and enclosed with a bracket. \n",
    "\n",
    "With the quotation mark,  **%s** and **%d** are used to specify formating 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": {},
   "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": {},
   "source": [
    "There are extra charaters that are used together with above symbols:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "source": [
    "Here are  more examples that use above specifiers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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 decinal points\n",
    "print('Output a float number: %10.4f' % (3.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": {},
   "source": [
    "### 2.5 Notes on *Python*\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 parantheses, \n",
    "\tyour programs should works fine in both versions.  "
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}