Mixed-Up Code Questions

Section 20.11 Mixed-Up Code Questions

Checkpoint 20.11.1.

Create a class Person with a constructor that takes first_name and last_name and inititalize those attributes in the current object. Next, create a class called Customer that inherits from Person with a constructor that takes first_name, last_name, and id. Call the constructor in Person to initialize first_name and last_name and then also set the id attribute in the Customer object. For example, Person("Barb", "Ericson").last_name == "Ericson" and Customer("Barb", "Ericson", "a1").id == ``"a1".

class Person:
---
    def __init__(self, first_name, last_name):
---
    def init(first_name, last_name):  #paired
---
        self.first_name = first_name
        self.last_name = last_name
---
class Customer(Person):
---
class Customer extends Person:  #paired
---
    def __init__(self, first_name, last_name, id):
---
    def __init__(first_name, last_name, id):  #paired
---
        super().__init__(first_name, last_name)
---
        super.__init__(first_name, last_name)  #paired
---
        self.id = id

Checkpoint 20.11.2.

Create a class called Person with a constructor that takes name and age. Next, create a class called Student that inherits from Person. The constructor for Student takes name, age, and gpa. Have the constructor for the Student class call the constructor for the Person class to initialize the name and age and then set the value for the gpa. For example, Person('Susan', 13).name would be "Susan" and Student('Sally', 16, 3.7).gpa would be 3.7.

class Person:
---
    def __init__(self, name, age):
---
    def init(self, name, age):  #paired
---
        self.name = name
        self.age = age
---
class Student(Person):
---
class Student():  #paired
---
    def __init__(self, name, age, gpa):
---
    def __init__(name, age, gpa):  #paired
---
        super().__init__(name, age)
---
        super.__init__(name,age)  #paired
---
        self.gpa = gpa

Checkpoint 20.11.3.

Create a class called Building with a constructor that inititalizes the attributes floors and sqft. Next, create a class called House that inherits from Building. The constructor for House should take floors, sqft, and bedrooms and call the construtor in Building to initialze the floors and sqft before setting the attribute bedrooms. For example, Building(15, 10000).floors would be 15 and House(3, 2000, 3).bedrooms would be 3.

class Building:
---
    def __init__(self, floors, sqft):
---
    def __init__(floors, sqft):  #paired
---
        self.floors = floors
        self.sqft = sqft
---
class House(Building):
---
class House:  #paired
---
    def __init__(self, floors, sqft, bedrooms):
---
    def __init__(floors, sqft, bedrooms):  #paired
---
        super().__init__(floors, sqft)
---
        super.__init__(floors, sqft)  #paired
---
        self.bedrooms = bedrooms

Checkpoint 20.11.4.

Create a class Account with an attribute of balance and methods of deposit and withdraw that both take an amount. For example, Account(200).withdraw(50) should set the balance to 150 and Account(200).deposit(100) should set the balance to 300.

class Account:
---
    def __init__(self, balance):
---
        self.balance = balance
---
    def deposit(self, amount):
---
    def deposit(amount):  #paired
---
        self.balance += amount
---
        balance += amount  #paired
---
    def withdraw(self, amount):
---
    def withdraw(amount):  #paired
---
        self.balance -= amount
---
        balance -= amount  #paired

Checkpoint 20.11.5.

Create a class Animal with an attribute of name and a method make_noise that returns "Noise". Then create a Dog class that inherits from Animal. Have the constructor in Dog call the constructor in Animal to initialze the name. In Dog also override the make_noise method inherited from Animal to return "Bark". For example, Animal("Diana").make_noise() returns "Noise" and Dog("Percy").make_noise() returns "Bark".

class Animal:
---
def class Animal:  #paired
---
    def __init__(self, name):
---
        self.name = name
---
    def make_noise(self):
---
    def make_noise():  #paired
---
        return "Noise"
---
class Dog(Animal):
---
class Dog:  #paired
---
    def __init__(self, name):
---
        super().__init__(name)
---
    def make_noise(self):
