Code-Example-001.01-Introduction-to-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 1: Introduction to Python\n",
    "\n",
    "Python is a high-level programming language with extensive libraries available to perform various data analysis tasks. \n",
    "The following tutorial contains examples of using various data types, functions, and library modules available in the standard Python library. The notebook can be downloaded from http://www.cse.msu.edu/~ptan/dmbook/tutorials/tutorial1/tutorial1.ipynb. Read the step-by-step instructions below carefully. To execute the code, click on each cell below and press the SHIFT-ENTER keys simultaneously.\n",
    "\n",
    "We begin with some basic information about Python:\n",
    "1. Python is an interpreted language, unlike other high-level programming languages such as C or C++. You only need to submit your Python program to an interpreter for execution, without having to explicitly compile and link the code first.\n",
    "\n",
    "2. Python is a dynamically typed language, which means variable names are bound to their respective types during execution time. You do not have to explicitly declare the type of a variable before using it in the code unlike Java, C++, and other statically-typed languages.\n",
    "\n",
    "3. Instead of using braces '{' and '}', Python uses whitespace indentation to group together related statements in loops or other control-flow statements.\n",
    "\n",
    "4. Python uses the hash character ('#') to precede single-line comments. Triple-quoted strings (''') are commonly used to denote multi-line comments (even though it is not part of the standard Python language) or docstring of functions.\n",
    "\n",
    "5. Python uses pass by reference (instead of pass by value) when assigning a variable to another (e.g., a = b) or when passing an object as input argument to a function. Thus, any modification to the assigned variable or to the input argument within the function will affect the original object.  \n",
    "\n",
    "6. Python uses `None` to denote a null object (e.g., a = None). You do not have to terminate each statement with a terminating character (such as a semicolon) unlike other languages.\n",
    "\n",
    "7. You may access the variables or functions defined in another Python program file using the `import` command. This is analogous to the `import` command in Java or the `#include` command in C or C++."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Elementary Data Types\n",
    "\n",
    "The standard Python library provides support for various elementary data types, including including integers, booleans, floating points, and strings. A summary of the data types is shown in the table below.\n",
    "\n",
    "| &nbsp;  |      Data Type    |   Example   | \n",
    "|:--------|:-----------------:|:------------|\n",
    "|Number   | Integer           | x = 4       |\n",
    "| &nbsp;  | Long integer      | x = 15L     | \n",
    "| &nbsp;  | Floating point    | x = 3.142   | \n",
    "| &nbsp;  | Boolean           | x = True    |\n",
    "|Text     | Character         | x = 'c'     |\n",
    "| &nbsp;  | String            | x = \"this\" or x = 'this' |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 <class 'int'>\n",
      "True <class 'bool'>\n",
      "3.7 <class 'float'>\n",
      "This is a string <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = 4              # integer\n",
    "print(x, type(x))\n",
    "\n",
    "y = True           # boolean (True, False)\n",
    "print(y, type(y))\n",
    "\n",
    "z = 3.7            # floating point\n",
    "print(z, type(z))\n",
    "\n",
    "s = \"This is a string\"    # string\n",
    "print(s, type(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are some of the arithmetic operations available for manipulating integers and floating point numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 8 12 6 18 2\n",
      "3.7 1.7000000000000002 1.2333333333333334 1.0 13.690000000000001\n",
      "3.7 13.690000000000001 4 3\n"
     ]
    }
   ],
   "source": [
    "x = 4            # integer\n",
    "x1 = x + 4       # addition \n",
    "x2 = x * 3       # multiplication\n",
    "x += 2           # equivalent to x = x + 2\n",
    "x3 = x       \n",
    "x *= 3           # equivalent to x = x * 3\n",
    "x4 = x      \n",
    "x5 = x % 4       # modulo (remainder) operator\n",
    "\n",
    "z = 3.7          # floating point number\n",
    "z1 = z - 2       # subtraction\n",
    "z2 = z / 3       # division\n",
    "z3 = z // 3      # integer division\n",
    "z4 = z ** 2      # square of z \n",
    "z5 = z4 ** 0.5   # square root\n",
    "z6 = pow(z,2)    # equivalent to square of z\n",
    "z7 = round(z)    # rounding z to its nearest integer \n",
    "z8 = int(z)      # type casting float to int\n",
    "\n",
    "print(x,x1,x2,x3,x4,x5)\n",
    "print(z,z1,z2,z3,z4)\n",
    "print(z5,z6,z7,z8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are some of the functions provided by the math module for integers and floating point numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "16.0\n",
      "54.598150033144236\n",
      "2.0\n",
      "4.0\n",
      "24\n",
      "1\n",
      "0\n",
      "0\n",
      "3.6739403974420594e-16\n",
      "0.9999999869751758\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = 4\n",
    "print(math.sqrt(x))      # sqrt(4) = 2\n",
    "print(math.pow(x,2))     # 4**2 = 16\n",
    "print(math.exp(x))       # exp(4) = 54.6\n",
    "print(math.log(x,2))     # log based 2  (default is natural logarithm)\n",
    "print(math.fabs(-4))     # absolute value\n",
    "print(math.factorial(x)) # 4! = 4 x 3 x 2 x 1 = 24\n",
    "\n",
    "z = 0.2\n",
    "print(math.ceil(z))      # ceiling function\n",
    "print(math.floor(z))     # floor function\n",
    "print(math.trunc(z))     # truncate function\n",
    "\n",
    "z = 3*math.pi            # math.pi = 3.141592653589793 \n",
    "print(math.sin(z))       # sine function\n",
    "print(math.tanh(z))      # arctan function\n",
    "\n",
    "x = math.nan             # not a number\n",
    "print(math.isnan(x))\n",
    "\n",
    "x = math.inf             # infinity\n",
    "print(math.isinf(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The following are some of the logical operations available for booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "y1 = True\n",
    "y2 = False\n",
    "\n",
    "print(y1 and y2)       # logical AND\n",
    "print(y1 or y2)        # logical OR\n",
    "print(y1 and not y2)   # logical NOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following are some of the operations and functions for manipulating strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "his\n",
      "4\n",
      "Length of string is 4\n",
      "THIS\n",
      "this\n",
      "This\n",
      "This is another string\n",
      "That at a string\n",
      "8\n",
      "True\n",
      "True\n",
      "False\n",
      "This is a string too\n",
      "This This This \n"
     ]
    }
   ],
   "source": [
    "s1 = \"This\"\n",
    "\n",
    "print(s1[1:])                    # print last three characters \n",
    "print(len(s1))                               # get the string length\n",
    "print(\"Length of string is \" + str(len(s1))) # type casting int to str\n",
    "print(s1.upper())                            # convert to upper case\n",
    "print(s1.lower())                            # convert to lower case\n",
    "\n",
    "s2 = \"This is a string\"\n",
    "words = s2.split(' ')             # split the string into words\n",
    "print(words[0])\n",
    "print(s2.replace('a','another'))  # replace \"a\" with \"another\"\n",
    "print(s2.replace('is','at'))      # replace \"is\" with \"at\"\n",
    "print(s2.find(\"a\"))               # find the position of \"a\" in s2\n",
    "print(s1 in s2)                   # check if s1 is a substring of s2\n",
    "\n",
    "print(s1 == 'This')               # equality comparison\n",
    "print(s1 < 'That')                # inequality comparison\n",
    "print(s2 + \" too\")                # string concatenation\n",
    "print((s1 + \" \")* 3)              # replicate the string 3 times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Compound Data Types\n",
    "\n",
    "The following examples show how to create and manipulate a list object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[1, 3, 5, 7, 9]\n",
      "[0, 2, 4, 6, 8]\n",
      "5\n",
      "[1, 3]\n",
      "[5, 7, 9]\n",
      "5\n",
      "25\n",
      "[1, 3, 5, 7, 9, 11]\n",
      "11\n",
      "[1, 3, 5, 7, 9]\n",
      "[1, 3, 5, 7, 9, 11, 13, 15]\n",
      "[1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1, 3, 5, 7, 9]\n",
      "[1, 3, 4, 5, 7, 9]\n",
      "[9, 7, 5, 4, 3, 1]\n"
     ]
    }
   ],
   "source": [
    "intlist = [1, 3, 5, 7, 9]\n",
    "print(type(intlist))\n",
    "print(intlist)\n",
    "intlist2 = list(range(0,10,2))   # range[startvalue, endvalue, stepsize]\n",
    "print(intlist2)\n",
    "\n",
    "print(intlist[2])                # get the third element of the list\n",
    "print(intlist[:2])               # get the first two elements\n",
    "print(intlist[2:])               # get the last three elements of the list\n",
    "print(len(intlist))              # get the number of elements in the list\n",
    "print(sum(intlist))              # sums up elements of the list\n",
    "\n",
    "intlist.append(11)               # insert 11 to end of the list\n",
    "print(intlist)\n",
    "print(intlist.pop())             # remove last element of the list\n",
    "print(intlist)\n",
    "print(intlist + [11,13,15])      # concatenate two lists\n",
    "print(intlist * 3)               # replicate the list\n",
    "intlist.insert(2,4)              # insert item 4 at index 2  \n",
    "print(intlist)\n",
    "intlist.sort(reverse=True)       # sort elements in descending order\n",
    "print(intlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['this', 'is', 'a', 'list']\n",
      "<class 'list'>\n",
      "True\n",
      "a\n",
      "['this', 'is']\n",
      "['a', 'list']\n",
      "this is a list too\n",
      "['this', 'a', 'list', 'too']\n"
     ]
    }
   ],
   "source": [
    "mylist = ['this', 'is', 'a', 'list']\n",
    "print(mylist)\n",
    "print(type(mylist))\n",
    "\n",
    "print(\"list\" in mylist)          # check whether \"list\" is in mylist\n",
    "print(mylist[2])                 # show the 3rd element of the list\n",
    "print(mylist[:2])                # show the first two elements of the list\n",
    "print(mylist[2:])                # show the last two elements of the list\n",
    "mylist.append(\"too\")             # insert element to end of the list\n",
    "\n",
    "separator = \" \"\n",
    "print(separator.join(mylist))    # merge all elements of the list into a string\n",
    "\n",
    "mylist.remove(\"is\")              # remove element from list\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following examples show how to create and manipulate a dictionary object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'MI': 'Michigan', 'MN': 'Minnesota', 'TX': 'Texas', 'CA': 'California'}\n",
      "dict_keys(['MI', 'MN', 'TX', 'CA'])\n",
      "dict_values(['Michigan', 'Minnesota', 'Texas', 'California'])\n",
      "4\n",
      "Michigan\n",
      "False\n",
      "True\n",
      "{'apples': 3, 'oranges': 4, 'bananas': 2, 'cherries': 10}\n",
      "['apples', 'bananas', 'cherries', 'oranges']\n",
      "[('apples', 3), ('bananas', 2), ('cherries', 10), ('oranges', 4)]\n",
      "[('bananas', 2), ('apples', 3), ('oranges', 4), ('cherries', 10)]\n"
     ]
    }
   ],
   "source": [
    "abbrev = {}\n",
    "abbrev['MI'] = \"Michigan\"\n",
    "abbrev['MN'] = \"Minnesota\"\n",
    "abbrev['TX'] = \"Texas\"\n",
    "abbrev['CA'] = \"California\"\n",
    "\n",
    "print(abbrev)\n",
    "print(abbrev.keys())            # get the keys of the dictionary\n",
    "print(abbrev.values())          # get the values of the dictionary\n",
    "print(len(abbrev))              # get number of key-value pairs\n",
    "\n",
    "print(abbrev.get('MI'))\n",
    "print(\"FL\" in abbrev)\n",
    "print(\"CA\" in abbrev)\n",
    "\n",
    "keys = ['apples', 'oranges', 'bananas', 'cherries']\n",
    "values = [3, 4, 2, 10]\n",
    "fruits = dict(zip(keys, values))\n",
    "print(fruits)\n",
    "print(sorted(fruits))     # sort keys of dictionary\n",
    "\n",
    "from operator import itemgetter\n",
    "print(sorted(fruits.items(), key=itemgetter(0)))    # sort by key of dictionary\n",
    "print(sorted(fruits.items(), key=itemgetter(1)))    # sort by value of dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following examples show how to create and manipulate a tuple object. Unlike a list, a tuple object is immutable, i.e., they cannot be modified after creation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('MI', 'Michigan', 'Lansing')\n",
      "('Michigan', 'Lansing')\n",
      "[('MI', 'Michigan', 'Lansing'), ('CA', 'California', 'Sacramento'), ('TX', 'Texas', 'Austin')]\n",
      "('TX', 'Texas', 'Austin')\n",
      "('TX', 'Texas', 'Austin')\n",
      "('Texas', 'Austin')\n",
      "[('TX', 'Texas', 'Austin'), ('MI', 'Michigan', 'Lansing'), ('CA', 'California', 'Sacramento')]\n"
     ]
    }
   ],
   "source": [
    "MItuple = ('MI', 'Michigan', 'Lansing')\n",
    "CAtuple = ('CA', 'California', 'Sacramento')\n",
    "TXtuple = ('TX', 'Texas', 'Austin')\n",
    "\n",
    "print(MItuple)\n",
    "print(MItuple[1:])\n",
    "\n",
    "states = [MItuple, CAtuple, TXtuple]    # this will create a list of tuples\n",
    "print(states)\n",
    "print(states[2])\n",
    "print(states[2][:])\n",
    "print(states[2][1:])\n",
    "\n",
    "states.sort(key=lambda state: state[2])  # sort the states by their capital cities\n",
    "print(states)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Control Flow Statements\n",
    "\n",
    "Similar to other programming languages, the control flow statements in Python include if, for, and while statements. Examples on how to use these statements are shown below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 10 is even\n",
      "x = 10 is positive\n"
     ]
    }
   ],
   "source": [
    "# using if-else statement\n",
    "\n",
    "x = 10\n",
    "\n",
    "if x % 2 == 0:\n",
    "    print(\"x =\", x, \"is even\")\n",
    "else:\n",
    "    print(\"x =\", x, \"is odd\")\n",
    "\n",
    "if x > 0:\n",
    "    print(\"x =\", x, \"is positive\")\n",
    "elif x < 0:\n",
    "    print(\"x =\", x, \"is negative\")\n",
    "else:\n",
    "    print(\"x =\", x, \"is neither positive nor negative\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "that\n",
      "at\n",
      "a\n",
      "latt\n",
      "[4, 2, 1, 4]\n",
      "['Austin', 'Lansing', 'Sacramento']\n",
      "['apples', 'oranges', 'bananas', 'cherries']\n"
     ]
    }
   ],
   "source": [
    "# using for loop with a list\n",
    "\n",
    "mylist = ['this', 'is', 'a', 'list']\n",
    "for word in mylist:\n",
    "    print(word.replace(\"is\", \"at\"))\n",
    "    \n",
    "mylist2 = [len(word) for word in mylist]   # number of characters in each word\n",
    "print(mylist2)\n",
    "\n",
    "# using for loop with list of tuples\n",
    "\n",
    "states = [('MI', 'Michigan', 'Lansing'),('CA', 'California', 'Sacramento'),\n",
    "          ('TX', 'Texas', 'Austin')]\n",
    "\n",
    "sorted_capitals = [state[2] for state in states]\n",
    "sorted_capitals.sort()\n",
    "print(sorted_capitals)\n",
    "\n",
    "# using for loop with dictionary\n",
    "\n",
    "fruits = {'apples': 3, 'oranges': 4, 'bananas': 2, 'cherries': 10}\n",
    "fruitnames = [k for (k,v) in fruits.items()]\n",
    "print(fruitnames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "First non-negative number: 0\n"
     ]
    }
   ],
   "source": [
    "# using while loop\n",
    "\n",
    "mylist = list(range(-10,10))\n",
    "print(mylist)\n",
    "\n",
    "i = 0\n",
    "while (mylist[i] < 0):\n",
    "    i = i + 1\n",
    "    \n",
    "print(\"First non-negative number:\", mylist[i])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 User-Defined Functions\n",
    "\n",
    "You can create your own functions in Python, which can be named or unnamed. Unnamed functions are defined using the lambda keyword as shown in the previous example for sorting a list of tuples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "myfunc = lambda x: 3*x**2 - 2*x + 3      # example of an unnamed quadratic function\n",
    "\n",
    "print(myfunc(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-11, 12, 23, 45, 71]\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# The following function will discard missing values from a list\n",
    "def discard(inlist, sortFlag=False):    # default value for sortFlag is False \n",
    "    outlist = []\n",
    "    for item in inlist:\n",
    "        if not math.isnan(item):\n",
    "            outlist.append(item)\n",
    "            \n",
    "    if sortFlag:\n",
    "        outlist.sort()\n",
    "    return outlist\n",
    "\n",
    "mylist = [12, math.nan, 23, -11, 45, math.nan, 71]\n",
    "\n",
    "print(discard(mylist,True))    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 File I/O\n",
    "\n",
    "You can read and write data from a list or other objects to a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State= Michigan ( MI ) Capital: Lansing\n",
      "\n",
      "State= California ( CA ) Capital: Sacramento\n",
      "\n",
      "State= Texas ( TX ) Capital: Austin\n",
      "\n",
      "State= Minnesota ( MN ) Capital: St Paul\n"
     ]
    }
   ],
   "source": [
    "states = [('MI', 'Michigan', 'Lansing'),('CA', 'California', 'Sacramento'),\n",
    "          ('TX', 'Texas', 'Austin'), ('MN', 'Minnesota', 'St Paul')]\n",
    "\n",
    "with open('states.txt', 'w') as f:\n",
    "    f.write('\\n'.join('%s,%s,%s' % state for state in states))\n",
    "    \n",
    "with open('states.txt', 'r') as f:\n",
    "    for line in f:\n",
    "        fields = line.split(sep=',')    # split each line into its respective fields\n",
    "        print('State=',fields[1],'(',fields[0],')','Capital:', fields[2])"
   ]
  }
 ],
 "metadata": {
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}