LAB2-python basic(vscode)v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# ArubaNetworks Automation product training - LAB2 (Python Lab Part)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Note: Before you start this lab, please clear all the output and ensure you did not ignore running any code cell. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.1 First Python code"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Let us start with using python print function and print a string \"Hello World\"."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "#Say hello world in Python\r\n",
    "print(\"Hello World!\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "###Note once you play the following (name = input....) code look above on top for \"what is you name?(press 'Enter' to confirm or 'Esape' to cancel),\"  to type in your answer in the box. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "name = input('what is your name?')\r\n",
    "print('Hello World! My name is', name)"
   ],
   "outputs": [],
   "metadata": {
    "scrolled": true
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Yes, that is it. In this example, we got the input() function to take user input, and display it using the print() function for output. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.2 Command  Python Data types"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Next, we will show common data types in python and how to access it. Let us be familiar with common python data types first."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "####  Data Type 1 -String"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(\"ABC\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #We can use the type() function to know what the data type is."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(type(\"ABC\"))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Right,it is a string. but if we print ABC without quotos? what will happen?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #You can see the difference is the first \"ABC\" is a string, but the second one is a variable that is not defined yet."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Variable is the logical names that you give to refer to the memory/address space that holds the data you need for your computation. Python supports a variety of data types:\r\n",
    "    \r\n",
    "    -string (character, character sequence)\r\n",
    "\r\n",
    "    -numeric (integer, float)\r\n",
    "\r\n",
    "    -boolean (True or False)\r\n",
    "\r\n",
    "    -lists (collection of values)\r\n",
    "\r\n",
    "    -Dictionary (\"key\":\"value\")\r\n",
    "\r\n",
    "    -Nonetype\r\n",
    "\r\n",
    "    -custom datatypes (objects of classes)\r\n",
    "\r\n",
    "    etc.\r\n",
    "\r\n",
    "    we have already shown the string. Let's learn others\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Data type 2 - Numberic "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Float"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = 2 * 1.5;\r\n",
    "print(ABC)\r\n",
    "print(type(ABC))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Integer."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = 2 * 3\r\n",
    "print(ABC)\r\n",
    "print(type(ABC))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #what do you think \"1\" is a string or integer?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(type(\"1\"))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Right, it is a string which can be quoted by single quote (') or double quotes (\"). How to transform this string into an integer? Use int() function. Likewise, you can use the str() function to tranform other Data types to a string."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(int(\"1\"))\r\n",
    "print(type(int(\"1\")))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(str(1))\r\n",
    "print(type(str(1)))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Data type 4 - List"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Lists and tuples are a collection of items of heterogenous/homogenous types. However,\r\n",
    "    -lists are mutable, and tuples are immutable.\r\n",
    "    -list items are enclosed within square brackets [], and tuple items are enclosed within parentheses ()\r\n",
    "    let's check an example of a list."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = [apple,orange,watermelon,pear]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Pleae notice that there is an NameError said the variable is not defined. Let us change the variable to a string."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = [\"apple\",\"orange\",\"watermelon\",\"pear\"]\r\n",
    "print(ABC)\r\n",
    "print(type(ABC))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #How to access and print the first element of this list? \r\n",
    "    #Note Python indexing/numbering always starts from zero (0), so the first element 'apple' is 0, the second element 'orange' is 1, the third element 'watermelon' is 2 and the fourth element 'pear' is 3. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC[0])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #How to access the last element \"pear\"?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC[-1]) #comment: -1 mean the last index number\r\n",
    "#or\r\n",
    "print(ABC[3])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #How to access all middle elements?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC[1:-1])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Or you can run ABC[1:3], here \"3\" means \"-1\" which is the last element of the list. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC[1:3])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #What is the length of this list? you can use len() function."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(len(ABC))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###Now let us look at a tricky one. How to print the second letter of second element? In this case, it should be the \"r\" of \"Orange\". "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC[1][1])\r\n",
    "#This technique is also, called slicing."
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Data type 5 - tuple"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = (1,2,3,4,5,6)\r\n",
    "print(ABC)\r\n",
    "print(type(ABC)) "
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###Can we change some data, for example, replace the '3' in the tuple to 9, like a list? Check the example below."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC[2] = 9"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Answer is NO\r\n",
    "    #You will see a TypeError here. It means a tuple is immutable.\r\n",
    "    #So list is mutable, but the tuple is immutable.\r\n",
    "    #Also, list is inside brackets [value, value, etc], and tuple is inside parentheses (value, value, etc)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Data type 6 - Dictionary"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = {\r\n",
    "  \"name\":\"Tom\",\r\n",
    "  \"age\":\"36\",\r\n",
    "  \"Gender\":\"Male\"\r\n",
    "  }\r\n",
    "print(ABC)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "###Note dictionaries are mader up of key:value pair and ditionaries are inside brace {\"key\":\"vlaue\", \"key\":\"value\",\"key\":\"value\"}"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(type(ABC))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###How to display parts of dictionary for example how do you get Tom's age?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC[\"age\"])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###Now we realized that his age is wrong, he is 40 aleady. then how to change his age in the dictionary?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC['age'] = 40"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###How about if we have a list of dictionary?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = [{\r\n",
    "  \"name\":\"Tom\",\r\n",
    "  \"age\":\"36\",\r\n",
    "  \"Gender\":\"Male\"\r\n",
    "  },{\r\n",
    "  \"name\":\"BOB\",\r\n",
    "  \"age\":\"20\",\r\n",
    "  \"Gender\":\"Male\"\r\n",
    "  },{\r\n",
    "  \"name\":\"Alice\",\r\n",
    "  \"age\":\"26\",\r\n",
    "  \"Gender\":\"Female\"\r\n",
    "  }\r\n",
    "]\r\n",
    "print(ABC)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#Based on the above print result, how many elements are in the list of dictionary? \r\n",
    "\r\n",
    "#Answer: 3 \r\n",
    "#0 {'name': 'Tom', 'age': '36', 'Gender': 'Male'}, \r\n",
    "#1 {'name': 'BOB', 'age': '20', 'Gender': 'Male'}, \r\n",
    "#2 {'name': 'Alice', 'age': '26', 'Gender': 'Female'}\r\n",
    "\r\n",
    "#How many elments with the third element?  \r\n",
    "\r\n",
    "#Answer: 3\r\n",
    "#0 'name': 'Alice', \r\n",
    "#1 'age': '26', \r\n",
    "#2 'Gender': 'Female' "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(type(ABC))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###How do you get Alice's age?"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(ABC[2][\"age\"])\r\n",
    "#The index number [2] is {'name': 'Alice', 'age': '26', 'Gender': 'Female'} based on the previous example, and then [age] is the dictionary \"key,\" so result is the value \"26\"."
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Data type 7 - Boolean"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = True\r\n",
    "print(ABC)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(type(ABC))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ABC = not True\r\n",
    "print(ABC)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Data type 8 - NoneType"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###A function implicitly returns None if it reaches the end of the function's block of statements and does not encounter a return statement. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "def has_no_return_function():\r\n",
    "    print (\"I have no return\")\r\n",
    "\r\n",
    "print (type(has_no_return_function()))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.3 Conditional"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    " ###Before running the below program, consider which sentence will be printed. Then run the cell and verify if you are right."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "a = 100\r\n",
    "b = 99\r\n",
    "if b > a:\r\n",
    "  print(\"b is greater than a\")\r\n",
    "elif a == b:\r\n",
    "  print(\"a and b are equal\")\r\n",
    "else:\r\n",
    "  print(\"a is greater than b\")\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "  ###Note: here, you may notice None is almost equal to False in the If statement. Why do we say it is almost?  See below examples to understand the similarity and differences:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "x = None\r\n",
    "print(x)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(not x)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "if (not x):\r\n",
    " print (\"'if not x'. This means 'not x' is true\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "if x == False:\r\n",
    " print('x is False')"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "  ###Why above program has no output? this means 'X' is not 'False'."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "if (not x) == (not False):\r\n",
    "    print (\"'not x' equals 'not False'\")\r\n",
    "#not x equals not False"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.4 Python Loops"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #While Loop.\r\n",
    "    #Let us look at While loop first. The while loop in Python executes a block of code until the specified condition becomes False. In other words, the code within the statement will continue to execute repetitiously until the condition is no longer valid (True). "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "i=1\r\n",
    "while i<3:\r\n",
    "  print(i)\r\n",
    "  i+=1\r\n",
    "else:\r\n",
    " print(\"i is no longer less than 3\")\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    \r\n",
    "    #for loop. \r\n",
    "    #Let us look at the examples shown in the presentation."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for x in range(3,5):\r\n",
    "    print(x)\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "###NOTE: When using the range, the range stops one number before the last. For example range(0,9), result of range would be 0,1,2,3,4,5,6,7, and 8 "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #In the below example, you will see how to loop in the elements of a list."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "fruits = ['apple','banana','cherry']\r\n",
    "for x in fruits:\r\n",
    "  print(x)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #In the below example,we will see how to loop in the keys and Values of a dictionary.\r\n",
    "    #The first example below, show how to get all the keys of the dictionary."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "super_heroes = {'Captain America':'Steve Rogers','Spiderman':'Peter Parker'}\r\n",
    "for superhero in super_heroes.keys():\r\n",
    " print(superhero)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #The second example belowm, show how to get all the Values of the dictionary."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "super_heroes = {'Captain America':'Steve Rogers','Spiderman':'Peter Parker'}\r\n",
    "for superhero in super_heroes.values():\r\n",
    " print(superhero)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Try to create a loop in super_heroes.items(). Then find out what is the difference with .keys() and .values()."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.5 Python Functions"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "       ###A function is a block of code that only runs when it is called. You can pass data, known as parameters or arguments, into a function. We have already seen some built-in functions, like input() and print() in previous examples. Let us look at an easy custom function without the argument shown in the presentation."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "#A Function without argument\r\n",
    "\r\n",
    "#define the function\r\n",
    "\r\n",
    "def my_function():\r\n",
    "  print(\"Hello World!\")\r\n",
    "\r\n",
    "#call the function\r\n",
    "my_function()\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "###Below is an example of a function with argument and how you can pass data to the function.  "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "#A Function with arguments\r\n",
    "\r\n",
    "def my_function(firstname):\r\n",
    "  print('Hello ' + firstname)\r\n",
    "\r\n",
    "\r\n",
    "my_function('Alice')\r\n",
    "\r\n",
    "my_function('Bob')"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.6 Pyhon Modules"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    ###Module is a set of functions in a file. When using a function from a module, use the syntax: module_name.function_name."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    " There are two different ways to be used for importing modules into a script:\r\n",
    "\r\n",
    "1.  Import Statement\r\n",
    "2.  From... Import... Statement\r\n",
    "\r\n",
    "For example, we have a python file named test.py. We try to import external functions into test.py. \r\n",
    "\r\n",
    "The current module Architecture is below:\r\n",
    "\r\n",
    "mymodule\\\r\n",
    "\r\n",
    "    a.py\r\n",
    "    \r\n",
    "    b.py\r\n",
    "\r\n",
    "If we use the first way, then we can use \"import mymodule\", then you use \"mymodule.a()\" to get the functionality of a.py.\r\n",
    "If we use the second way, then we can use \"from mymodule import a\". Then you can just use \"a()\" without module name.\r\n",
    "\r\n",
    "\r\n",
    "Note: If the module name is followed by \"as\",  then the name following as is bound directly to the imported module.\r\n",
    "eg. import pandas as pd\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Note Here Because the notebook is not python format. So we have to install an external module to support Jupyter notebook can read the modules in another notebook. In this case, that module name is \"demo_module_1\". If the module name is python-format with \".py,\" then no need to install the import_ipynb module."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "!python -m pip install import_ipynb\r\n",
    "!python -m pip install nbformat"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import sys\r\n",
    "sys.path.append(\"c://users/student/appdata/local/programs/python/python37-32/lib/site-packages\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "#import the module and call the function\r\n",
    "import import_ipynb\r\n",
    "import demo_module_1"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "#run functions inside the module.\n",
    "demo_module_1.greeting('Jonathan')\n",
    "demo_module_1.room('101')"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#Challenge:\n",
    "\n",
    "Because we use the first importing way to \"Import demo_module_1\", so we have to use demo_module_1.greeting() to get the greeting function. Suppose we use \"from demo_module_1 import greeting\", you can directly use greeting() without \"demo_module_1\" in your code. You can take a try at this."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Understand ' _  _ main _  _  '"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Every Python module has it’s __name__ defined and if this is ‘__main__’, it implies that the module is running standalone by the user. \n",
    "    If you import this script as a module in another script, the __name__ is set to the name of the script/module.\n",
    "    if __name__ == “main”: is used to execute some code only if the file was run directly, and not imported. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #In the demo_module, we have a function named \"test_main\". \r\n",
    "     \r\n",
    "        def test_main():\r\n",
    "          print(\"check out if 'the name is __main__' is printed below\")\r\n",
    "          if __name__=='__main__':\r\n",
    "            print('the name is __main__')\r\n",
    "    \r\n",
    "        \r\n",
    "    #You may notice that in this function, there is a print sentence and an IF sentence. If the name == __main__, it will print out \"hello test_main\". Now execute the below code."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "demo_module_1.test_main()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "     #NOTE: It looks like \"the name is __main__\" is not shown. This means this module used here itself is not \"__main__\".\n",
    "    You can go back to demo_module to execute that code. You will see it will print out \"the name is __main__\".because that \n",
    "    function is executed locally, not from other modules."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.7 Python Classes and Objects"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Python is an object-oriented programming (OOP) language. A Class is a means of bundling data and functionality. \r\n",
    "    A Class is like an object constructor or a \"blueprint\" for creating objects. The __init__() function is called automatically every time the class is being used to create a new object."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Example 1: Create a class named Person, use the __init__() function to assign values for name and age"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class Person:                                    # class is a keyword and “Person” is the name of the class\r\n",
    "  def __init__(self, name,age,gender):           # constructor method -instantiation\r\n",
    "    self.name = name                             # the first piece of data is the name\r\n",
    "    self.age = age                               # the second piece of data is the age\r\n",
    "    self.gender = gender                         # the third piece of data is the gender\r\n",
    "\r\n",
    "P1=Person('Tom',25,'male')        #P1 is an object (or instance of class).When executed, think of P1 'replacing' the word self \r\n",
    "\r\n",
    "print(P1.name)             # returns Tom so you can think of P1 as replacing the word ‘self’\r\n",
    "\r\n",
    "print(P1.age)              #returns 25 so you can think of P1 as replacing the word ‘self’ \r\n",
    "\r\n",
    "print(P1.gender)           #returns male so you can think of P1 as replacing the word ‘self’ \r\n",
    "\r\n",
    "print(P1)\r\n",
    "    \r\n",
    "    "
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class Person:   # class is a keyword\r\n",
    "  def __init__(self, name, age):   # constructor nethod -instantiation\r\n",
    "    self.name = name   # the first piece of data is the name\r\n",
    "    self.age = age    # the second piece of data is the age\r\n",
    "\r\n",
    "  def myfunc(self): #return state of object \r\n",
    "    print('Hello my name is ' + self.name + ' and my age is '+str(self.age))   \r\n",
    "    \r\n",
    "P1=Person('Tom',25)            # P1 is an object\r\n",
    "P1.myfunc()  \r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#Challenge\r\n",
    "\r\n",
    "#Please add another person, Bob, with the variable P2. Input Bob's age by input() function and compare his age to Tom. If his age > Tom, then print out \"Bob is older,\" if they are the same age, then print out \"Bob has same age with Tom,\" else print out \"Bob is younger.\" Below is you have been given an example code, but there are some errors. Try doing some troubleshooting, and there are some hints you can check out in the cell below if you get stuck. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "age = input(\"enter bob's age: \")\r\n",
    "P2=Person('Bob',age)\r\n",
    "if int(P2.age) > int(P1.age):\r\n",
    "  print(\"Bos is older\")\r\n",
    "elif P2.age == P1.age:\r\n",
    "  print(\"Bob has same age with Tom\")\r\n",
    "else:\r\n",
    "    print(\"Bob is younger\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #Hints:\n",
    "    \n",
    "    1.check out the conditional syntax. \n",
    "    2.Understand the difference between \"=\" and \"==\".\n",
    "    3.The variable is case sensitive. \n",
    "    4.Input() here is importing a string, not integer."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2.8 Try Except"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #The try block lets you test a block of code for errors.\n",
    "    The except block lets you handle the error.\n",
    "    If there is no exception, then else block will be executed\n",
    "    The finally block lets you execute code, regardless of the result of the try- and except blocks. (optional)\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "def divide(x, y):\r\n",
    "    try:\r\n",
    "        # Floor Division : Gives only Fractional\r\n",
    "        # Part as Answer\r\n",
    "        result = x / y\r\n",
    "    except ZeroDivisionError as error:\r\n",
    "        print(\"Sorry! You are dividing by zero \")\r\n",
    "        print(error)\r\n",
    "    else:\r\n",
    "        print(\"Yeah! Your answer is :\", result)\r\n",
    "    finally:\r\n",
    "        print('##This is always printed##')       \r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "       #let the code execute the below function. It will do try block first. Because it never encounters any Error so that it will execute else block, then always execute finally block.\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "divide(4, 2)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "    #let the code execute an error. It will do try block first, then it encounters an zeroDivisionError, then always execute finally block.\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "divide(4, 0)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## You completed LAB2"
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "e0e40265fc28ccc0865eea50bddb6e1dcf4d3a87d1a1b7916a506223c1366b3b"
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}