Quantumplations

doggie = Dog("wolly", 44)
print(doggie.dog_name)
print(doggie.years_old)
print(doggie.add_one(4))
print(doggie.bark())
print(doggie.get_name())
print(doggie.get_age())
print(doggie.set_age(22))
print(doggie.years_old)

class Student:
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade

    def get_grade(self):
        return self.grade
    
class Course:
    def __init__(self, name, max_students):
        self.name = name
        self.max_students = max_students
        self.students = []

    def enroll_student(self, student):
        if len(self.students) < self.max_students:
            self.students.append(student)
            return True
        return False
    
    def get_average_grade(self):
        sum = 0 
        for student in self.students:
            sum += student.get_grade()
        return sum / len(self.students)

s1 = Student("Tim", 19, 95)
s2 = Student("Bill", 19, 75)
s3 = Student("Jill", 19, 65)
        
c1 = Course("Science", 2)
c1.enroll_student(s1)
c1.enroll_student(s2)
print(c1.enroll_student(s3))
print(c1.students)
print(c1.students[0].name)
print(c1.get_average_grade())

# Example of inheritance 
class Pet: #parent class
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        print(f"My name is {self.name} and I'm {self.age} years old.")

    def speak(self):
        print("I don't know what to say")

class Cat(Pet): #child class inherits parent class
    def __init__(self, name, age, color):
        super().__init__(name, age) # reference the super class, aka Pet parent class, view __init__(name, age) as going together
        self.color = color
    def speak(self):
        print("Meow")

    def show(self):
        print(f"My name is {self.name} and I'm {self.age} years old and my color is {self.color}")

class Dog(Pet): #child class inherits parent class
    def speak(self):
        print("Bark")

class Fish(Pet):
    pass

p = Pet("Tim", 19)
p.show()
c = Cat("Bill", 38, "Brown")
c.show()
d = Dog("Jill", 25)
d.show()
f = Fish("Bubbles", 29)
f.show()
print("---")
p.speak()
c.speak()
d.speak()
f.speak()

# Class attributes/methods vs. Instance attributes/methods
class Person:
    number_of_people = 0 # class attribute (defined w/o using self, thus not specific to an instance of the class)
    # class attributes would be preferred over just a simple global variable because the class is portable, and so
    # the value of any class attributes would come along for the ride whenever the class is imported into another file
    
    def __init__(self, name):
        self.name = name
        Person.add_person()

    @classmethod # decorator 
    def number_of_people_(cls): # class method (again, it's for the whole class, not just a specific instance/object of the class)
        return cls.number_of_people
        
    @classmethod
    def add_person(cls):
        cls.number_of_people += 1

p1 = Person("Tim")
print(Person.number_of_people)
p2 = Person("Jill")
print(p1.number_of_people)
print(p2.number_of_people)
print(Person.number_of_people)
Person.number_of_people = 8
print(p1.number_of_people)
print(p2.number_of_people)
print(Person.number_of_people_())

# Static methods 
class Math:
    
    @staticmethod # decorator which is unchanging, no access to an instance hence don't change anything
    def add5(x):
        return x + 5
    
    @staticmethod # they're basically just regular functions that happen to sit in a class for organizational purposes
    def add10(x):
        return x + 10
    
    @staticmethod
    def pr():
        print("Run!")
    
print(Math.add5(8))
print(Math.add10(4))
Math.pr()