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

# Werkzeug is a collection of libraries that can be used to create a WSGI (Web Server Gateway Interface)
# A gateway in necessary as a web server cannot communicate directly with Python.
# In this case, imports are focused on generating hash code to protect passwords.
from werkzeug.security import generate_password_hash, check_password_hash
import json
from datetime import date

# Define a User Class/Template
# -- A User represents the data we want to manage
class User:    
    # constructor of a User object, initializes the instance variables within object (self)
    def __init__(self, name, uid, password, classOf, dob):
        self._name = name    # variables with self prefix become part of the object, 
        self._uid = uid
        self.set_password(password)
        self.classOf = classOf
        self.dob = dob 

    # a name getter method, extracts name from object
    @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
    
    @property
    def password(self):
        return self._password[0:10] + "..." # because of security only show 1st characters
    
    #getter
    @property
    def classOf(self):
        return self._classOf  
    
    #setter
    @classOf.setter
    def classOf(self, classOf):
        self._classOf = classOf
        
    #getter
    @property
    def dob(self):
        return self._dob
    
    #setter
    @dob.setter
    def dob(self, dob):
        self._dob = dob 
    
    # 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 str(object) in human readable form, uses getter
    def __str__(self):
        return f'name: "{self.name}", id: "{self.uid}", psw: "{self.password}", classOf: "{self.classOf}", dob: "{self.dob}"'

    # output command to recreate the object, uses attribute directly
    def __repr__(self):
        return f'Person(name={self._name}, uid={self._uid}, password={self._password}, classOf: {self._classOf}, dob:{self.dob})'


# tester method to print users
def tester(users, uid, psw, classOf, dob):
    result = None
    for user in users:
        # test for match in database
        if user.uid == uid and user.is_password(psw):  # check for match
            print("* ", end="")
            result = user
        # print using __str__ method
        print(str(user))
    return result
        

# place tester code inside of special if!  This allows include without tester running
if __name__ == "__main__":

    # define user objects
    u1 = User(name='Thomas Edison', uid='toby', password='123toby', classOf='2020', dob='2003-11-4')
    u2 = User(name='Nicholas Tesla', uid='nick', password='123nick', classOf='1993', dob='1979-11-3')
    u3 = User(name='Alexander Graham Bell', uid='lex', password='123lex', classOf='1865', dob='1845-2-21')
    u4 = User(name='Eli Whitney', uid='eli', password='123eli', classOf='1790', dob='1772-4-16')
    u5 = User(name='Hedy Lemarr', uid='hedy', password='123hedy', classOf='2003', dob='1988-1-30')

    # put user objects in list for convenience
    users = [u1, u2, u3, u4, u5]

    # Find user
    print("Test 1, find user 3")
    u = tester(users, u3.uid, "123lex", "1865", "2003-11-4")


    # Change user
    print("Test 2, change user 3")
    u.name = "Sean Yeung"
    u.uid = "sy1055"
    u.set_password("123qwerty")
    u.classOf = "2013"
    u.dob = "1995-1-1"
    u = tester(users, u.uid, "123qwerty", "2013", "1995-1-1")


    # Make dictionary
    ''' 
    The __dict__ in Python represents a dictionary or any mapping object that is used to store the attributes of the object. 
    Every object in Python has an attribute that is denoted by __dict__. 
    Use the json.dumps() method to convert the list of Users to a JSON string.
    '''
    print("Test 3, make a dictionary")
    json_string = json.dumps([user.__dict__ for user in users]) 
    print(json_string)

    print("Test 4, make a dictionary")
    json_string = json.dumps([vars(user) for user in users]) 
    print(json_string)