---
    def make_noise():  #paired
---
        return "Bark"

Checkpoint 20.11.6.

Create a class Animal with an attribute of name and a method make_noise that returns "Noise". Then create a Cat class that inherits from Animal. Have the constructor in Cat call the constructor in Animal to initialze the name. In Cat also override the make_noise method inherited from Animal to return "Meow". For example, Animal("Spike").make_noise() returns "Noise" and Cat("Diana").make_noise() returns "Meow".

class Animal:
---
def class Animal:  #paired
---
    def __init__(self, name):
---
        self.name = name
---
    def make_noise(self):
---
    def make_noise():  #paired
---
        return "Noise"
---
class Cat(Animal):
---
class Cat:  #paired
---
    def __init__(self, name):
---
        super().__init__(name)
---
    def make_noise(self):
---
    def make_noise():  #paired
---
        return "Meow"

Checkpoint 20.11.7.

Given a class Point that has attributes of x and y and a method distance_to(self, other) that returns the distance between the current point (self) and the other point, create a MyCircle class that has a constructor that takes two attibutes p1 and p2 both objects of the class Point. Also create a radius method that returns the radius of the circle (half the distance between the two points that define circle).

class MyCircle:
---
class MyCircle(Point):  #paired
---
    def __init__(self, p1, p2):
---
    def __init__(p1, p2):  #paired
---
        self.p1 = p1
        self.p2 = p2
---
    def radius(self):
---
    def radius():  #paired
---
        return self.p1.distance_to(self.p2) / 2
---
        return p1.distance_to(p2) / 2  #paired

Checkpoint 20.11.8.

Given a class Item with an attributes of name and price, create an Order class that has an attribute item_list that is intitialized to the empty list in the constructor. Then add an add_item method that takes an item and appends it to the item_list attribute. Then create a get_total method that returns the total price for all the items in item_list attribute.

class Order:
---
class Order(Item):  #paired
---
    def __init__(self):
---
        self.item_list = []
---
        self.item_list = ()  #paired
---
    def add_item(self, item):
---
        self.item_list.appand(item)
---
        item_list.appand(item)  #paired
---
    def get_total(self):
---
        total = 0
---
        for item in self.item_list:
---
        for item in item_list:  #paired
---
            total += item.price
---
        return total

Checkpoint 20.11.9.

Given a class Account with an attribute balance and methods of deposit and withdraw, create a SavingsAccount class that inherits from Account. Create a constructor that takes balance and interest. In the SavingsAccount constructor call the Account constructor to intitialze the balance and then initialize the interest. Then create a pay_interest method that adds the interest to the balance (divide the interest rate by 100 and multiply it by the balance to determine the amount to add).

class SavingsAccount(Account):
---
class SavingsAccount:  #paired
---
    def __init__(self, balance, interest):
---
    def __init__(balance, interest):  #paired
---
        super().__init__(balance)
---
        super.__init__(balance)  #paired
---
        self.interest = interest
---
    def pay_interest(self):
---
    def pay_interest():  #paired
---
        amount = self.interest / 100
---
        self.balance += amount * self.balance
---
        self.balance += self.amount * self.balance  #paired

Checkpoint 20.11.10.

Given a class Treasure that has attributes of name and points, create a class Room that has attributes of name and treasures. Initialize treasures to the empty list in the constructor. Create a add_treasure method in Room that adds a passed Treasure object to treasures. Next create a get_points method in Room that returns the total of all of the points for the Treasure in treasures.

class Room:
---
class Room (Treasure):  #paired
---
    def __init__(self, name):
---
        self.name = name
        self.treasures = []
---
    def add_treasure(self, treasure):
---
        self.treasures.append(treasure)
---
        treasures.append(treasure)  #paired
---
    def get_points(self):
---
        total = 0
---
        for treasure in self.treasures:
---
        for treasure in treasures:  #paired
---
            total += treasure.points
---
        return total

Python for Everyone: The PreTeXt Interactive Edition

Search Results: