Object_Oriented_Programming_inPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object-Oriented Programming in Python\n",
    "\n",
    "## Getting ready for object-oriented programming\n",
    "\n",
    "### Creating functions\n",
    "We will review functions, as they are key building blocks of object-oriented programs.\n",
    "\n",
    "For this, we will create a simple function average_numbers() which averages a list of numbers. Remember that lists are a basic data type in Python that we can build using the [] bracket notation.\n",
    "\n",
    "Here is an example of a function that returns the square of an integer:\n",
    "\n",
    "```python\n",
    "def square_function(x):\n",
    "    x_squared =  x**2\n",
    "    return x_squared\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5\n"
     ]
    }
   ],
   "source": [
    "# Create function that returns the average of an integer list\n",
    "def average_numbers(num_list): \n",
    "    avg = sum(num_list)/float(len(num_list)) # divide by length of list\n",
    "    return avg\n",
    "\n",
    "# Take the average of a list: my_avg\n",
    "my_avg = average_numbers([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "# Print out my_avg\n",
    "print(my_avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a complex data type\n",
    "We'll take a closer look at the flexibility of the list data type, by creating a list of lists.\n",
    "\n",
    "In Python, lists usually look like our list example below, and can be made up of either simple strings, integers, or a combination of both.\n",
    "\n",
    "```python\n",
    "list = [1,2]\n",
    "```\n",
    "\n",
    "In creating a list of lists, we're building up to the concept of a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 4], [5, 6, 7, 8]]\n"
     ]
    }
   ],
   "source": [
    "# Create a list that contains two lists: matrix\n",
    "matrix = [[1,2,3,4], [5,6,7,8]]\n",
    "\n",
    "# Print the matrix list\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to NumPy Internals\n",
    "\n",
    "Numpy is a packhage for scientific computing in python.\n",
    "* Uses matrices and vectors as data strucured.\n",
    "* Perfect for data science, where the data lasi out in table-like formats.\n",
    "\n",
    "### Create a function that returns a NumPy array\n",
    "In this exercise, we'll continue working with the numpy package and our previous structures.\n",
    "\n",
    "We'll create a NumPy array of the float (numerical) data type so that we can work with a multi-dimensional data objects, much like columns and rows in a spreadsheet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3. 4.]\n",
      " [5. 6. 7. 8.]]\n"
     ]
    }
   ],
   "source": [
    "# Import numpy as np\n",
    "import numpy as np\n",
    "\n",
    "# List input: my_matrix\n",
    "my_matrix = [[1,2,3,4], [5,6,7,8]] \n",
    "\n",
    "# Function that converts lists to arrays: return_array\n",
    "def return_array(matrix):\n",
    "    array = np.array(matrix, dtype = float)\n",
    "    return array\n",
    "    \n",
    "# Call return_array on my_matrix, and print the output\n",
    "print(return_array(my_matrix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Objects\n",
    "*Class* : It is a chunk of code that has functions and varianles \n",
    "\n",
    "**OOP Dictionary**\n",
    "\n",
    "|Imperative|OOP|\n",
    "|---|---| \n",
    "|Variable|Attribute/Field|\n",
    "|function|Method|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Declaring a Class\n",
    "\n",
    "```python\n",
    "# we have special name of class follewed by class name:\n",
    "class Dinosor:\n",
    "    #we are not putting nay content or values in the class yet\n",
    "    pass\n",
    "```\n",
    "\n",
    "#### Creating a class\n",
    "We're going to be working on building a class, which is a way to organize functions and variables in Python. To start with, let's look at the simplest possible way to create a class.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declare a class\n",
    "class DataShell:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep dive into classes and objects\n",
    "### Intro to Classes\n",
    "We will build a class that will help us understand how Pandas DataFrame works under the hoods. We will call our class DataShell andi= it will take the ideas behind the pandas DataFrame and recreate from scratch. From our DataShell, we will build towards a DataFrame Class that takes a file of data as input and gives us back some information about it. We created a place holder for a class DataShell before. Now look at the class when it's fully fleshed out. \n",
    "\n",
    "First, it has an constructor, with an init method. it also has severel other methods. (NOT: methods are class functions.), including one that creates the datasell from a file object, and that can renema columns in the datashell. it also has a method to print out the contents of the datashell, show_shell, and one to create a five-figure summary_figure_summary.\n",
    "\n",
    "This class basic functionality:\n",
    "* take a CVS file\n",
    "* crete a numpy aarray from each one of the rows.\n",
    "* perform changes on the numpy array\n",
    "\n",
    "AS a Review, the basic features of a class in Python are: Constructors, Attribute, and Methids.\n",
    "\n",
    "```python\n",
    "class DataShell:\n",
    "    def __init__(self, filename):\n",
    "        self.filename =filename #attribute\n",
    "    \n",
    "    def create_datashell(self):\n",
    "        self.array = np.genfromtxt(self.filename, delimiter=',', dtype=None)\n",
    "        return self.array\n",
    "    def rename_column(self, old_colname, new_colname):\n",
    "        for index, value in enumarate(self.array[0]):\n",
    "            if value == old_colname.encode('UTF-8'):\n",
    "                self.array[0][index] = new_colname\n",
    "        return self.array\n",
    "        \n",
    "```\n",
    "\n",
    "Let's start with the init function.\n",
    "**init Function:** this is  known as the contructor for the class. you may notice the special underscores thet initialize the class. Within the constructor, we see the filename variable beging passed in as a parameter. this is a class variable or attrubute, and it's initialized when we create the class.Then  there are two methods. One that cretes the datashell by taking in a cvs file and returning arrays: and the second methods which renames columns in the datashell. Special keywords and features to take noteof include self, return, and the class attribure, filename. we'll dig into all of these in detail. \n",
    "\n",
    "### How to call the class\n",
    "\n",
    "we crete our class, with methots and attributes. Then weinstantiate the class by assingning a variable to it. Our class takes an input and then we call the instance of the class by callling athe variable, ot pointer tto the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DataShell:\n",
    "    def __init__(self, filename):\n",
    "        self.filename =filename #attribute\n",
    "    \n",
    "    def create_datashell(self):\n",
    "        self.array = np.genfromtxt(self.filename, delimiter=',', dtype=None)\n",
    "        return self.array\n",
    "    def rename_column(self, old_colname, new_colname):\n",
    "        for index, value in enumarate(self.array[0]):\n",
    "            if value == old_colname.encode('UTF-8'):\n",
    "                self.array[0][index] = new_colname\n",
    "        return self.array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.DataShell at 0x1047c1c18>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#let's call our class\n",
    "our_data_shell = DataShell('data/aapl.csv')\n",
    "our_data_shell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing a Class and Self\n"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}