Jupyter/M02-Python/M02C-DataTypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UP2Th8B0LLey"
   },
   "source": [
    "\n",
    "![Cloud-First](../image/CloudFirst.png) \n",
    "\n",
    "\n",
    "# SIT742: Modern Data Science\n",
    "\n",
    "\n",
    "**(Module: Python Foundations for Big Data)**\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",
    "- If you found any issue/bug for this document, please submit an issue at [tulip-lab/sit742](https://github.com/tulip-lab/sit742/issues)\n",
    "\n",
    "\n",
    "Prepared by **SIT742 Teaching Team**\n",
    "\n",
    "---\n",
    "\n",
    "## Session 2C:  Basic data types\n",
    "\n",
    "1. [String](#cell_string)\n",
    "\n",
    "2. [Number](#cell_number)\n",
    "\n",
    "3. [Data conversion and comparison](#cell_conversion)\n",
    "\n",
    "4. [Input and output](#cell_input)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "M2sk2y0ILLfy"
   },
   "source": [
    "<a id = \"cell_close\"></a>"
   ]
  },
  {
   "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": [
    "## 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": {
    "colab": {},
    "colab_type": "code",
    "id": "CG-9AQrmLLf7"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5ZsarfIpLLgO"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zilCIz-GLLga"
   },
   "outputs": [],
   "source": [
    "text = 'Hello, World!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cHelVR_8LLgg"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "A8eOiupBLLgq"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QcxK0VgBLLg9"
   },
   "outputs": [],
   "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",
    "```\n",
    "</details>"
   ]
  },
  {
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kcq185ULLLhD"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "X-DGDDQaLLhI"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "q1mgdutELLhU"
   },
   "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": {
    "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5j7kVvnnLLhd"
   },
   "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": {
    "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DC97cQs2LLhj"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "U5PUlblFLLh3"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6Hx7whpWLLh9"
   },
   "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": {
    "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "atOH5kwTLLiC"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "b4rw4CjPLLiG"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "i0jfd08dLLiK"
   },
   "outputs": [],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gDymwzHmLLiN"
   },
   "outputs": [],
   "source": [
    "greeting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-xdxHvZlLLiQ"
   },
   "outputs": [],
   "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 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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4bJEQg_MLLiU"
   },
   "outputs": [],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "p6bV4vC9LLiX"
   },
   "outputs": [],
   "source": [
    "3 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-Rs_u_qnLLia"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "l5ee7L9mLLif"
   },
   "outputs": [],
   "source": [
    "15 / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZtobUWNcLLij"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hT18fhA8LLim"
   },
   "outputs": [],
   "source": [
    "14 // 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Jj02iHTpLLip"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WIZ3IGCILLis"
   },
   "outputs": [],
   "source": [
    "14 % 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4Ao-du3_LLix"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q8-htgKSLLi0"
   },
   "outputs": [],
   "source": [
    "2 + 3 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MTstkwWoLLi2"
   },
   "outputs": [],
   "source": [
    "(2 + 3) * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "X5zqw9gQLLi6"
   },
   "outputs": [],
   "source": [
    "2 + 3 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2J5jmyrALLi8"
   },
   "outputs": [],
   "source": [
    "(2 + 3) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4c0ohRKmLLi-"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TsmyIIe0LLjC"
   },
   "outputs": [],
   "source": [
    "x = 3\n",
    "y = 2\n",
    "x + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "joZHkCbELLjJ"
   },
   "outputs": [],
   "source": [
    "sum = x + y\n",
    "sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2lzP8lYMLLjU"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "D1hxyg1mLLjX"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qb0BdkZ9LLja"
   },
   "outputs": [],
   "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": [
    "## 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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "V62kYzxKLLjf"
   },
   "outputs": [],
   "source": [
    "type('Hello, world!)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Boe-ivfiLLjh"
   },
   "outputs": [],
   "source": [
    "input_Value = '45.6'\n",
    "type(input_Value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4wGHArWZLLji"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "i9bnxwLRLLjk"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hpz8oajsLLjp"
   },
   "outputs": [],
   "source": [
    "5 > 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vZnUQd69LLjx"
   },
   "outputs": [],
   "source": [
    "type(5 > 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Zfw9EfrqLLj0"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "l4dFT7CYLLj1"
   },
   "outputs": [],
   "source": [
    "'cat' < 'dog'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EzfdIp6XLLj3"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "s88N5oeRLLj4"
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TJOHXNYOLLj8"
   },
   "outputs": [],
   "source": [
    "# Both condition #1 and condition #2 are True?\n",
    "3 < 4  and 7 < 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "e3678xUuLLj9"
   },
   "outputs": [],
   "source": [
    "# Either condition 1 or condition 2 are True?\n",
    "3 < 4  or 7 > 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AgVnOhigLLj-"
   },
   "outputs": [],
   "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": [
    "## 4. Input and output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DWqLiEZ1LLkH"
   },
   "source": [
    "All programming 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": {
    "colab": {},
    "colab_type": "code",
    "id": "uotQ6pd8LLkH"
   },
   "outputs": [],
   "source": [
    "nInput  = input('Enter your number here:\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jhMpU6dfLLkJ"
   },
   "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": {
    "colab": {},
    "colab_type": "code",
    "id": "otpC8BEbLLkJ"
   },
   "outputs": [],
   "source": [
    "print(nInput + 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FaIP1_b4LLkL"
   },
   "source": [
    "The input need to be converted to an integer before the match operation can be performed as follows because the string data cannot add the integer data directly. They are totally different two types of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pe9Ey8M-LLkL"
   },
   "outputs": [],
   "source": [
    "print(int(nInput) + 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hWChILEcLLkP"
   },
   "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": {
    "colab": {},
    "colab_type": "code",
    "id": "UBLRtd-kLLkP"
   },
   "outputs": [],
   "source": [
    "name = 'David'\n",
    "print('Hello, ' + name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OyEkpA3mLLkR"
   },
   "source": [
    "Another way of achieving this is using **print()** function with *string formatting*. We need to use the *string formatting operator*, the percent(**%**) sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "33qCABY9LLkS"
   },
   "outputs": [],
   "source": [
    "name = 'David'\n",
    "print('Hello, %s' % name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UvuFlcAcLLkW"
   },
   "source": [
    "Here is another example with two variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-cFfoUp5LLkX"
   },
   "outputs": [],
   "source": [
    "name = 'David'\n",
    "age = 23\n",
    "print('%s is %d years old.' % (name, age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MZQSERheLLkl"
   },
   "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 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": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9CSC_2NOLLkn"
   },
   "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 decimal points\n",
    "print('Output a float number: %10.4f' % (3.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FeXQfC1OLLkq"
   },
   "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))"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "M02C-DataTypes.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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}