Test 1, find user 3
name: "Thomas Edison", id: "toby", psw: "sha256$A08...", classOf: "2020", dob: "2003-11-4"
name: "Nicholas Tesla", id: "nick", psw: "sha256$3Xz...", classOf: "1993", dob: "1979-11-3"
* name: "Alexander Graham Bell", id: "lex", psw: "sha256$Gug...", classOf: "1865", dob: "1845-2-21"
name: "Eli Whitney", id: "eli", psw: "sha256$txD...", classOf: "1790", dob: "1772-4-16"
name: "Hedy Lemarr", id: "hedy", psw: "sha256$YTG...", classOf: "2003", dob: "1988-1-30"
Test 2, change user 3
name: "Thomas Edison", id: "toby", psw: "sha256$A08...", classOf: "2020", dob: "2003-11-4"
name: "Nicholas Tesla", id: "nick", psw: "sha256$3Xz...", classOf: "1993", dob: "1979-11-3"
* name: "Sean Yeung", id: "sy1055", psw: "sha256$O9v...", classOf: "2013", dob: "1995-1-1"
name: "Eli Whitney", id: "eli", psw: "sha256$txD...", classOf: "1790", dob: "1772-4-16"
name: "Hedy Lemarr", id: "hedy", psw: "sha256$YTG...", classOf: "2003", dob: "1988-1-30"
Test 3, make a dictionary
[{"_name": "Thomas Edison", "_uid": "toby", "_password": "sha256$A08fS4Pbn76amxjZ$cc18f215302292f76682dcd336c34f37306f9252c6da4b8f2ccb1670d589065f", "_classOf": "2020", "_dob": "2003-11-4"}, {"_name": "Nicholas Tesla", "_uid": "nick", "_password": "sha256$3XzD7coJci5cDQOW$2aebb38a2485d9cbab9fe87c2a4caae8c12dd88e3edd8ed14e9af30fea3a11a7", "_classOf": "1993", "_dob": "1979-11-3"}, {"_name": "Sean Yeung", "_uid": "sy1055", "_password": "sha256$O9vJAUhh78PPqm0T$efa26a17425fa5894938ae59dfda3a1a7b8bd814ae26e3f46cc9c0bda4a575da", "_classOf": "2013", "_dob": "1995-1-1"}, {"_name": "Eli Whitney", "_uid": "eli", "_password": "sha256$txDu4ef0yJYIjE3b$23c4080ffd962965ec61fe49418ccddafbe29d7abe414418862e10ff3b088026", "_classOf": "1790", "_dob": "1772-4-16"}, {"_name": "Hedy Lemarr", "_uid": "hedy", "_password": "sha256$YTGwu50uIAXVLl8L$96d2f13b3208c6b008c996464969ccf3e7d2a4dbc296fc1a8a6e833828c0a1d0", "_classOf": "2003", "_dob": "1988-1-30"}]
Test 4, make a dictionary
[{"_name": "Thomas Edison", "_uid": "toby", "_password": "sha256$A08fS4Pbn76amxjZ$cc18f215302292f76682dcd336c34f37306f9252c6da4b8f2ccb1670d589065f", "_classOf": "2020", "_dob": "2003-11-4"}, {"_name": "Nicholas Tesla", "_uid": "nick", "_password": "sha256$3XzD7coJci5cDQOW$2aebb38a2485d9cbab9fe87c2a4caae8c12dd88e3edd8ed14e9af30fea3a11a7", "_classOf": "1993", "_dob": "1979-11-3"}, {"_name": "Sean Yeung", "_uid": "sy1055", "_password": "sha256$O9vJAUhh78PPqm0T$efa26a17425fa5894938ae59dfda3a1a7b8bd814ae26e3f46cc9c0bda4a575da", "_classOf": "2013", "_dob": "1995-1-1"}, {"_name": "Eli Whitney", "_uid": "eli", "_password": "sha256$txDu4ef0yJYIjE3b$23c4080ffd962965ec61fe49418ccddafbe29d7abe414418862e10ff3b088026", "_classOf": "1790", "_dob": "1772-4-16"}, {"_name": "Hedy Lemarr", "_uid": "hedy", "_password": "sha256$YTGwu50uIAXVLl8L$96d2f13b3208c6b008c996464969ccf3e7d2a4dbc296fc1a8a6e833828c0a1d0", "_classOf": "2003", "_dob": "1988-1-30"}]

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(2005, 10, 30)
age = calculate_age(dob)
print(age)
print(dob)
17
2005-10-30

Using Hack Helper for Age

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))
    
    #getter
    @property
    def classOf(self):
        return self._classOf  
    
    #setter
    @classOf.setter
    def classOf(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,
            "classOf": self.classOf
        }
        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}, classOf={self._classOf})'
    

if __name__ == "__main__":
    u1 = User(name='Kaylee Hou', uid='kaylee', password='kaylee88', dob=date(2005, 10, 30), classOf='2023')
    u2 = User(name='Theodore Huntalas', uid='Theo', password='theoh123', dob=date(2006, 1, 31), classOf='2024')
    u3 = User(name='Haeryn Yu', uid='haeryn', password='hae1ryn', dob=date(2007, 4, 29), classOf='2025')
    u4 = User(name='Ellie Pang', uid='ellie', password='e11ie', dob=date(2007, 11, 1), classOf='2025')

    print("Print users info:")
    print(u1)
    print(u2)
    print(u3)
    print(u4)
    
    print("\nJSON ready string:\n", u1, u2, u3, u4,"\n") 
    print("Raw Variables of object:\n", vars(u1), "\n") 
    print("Raw Attributes and Methods of object:\n", dir(u1), "\n")
    print("Representation to Re-Create the object:\n", repr(u1), "\n") 
Print users info:
{"name": "Kaylee Hou", "uid": "kaylee", "dob": "10-30-2005", "age": 17, "classOf": "2023"}
{"name": "Theodore Huntalas", "uid": "Theo", "dob": "01-31-2006", "age": 16, "classOf": "2024"}
{"name": "Haeryn Yu", "uid": "haeryn", "dob": "04-29-2007", "age": 15, "classOf": "2025"}
{"name": "Ellie Pang", "uid": "ellie", "dob": "11-01-2007", "age": 15, "classOf": "2025"}

