Lecture1-PythonBasics/Lecture1_Module1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center"
   },
   "source": [
    "# Lab 1: Introduction to Python\n",
    "In this lab, you will learn the basics of Python. Particullary, the following topics will be covered in this lab:\n",
    "<ol>\n",
    "    <li> [What is Python?]</li>\n",
    "    <li> How to check the version on installed Python?</li>\n",
    "    <li> First Program </li>\n",
    "    <li> Python Indentation </li>\n",
    "    <li> Python Variables </li>\n",
    "    </ol>\n",
    "    \n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## What is Python?\n",
    "<p>\n",
    "    Python is a popular programming language. It was created by Guido van Rossum, and released in 1991. </p>\n",
    "<ul>\n",
    "    <h>It is used for:</h>\n",
    "\n",
    "<li>web development (server-side),</li>\n",
    "<li>software development, </li>\n",
    "<li> mathematics, </li>\n",
    "<li> system scripting. </li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to check the version on installed Python?\n",
    "<p > To check the version of the installed Python: </p>\n",
    "<ul> \n",
    "    <li>If you are using Windows or Linux, open the command line and type python --version </li>\n",
    "    <li>If you are using Mac, open the terminal and type python --version </li>\n",
    "    </ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First Program"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the first program of Python, you will write a program that will display a sentence on the screen.\n",
    "~~~~\n",
    "    print('Hello World!')\n",
    "~~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print('Hello World!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Indentation (#1)\n",
    "\n",
    "<p> Python uses indentation to indicate a block of code.</p>\n",
    "\n",
    "~~~~ \n",
    "if 5 > 2:\n",
    "    print (\"Five is greater than two!\")\n",
    "~~~~\n",
    "\n",
    "<font color=red> **Warning:** _Python will give an error if you skip the indentatin!!!_ </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Five is greater than two\n"
     ]
    }
   ],
   "source": [
    "if 5>2:\n",
    "    print(\"Five is greater than two\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Variables\n",
    "<font color=green> **Variables are containers for storing data values** </font>\n",
    "\n",
    "In Python, variables are created when you assign a value to it:\n",
    "<code> x = 5 </code>\n",
    "The above code will create a variable x, whose value is 5. Similarlary, you can create a variable and store a string in that variable. For example:\n",
    "<code> y = \"Hello World!\" </code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 Hello World!\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = \"Hello World!\"\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assign Value to Multiple Variables\n",
    "Python allows you to assign values to muliple variables\n",
    "\n",
    "~~~~ \n",
    "x, y, z = \"Orange\", 3.5, \"CGPA\" \n",
    "~~~~\n",
    "\n",
    "\n",
    "Likewise, you can assign the same value to multiple variables in one line:\n",
    "~~~~\n",
    " x = y = z = \"Orange\"\n",
    "~~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  Orange , y =  3.5 , z =  CGPA\n"
     ]
    }
   ],
   "source": [
    "x, y, z = \"Orange\", 3.5, \"CGPA\"\n",
    "print(\"x = \",x, \", y = \", y, \", z = \", z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x =  orange , y =  orange , z =  orange\n"
     ]
    }
   ],
   "source": [
    "x = y = z = \"orange\"\n",
    "print(\"x = \",x, \", y = \", y, \", z = \", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "For numbers, the <code>+</code> character works as a mathematical operator:\n",
    "~~~~\n",
    "x = 10\n",
    "y = 20\n",
    "print(x + y)\n",
    "~~~~\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x+y =  -40\n"
     ]
    }
   ],
   "source": [
    "x, y = -60, 20\n",
    "print('x+y = ', x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### The global Keyword\n",
    "Normally, when you create a variable inside a function, that variable is local, and can only be used inside that function.\n",
    "\n",
    "To create a global variable inside a function, you can use the <font color=red highlight>**global**</font> keyword.\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is a wonderful language\n"
     ]
    }
   ],
   "source": [
    "def MyFunc():\n",
    "    global x\n",
    "    x = 'wonderful language'\n",
    "    \n",
    "MyFunc()\n",
    "print(\"Python is a \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Data Types\n",
    "\n",
    "<p> Variables can store data of different types, and different types can do different things. </p>\n",
    "\n",
    "<p>Python has the following data types built-in by default, in these categories: </p>\n",
    "\n",
    "\n",
    "|    Variable Types    |    Data Types    |\n",
    "|---|---|\n",
    "|Text Type | str|\n",
    "|Numeric Types|\tint, float, complex|\n",
    "|Sequence Types|\tlist, tuple, range|\n",
    "|Mapping Type|\tdict|\n",
    "|Set Types|\tset, frozenset|\n",
    "|Boolean Type|\tbool|\n",
    "|Binary Types|\tbytes, bytearray, memoryview|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### Python Numbers\n",
    "There are three numeric types in Python:\n",
    "\n",
    "    1. int\n",
    "    2. float\n",
    "    3. complex\n",
    "\n",
    "Variables of numeric types are created when you assign a value to them:\n",
    "~~~~\n",
    "x = 1    # int\n",
    "y = 2.8  # float\n",
    "z = 1j   # complex\n",
    "~~~~\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "x = 1    # int\n",
    "y = 2.8  # float\n",
    "z = 1j   # complex\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "#### Type Conversion\n",
    "You can convert from one type to another with the <font color=red>int()</font>, <font color=red>float()</font>, and <font color=red>complex()</font> methods:\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "2\n",
      "(1+0j)\n",
      "<class 'float'>\n",
      "<class 'int'>\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "x = 1 # int\n",
    "y = 2.8 # float\n",
    "z = 1j # complex\n",
    "\n",
    "#convert from int to float:\n",
    "a = float(x)\n",
    "\n",
    "#convert from float to int:\n",
    "b = int(y)\n",
    "\n",
    "#convert from int to complex:\n",
    "c = complex(x)\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "#### Specify a Variable Type\n",
    "There may be times when you want to specify a type on to a variable. This can be done with casting. Python is an object-orientated language, and as such it uses classes to define data types, including its primitive types.\n",
    "\n",
    "Casting in python is therefore done using constructor functions:\n",
    "\n",
    "* **int()** - constructs an integer number from an integer literal, a float literal (by rounding down to the previous whole number), or a string literal (providing the string represents a whole number)\n",
    "* **float()** - constructs a float number from an integer literal, a float literal or a string literal (providing the string represents a float or an integer)\n",
    "* **str()** - constructs a string from a wide variety of data types, including strings, integer literals and float literals\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(1)   # x will be 1\n",
    "y = int(2.8) # y will be 2\n",
    "z = int(\"3\") # z will be 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = float(1)     # x will be 1.0\n",
    "y = float(2.8)   # y will be 2.8\n",
    "z = float(\"3\")   # z will be 3.0\n",
    "w = float(\"4.2\") # w will be 4.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = str(\"s1\") # x will be 's1'\n",
    "y = str(2)    # y will be '2'\n",
    "z = str(3.0)  # z will be '3.0'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Strings\n",
    "\n",
    "String literals in python are surrounded by either single quotation marks, or double quotation marks.\n",
    "\n",
    "<font color=red> **'hello'**</font> is the same as <font color=red> **\"hello\"**</font>.\n",
    "\n",
    "You can display a string literal with the <font color=red> **print()**</font> function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\")\n",
    "print('Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assign String to a Variable\n",
    "* Assigning a string to a variable is done with the variable name followed by an equal sign and the string\n",
    "* You can assign a multiline string to a variable by using three quotes Or three single quotes\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Lorem ipsum dolor sit amet,\n",
      "consectetur adipiscing elit,\n",
      "sed do eiusmod tempor incididunt\n",
      "ut labore et dolore magna aliqua.\n",
      "Lorem ipsum dolor sit amet,\n",
      "consectetur adipiscing elit,\n",
      "sed do eiusmod tempor incididunt\n",
      "ut labore et dolore magna aliqua.\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello\"\n",
    "print(a)\n",
    "b = \"\"\"Lorem ipsum dolor sit amet,\n",
    "consectetur adipiscing elit,\n",
    "sed do eiusmod tempor incididunt\n",
    "ut labore et dolore magna aliqua.\"\"\"\n",
    "print(b)\n",
    "c = '''Lorem ipsum dolor sit amet,\n",
    "consectetur adipiscing elit,\n",
    "sed do eiusmod tempor incididunt\n",
    "ut labore et dolore magna aliqua.'''\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Strings are Arrays\n",
    "Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.\n",
    "\n",
    "Square brackets can be used to access elements of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n",
      "llo\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello, World!\"\n",
    "print(a[1])\n",
    "print(a[2:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Negative Indexing\n",
    "Use negative indexes to start the slice from the end of the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!\n",
      "orl\n"
     ]
    }
   ],
   "source": [
    "b = \"Hello, World!\"\n",
    "print(b[-1])\n",
    "print(b[-5:-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "<font color=red> **Question**: How can we access different letters in a string? </font>\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### String Length\n",
    "To get the length of a string, use the len() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello, World!\"\n",
    "print(len(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Methods\n",
    "Python has a set of built-in methods that you can use on strings.\n",
    "\n",
    "* The strip() method removes any whitespace from the beginning or the end:\n",
    "~~~~\n",
    "a = \" Hello, World! \"\n",
    "print(a.strip()) # returns \"Hello, World!\"\n",
    "~~~~\n",
    "\n",
    "* The lower() method returns the string in lower case:\n",
    "~~~~\n",
    "a = \"Hello, World!\"\n",
    "print(a.lower())\n",
    "~~~~\n",
    "* The upper() method returns the string in upper case:\n",
    "~~~~\n",
    "a = \"Hello, World!\"\n",
    "print(a.upper())\n",
    "~~~~\n",
    "* The replace() method replaces a string with another string:\n",
    "~~~~\n",
    "a = \"Hello, World!\"\n",
    "print(a.replace(\"H\", \"J\"))\n",
    "~~~~\n",
    "* The split() method splits the string into substrings if it finds instances of the separator:\n",
    "~~~~\n",
    "a = \"Hello, World!\"\n",
    "print(a.split(\",\")) # returns ['Hello', ' World!']\n",
    "~~~~\n",
    "\n",
    "There are may Python [built-in methods][1] that you can use on strings.\n",
    "\n",
    "[1]: https://www.w3schools.com/python/python_strings.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check String\n",
    "To check if a certain phrase or character is present in a string, we can use the keywords in or not in.\n",
    "\n",
    "\n",
    "* Check if the phrase \"ain\" is present in the following text:\n",
    "~~~~\n",
    "txt = \"The rain in Spain stays mainly in the plain\"\n",
    "x = \"ain\" in txt\n",
    "print(x)\n",
    "~~~~\n",
    "\n",
    "* Check if the phrase \"ain\" is NOT present in the following text:\n",
    "~~~~\n",
    "txt = \"The rain in Spain stays mainly in the plain\"\n",
    "x = \"ain\" not in txt\n",
    "print(x) \n",
    "~~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "txt = \"The rain in Spain stays mainly in the plain\"\n",
    "x = \"ain\" in txt\n",
    "print(x)\n",
    "txt = \"The rain in Spain stays mainly in the plain\"\n",
    "x = \"ain\" not in txt\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### String Concatenation\n",
    "To concatenate, or combine, two strings you can use the + operator.\n",
    "\n",
    "\n",
    "* Merge variable a with variable b into variable c:\n",
    "~~~~\n",
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "c = a + b\n",
    "print(c)\n",
    "~~~~\n",
    "\n",
    "* To add a space between them, add a \" \":\n",
    "~~~~\n",
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "c = a + \" \" + b\n",
    "print(c)\n",
    "~~~~"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HelloWorld\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "c = a + b\n",
    "print(c)\n",
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "c = a + \" \" + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.2 64-bit",
   "language": "python",
   "name": "python38264bitc8ae904922064ca0aa4c7591754d7c52"
  },
  "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.2"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}