Hello! So I have a homework assignment that I can't seem to understand. The 
problems are talking about classes and subclasses. My issue is that the 
examples use objects as arguments and I don't know how to make that happen 
without getting a name error. The question is:

Create a subclass of Openable called Lockable for representing physical objects 
that can be unlocked and opened. Remember to make sure that Lockable is a 
subclass of Openable. In addition to the methods and attributes it 
automatically inherits from Openable and Thing, it should have:
A public boolean attribute called is_locked that represents whether or not the 
object is locked.
A public attribute called key which is a Thing object that represents the item 
that can be used as akey to unlock the Lockable object.
An overridden constructor that takes two strings (the name and the location), a 
Thing (the key), and two optional boolean values (first, whether the object 
starts off open and second, whether it starts out locked). If neither of the 
optional boolean values are given, then the object should default to being 
closed but not locked. If only the first of the optional arguments (the 
starting "openness" state) is given, then the object should start out unlocked.
Your version of .__init__() for Lockable must use the version of .__init__() 
from the superclass Openable to handle the name, location, and "openness" 
state. Setting the is_locked and key attributes are the only ones you need to 
handle separately.
So you should be able to create Lockable objects with commands* like 
Lockable("front door", "in the foyer", house_key, False, True) (returning an 
object that starts out closed and locked), or Lockable("diary", "under Sam's 
bed", tiny_key, True) (returning an object that starts out open and unlocked), 
or Lockable("ancient treasure chest", "at the bottom of the sea", rusty_key) 
(returning an object that starts out closed and unlocked).
*Assuming that the variables house_key, tiny_key, and rusty_key already exist 
and refer to instances of Things.

My code is:
class Thing:
    """represents physical objects in a game

    attributes: name(str), location(str)"""
    def __init__(self, name, location):
        """creates a Thing with a name and location

        str, str"""
        self.name = name
        self.location = location
    def __repr__(self):
        """returns the Thing as a string that could be used to create a Thing

        None-> str"""
        return "Thing(" + self.name + ", " + self.location + ")"
    def description(self):
        """returnd the Thing along with its name and location in a string

        None -> str"""
        return "The " + repr(self.name) + " is " + repr(self.location) + "."
    
class Openable(Thing):
    """representing the Things that can be opened

    attributes: name(str), location(str), is_open(str)"""
    def __init__(self, name, location, is_open = False):
        """creates a Thing with a name and location

        str, str"""
        Thing.__init__(self, name, location)
        self.is_open = is_open
    def __repr__(self):
        """returns the Thing as a string that could be used to create an 
Openable

        None-> str"""
        return "Openable('" + self.name + "', '" + self.location + "', '" + 
str(self.is_open) + "')"
    def description(self):
        """returnd the Thing along with its name and location and whether it is 
open in a string

        None -> str"""
        if self.is_open == True:
            opened = "is open"
        else:
            opened = "is closed"
        return "The " + self.name + self.location + " is " + opened + "."
    def try_open(self):
        """tries to open the Openable and returns the result

        None -> bool"""
        if self.is_open == True:
            return False
        if self.is_open == False:
            self.is_open = True
            return True

class Lockable(Openable):
    """respresents the Openable Things that are Lockable

    attributes: name(str), location(str), is_open(str), is_locked(str), 
key(str)"""
    def __init__(self, name, location, key, is_open = False, is_locked = False):
        """creates a Thing with a name and location

        str, str"""
        Openable.__init__(self, name, location, is_open = False)
        self.is_locked = is_locked
    def __repr__(self):
        """returns the Thing as a string that could be used to create an 
Lockable

        None-> str"""
        return "Lockable('" + self.name + "', '" + self.location + "', '" + 
str(self.is_open) + "', '" + str(self.is_locked) + "')"
    def description(self):
        """returnd the Thing along with its name and location and whether it is 
open in a string and whether it is locked

        None -> str"""
        if self.is_open == True:
            opened = "is open"
            return "The " + self.name + self.location + " is " + opened + "."
        elif self.is_open == Flase:
            opened = "is closed"
            if self.is_locked == True:
                locked = "is locked"
                return "The " + self.name + self.location + " is " + locked + 
"."
            else:
                locked = "is unlocked"
        return "The " + self.name + self.location + " is " + opened + " but " + 
locked + "."

The example command is: Lockable("diary", "under Sam's bed", tiny_key, True)

And I keep getting a NameError: tiny_key is not defined. 

What do I do?
-- 
https://mail.python.org/mailman/listinfo/python-list

Reply via email to