JSON ready string:
 {"name": "Kaylee Hou", "uid": "kaylee", "dob": "10-30-2005", "age": 17, "classOf": "2023"} {"name": "Theodore Huntalas", "uid": "Theo", "dob": "01-31-2006", "age": 16, "classOf": "2024"} {"name": "Haeryn Yu", "uid": "haeryn", "dob": "04-29-2007", "age": 15, "classOf": "2025"} {"name": "Ellie Pang", "uid": "ellie", "dob": "11-01-2007", "age": 15, "classOf": "2025"} 

Raw Variables of object:
 {'_name': 'Kaylee Hou', '_uid': 'kaylee', '_password': 'sha256$XDLw2Gqnz2oXFPuz$3914bcc056b4eb2604c8c6db7d32d79d013e950b763a80e8c5c556ece053fb4c', '_dob': datetime.date(2005, 10, 30), '_classOf': '2023'} 

Raw Attributes and Methods of object:
 ['__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'] 

Representation to Re-Create the object:
 User(name=Kaylee Hou, uid=kaylee, password=sha256$XDLw2Gqnz2oXFPuz$3914bcc056b4eb2604c8c6db7d32d79d013e950b763a80e8c5c556ece053fb4c,dob=2005-10-30, classOf=2023) 

Class Design for My Project

import json
class userInfo:    

    def __init__(user, firstName, lastName, extracurricular, hoursPerWeek, coachName):
        user._firstName = firstName    # variables with self prefix become part of the object, 
        user._lastName = lastName
        user._extracurricular = extracurricular
        user._hoursPerWeek = hoursPerWeek
        user._coachName = coachName
    
    # first name getter 
    @property
    def firstName(user):
        return user._firstName
    
    # first name setter 
    @firstName.setter
    def firstName(user, firstName):
        user._firstName = firstName
    
    # last name getter 
    @property
    def lastName(user):
        return user._lastName
    
    # last name setter 
    @lastName.setter
    def lastName(user, lastName):
        user._lastName = lastName
    
    #extracurricular getter 
    @property
    def extracurricular(user):
        return user._extracurricular
    
    #extracurricular setter
    @extracurricular.setter
    def extracurricular(user, extracurricular):
        user._extracurricular = extracurricular
    
    #hours per week getter    
    @property
    def hoursPerWeek(user):
        return user._hoursPerWeek
    
    # hoursPerWeek setter
    @hoursPerWeek.setter
    def hoursPerWeek(user, hoursPerWeek):
        user._hoursPerWeek = hoursPerWeek
        
    #coach name getter    
    @property
    def coachName(user):
        return user._coachName
    
    # coach name setter
    @coachName.setter
    def coachName(user,coachName):
        user._coachName = coachName
        
    # output content using str(object) in human readable form, uses getter
    def __str__(user):
        return f'first name: "{user.firstName}", last name: "{user.lastName}", extracurricular: "{user.extracurricular}", hours per week: "{user.hoursPerWeek}", coach name: "{user.coachName}"'

    # output command to recreate the object, uses attribute directly
    def __repr__(user):
        return f'Person(first name={user._firstName}, last name={user._lastName}, extracurricular={user._extracurricular}, hours per week: {user._hoursPerWeek}, coach name:{user.coachName})'

# tester method to print users
def tester(user, firstName, lastName, extracurricular, hoursPerWeek, coachName):
    result = None
    for user in users:
        print(str(user))
    return result
        

# place tester code inside of special if!  This allows include without tester running
if __name__ == "__main__":

    # define user objects
    u1 = userInfo(firstName='Kaylee', lastName='Hou', extracurricular='Guitar', hoursPerWeek='5', coachName='N/A')
    u2 = userInfo(firstName='Theo', lastName='Huntalas', extracurricular='Skateboarding', hoursPerWeek='3', coachName='N/A')
    u3 = userInfo(firstName='Ellie', lastName='Pang', extracurricular='Soccer', hoursPerWeek='8', coachName='Coach Robby')
    u4 = userInfo(firstName='Haeryn', lastName='Yu', extracurricular='Kickboxing', hoursPerWeek='2', coachName='Coach Burr')
        
    # put user objects in list for convenience
    users = [u1, u2, u3, u4]

    print("Users in Database in JSON:\n\n",u1) 
    print(u2)
    print(u3)
    print(u4)
Users in Database in JSON:

 first name: "Kaylee", last name: "Hou", extracurricular: "Guitar", hours per week: "5", coach name: "N/A"
first name: "Theo", last name: "Huntalas", extracurricular: "Skateboarding", hours per week: "3", coach name: "N/A"
first name: "Ellie", last name: "Pang", extracurricular: "Soccer", hours per week: "8", coach name: "Coach Robby"
first name: "Haeryn", last name: "Yu", extracurricular: "Kickboxing", hours per week: "2", coach name: "Coach Burr"