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

# 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):
        self._name = name    # variables with self prefix become part of the object, 
        self._uid = uid
        self.set_password(password)

    # 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

    # 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}"'

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


# tester method to print users
def tester(users, uid, psw):
    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')
    u2 = User(name='Nicholas Tesla', uid='nick', password='123nick')
    u3 = User(name='Alexander Graham Bell', uid='lex', password='123lex')
    u4 = User(name='Eli Whitney', uid='eli', password='123eli')
    u5 = User(name='Hedy Lemarr', uid='hedy', password='123hedy')

    # 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")


    # Change user
    print("Test 2, change user 3")
    u.name = "John Mortensen"
    u.uid = "jm1021"
    u.set_password("123qwerty")
    u = tester(users, u.uid, "123qwerty")


    # 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$PzB..."
name: "Nicholas Tesla", id: "nick", psw: "sha256$VVj..."
* name: "Alexander Graham Bell", id: "lex", psw: "sha256$1bg..."
name: "Eli Whitney", id: "eli", psw: "sha256$aP0..."
name: "Hedy Lemarr", id: "hedy", psw: "sha256$qT5..."
Test 2, change user 3
name: "Thomas Edison", id: "toby", psw: "sha256$PzB..."
name: "Nicholas Tesla", id: "nick", psw: "sha256$VVj..."
* name: "John Mortensen", id: "jm1021", psw: "sha256$kb6..."
name: "Eli Whitney", id: "eli", psw: "sha256$aP0..."
name: "Hedy Lemarr", id: "hedy", psw: "sha256$qT5..."
Test 3, make a dictionary
[{"_name": "Thomas Edison", "_uid": "toby", "_password": "sha256$PzB5YQK8zCKG2Gb0$56407dced0f75ed54b2d50724ec92243f14e3d1d1429a2ecb2e5c9833fced67f"}, {"_name": "Nicholas Tesla", "_uid": "nick", "_password": "sha256$VVj0n7rlkXIAhM7K$a919c46fbbfc261fb40f5dde9eaeef510ece8c3ad795acceaf3c108e26e54e81"}, {"_name": "John Mortensen", "_uid": "jm1021", "_password": "sha256$kb6YzWyqV75jJzNv$38dc0aa0752c1f979ccccb2449356df8ae3d16206df0a237a6d19b7e3d8bef56"}, {"_name": "Eli Whitney", "_uid": "eli", "_password": "sha256$aP0gTrunAAWQdJzi$dfc1ab499a5c7021dc52a22f4e7ca2680b60e7a38e72544c7a7000f168544d46"}, {"_name": "Hedy Lemarr", "_uid": "hedy", "_password": "sha256$qT5XEnjPcz7KeM7T$2ad75509a4397b92c838623ed61286f1e8b858dddb837b1c4358bbdd9af86439"}]
Test 4, make a dictionary
[{"_name": "Thomas Edison", "_uid": "toby", "_password": "sha256$PzB5YQK8zCKG2Gb0$56407dced0f75ed54b2d50724ec92243f14e3d1d1429a2ecb2e5c9833fced67f"}, {"_name": "Nicholas Tesla", "_uid": "nick", "_password": "sha256$VVj0n7rlkXIAhM7K$a919c46fbbfc261fb40f5dde9eaeef510ece8c3ad795acceaf3c108e26e54e81"}, {"_name": "John Mortensen", "_uid": "jm1021", "_password": "sha256$kb6YzWyqV75jJzNv$38dc0aa0752c1f979ccccb2449356df8ae3d16206df0a237a6d19b7e3d8bef56"}, {"_name": "Eli Whitney", "_uid": "eli", "_password": "sha256$aP0gTrunAAWQdJzi$dfc1ab499a5c7021dc52a22f4e7ca2680b60e7a38e72544c7a7000f168544d46"}, {"_name": "Hedy Lemarr", "_uid": "hedy", "_password": "sha256$qT5XEnjPcz7KeM7T$2ad75509a4397b92c838623ed61286f1e8b858dddb837b1c4358bbdd9af86439"}]

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(2004, 12, 31)
age = calculate_age(dob)
print(age)
class Student:
    def __init__(self, name, age, year, date_of_birth):
        self.name = name
        self.age = age
        self.class_of = year
        self.date_of_birth = date_of_birth
        
    @property
    def get_class_of(self):
        return self.class_of

    @get_class_of.setter
    def set_class_of(self, year):
        self.class_of = year
    
    @property
    def get_date_of_birth(self):
        return self.date_of_birth

    @get_date_of_birth.setter
    def set_date_of_birth(self, date):
        self.date_of_birth = date

# Create a list to store the students
students = []

# Create and add the first student
s = Student("Tanay", 15, 2025, "07-24-2007")
students.append(s)

# Create and add more students
students.append(Student("John", 16, 2026, "01-01-2006"))
students.append(Student("Mary", 17, 2027, "02-14-2005"))

# Print the information for all students
for student in students:
    print(student.name)
    print(student.age)
    print(student.class_of)
    print(student.date_of_birth)
Tanay
15
2025
07-24-2007
John
16
2026
01-01-2006
Mary
17
2027
02-14-2005
import json

class signupInfo:    

    def __init__(user, firstName, lastName, age, description,):
        user._firstName = firstName    # variables with self prefix become part of the object, 
        user._lastName = lastName
        user.age = age
        user.description = description

    # 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
    
    #age getter 
    @property
    def ages(user):
        return user._age
    
    #age setter
    @ages.setter
    def ages(user, age):
        user._age = age
    
    #description getter    
    @property
    def descriptions(user):
        return user._description
    
    # description setter
    @descriptions.setter
    def descriptions(user, description):
        user._age = description
        
    # output content using str(object) in human readable form, uses getter
    def __str__(user):
        return f'first name: "{user.firstName}", last name: "{user.lastName}", age: "{user.age}", description: "{user.description}'

    # output command to recreate the object, uses attribute directly
    def __repr__(user):
        return f'Person(first name={user._firstName}, last name={user._lastName}, age={user._age}, description: {user._description}'

# tester method to print users
def tester(user, firstName, lastName, age, description):
    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 = signupInfo(firstName='Yuri', lastName='S', age='16', description='I am a hard worker, I have worked in the fast food industry for 1/2 a year')
    u2 = signupInfo(firstName='Tanay', lastName='P', age='15', description='I am looking for a job, I want to start creating passive income')
    u3 = signupInfo(firstName='Aniket', lastName='C', age='15', description='I am looking forward to working with Burger Bytes, I am an experienced cook and cashier')
    u4 = signupInfo(firstName='Soham', lastName='K', age='15', description='I have worked in the fast food industry for a few years now. I have worked at multiple food chains, but burger bytes is calling for me.')
        
    # 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: "Yuri", last name: "S", age: "16", description: "I am a hard worker, I have worked in the fast food industry for 1/2 a year
first name: "Tanay", last name: "P", age: "15", description: "I am looking for a job, I want to start creating passive income
first name: "Aniket", last name: "C", age: "15", description: "I am looking forward to working with Burger Bytes, I am an experienced cook and cashier
first name: "Soham", last name: "K", age: "15", description: "I have worked in the fast food industry for a few years now. I have worked at multiple food chains, but burger bytes is calling for me.