Model and Object-Oriented Programming
Object Oriented Programming is a part of learning Python. The objective of this blog is to introduce OOP with the intention of PBL task to create a database. The foundations for a database is defining a Class and understanding instance data and methods. A database is often a focus of backend coding as it will store persistent data, that can be recalled after the immediate session is closed.
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 ...)
# 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)
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 cellin this notebook- Define init and self attributes
- Define setters and getters
- Make a tester
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:", age)
# def __init__(self, gradyear):
#self._gradyear = gradyear
#@property
#def gradyear(self):
# return self._gradyear
#@gradyear.setter
#def gradyear(self, gradyear):
# self._gradyear = gradyear
#student = classOf(gradyear=2024)
#print("Graduation Year:", student.gradyear)
#def calculate_age(born):
# today = date.today()
# return today.year - born.year - ((today.month, today.day) < (born.month, born.day))
#def classOF(age):
# today = date.today()
# tillgrad = 18 - age
# gradyear = today.year + tillgrad
# return gradyear
#dob = date(2006, 5, 16)
#age = calculate_age(dob)
#graduationyear = classOf(age)
#print("age:", age, "graduation year:", graduationyear)
#import json
#class Student:
# constructor of a User object, initializes the instance variables within object (self)
# def __init__(self, name, dob, gradyear, age):
# self._name = name # variables with self prefix become part of the object,
# self._dob = dob
# self._gradyear = gradyear
# self._age = age
# 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 name getter method, extracts birthday from object
#@property
#def dob(self):
# return self._dob
# a setter function, allows dob to be updated after initial object creation
#@dob.setter
#def dob(self, name):
# self._dob = dob
# def calculate_age(born):
# today = date.today()
# return today.year - born.year - ((today.month, today.day) < (born.month, born.day))
# a name getter method, extracts graduation year from object
#@property
#def gradyear(self):
# return self._gradyear
# a setter function, allows grad year to be updated after initial object creation
#@gradyear.setter
#def gradyear(self, name):
# self._gradyear = gradyear
#@property
#def age(self):
# return self._age
# dob = date(2004, 12, 31)
# age = calculate_age(dob)
# print(age)
# place tester code inside of special if! This allows include without tester running
#if __name__ == "__main__":
# define user objects
# s1 = Student(name='Ava Carlson', dob='2006, 05, 16', gradyear='2024', age='16')
# s2 = Student(name='Alexa Carlson', dob='2006, 05, 16', gradyear='2024', age='16')
# s3 = Student(name='Dylan Carlson', dob='2001, 08, 15', gradyear='2020', age='21')
# s4 = Student(name='Grant Carlson', dob='2004, 03, 23', gradyear='2022', age='18')
# put user objects in list for convenience
#students = [s1, s2, s3, s4]
# Find user
#print("Test 1, find user 3")
#s = tester(students, s3.gradyear, "2024")
# Change user
#print("Test 2, change user 3")
#s.name = "Brian Carlson"
#s.gradyear = "1995"
#s = tester(users, s.gradyear, "2000")
# 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([student.__dict__ for student in students])
#print(json_string)
#print("Test 4, make a dictionary")
#json_string = json.dumps([vars(student) for student in students])
#print(json_string)
# 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, gradCLASS, dob, age):
self._name = name # variables with self prefix become part of the object,
self._uid = uid
self._gradCLASS = gradCLASS
self._dob = dob
self._age = age
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
# a name getter method, extracts name from object
@property
def gradCLASS(self):
return self._gradCLASS
# a setter function, allows name to be updated after initial object creation
@name.setter
def gradCLASS(self, gradCLASS):
self._gradCLASS = gradCLASS
# a name getter method, extracts name from object
@property
def age(self):
return self._age
# a setter function, allows name to be updated after initial object creation
@name.setter
def age(self, age):
self._age = age
# a name getter method, extracts name from object
@property
def dob(self):
return self._dob
# a setter function, allows name to be updated after initial object creation
@name.setter
def dob(self, dob):
self._dob = dob
@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})'
from datetime import date
def calculate_age(born):
today = date.today()
return today.year - born.year - ((today.month, today.day) < (born.month, born.day))
# tester method to print users
def tester(users, uid, psw, gradCLASS, dob, age):
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='Dylan Carlson', uid='dylan', password='123dylan', gradCLASS='2020', dob=(2001, 8, 15), age=calculate_age(date(2001, 8, 15)))
u2 = User(name='Grant Carlson', uid='grant', password='123grant', gradCLASS='2022', dob=(2004, 3, 24), age=calculate_age(date(2004, 3, 24)))
u3 = User(name='Neil Carlson', uid='neil', password='123neil', gradCLASS='1988', dob=(1970, 7, 3), age=calculate_age(date(1970, 7, 3)))
u4 = User(name='Leslie Carlson', uid='les', password='123les', gradCLASS='1988', dob=(1970, 9, 7), age=calculate_age(date(1970, 9, 7)))
u5 = User(name='Ava Carlson', uid='ava', password='123ava', gradCLASS='2024', dob=(2006, 5, 16), age=calculate_age(date(2006, 5, 16)))
# 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, "123neil", u3.gradCLASS, u3.dob, u3.age)
# Change user
print("Test 2, change user 3")
u.name = "John Mortensen"
u.uid = "jm1021"
u.set_password("123qwerty")
u.gradCLASS = '2024'
dob = '11-2-16'
u = tester(users, u.uid, "123qwerty", u.gradCLASS, u.dob, u.age)
# 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)
# 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, gradCLASS, dob, age):
self._name = name # variables with self prefix become part of the object,
self._uid = uid
self._gradCLASS = gradCLASS
self._dob = dob
self._age = age
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
# a name getter method, extracts name from object
@property
def gradCLASS(self):
return self._gradCLASS
# a setter function, allows name to be updated after initial object creation
@name.setter
def gradCLASS(self, gradCLASS):
self._gradCLASS = gradCLASS
# a name getter method, extracts name from object
@property
def age(self):
return self._age
# a setter function, allows name to be updated after initial object creation
@name.setter
def age(self, age):
self._age = age
# a name getter method, extracts name from object
@property
def dob(self):
return self._dob
# a setter function, allows name to be updated after initial object creation
@name.setter
def dob(self, dob):
self._dob = dob
@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})'
from datetime import date
def calculate_age(born):
today = date.today()
return today.year - born.year - ((today.month, today.day) < (born.month, born.day))
# tester method to print users
def tester(users, uid, psw, gradCLASS, dob, age):
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='Dylan Carlson', uid='dylan', password='123dylan', gradCLASS='2020', dob=(2001, 8, 15), age=calculate_age(date(2001, 8, 15)))
u2 = User(name='Grant Carlson', uid='grant', password='123grant', gradCLASS='2022', dob=(2004, 3, 24), age=calculate_age(date(2004, 3, 24)))
u3 = User(name='Neil Carlson', uid='neil', password='123neil', gradCLASS='1989', dob=(1970, 7, 3), age=calculate_age(date(1970, 7, 3)))
u4 = User(name='Leslie Carlson', uid='les', password='123les', gradCLASS='1989', dob=(1970, 9, 7), age=calculate_age(date(1970, 9, 7)))
u5 = User(name='Ava Carlson', uid='ava', password='123ava', gradCLASS='2024', dob=(2006, 5, 16), age=calculate_age(date(2006, 5, 16)))
# 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, "123neil", u3.gradCLASS, u3.dob, u3.age)
# Change user
print("Test 2, change user 3")
u.name = "John Mortensen"
u.uid = "jm1021"
u.set_password("123qwerty")
u.gradCLASS = '2024'
dob = '11-2-16'
u = tester(users, u.uid, "123qwerty", u.gradCLASS, u.dob, u.age)
# 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)
# this may be useful for our project
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, gradCLASS):
self._name = name # variables with self prefix become part of the object,
self._uid = uid
self.set_password(password)
self._dob = dob
self._gradCLASS = gradCLASS
@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 gradCLASS(self):
return self._gradCLASS
# a setter function, allows name to be updated after initial object creation
@gradCLASS.setter
def gradCLASS(self, gradCLASS):
self._gradCLASS = gradCLASS
# 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,
"class" : self.gradCLASS
}
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)
if __name__ == "__main__":
u1 = User(name='Thomas Edison', uid='toby', password='123toby', dob=date(1847, 2, 11), gradCLASS='1868')
print("JSON ready string:\n", u1, "\n")
print("Raw Variables of object:\n", vars(u1), "\n")
print("Raw Attributes and Methods of object:\n", dir(u1), "\n")