Model and Object-Oriented Programming

• Class and Object Terms
• Class and Object Code
• Hacks
• Start Code for Hacks

Class and Object Terms

The foundations of Object-Oriented Programming is defining a Class

• In Object-Oriented Programming (OOP), a class is a blueprint for creating an Object. (a data structure). An Object is used like many other Python variables.
• A Class has ...
  • a collection of data, these are called Attributes and in Python are pre-fixed using the keyword self
  • a collection of Functions/Procedures. These are called *Methods when they exist inside a Class definition.
• An Object is created from the Class/Template. Characteristics of objects ...
  • an Object is an Instance of the Class/Template
  • there can be many Objects created from the same Class
  • each Object contains its own Instance Data
  • the data is setup by the Constructor, this is the "init" method in a Python class
  • all methods in the Class/Template become part of the Object, methods are accessed using dot notation (object.method())
• A Python Class allow for the definition of @ decorators, these allow access to instance data without the use of functions ...
  • @property decorator (aka getter). This enables developers to reference/get instance data in a shorthand fashion (object.name versus object.get_name())
  • @name.setter decorator (aka setter). This enables developers to update/set instance data in a shorthand fashion (object.name = "John" versus object.set_name("John"))
  • observe all instance data (self._name, self.email ...) are prefixed with "", this convention allows setters and getters to work with more natural variable name (name, email ...)

Class and Object Code

from werkzeug.security import generate_password_hash, check_password_hash
from datetime import date
import json

class User:    

    def __init__(self, name, uid, password, dob, classOf):
        self._name = name    # variables with self prefix become part of the object, 
        self._uid = uid
        self.set_password(password)
        self._dob = dob
        self._classOf = classOf
    
    @property
    def name(self):
        return self._name
    
    # a setter function, allows name to be updated after initial object creation
    @name.setter
    def name(self, name):
        self._name = name
    
    # a getter method, extracts email from object
    @property
    def uid(self):
        return self._uid
    
    # a setter function, allows name to be updated after initial object creation
    @uid.setter
    def uid(self, uid):
        self._uid = uid
        
    # check if uid parameter matches user id in object, return boolean
    def is_uid(self, uid):
        return self._uid == uid
    
    # dob property is returned as string, to avoid unfriendly outcomes
    @property
    def dob(self):
        dob_string = self._dob.strftime('%m-%d-%Y')
        return dob_string
    
    # dob should be have verification for type date
    @dob.setter
    def dob(self, dob):
        self._dob = dob
        
    # age is calculated and returned each time it is accessed
    @property
    def age(self):
        today = date.today()
        return today.year - self._dob.year - ((today.month, today.day) < (self._dob.month, self._dob.day))

    @property
    def classOf(self):
        return self._classOf
    
    # a setter function, allows classOf to be updated after initial object creation
    @classOf.setter
    def name(self, classOf):
        self._classOf = classOf
    
    # dictionary is customized, removing password for security purposes
    @property
    def dictionary(self):
        dict = {
            "name" : self.name,
            "uid" : self.uid,
            "dob" : self.dob,
            "age" : self.age
        }
        return dict
    
    # update password, this is conventional setter
    def set_password(self, password):
        """Create a hashed password."""
        self._password = generate_password_hash(password, method='sha256')

    # check password parameter versus stored/encrypted password
    def is_password(self, password):
        """Check against hashed password."""
        result = check_password_hash(self._password, password)
        return result
        
    
    # output content using json dumps, this is ready for API response
    def __str__(self):
        return json.dumps(self.dictionary)
    
    # output command to recreate the object, uses attribute directly
    def __repr__(self):
        return f'User(name={self._name}, uid={self._uid}, password={self._password},dob={self._dob})'
    

if __name__ == "__main__":
    u1 = User(name='Thomas Edison', uid='toby', password='123toby', dob=date(1847, 2, 11), classOf='1864')

    
    print("JSON ready string:\n", u1, "\n") 
    print("unmodified variables of the object:\n", vars(u1), "\n") 
    print("umodified attributes:\n", dir(u1), "\n")
    print("recreatable piece of object:\n", repr(u1), "\n") 

    

JSON ready string:
 {"name": "1864", "uid": "toby", "dob": "02-11-1847", "age": 175} 

unmodified variables of the object:
 {'_name': 'Thomas Edison', '_uid': 'toby', '_password': 'sha256$6ydvgFvczhynVr3z$62cdcdc65e57e44a96f77d6538e024f2e047ee59999b9cc1c23bb7a1f4a03b77', '_dob': datetime.date(1847, 2, 11), '_classOf': '1864'} 

umodified attributes:
 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_classOf', '_dob', '_name', '_password', '_uid', 'age', 'classOf', 'dictionary', 'dob', 'is_password', 'is_uid', 'name', 'set_password', 'uid'] 

recreatable piece of object:
 User(name=Thomas Edison, uid=toby, password=sha256$6ydvgFvczhynVr3z$62cdcdc65e57e44a96f77d6538e024f2e047ee59999b9cc1c23bb7a1f4a03b77,dob=1847-02-11) 

class = user u1 = object and will have all features we set up for class

Hacks

Add new attributes/variables to the Class. Make class specific to your CPT work.

• Add classOf attribute to define year of graduation
  • Add setter and getter for classOf
• Add dob attribute to define date of birth
  • This will require investigation into Python datetime objects as shown in example code below
  • Add setter and getter for dob
• Add instance variable for age, make sure if dob changes age changes
  • Add getter for age, but don't add/allow setter for age
• Update and format tester function to work with changes

Start a class design for each of your own Full Stack CPT sections of your project

• Use new code cell in this notebook
• Define init and self attributes
• Define setters and getters
• Make a tester

Start Code for Hacks

from datetime import date


def calculate_age(born):
    today = date.today()
    return today.year - born.year - ((today.month, today.day) < (born.month, born.day))

dob = date(2006, 8, 7)
age = calculate_age(dob)
print(age)

16

MY GAME FEATURES: master mind game:

-for() loops to create grid of circles -if() statements to determine if all four markers are placed -if() statements to determine if input sequence is correct -random color variables are assigned new values depending on sequence input -randomly generated sequence