Intermediate_Python.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8sUrEKMkGmPF"
      },
      "source": [
        "# Objectives\n",
        "* **Hands-on**\n",
        " * Classes/Objects\n",
        " * Modules & Imports\n",
        " * Packages & Libraries\n",
        " * File I/O\n",
        " \n",
        "* **Future Topics**\n",
        "* **Helpful hints & resources**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DxASzjEvGmPI"
      },
      "source": [
        "# Classes and Objects\n",
        "### Some OOP Terminologies\n",
        "Python supports object-oriented programming (OOP). Some OOP terminologies include;\n",
        "#### Class\n",
        "* Prototype for objects that defines a set of attributes that characterize any object of the class.\n",
        "* There are two types of classes. **System Defined** and **User Defined** classes\n",
        "* Example of a system defined class is the **'str'** class for string literals\n",
        "\n",
        "#### Object\n",
        "* Unique instance of a class\n",
        "* It comprises both data members and methods as defined by its class"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-Vg4AKwDGmPJ"
      },
      "outputs": [],
      "source": [
        "var = 'This is a string object'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "44gRCbm6GmPK"
      },
      "source": [
        "* **'var'** is an object of String class\n",
        "\n",
        "#### Instantiation\n",
        "* The creation of an object (instance of a class)\n",
        "\n",
        "#### Attributes\n",
        "* Data members and methods, accessed via dot notation\n",
        "\n",
        "#### Data member\n",
        "* Holds data associated with a class and its objects\n",
        "* May be a class variable or instance variable\n",
        "\n",
        "#### Class variable\n",
        "* Shared with all instances of a class\n",
        "* Defined within a class but outside any of the class's methods\n",
        "\n",
        "####  Instance variable\n",
        "* Defined inside a method and belongs only to the current instance/object\n",
        "\n",
        "#### Method\n",
        "* A special kind of function that is defined in a class definition"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZBzzuGskGmPL"
      },
      "outputs": [],
      "source": [
        "var.upper()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0j-EghdBGmPL"
      },
      "source": [
        "### Defining a User-defined class\n",
        "* To create a class, it begins with keyword **'class'** followed by the class name\n",
        "\n",
        "  **class ClassName:**\n",
        "\n",
        "  $\\;\\;\\;\\;\\;\\;$**class variables** # shared among all instances of this class\n",
        "\n",
        "  $\\;\\;\\;\\;\\;\\;$**return expression**\n",
        "\n",
        "  $\\;\\;\\;\\;\\;\\;$**def \\__init__(self,class_parameter[s]) :**\n",
        "\n",
        "  $\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$**self.instance_variables[s] = class_parameter[s]**\n",
        "\n",
        "  $\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$**\\__init__ method body**\n",
        "\n",
        "  $\\;\\;\\;\\;\\;\\;$**class body**\n",
        "  \n",
        "* By convention class names begin with an initial caps\n",
        "* Includes a compulsory intial method **'\\__init__( )'**<br> \n",
        "  (**NB**: **'\\__'** is double underscore)\n",
        "  Python calls this method when you create a new instance of this class\n",
        "* **'\\__init__( )'** can include optional parameters that might be required at initialization of the class\n",
        "* Class body has statements that define attributes (data and methods)\n",
        "* All other class methods are normal functions except the **first compulsory** argument to each method is **'self'**\n",
        "* See example below"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "khWdCt8uGmPM"
      },
      "outputs": [],
      "source": [
        "class Employee:\n",
        "    # A class variable\n",
        "    empCount = 0\n",
        "    # Compulsory initial method. Notice the compulsory self arguments\n",
        "    def __init__(self, name, salary):\n",
        "        self.name = name\n",
        "        self.salary = salary\n",
        "        Employee.empCount += 1 # Notice how class variables are referenced\n",
        "    # First method. Notice the compulsory self arguments\n",
        "    def displayCount(self):\n",
        "        print (\"This is Employee # %d\" % Employee.empCount)\n",
        "    # Second method. Notice the compulsory self arguments\n",
        "    def displayEmployee(self, increment):\n",
        "        print (\"Name : \", self.name, \", Salary: \", str(self.salary), \", Next year Salary: \" + str(self.salary+increment))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GDwlljDpGmPN"
      },
      "source": [
        "**Creating an Object of class Employee**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tp70SZMyGmPN"
      },
      "outputs": [],
      "source": [
        "emp1 = Employee(\"Zara\", 2000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZKwRJJV2GmPO"
      },
      "source": [
        "**Calling a method**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u77GsDNSGmPO"
      },
      "outputs": [],
      "source": [
        "emp1.displayCount()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rCBFxfQFGmPP"
      },
      "source": [
        "**Creating another object**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KoDTipm1GmPP"
      },
      "outputs": [],
      "source": [
        "emp2 = Employee(\"John\", 5000)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s4bqJfUcGmPP"
      },
      "source": [
        "**Calling another method**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DUsFcyHQGmPQ"
      },
      "outputs": [],
      "source": [
        "emp2.displayEmployee(200)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C2TrN9DfGmPQ"
      },
      "source": [
        "**A class variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sCPzmFziGmPR"
      },
      "outputs": [],
      "source": [
        "Employee.empCount"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "22fJVl4FGmPR"
      },
      "source": [
        "**An instance variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YRmv1xoDGmPR"
      },
      "outputs": [],
      "source": [
        "emp1.name"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9YzKAZLIGmPR"
      },
      "outputs": [],
      "source": [
        "print(\"Total number of Employees is %d\" % Employee.empCount)\n",
        "print(\"Name of second employee is\", emp2.name)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#RUN THIS CELL, IF YOU'RE ON \"COLAB\"\n",
        "\n",
        "#Cloning a repository from GitHub\n",
        "!git clone https://github.com/CEASLIBRARY/MyPackage     \n",
        "\n",
        "#Downloading the files to the working directory\n",
        "!wget https://raw.githubusercontent.com/CEASLIBRARY/Intermediate_Python/master/capitals.csv\n",
        "!wget https://raw.githubusercontent.com/CEASLIBRARY/Intermediate_Python/master/example.txt    \n",
        "!wget https://raw.githubusercontent.com/CEASLIBRARY/Intermediate_Python/master/example2.txt         \n",
        "!wget https://raw.githubusercontent.com/CEASLIBRARY/Intermediate_Python/master/example3.txt\n",
        "!wget https://raw.githubusercontent.com/CEASLIBRARY/Intermediate_Python/master/support.py\n",
        "!wget https://raw.githubusercontent.com/CEASLIBRARY/Intermediate_Python/master/uc_student.py"
      ],
      "metadata": {
        "id": "60XryAFTXnAC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Modules and Imports\n",
        "* A module is a file that contains definitions - including functions, variables and classes - that you can use once it is imported\n",
        "* A module can also include runnable code\n",
        "* Two types of modules\n",
        " * **System-defined** - Built-in modules like **'random'** located in **'random.py'** file\n",
        " * **User-defined** - Put all the related codes and definitions in a single file and save as **'.py'**"
      ],
      "metadata": {
        "id": "Dvva2MBgG9zg"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g-S0pJujGmPS"
      },
      "source": [
        "### Creating a User-defined Module\n",
        "To create a module called **'support'**\n",
        "* Open an empty script\n",
        "* Write the code and definitions. Use example below\n",
        "  \n",
        "  **pressure = 103.9**\n",
        "  \n",
        "  **def adding(x , y):**\n",
        "  \n",
        "  $\\;\\;\\;\\;\\;\\;$**return x + y**\n",
        "  \n",
        "  **def subtr(x , y):**\n",
        "  \n",
        "  $\\;\\;\\;\\;\\;\\;$**return x - y**\n",
        "  \n",
        "  \n",
        "* Save script as **'support.py'**\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing Modules\n",
        "Use **'import'** command to load a library into a program's memory\n",
        "\n",
        "#### Generic import\n",
        "Import only whole module(s)\n",
        "\n",
        "*Syntax*:\n",
        "<br>\n",
        "**import module_1 ,module_2 ,...module_N**\n",
        "\n",
        "*Usage*:"
      ],
      "metadata": {
        "id": "P_hn2DCfHDUX"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EVlsyc3EGmPS"
      },
      "outputs": [],
      "source": [
        "import support\n",
        "import math, random\n",
        "print(support.pressure)\n",
        "v = support.adding(2,3)\n",
        "print(v)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j8WvqeUfGmPS"
      },
      "source": [
        "#### Generic import with alias\n",
        "*Syntax*:\n",
        "<br>\n",
        "**import module_1 as m_1, module_2 as m_2, ...module_N as m_N**\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yFzB-yB3GmPT"
      },
      "outputs": [],
      "source": [
        "import math as m, support as s\n",
        "v = s.adding(2,3)\n",
        "print(v)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mwDan8MmGmPT"
      },
      "source": [
        "#### Specific items import \n",
        "Load only specific items from module\n",
        "\n",
        "*Syntax*:\n",
        "<br>\n",
        "**from module_name import item_1, item_2, ...item_N**\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JkCVGKDPGmPT"
      },
      "outputs": [],
      "source": [
        "from support import adding\n",
        "v = adding(2,3)\n",
        "print(v)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5h0a4OfEGmPT"
      },
      "source": [
        "#### Universal import\n",
        "Import all items in a module individually\n",
        "\n",
        "*Syntax*:\n",
        "<br>\n",
        "**from module_name import**\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gdGCevsjGmPT"
      },
      "outputs": [],
      "source": [
        "from support import *\n",
        "v = adding(2,3)\n",
        "u = subtr(2,3)\n",
        "print(u)\n",
        "print(v)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gfSYkperGmPT"
      },
      "source": [
        "### More on Modules\n",
        "* **dir (module_name)** returns a sorted list of strings with names of items in a module\n",
        "* **help (module_name)** find out more about a module's contents"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_f2P3_i9GmPU"
      },
      "outputs": [],
      "source": [
        "import math\n",
        "content = dir(math)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "XdnupQ4pGmPU"
      },
      "outputs": [],
      "source": [
        "print(content)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nix0K4cpGmPU"
      },
      "outputs": [],
      "source": [
        "help(math)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0lGVmnsDGmPU"
      },
      "source": [
        "# Exercise 1\n",
        "### Creating a Module with a Function and Class definitions\n",
        "1. Create a module with the following entities\n",
        "   * A function called **'demographics'** to ask a user for their first name, last name and year of birth and returns these values in that order.<br>\n",
        "     NB: Remember the **input( )** or **raw_iput( )** functions for Python 3 and 2 respectively.\n",
        "   * A function called **'uc_6_2'** with two string inputs (two names of a person with the first name as first input). This function returns the UC 6+2\n",
        "   * A class called **'Student'** with the following attributes\n",
        "     * Takes three string input(First name, last name, and year of birth in that order) to create an object of this class\n",
        "     * A **'student_count'** CLASS VARIABLE to track the count of every student object created so to use them in creating a student number for each student\n",
        "     * A method called **'student_number'** to return the student number. A student number is the **student's year of birth** + **student's count**\n",
        "     * A method called **'student_id'** calls the **'uc_6_2'** function to return the student ID\n",
        "   * Save the module as **'uc_student.py'**\n",
        "<br><br>  \n",
        "2. Imports the uc_student.py module into your session\n",
        "   * Create 3 student objects using the following steps\n",
        "     * For each student call the **'demographics( )'** function as save the output in a variable\n",
        "     * Use the information provided to create a student object\n",
        "   * Print the student number and student id of each student object\n",
        "   * Print the total number of students"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JAbnuc33GmPU"
      },
      "source": [
        "### Solving Part 2 of Exercise\n",
        "**Import the ' uc_student ' module into your session with an alias**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f7MxXBn-GmPV"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "71nh0Q0iGmPV"
      },
      "source": [
        "**Call the ' demographics ' function to take inputs for first student and store in a variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GtKDhvgOGmPV"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WXnaVrS1GmPV"
      },
      "source": [
        "**Call the ' Student ' class create first student object using the list saved in the command above and store in a variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qmoRFZHkGmPV"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "04yyic58GmPV"
      },
      "source": [
        "**Call the ' demographics ' function to take inputs for second student and store in a variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qz-MDVbNGmPV"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hkl5e2LJGmPV"
      },
      "source": [
        "**Call the ' Student ' class create second student object using the list saved in the command above and store in a variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AeTfXM34GmPW"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QbkHTtcBGmPW"
      },
      "source": [
        "**Call the ' demographics ' function to take inputs for third student and store in a variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fZ6BXpDWGmPW"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xmqpTYu7GmPW"
      },
      "source": [
        "**Call the ' Student ' class create third student object using the list saved in the command above and store in a variable**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s3_kH9rjGmPW"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ldy77wUoGmPW"
      },
      "source": [
        "**Print the student number and student id of each student object**\n",
        "\n",
        "**Hint:** Replace the **?** in below command with appropriate code.\n",
        "<br>\n",
        "Do this for all three student objects in the cell below\n",
        "<br>\n",
        "**print ( 'Number of First Student : ', ? , ' ; ID of First Student : ', ? )**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vcg5QOH6GmPW"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BbbPfDIrGmPW"
      },
      "source": [
        "# Packages in Python\n",
        "* A hierarchical file directory structure containing modules and subfolders and sub-subfolders as subpackages or sub-subpackages\n",
        "* It helps organize projects files in a single Python application environment\n",
        "* Each folder has a file called **'\\__init__.py'**\n",
        "* You can create your own Package\n",
        "* **'\\__init__.py'** file contains imports statements for modules in the folder and other code to be executed\n",
        "* The Package or folder can be imported using the folder name. Same import rules discussed earlier apply\n",
        "* When a Package is imported, it is initialized by running the **'\\__init__.py'** file\n",
        "* **System-defined** Packages - Already Built-in modules. An example is the **'email'** package for managing email messages\n",
        "* **User-defined** Packages - You can create your own Package. See example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "k19lg7AhGmPX"
      },
      "outputs": [],
      "source": [
        "import MyPackage as m"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tZcZEq-KGmPX"
      },
      "outputs": [],
      "source": [
        "m.uc_student.demographics()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zgmO6IGRGmPX"
      },
      "outputs": [],
      "source": [
        "m.uc_6_2('John','Smith')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Libraries\n",
        "* A Library is a collection of modules and packages that can be used by other python programs\n",
        "* The python community use the words **package** and **library** interchangeably\n"
      ],
      "metadata": {
        "id": "RkdpaHjlHVKD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### Python Standard Library\n",
        "* Python has a Standard Library with **System-defined** modules and packages\n",
        "* The Python Standard Library is downloaded on local drive when Python is installed\n",
        "* For More info at https://docs.python.org/3/library/\n"
      ],
      "metadata": {
        "id": "Ar9uXcu-HgAo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### Additional/External Libraries\n",
        "* Many other modules and packages created by the Python community and third-party teams are kept on Libraries outside of the Standard Library\n",
        "* The **Python Package Index (PyPI)** is the official third-party software repository or library for Python\n",
        "* Many definitions created by the Python community and third-party teams are shared on PyPI\n",
        "* More info on PyPI at https://pypi.org/\n",
        "* There are other External Libraries aside PyPI\n",
        "* You may use a package management system like **'pip'** to install a Package from PyPI and other sources\n",
        "* Popular packages not on the Standard Library include **numpy** for multi-dimensional arrays, **matplotlib** for plotting and graphs and **pandas** for data manipulation and analysis. Thes are available on PyPI"
      ],
      "metadata": {
        "id": "RJwSFAg3HbhY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Installing external Packages via command line using 'pip'\n",
        "* **'pip'** can install from\n",
        " * PyPI (Python Package Index)\n",
        " * Local directories\n",
        " * Remote source archives\n",
        " * urls with VCS support using url prefixes ( 'git+', 'hg+', 'bzr+', 'svn+' for Git, Mercurial, Subversion and Bazaar respectively)\n",
        "* **'pip'** uses PyPI as the default source for packages and their dependencies\n",
        "* Open Command Prompt for Windows or Terminal for Mac or Linux to install a package via **'pip'** \n",
        "\n",
        " Syntax for installing from PyPI**:\n",
        " \n",
        " **pip install package-name**\n",
        "\n",
        " **Usage**:\n",
        " \n",
        " **pip install numpy**\n",
        "* More info on installing packages on PyPI and other sources visit using **'pip'** at\n",
        " * https://packaging.python.org/tutorials/installing-packages/\n",
        " * https://pip.pypa.io/en/latest/reference/pip_install/"
      ],
      "metadata": {
        "id": "cBY3ehlVHkLA"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ct928da_GmPX"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        " \n",
        "# File Objects\n",
        "* To read or write to a file you need to create a file object for the file\n",
        "* **open()** is a built-in system function used to create file objects\n",
        "  \n",
        "*Syntax*:<br>\n",
        "**file_object = open(file_path_name [, access_mode] [, buffering] )**\n",
        "  \n",
        "**file_path_name** − String value containing file name or file system path.<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$NB: Depending on the access mode, a new file is created if file does not exist.<br>\n",
        "**access_mode** − Optional String value representing mode while opening a file (read, write, append, etc).<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$Default value is **'r'** for read.<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$A new file is created if file does not exist only for write and append modes.<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$A complete list of possible mode values in workshop material and online guide.<br>\n",
        "**buffering** − Optional integer used to set the buffering policy.<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$Defaults value is -1.<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$0 to switch buffering off (only in binary mode),<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$1 to select line buffering (only usable in text mode),<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$> 1 to indicate the size in bytes of a fixed-size chunk buffer (only in binary mode),<br>\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$< 1 default behavior.\n",
        "  \n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MDvSxsXxGmPX"
      },
      "outputs": [],
      "source": [
        "my_file_1 = open(\"example.txt\", \"r\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "394vUS3TGmPY"
      },
      "outputs": [],
      "source": [
        "my_file_2 = open(\"example2.txt\", \"a+\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3uR-WQkeGmPY"
      },
      "source": [
        "### File Object Data Attributes\n",
        "**file.closed** - Returns 'True' if the file is closed. Otherwise 'False'<br/>**file.mode** - Returns access mode with which the file was opened<br/>**file.name** - Returns name of the file<br/>  \n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GXJU6gLmGmPY"
      },
      "outputs": [],
      "source": [
        "print (\"Name of the file: \", my_file_1.name)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9w_wY52GmPY"
      },
      "source": [
        "### File Object Methods\n",
        "**read( )**<br>\n",
        "Reads a string from an open file. Python strings can have binary data.\n",
        "\n",
        "*Syntax*:<br>\n",
        "**var = file_object.read ( [count] )**<br>\n",
        "count is an optional parameter for the number of bytes to read\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w-38nCWHGmPY"
      },
      "outputs": [],
      "source": [
        "text = my_file_1.read()\n",
        "print (\"Read String is: \", text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1CA3O6WDGmPY"
      },
      "source": [
        "**write( )**<br>\n",
        "Writes any string to an open file in write or append mode.\n",
        "\n",
        "*Syntax*:<br>\n",
        "**file_object.write (string)**<br>\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nzy1_5mqGmPZ"
      },
      "outputs": [],
      "source": [
        "my_file_2.write('\\nNew Entries')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fFJPn3rWGmPZ"
      },
      "source": [
        "**close( )**<br>\n",
        "Closes the file object. No more writing or reading can be done after.\n",
        "\n",
        "*Syntax*:<br>\n",
        "**file_object.close( )**<br>\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GCbQJRsnGmPZ"
      },
      "outputs": [],
      "source": [
        "my_file_1.close()\n",
        "my_file_2.close()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W46myBTJGmPZ"
      },
      "source": [
        "\n",
        "The **'os'** system module provides functions that operate on files such as renaming and deleting files.\n",
        "#### rename()\n",
        "*Syntax*:<br>\n",
        "**import os**<br>\n",
        "**os.rename(current_file_name, new_file_name)**\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6mzDnK7_GmPZ"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "os.rename('example3.txt', 'example_3.txt')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OapHJ5-5GmPZ"
      },
      "source": [
        "#### rename()\n",
        "*Syntax*:<br>\n",
        "**os.remove(file_name)**\n",
        "\n",
        "*Usage*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9gdSIDTPGmPa"
      },
      "outputs": [],
      "source": [
        "os.remove('example_3.txt')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ftBLPlNQGmPa"
      },
      "source": [
        "### File Operations Coding\n",
        "#### Reading from a file\n",
        "NB: File needs to be closed after it has been opened."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XODIm-6SGmPa"
      },
      "outputs": [],
      "source": [
        "my_file = open(\"example.txt\", \"r\")\n",
        "text = my_file.read()\n",
        "my_file.close()\n",
        "print(text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "phDVaMY2GmPa"
      },
      "source": [
        "#### Better File Reading code using 'with' block construct\n",
        "Following syntax will automatically close files"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FCUftZzIGmPa"
      },
      "outputs": [],
      "source": [
        "with open('example.txt', 'r') as my_file:\n",
        "    text = my_file.read()\n",
        "print(text)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VIOjI1RwGmPa"
      },
      "source": [
        "#### Reading individual lines in a file as a list using 'for line in' loop\n",
        "We often want to read in a file line by line and storing them in a list"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oDRT2RaQGmPa"
      },
      "outputs": [],
      "source": [
        "lines = []\n",
        "with open('example.txt', 'r') as my_file:\n",
        "    for b in my_file:\n",
        "        lines.append(b.strip()) # strip gets rid of line breaks\n",
        "# at the end of each line\n",
        "for a in lines:\n",
        "    print(a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UJM7tCwTGmPa"
      },
      "source": [
        "####  Writing to a file\n",
        "NB:  File needs to be closed after it has been opened."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z5DOVcnMGmPb"
      },
      "source": [
        "#### Better code using the 'with' block construct to automatically close file"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L5XBqITBGmPb"
      },
      "outputs": [],
      "source": [
        "names = ['John Smith','Sarah Blunt ','Dag Heward-Mills','John Wick']\n",
        "with open('example2.txt', 'a+') as new_file:\n",
        "    for i in names:\n",
        "        new_file.write('\\n' + i)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Am4ObG6GmPb"
      },
      "source": [
        "### Using the 'csv' System Module for CSV files\n",
        "* Reading or writing to a **'.csv'** files is a common Python task\n",
        "* A common way to do that is to read a csv as a list of dictionaries\n",
        "* The **'csv'** module is used for this"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "spdh9Pa0GmPb"
      },
      "outputs": [],
      "source": [
        "import csv"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iLCzQpTvGmPb"
      },
      "source": [
        "#### Reading from a ' .csv ' file using ' csv.DictReader ( ) ' function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9uH0t11VGmPb"
      },
      "outputs": [],
      "source": [
        "capitals = [] # make empty list\n",
        "with open('capitals.csv', 'r') as csvfile: # open file object\n",
        "    reader = csv.DictReader(csvfile) # create a reader object\n",
        "    for row in reader: # loop through rows\n",
        "        capitals.append(row) # append each row to the list\n",
        "print(capitals[:5]) # print first 6 rows"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jROqnJqdGmPb"
      },
      "source": [
        "#### Writing to a '.csv' file is similar. Use 'csv.DictWriter ( )' function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "93ci76YmGmPb"
      },
      "outputs": [],
      "source": [
        "keys = capitals[0].keys() # get keys using first item of Dictionary\n",
        "print(keys)\n",
        "with open('capitals2.csv', 'w') as csv_file: # open file object\n",
        "    writer = csv.DictWriter(csv_file, keys) # create a writer object\n",
        "    writer.writeheader() # write the header\n",
        "    writer.writerows(capitals[0:10]) # write the first 10 rows"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "43-_He4OGmPc"
      },
      "source": [
        "# Appendix\n",
        "## What is IPython?\n",
        "* An interactive command shell for multiple programming languages\n",
        "* Originally developed for Python\n",
        "* Similar to the standard Python shell but more interactive\n",
        "\n",
        "## What is Jupyter Notebook?\n",
        "* An open-source web application that allows you to create, save and share documents (Notebooks) that contain live code, equations, visualizations and simple text called Markdown\n",
        "* Jupyter Notebook can run multiple languages (including Python and R)\n",
        "* Compatibile to kernels for many programming languages (currently 49 in total)\n",
        "* Default Kernel is IPython\n",
        "\n",
        "## What is the Anaconda Distribution?\n",
        "* Open-source distribution for programming languages (Python and R) and tools used for data science and machine learning\n",
        "* Tools include Jupyter notebook, IPython shell, standard Python shell, rstudio and spyder (an advanced IDE for Python)\n",
        "\n",
        "## Download & Installation\n",
        "### Anaconda \n",
        "Latest releases - Anaconda 5.3.1\n",
        "* Download at https://www.anaconda.com/download/\n",
        "* Select the right operating system (Windows, Mac or Linux)\n",
        " \n",
        "### Jupyter Notebook\n",
        "* Install Jupyter Notebook by **installing Anaconda**\n",
        " * Anaconda installs Jupyter Notebook alongside Python, IPython and other commonly used packages for scientific computing and data science\n",
        " * Highly recommended for new users\n",
        "\n",
        "* Installing stand alone Jupyter **via command line**\n",
        " * For more experienced Python users\n",
        " * **Prerequisite:** Python 3.3 or greater, or Python 2.7 and **pip**\n",
        " * Open Command Prompt for Windows or Terminal for Mac or Linux\n",
        " * Type the following command<br>\n",
        "   Python 2 - **pip install jupyter**<br>\n",
        "   Python 3 - **pip3 install jupyter**\n",
        "   \n",
        "## Starting Jupyter Notebook\n",
        "* Via Anaconda (Recommended for new users)\n",
        " * Open the **Anaconda Navigator** program on your computer and search for the Jupyter Notebook icon\n",
        " * Jupyter Notebook can also be started directly from the program menu\n",
        "* Start Jupyter via command line (Experienced users)\n",
        " * Open Command Prompt for Windows or Terminal for Mac or Linux\n",
        " * Type the command<br>\n",
        "   **jupyter notebook**\n",
        " \n",
        "## Exploring the Jupyter Interface\n",
        "### 'Files' tab\n",
        "* Navigate to the folder from which you want to work\n",
        "* Create new Python Notebooks, scripts with Text File, folders or Terminals\n",
        "![image.png](attachment:image.png)\n",
        "### 'Running' tab\n",
        "* Monitor currently running Terminals and Notebooks\n",
        "### New Text Files/Scripts\n",
        "* New scripts are used to save python scripts or programs \n",
        "* New scripts are saved in the current folder path\n",
        "* Change the Language to python and rename the file with a **'.py'** extension\n",
        "### New Python Notebooks\n",
        "* A notebook allows you to create, save and share documents that contain live code\n",
        "* New Notebooks are saved in the current folder path as a .ipynb extension\n",
        "* You may rename the notebook\n",
        "* To add python code, select **'Code'** in the dropdown\n",
        " * Hit **Enter** to add another line in the current cell\n",
        " * Hit **Control-Enter** or click **Run** executes the code in a cell. This will automatically add a new cell below\n",
        "* To add normal text as narrative to the notebook, select **'Markdown'** or **'Heading'** in the dropdown\n",
        " * Go to this link for more on Markdowns - https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Dxo8BNkGmPc"
      },
      "source": [
        "# Advanced and Future Topics\n",
        "* Error Handling and Exceptions\n",
        "* List Comprehensions\n",
        "* Regular Expressions\n",
        "* Database Access\n",
        "* Multithreading\n",
        "\n",
        "# Helpful Resources\n",
        "* CEAS Library Python resources - http://guides.libraries.uc.edu/python\n",
        "* Online links & tutorials\n",
        " * Python documentation - https://www.python.org/doc/\n",
        " * Python Programming wiki book - http://en.wikibooks.org/wiki/Python_Programming\n",
        " * Python tutorials - Udemy, Code academy, etc\n",
        " * Tutorials Point - https://www.tutorialspoint.com/python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zwb859xhGmPc"
      },
      "source": [
        "# $\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$Questions ??\n",
        "\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$**Thank you for attending the workshop !!**\n",
        "\n",
        "\n",
        "$\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;$**Your kind suggestions/feedbacks are more than welcome**"
      ]
    }
  ],
  "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.7.10"
    },
    "colab": {
      "name": "Intermediate Python.ipynb",
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}