Module 0.11.0 - Object Oriented Programming

• a programming style based on the use of classes and objects

• a class is a blueprint for an object

• an object is a variable created from a class's definition

• object's have attributes and behaviors

  • an attribute is an object's properties

  • a behavior [or method] is what an object does

0.11.1 - Class's Put Into Context

This will be our hypothetical for most of this lesson

• let's say you are making a game with python

• in this game, there will be different types of dogs

• instead of individually programming each dog, we can create a blueprint or class that all the dogs can follow

---

• let's say we make a dog class (or blueprint)

• we will need to account for a dog's attributes and behaviors

• the attributes of a dog:

  • name

  • color

  • breed

• the behaviors of a dog

  • bark

  • they play fetch

  • move forward, backward, left, and right

0.11.2 - Creating A Class

• "class" statement, creates a class

  • it is a good programming practice to make class's start with a capital letter

    • to differentiate them from functions and modules

# this is our "Dog" class
class Dog:

• we now need to add our instance variables, these variables will contain the dogs' attributes

  • things like the dogs name and fur color

• "__init__" method, initializes instance variables to the class [init = initialize]

  • this "__init__" method is reffered to as the class constructor

• class methods are structured like functions

• all methods in a class take "self" as their first parameter

  • "self" parameter, an access point to the current instance of the class

  • the "self" parameter doesn't actually have to be called self, it's just good practice

# this is our "Dog" class
class Dog:

	# init method, takes in the attributes "name" and "color"
	def __init__(self, name, color):
		self.name = name
		self.color = color

• we can now add our dog objects

duke = Dog("Duke", "White")
sam = Dog("Sam", "Black")

• we can output and use the dog object's attributes

dog_tuple = (duke, sam)

for dog in dog_tuple:
	print(f"{dog.name} has {dog.color} fur")
	
>>> "Duke has White fur"
>>> "Sam has Black fur"

0.11.3 - Adding Behaviors

• now that the dog objects have their own attributes, we can give them behaviors like barking or growling

# this is our "Dog" class
class Dog:

	# init method, takes in the attributes "name" and "color"
	def __init__(self, name, color):
		self.name = name
		self.color = color
		
	# barking method
	def bark(self):
		print("Woof")
		
	# growling method
	def growl(self):
		print("Grrr")

duke = Dog("Duke", "White")
sam = Dog("Sam", "Black")

duke.bark()
sam.growl()

>>> "Woof"
>>> "Grrr"

• class's can also have attributes that are only accessible to the class

• created by initializing variables in the class

# this is our "Dog" class
class Dog:

	# class specific attribute
	legs = 4

	# init method, takes in the attributes "name" and "color"
	def __init__(self, name, color):
		self.name = name
		self.color = color
		
	# barking method
	def bark(self):
		print("Woof")
		
	# growling method
	def growl(self):
		print("Grrr")

duke = Dog("Duke", "White")
sam = Dog("Sam", "Black")

duke.bark()
sam.legs

>>> "Woof"
>>> 4

0.11.4 - Inheritance

• congrats, the game is sucessful upon it's release

• eventually, people get tired of dogs, they want more animals like cats

• now we could make another entire class for cats, but cat's have the same attributes as dogs, but different behaviours

• for situations like this we can inherit attribues and behaviors from other class's.

---

• a super class is a class that other class's [subclass's] can inherit from

• let's make a super class called "Animal"

# this is our super class
class Animal:

let's say that all of the animals in our game share these same attributes

• name

• color

• breed

# this is our super class
class Animal:
	# intialize our shared attributes
	def __init__(self, name, color, breed):
		self.name = name
		self.color = color
		self.breed = breed	

• note that if an object doesn't have attributes or behaviours, you don't need to add them in the blueprint or class

• let's make our animal subclass's

• to inherit from a class, mention the super class's name in parenthesis "()" after the supclass

# this is our super class
class Animal:
	# intialize our shared attributes
	def __init__(self, name, color, breed):
		self.name = name
		self.color = color
		self.breed = breed	

# this dog subclass inherits from our "Animal" super class
class Dog(Animal):
	# we only need to initialize anything specific to dogs, no init needed
	
	# barking method
	def bark(self):
		print("Woof")
		
# this cat subclass inherits from our "Animal" super class
class Cat(Animal):
	# we only need to initialize anything specific to cats, no init needed
	
	# purring method
	def purr(self):
		print("Purr")

now we can make our animal objects

sam = Dog("Same", "Black", "Doberman")
jasper = Cat("Jasper", "White", "American Bobtail")

sam.bark()
jasper.purr()

>>> "Woof"
>>> "Purr"

when a subclass inherits from a super class, behaviors or attributes with the same name are overwritten by the subclass

# this is our super class
class Animal:
	# intialize our shared attributes
	def __init__(self, name, color, breed):
		self.name = name
		self.color = color
		self.breed = breed	
	
	# superclass speaking method
	def speak(self):
		print("Rawr")

# this dog subclass inherits from our "Animal" super class
class Dog(Animal):
	# we only need to initialize anything specific to dogs, no init needed
	
	# bsubclass speaking method overwrites superclass speaking method
	# because they share the same name
	def speak(self):
		print("Woof")

sam = Dog("Same", "Black", "Doberman")
sam.speak()

>>> "Woof"

0.11.5 - More Advanced Topics

• OOP [Object Oriented Programming] can get very complicated very quickly

• due to this being a beginner friendly, cybersecurity focused, curriculem we will end the topic of OOP here

• however, CosmodiumCS will be releasing an Advanced level Python course in the near future

  • here we will more advanced topics like generators, recursion, decorators, magic methods [dunders], hiding class data, class and static methods, properties, and more

• until then, I will link some free and open source resources for if you wish to continue learning

Tech With Tim, Python OOP - 'https://www.youtube.com/watch?v=JeznW_7DlB0'
W3Schools - 'https://www.w3schools.com/python/python_reference.asp'