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})'
    
    def __dir__(self):
        return ["name", "uid"]


# 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$gfn..."
name: "Nicholas Tesla", id: "nick", psw: "sha256$TCT..."
* name: "Alexander Graham Bell", id: "lex", psw: "sha256$lHl..."
name: "Eli Whitney", id: "eli", psw: "sha256$DpD..."
name: "Hedy Lemarr", id: "hedy", psw: "sha256$z9X..."
Test 2, change user 3
name: "Thomas Edison", id: "toby", psw: "sha256$gfn..."
name: "Nicholas Tesla", id: "nick", psw: "sha256$TCT..."
* name: "John Mortensen", id: "jm1021", psw: "sha256$fvT..."
name: "Eli Whitney", id: "eli", psw: "sha256$DpD..."
name: "Hedy Lemarr", id: "hedy", psw: "sha256$z9X..."
Test 3, make a dictionary
[{"_name": "Thomas Edison", "_uid": "toby", "_password": "sha256$gfnYfIgbX9G9wOM0$0de2c63a1d0da6e429dc466560f2a960e34378f1939bcbbe41068dfabd2188c9"}, {"_name": "Nicholas Tesla", "_uid": "nick", "_password": "sha256$TCTqqpsbv0HTeSdS$6ea1236e02f4185e61bb0b65c5cf840468d6b45a789b88b8db2d65fe0c8758fc"}, {"_name": "John Mortensen", "_uid": "jm1021", "_password": "sha256$fvTQGd02jvUOoOlo$be1cab107ae51b0f32bb4f2799917e08f41b09befb3ba97a375f81533eb494b0"}, {"_name": "Eli Whitney", "_uid": "eli", "_password": "sha256$DpDrCkEof8fVKnGR$a89bcbcf0010d56b54f3226eeeac7f0977b97ce0a80a464a499bfbb8f4091c88"}, {"_name": "Hedy Lemarr", "_uid": "hedy", "_password": "sha256$z9XGDt3tUC6hscFM$aa25fa3ed1f4d82f4ed01e8e4efd009971bbe072a8b9fa0d80edc12ab29ad5c1"}]
Test 4, make a dictionary
[{"_name": "Thomas Edison", "_uid": "toby", "_password": "sha256$gfnYfIgbX9G9wOM0$0de2c63a1d0da6e429dc466560f2a960e34378f1939bcbbe41068dfabd2188c9"}, {"_name": "Nicholas Tesla", "_uid": "nick", "_password": "sha256$TCTqqpsbv0HTeSdS$6ea1236e02f4185e61bb0b65c5cf840468d6b45a789b88b8db2d65fe0c8758fc"}, {"_name": "John Mortensen", "_uid": "jm1021", "_password": "sha256$fvTQGd02jvUOoOlo$be1cab107ae51b0f32bb4f2799917e08f41b09befb3ba97a375f81533eb494b0"}, {"_name": "Eli Whitney", "_uid": "eli", "_password": "sha256$DpDrCkEof8fVKnGR$a89bcbcf0010d56b54f3226eeeac7f0977b97ce0a80a464a499bfbb8f4091c88"}, {"_name": "Hedy Lemarr", "_uid": "hedy", "_password": "sha256$z9XGDt3tUC6hscFM$aa25fa3ed1f4d82f4ed01e8e4efd009971bbe072a8b9fa0d80edc12ab29ad5c1"}]

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

Completed Hacks

Modifying Mr. Mort's hack helper 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

    @property
    def classOf(self):
        return self._classOf
    
    # a setter function, allows name to be updated after initial object creation
    @classOf.setter
    def classOf(self, classOf):
        self._classOf = classOf
        
    # 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))
    
    # 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 of" : 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)
        

if __name__ == "__main__":
    u1 = User(name='Thomas Edison', uid='toby', password='123toby', dob=date(1847, 2, 11), classOf='1904')
    u2 = User(name='Quandale Dingle', uid='QDingle', password='123Dingle', dob=date(1978, 1, 10), classOf='1996')
    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")
    #organize users in a list
    users = [u1, u2]
    print("User records in JSON (dictionary) format:")
    # Format data so that its ready to be stored in the database
    print(json.dumps(str([user.__dict__ for user in users])))
JSON ready string:
 {"name": "Thomas Edison", "uid": "toby", "dob": "02-11-1847", "age": 175, "class of": "1904"} 

Raw Variables of object:
 {'_name': 'Thomas Edison', '_uid': 'toby', '_password': 'sha256$noT9lMk6sX6uvZ2I$c5b7c2128bcb2f96c5f48cbc95dc195c80b7ef68b7bf7ed718e4ce1c549c9ac2', '_dob': datetime.date(1847, 2, 11), '_classOf': '1904'} 

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'] 

User records in JSON format:
"[{'_name': 'Thomas Edison', '_uid': 'toby', '_password': 'sha256$noT9lMk6sX6uvZ2I$c5b7c2128bcb2f96c5f48cbc95dc195c80b7ef68b7bf7ed718e4ce1c549c9ac2', '_dob': datetime.date(1847, 2, 11), '_classOf': '1904'}, {'_name': 'Quandale Dingle', '_uid': 'QDingle', '_password': 'sha256$Mt9oinmZWfnvdr50$aa7cbd39f696cce271800ee21f094a8622ff4aa19db67817c4c3ff61dbe66f60', '_dob': datetime.date(1978, 1, 10), '_classOf': '1996'}]"

Implementing Classes into our CPT Idea

import json

