Session 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Ummah Tech](imgs/logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python DS Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the third session of this course. Toady, we will be covering the basics of writing functions, methods, and object oriented programming. Before jumping into things, let's quickly review what we covered in the first session, as well as the homework assignment problems. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session 2 Review"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Ask more questions!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PEMDAS and Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You saw the importance of being explicit with operators when attempting to preserve the order desired of operations in a mathematical statement. You also learned how to install modules using the terminal command `pip install MODULENAME`, that could be executed directly from with a notebook by preceding the command with a bang `!`. You also learned that once a module has been installed, it can be imported and used anywhere throughout your notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "random.randint(50,100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You also learned how to quickly get help or more context surrounding a module or class variable, and learned about tab-autocomplete, the `??` command for inline jupyter notebook help and how to search the web for help resolving errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists, Dictionaries, and Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You learned a lot about lists. How to create them, index into and slice them, update their values, append onto them, pop from them, and more. You also learned about dictionaries, when to use them, how to iterate them, and how they work as a set of `key:value` pairs. Lastly, you learned about conditionals and how powerful they were as a mechanism of controlling the execution flow of the code you write."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Review So Far"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `print` statement\n",
    "- three data types\n",
    "- variables\n",
    "- basic arithmetic \n",
    "- interacting with different data types\n",
    "- `input` statement\n",
    "- `int` statement\n",
    "- `float` statement\n",
    "- boolean logic\n",
    "- order of operations\n",
    "- installing and calling modules\n",
    "- lists\n",
    "- dictionaries\n",
    "- `for` loops\n",
    "- `if` / `elif` / `else` conditionals\n",
    "- `type` statement\n",
    "- `len` statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a program to see if a user entered number is odd or even\n",
    "1. Write a program that generates a random integer and stores it in a variable. Asks the user to guess the number. If they guessed too high, print 'Too High!'. If they guessed to low, print 'Too Low!'. Otherwise print, 'You Got It!'\n",
    "1. Given a list of numbers `mylist = [1,2,10,-5,20,30,-100]`, find the largest number.\n",
    "1. Given a list of numbers `mylist = [1,2,10,-5,20,30,-100]`, compute the sum of the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = input('..')\n",
    "num = int(num)\n",
    "if num % 2 == 0:\n",
    "    print('even')\n",
    "else:\n",
    "    print('odd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "actual = random.randint(1,10)\n",
    "guess = int(input('guess a #'))\n",
    "if guess > actual:\n",
    "    print('too hi')\n",
    "elif guess < actual:\n",
    "    print('too lo')\n",
    "else:\n",
    "    print('gotit')\n",
    "    \n",
    "print(actual)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [1,2,10,-5,20,30,-100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxv = mylist[0]\n",
    "\n",
    "for val in mylist:\n",
    "    #print(val)\n",
    "    if val > maxv:\n",
    "        maxv = val\n",
    "        \n",
    "    else:\n",
    "        pass\n",
    "\n",
    "print(maxv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sumv = 0\n",
    "\n",
    "for val in mylist:\n",
    "    sumv += val\n",
    "    # sumv = sumv + val\n",
    "        \n",
    "print(sumv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Session 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's on the plate for this evening:\n",
    "\n",
    "- Functions\n",
    "- Classes\n",
    "- Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are encapsulated blocks of code that get executed only when you invoke them. Think of functions like factories. Typically, some _work_ is done inside of a factory. In our analogy, whatever code or logic you place within the body of a function would be the work that gets done inside your function factory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunction():\n",
    "    numA = 10\n",
    "    numB = 20\n",
    "    \n",
    "    if numA > numB:\n",
    "        print('numA is larger')\n",
    "        \n",
    "    else:\n",
    "        print('numB is larger')\n",
    "        \n",
    "print('testing')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice the `def` keyword that precedes your function name. You can name your functions (almost) anything you want, but to indicate to Python that the thing you're naming is indeed a function, you have to start the line with `def`. Also notice the parenthesis.\n",
    "\n",
    "Two other things to take note of:\n",
    "1. All the code within the body of the function has been indented. Anything you do outside of this indentation block will not be considered part of the function.\n",
    "1. In Python, any statement that ends with a `:` will have at least a +1 line indentation block following it. This indentation is how you tell Python that the code is associated with the previous statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just because you have built a function does not mean it's going to run on its own. Just like a real factor, you have to turn it on before it does anything. In our case, we have to invoke the function to get it to run the code contained within it. We run functions in Python by _invoking_ them using parenthesis. This just means use the pre-defined function name followed by parenthesis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfunction()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What do you think are some of the benefits of writing code and then placing them into functions, as opposed to just having a single sequential list of commands?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Go ahead and fill out your responses to the above prompt.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a factory to be effective, it might want to produce something. For example, there are car factories that make cars, ceramic factories that produce cups and plates, etc.\n",
    "\n",
    "If we do some computation within our functions and want to _return_ the result to be used elsewhere in our code, we must make use of the `return` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunction():\n",
    "    numA = 10\n",
    "    numB = 20\n",
    "    \n",
    "    numA_larger = numA > numB\n",
    "    \n",
    "    if numA_larger:\n",
    "        print('numA is larger')\n",
    "        \n",
    "    else:\n",
    "        print('numB is larger')\n",
    "        \n",
    "    return numA_larger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when we invoke our function and it executes, the value stored in the returned variable will be transfered over to the line of code where the function was invoked. That makes it possible to do something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = myfunction()\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can take this a step further and store the resulting value in a variable to use later on in our code as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = myfunction()\n",
    "if result == True:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just about any data type can be returned from a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "def make_numbers():\n",
    "    \n",
    "    random_numbers = []\n",
    "    for _ in range(15):\n",
    "        random_numbers.append(\n",
    "            random.randint(0,100)\n",
    "        )\n",
    "        \n",
    "    return random_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "make_numbers()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you do not explicitly return a value from your function, then even if you do some computations within it, they will just 'disappear' once the function finishes doing it's work. Sort of like an ice factory that freezes water, but then you go home and forget to take your ice—it won't be waiting for you the next day!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_numbers():    \n",
    "    random_numbers = []\n",
    "    for _ in range(15):\n",
    "        random_numbers.append( random.randint(0,100) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(make_numbers())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python implicitly returns a value called `None` (capital N). You can actually create a variable and assign `None` to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What do you think is the data type of None?\n",
    "- Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you know how to create functions that run some isolated code, and can even return the result of your computations, it's time to learn how to pass data into a function. Going back to our factory analogy, if you own an ice cream factory, it's not enough to just build the factory and turn it on. You need to provide it with raw materials so that it can operate!\n",
    "\n",
    "To pass a value as input into a function, you first need to show Python how to accept / where to store said desired input. You do this in the function's _definition line_ by naming new variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def testfunc(value):\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now when you invoke your method, whatever you passed in will get printed to the display:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "testfunc(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "testfunc([1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numA = 20\n",
    "testfunc(numA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "me = {\n",
    "    'name': 'Authman',\n",
    "    'age': 50,\n",
    "    'occupation': 'Machine Learning Engineer'\n",
    "}\n",
    "testfunc(me)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outside the function, we can use whatever variable names we want to. When we invoke the function and pass data into it, Python (for the most part) copies the value we're passing in and stores it into a _new_ variable named whatever we defined in the function definition line.\n",
    "\n",
    "This is rather handy and extremely useful for us, my fellow lazy programmers. Can you imagine why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ask the user to enter a number, and store it in a variable called `count`\n",
    "- Pass `count` into a function that generates a list holding `count` number of random integers\n",
    "- Return the list you built\n",
    "- Print the values of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Go ahead and type code below to complete the above instruction:\n",
    "def make_numbers(count):    \n",
    "    random_numbers = []\n",
    "    for _ in range(count):\n",
    "        random_numbers.append( random.randint(0,100) )\n",
    "        \n",
    "    return random_numbers\n",
    "\n",
    "count = input()\n",
    "count = int(count)\n",
    "print(make_numbers(count))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You've learned how to input data into functions, how to do work within the body of the function, and how to return data out of a function. Now, let's test your knowledge. What will be the output of this statement?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(some_variable_123)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "what about this one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfun():\n",
    "    print(some_variable)\n",
    "    \n",
    "myfun()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Okay. How about this one then:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numA = 100\n",
    "\n",
    "def myfun():\n",
    "    print(numA)\n",
    "    \n",
    "myfun()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happened there?\n",
    "\n",
    "Earlier, you saw the proper 'etiquette' of interacting with a function. How to pass data in using it's parameters you defined. However, you should also be aware that there is a \"back door\" method for getting data into and out of a function...\n",
    "\n",
    "If you attempt to interact with a variable declared 'outside' of your function, your function will respect those variables and interact with them, naturally. For example, if I told you \"Trump said he liked Python...\" you would naturally understand who this Trump character I am speaking about is. Trump isn't in our classroom, so you expect that I am talking about the external Trump we all know and... well, you get the point.\n",
    "\n",
    "What do you think will happen when we run the code this time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numA = 100\n",
    "\n",
    "def myfun():\n",
    "    numA = 50\n",
    "    print(numA)\n",
    "    \n",
    "myfun()\n",
    "print(numA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Why did that happen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Go ahead and fill out your responses to the above prompt.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our Trump example above, imagine we actually had a dude named Trump in our classroom. If I then said \"Trump said he liked Python\", you would first believe I was speaking of the student in our classroom named Trump, before you thought I was talking about the president. Out Python functions act similar.\n",
    "\n",
    "By defining (and initializing) a variable within our function that has the same name as an external variable, Python believes anything we do after that point, within the confides of the function, is acting on the `local` numA. If we'd like to actually modify the `global` numA, we need explicitly let Python know that we wish to use it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numA = 100\n",
    "\n",
    "def myfun():\n",
    "    # There's only one `numA` here:\n",
    "    global numA\n",
    "    \n",
    "    numA = 50\n",
    "    print(numA)\n",
    "    \n",
    "myfun()\n",
    "print(numA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When functions were first introduced to programming languages, they revolutionized they _way_ programs were written. No longer were GOTO statements and line numbers necessary, and code could be written much more cleanly, especially if the functions are clearly named by a summary of what they do.\n",
    "\n",
    "Another huge step was the introduction of classes. Classes allow us to take functions a step further by grouping functions that act on similar data. They also allow us to create instances of similar data. The best way to understand this is with an example.\n",
    "\n",
    "Suppose we have a class of students and we want to store their details in our Python program. How would you accomplish that?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = [\n",
    "    {\n",
    "        'name': 'Authman',\n",
    "        'age': 50,\n",
    "        'email': 'uapatira@gmail.com',\n",
    "    },\n",
    "    \n",
    "    {\n",
    "        'name': 'Abdullah',\n",
    "        'age': 25,\n",
    "        'email': 'abdie@protonmail.com',\n",
    "    },\n",
    "    \n",
    "    {\n",
    "        'name': 'Aminah',\n",
    "        'age': 18,\n",
    "        'email': 'anuur@microsoft.com',\n",
    "    },\n",
    "    \n",
    "    {\n",
    "        'name': 'Muiz',\n",
    "        'age': 22,\n",
    "        'email': None,\n",
    "    },\n",
    "]\n",
    "\n",
    "students"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, you've defined storage for our _data_. You created a list of dictionaries to hold the details of our students. You can index into this list to get any specific single student:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "students[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Go ahead and write a function where you pass in a single student, like `students[0]` listed above, and the function prints 'Over 20' if the student's age is greater than 20 years old:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Go ahead and type code below to complete the above instruction:\n",
    "def over20(person):\n",
    "    if person['age'] > 20:\n",
    "        print('Older than 20')\n",
    "    else:\n",
    "        print('nah')\n",
    "        \n",
    "over20(students[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "over20(students[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Awesome! We can call this function whenever we want to act on one of our student dictionaries, and can even create more functions that do other things, such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_email(some_student):\n",
    "    if some_student['email'] is not None:\n",
    "        print('Yes!')\n",
    "        \n",
    "    else:\n",
    "        print('No!')\n",
    "        \n",
    "has_email(students[0])\n",
    "has_email(students[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This works fine for small tutorials. Once you start writing actual software that has hundreds of thousands of lines, or more, it's no longer going to cut it. Just like when you learned about lists, there were a bunch of functions that _only_ act on lists. You were able to see this list of functions by using tab complete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = []\n",
    "mylist. # Move your cursor after the period and hit tab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![List Methods](imgs/listmethods.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These _methods_ or class-functions are called on a list directly, and are not global functions:\n",
    "\n",
    "```\n",
    "pop(mylist)  # wrong!\n",
    "mylist.pop() # correct\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wouldn't it be amazing if you too could create functions that only act on certain data types? In fact, it'd be even **more** awesome if you could create your **own** data types. turns out, you can do both!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student():\n",
    "    def __init__(self, name, age, email):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.email = email\n",
    "        \n",
    "    def is_over_20(self):\n",
    "        if self.age > 20:\n",
    "            print('Over 20')\n",
    "            \n",
    "        else:\n",
    "            print('Nope')\n",
    "            \n",
    "    def has_email(self):\n",
    "        if self.email is None:\n",
    "            print('Nope')\n",
    "            \n",
    "        else:\n",
    "            print('Yes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take apart what's going on here. First, we created a brand new Python datatype, a class called Student. Think of this as a template that we'll be able to 'stamp' to create instances of students in the future. Or a factory mold, like the mold of car that the factory will use to create cars to sell.\n",
    "\n",
    "PEP8 / Python convention is to use a capital letter for classes. Notice the `:` which means all  code lines after it that we wish to include within the class must be indented.\n",
    "\n",
    "Next we created two functions, `is_over_20` and `has_email`, which were almost identical to the way we created them before. However now, instead of passing in a student dictionary, we now pass in some weird thing called `self`.\n",
    "\n",
    "Even though I called them them functions, technically, they are now _methods_. Methods are nothing but functions that exist inside a class. Class functions, if you will."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last piece that ties everything together is the `__init__` method. This is a very special method. Unlike the other two methods, you don't have to explicitly invoke `__init__`. Rather, it is called automatically whenever you create a new instance of your class. Let's see it in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "studentA = Student('Authman', 50, 'uapatira@gmail.com')\n",
    "studentB = Student('Abdullah', 25, 'abdie@protonmail.com')\n",
    "studentC = Student('Aminah', 18, 'anuur@microsoft.com')\n",
    "studentD = Student('Muiz', 22, None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we create a new student variable, the `__init__` method is automagically called for us and the values we passed are placed into the `__init__` functions parameters in the order they are defined.\n",
    "\n",
    "Alternatively, we can also name the values if we wish to change the order or potentially omit some:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "studentA = Student(\n",
    "    age=50,\n",
    "    name='Authman', \n",
    "    email='uapatira@gmail.com'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we use an `=` sign, and the parameters are passed like regular variable assignments rather than as dictionary key-value-pairs.\n",
    "\n",
    "Go ahead and use tab complete after the period to see what all is available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "studentA.  # Use tab complete after the period"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Student Class](imgs/class.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See what happens when you do a `type(studentA)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Go ahead and type code below to complete the above instruction:\n",
    "type(studentA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see both the class's methods, as well as its _member variables_. Let's see what happens if we print some of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(studentA.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(studentA.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "studentA.has_email()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "studentD.has_email()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(studentD.email)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of having a global function that we pass a student dictionary to, now we have a method defined right inside our specialized Student class / data type, that acts on variables associated with students.\n",
    "\n",
    "Let's take a moment to talk about that weird `self` variable.\n",
    "\n",
    "`self` is a _convenience variable_ that Python uses to keep track of a specific instance of a class. Notice that all class methods have `self` passed as the first parameter; yet, when we actually call a class method, we don't pass in a value for that variable:\n",
    "\n",
    "```\n",
    "def has_email(self):  # Our method definition\n",
    "\n",
    "studentA.has_email()  # Where did 'self' go?\n",
    "```\n",
    "\n",
    "It turns out Python does some magic for us under the hood. What's _actually_ going on is Python is passing the instance of the object we created, in this case `studentA` into the method as its first parameter `self`. In other words, Python is taking this:\n",
    "\n",
    "\n",
    "```\n",
    "studentA.has_email()\n",
    "```\n",
    "\n",
    "And then turning it into this:\n",
    "\n",
    "```\n",
    "Student.has_email(studentA)\n",
    "```\n",
    "\n",
    "Where `Student` is the class we just defined. If we jump into it's source code, we can see that `self` is actually now referring to `studentA`!\n",
    "\n",
    "```\n",
    "def has_email(studentA):\n",
    "    if studentA.email is None:\n",
    "        print('Nope')\n",
    "\n",
    "    else:\n",
    "        print('Yes')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class Senpai(Student):\n",
    "#     def is_over_20(self, val):\n",
    "#         super().is_over_20()\n",
    "        \n",
    "#         print('im super student', val)\n",
    "#         #....\n",
    "        \n",
    "# super_student = Senpai('Upperclassman', 10000, 'none@yahoo.com')\n",
    "# super_student.is_over_20('Yeah')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a function that takes two number and returns their product.\n",
    "1. Write a function that takes a number, and returns a list containing all ints between the passed in number and 0.\n",
    "1. Update the student class such that instead of printing the results directly within the methods, instead it returns the appropriate string of whatever the answer should be. Store that answer in a variable, and then print it from wherever you _call_ the method.\n",
    "1. Create a class for `Car`. Add 2-3 member variables, for example `millage`. And add methods that interact on those member variables.\n",
    "1. Come up with your own class use case."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Functions](https://www.tutorialspoint.com/python/python_functions.htm)\n",
    "- [By Reference and By Value](https://www.youtube.com/watch?v=wPZj-dlj00o)\n",
    "- [Classes](https://www.w3schools.com/python/python_classes.asp)\n",
    "- [Inheritance](https://www.python-course.eu/python3_inheritance.php)\n",
    "- [Class Repo](http://github.com/authman/pythonintror)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}