class Gamer:
    # Constructor:
    def __init__(self, ReactionTime, HiLo, Pong, Snake, Tokens):
        self._ReactionTime = ReactionTime
        self._HiLo = HiLo
        self._Pong = Pong
        self._Snake = Snake
        self._Tokens = HiLo + Pong + Snake + ReactionTime
    
    # Getters:
    @property
    def ReactionTime(self):
        return self._ReactionTime
    
    @property
    def HiLo(self):
        return self._HiLo

    @property
    def Pong(self):
        return self._Pong   

    @property
    def Snake(self):
        return self._Snake 
    
    @property
    def Tokens(self):
        return self._Tokens
   
    # Setters    
    @ReactionTime.setter
    def Weight(self, ReactionTime):
        self._ReactionTime = ReactionTime 

    @HiLo.setter
    def HiLo(self, HiLo):
        self._Bench = HiLo

    @Pong.setter
    def Pong(self, Pong):
        self._Pong = Pong

    @Snake.setter
    def Snake(self, Snake):
        self._Press = Snake

    @Tokens.setter
    def Tokens(self, Tokens):
        self.Pushup = Tokens

    @property
    def dictionary(self):
        dict = {
            "ReactionTime" : self.ReactionTime,
            "HiLo" : self.HiLo,
            "Pong" : self.Pong,
            "Snake" : self.Snake,
            "Tokens" : self.Tokens,
        }
        return dict

    def __str__(self):
        return json.dumps(self.dictionary)
    
    def __repr__(self):
        return f'Gamer(ReactionTime={self._ReactionTime}, HiLo={self._HiLo}, Pong={self._Pong}, Snake={self._Snake}, Tokens={self._Tokens})'

Gamer1 = Gamer(15, 22, 10, 4, 51)
Gamer2 = Gamer(22, 11, 9, 44, 87)
print("Gamer 1 ReactionTime Score:", Gamer1.ReactionTime, "points")
print("Gamer 1 HiLo Score:", Gamer1.HiLo, "points")
print("Gamer 1 Pong Score:", Gamer1.Pong, "points")
print("Gamer 1 Snake Score:", Gamer1.Snake, "points")
print("Gamer 1 Total:", Gamer1.Tokens, "tokens")
print("Gamer 2 ReactionTime Score:", Gamer2.ReactionTime, "points")
print("Gamer 2 HiLo Score:", Gamer2.HiLo, "points")
print("Gamer 2 Pong Score:", Gamer2.Pong, "points")
print("Gamer 2 Snake Score:", Gamer2.Snake, "points")
print("Gamer 2 Total:", Gamer2.Tokens, "tokens")
print(Gamer1)
print(Gamer2)

# Organize gamers in a list
# When more gamer records are created, append them to this list
gamers = [Gamer1, Gamer2]


print("")
print("Data formatted in JSON dictionary")
# Format data so that its ready to be stored in the database
print(json.dumps(str([Gamer.__dict__ for gamer in gamers])))
Gamer 1 ReactionTime Score: 15 points
Gamer 1 HiLo Score: 22 points
Gamer 1 Pong Score: 10 points
Gamer 1 Snake Score: 4 points
Gamer 1 Total: 51 tokens
Gamer 2 ReactionTime Score: 22 points
Gamer 2 HiLo Score: 11 points
Gamer 2 Pong Score: 9 points
Gamer 2 Snake Score: 44 points
Gamer 2 Total: 86 tokens
{"ReactionTime": 15, "HiLo": 22, "Pong": 10, "Snake": 4, "Tokens": 51}
{"ReactionTime": 22, "HiLo": 11, "Pong": 9, "Snake": 44, "Tokens": 86}

Data formatted in JSON dictionary
"[mappingproxy({'__module__': '__main__', '__init__': <function Gamer.__init__ at 0x7fc1e3aeab80>, 'ReactionTime': <property object at 0x7fc1f8de4e00>, 'HiLo': <property object at 0x7fc1e3a88bd0>, 'Pong': <property object at 0x7fc1e3a88b30>, 'Snake': <property object at 0x7fc1e3a889a0>, 'Tokens': <property object at 0x7fc1e3a88a40>, 'Weight': <property object at 0x7fc1e3a88b80>, 'dictionary': <property object at 0x7fc1e3a88ae0>, '__str__': <function Gamer.__str__ at 0x7fc1e3a81280>, '__repr__': <function Gamer.__repr__ at 0x7fc1e3a81310>, '__dict__': <attribute '__dict__' of 'Gamer' objects>, '__weakref__': <attribute '__weakref__' of 'Gamer' objects>, '__doc__': None}), mappingproxy({'__module__': '__main__', '__init__': <function Gamer.__init__ at 0x7fc1e3aeab80>, 'ReactionTime': <property object at 0x7fc1f8de4e00>, 'HiLo': <property object at 0x7fc1e3a88bd0>, 'Pong': <property object at 0x7fc1e3a88b30>, 'Snake': <property object at 0x7fc1e3a889a0>, 'Tokens': <property object at 0x7fc1e3a88a40>, 'Weight': <property object at 0x7fc1e3a88b80>, 'dictionary': <property object at 0x7fc1e3a88ae0>, '__str__': <function Gamer.__str__ at 0x7fc1e3a81280>, '__repr__': <function Gamer.__repr__ at 0x7fc1e3a81310>, '__dict__': <attribute '__dict__' of 'Gamer' objects>, '__weakref__': <attribute '__weakref__' of 'Gamer' objects>, '__doc__': None})]"

Tester Example Code

import unittest

class MyClass:
    def my_method(self, a, b):
        return a * b

class TestMyClass(unittest.TestCase):
    def setUp(self):
        self.my_object = MyClass()

    def test_my_method(self):
        result = self.my_object.my_method(2, 5)
        self.assertEqual(result, 10)

    def test_my_method_negative(self):
        result = self.my_object.my_method(-2, -5)
        self.assertEqual(result, 10)

if __name__ == '__main__':
    unittest.main()