[CS61A]Lab06

Lab Link: http://gaotx.com/cs61a/lab/lab06/
My solution: http://gaotx.com/blogs/2015/05/26/cs61a-lab06/

Question 2:
class Person(object):
        def __init__(self, name):
                self.name = name
                self.previous = 'I squirreled it away before it could catch on fire.'
        def say(self, stuff):
                self.previous = stuff
                return stuff
        def ask(self, stuff):
                return self.say("Would you please " + stuff)
        def greet(self):
                return self.say("Hello, my name is " + self.name)
        def repeat(self):
                return self.previous

Question 3:
class Account(object):
        def __init__(self, account_holder):
                self.balance = 0
                self.holder = account_holder
                self.transactions = []
        def deposit(self, amount):
                self.transactions.append(('deposit', amount))
                self.balance += amount
                return self.balance
        def withdraw(self, amount):
                if amount > self.balance:
                        return 'Insufficient funds'
                self.transactions.append(('withdraw', amount))
                self.balance = self.balance - amount
                return self.balance

Question 4:
class BadBankAccount(Account):
        def withdraw(self, amount):
                if self.overdrawn:
                        print('You have overdrawn, please add more money!')
                        return self.balance
                self.balance -= amount
                return self.balance
        @property
        def overdrawn():
                return self.balance < 0

# Q2
class Person(object):
    """Person class.

    >>> steven = Person("Steven")
    >>> steven.repeat()       # starts at whatever value you'd like
    'I squirreled it away before it could catch on fire.'
    >>> steven.say("Hello")
    'Hello'
    >>> steven.repeat()
    'Hello'
    >>> steven.greet()
    'Hello, my name is Steven'
    >>> steven.repeat()
    'Hello, my name is Steven'
    >>> steven.ask("preserve abstraction barriers")
    'Would you please preserve abstraction barriers'
    >>> steven.repeat()
    'Would you please preserve abstraction barriers'
    """
    def __init__(self, name):
        self.name = name
        "*** YOUR CODE HERE ***"
        self.last = 'I squirreled it away before it could catch on fire.'

    def say(self, stuff):
        "*** YOUR CODE HERE ***"
        self.last = stuff
        return stuff

    def ask(self, stuff):
        return self.say("Would you please " + stuff)

    def greet(self):
        return self.say("Hello, my name is " + self.name)

    def repeat(self):
        "*** YOUR CODE HERE ***"
        return self.last

# Q3
class Account(object):
    """A bank account that allows deposits and withdrawals.

    >>> eric_account = Account('Eric')
    >>> eric_account.deposit(1000000)   # depositing my paycheck for the week
    1000000
    >>> eric_account.transactions
    [('deposit', 1000000)]
    >>> eric_account.withdraw(100)      # buying dinner
    999900
    >>> eric_account.transactions
    [('deposit', 1000000), ('withdraw', 100)]
    """

    interest = 0.02

    def __init__(self, account_holder):
        self.balance = 0
        self.holder = account_holder
        "*** YOUR CODE HERE ***"
        self.transactions = []

    def deposit(self, amount):
        """Increase the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        self.transactions.append(('deposit', amount))
        self.balance = self.balance + amount
        return self.balance

    def withdraw(self, amount):
        """Decrease the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        self.transactions.append(('withdraw', amount))
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance = self.balance - amount
        return self.balance

# Q4
class BadBankAccount(Account):
    """ A subclass of bank account that allows an account holder to overdraw
    once, and then prevents them from withdrawing more money. You should also
    implement the property method overdrawn, which allows an account holder to
    check if they are overdrawn.

    >>> harold_account = BadBankAccount('Harold')
    >>> harold_account.deposit(100)   # depositing my paycheck for the week
    100
    >>> harold_account.withdraw(101)  # buying dinner
    -1
    >>> harold_account.overdrawn
    True
    >>> harold_account.withdraw(100000)
    You have overdrawn, please add more money!
    -1
    >>> harold_account.deposit(10)
    9
    >>> harold_account.overdrawn
    False
    """

    def withdraw(self, amount):
        """Decrease the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        if self.overdrawn:
            print('You have overdrawn, please add more money!')
            return self.balance
        self.balance = self.balance - amount
        return self.balance

    "*** YOUR CODE HERE ***"
    @property
    def overdrawn(self):
        return self.balance < 0

关于class的lab，so easy,上代码：
## Object-Oriented Programming ##

# Q2
class Person(object):
    """Person class.

    >>> steven = Person("Steven")
    >>> steven.repeat()       # starts at whatever value you'd like
    'I squirreled it away before it could catch on fire.'
    >>> steven.say("Hello")
    'Hello'
    >>> steven.repeat()
    'Hello'
    >>> steven.greet()
    'Hello, my name is Steven'
    >>> steven.repeat()
    'Hello, my name is Steven'
    >>> steven.ask("preserve abstraction barriers")
    'Would you please preserve abstraction barriers'
    >>> steven.repeat()
    'Would you please preserve abstraction barriers'
    """
    def __init__(self, name):
        self.name = name
        "*** YOUR CODE HERE ***"
        self.word = 'Leo is the best'

    def say(self, stuff):
        "*** YOUR CODE HERE ***"
        self.word = stuff
        return stuff

    def ask(self, stuff):
        return self.say("Would you please " + stuff)

    def greet(self):
        return self.say("Hello, my name is " + self.name)

    def repeat(self):
        "*** YOUR CODE HERE ***"
        return self.word

# Q3
class Account(object):
    """A bank account that allows deposits and withdrawals.

    >>> eric_account = Account('Eric')
    >>> eric_account.deposit(1000000)   # depositing my paycheck for the week
    1000000
    >>> eric_account.transactions
    [('deposit', 1000000)]
    >>> eric_account.withdraw(100)      # buying dinner
    999900
    >>> eric_account.transactions
    [('deposit', 1000000), ('withdraw', 100)]
    """

    interest = 0.02

    def __init__(self, account_holder):
        self.balance = 0
        self.holder = account_holder
        self.transactions = []
        "*** YOUR CODE HERE ***"

    def deposit(self, amount):
        """Increase the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        self.transactions.append(('deposit', amount))
        self.balance = self.balance + amount
        return self.balance

    def withdraw(self, amount):
        """Decrease the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        self.transactions.append(('withdraw', amount))
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance = self.balance - amount
        return self.balance

# Q4
class BadBankAccount(Account):
    """ A subclass of bank account that allows an account holder to overdraw
    once, and then prevents them from withdrawing more money. You should also
    implement the property method overdrawn, which allows an account holder to
    check if they are overdrawn.

    >>> harold_account = BadBankAccount('Harold')
    >>> harold_account.deposit(100)   # depositing my paycheck for the week
    100
    >>> harold_account.withdraw(101)  # buying dinner
    -1
    >>> harold_account.overdrawn
    True
    >>> harold_account.withdraw(100000)
    You have overdrawn, please add more money!
    -1
    >>> harold_account.deposit(10)
    9
    >>> harold_account.overdrawn
    False
    """

    def withdraw(self, amount):
        """Decrease the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        if self.balance < 0:
            print "You have overdrawn, please add more money!"
            print self.balance
        else:
            self.balance = self.balance - amount
            return self.balance

    "*** YOUR CODE HERE ***"
    def deposit(self, amount):
        self.balance = self.balance + amount
        return self.balance
   
    @property
    def overdrawn(self):
        if self.balance < 0:
            return True
        else:
            return False

只做了必做题，交一下作业！！！！


然后上传代码！

1. ## Object-Oriented Programming ##
   
2. 
   
3. # Q2
   
4. class Person(object):
   
5.     """Person class.
   
6. 
   
7.     >>> steven = Person("Steven")
   
8.     >>> steven.repeat()       # starts at whatever value you'd like
   
9.     'I squirreled it away before it could catch on fire.'
   
10.     >>> steven.say("Hello")
    
11.     'Hello'
    
12.     >>> steven.repeat()
    
13.     'Hello'
    
14.     >>> steven.greet()
    
15.     'Hello, my name is Steven'
    
16.     >>> steven.repeat()
    
17.     'Hello, my name is Steven'
    
18.     >>> steven.ask("preserve abstraction barriers")
    
19.     'Would you please preserve abstraction barriers'
    
20.     >>> steven.repeat()
    
21.     'Would you please preserve abstraction barriers'
    
22.     """
    
23.     def __init__(self, name):
    
24.         self.name = name
    
25.         self.prev = "I squirreled it away before it could catch on fire."
    
26. 
    
27.     def say(self, stuff):
    
28.         self.prev = stuff
    
29.         return stuff
    
30. 
    
31.     def ask(self, stuff):
    
32.         return self.say("Would you please " + stuff)
    
33. 
    
34.     def greet(self):
    
35.         return self.say("Hello, my name is " + self.name)
    
36. 
    
37.     def repeat(self):
    
38.         return self.prev
    
39. 
    
40. # Q3
    
41. class Account(object):
    
42.     """A bank account that allows deposits and withdrawals.
    
43. 
    
44.     >>> eric_account = Account('Eric')
    
45.     >>> eric_account.deposit(1000000)   # depositing my paycheck for the week
    
46.     1000000
    
47.     >>> eric_account.transactions
    
48.     [('deposit', 1000000)]
    
49.     >>> eric_account.withdraw(100)      # buying dinner
    
50.     999900
    
51.     >>> eric_account.transactions
    
52.     [('deposit', 1000000), ('withdraw', 100)]
    
53.     """
    
54. 
    
55.     interest = 0.02
    
56. 
    
57.     def __init__(self, account_holder):
    
58.         self.balance = 0
    
59.         self.holder = account_holder
    
60.         self.transactions = []
    
61. 
    
62.     def deposit(self, amount):
    
63.         """Increase the account balance by amount and return the
    
64.         new balance.
    
65.         """
    
66.         self.balance = self.balance + amount
    
67.         self.transactions.append(("deposit", amount))
    
68.         return self.balance
    
69. 
    
70.     def withdraw(self, amount):
    
71.         """Decrease the account balance by amount and return the
    
72.         new balance.
    
73.         """
    
74.         if amount > self.balance:
    
75.             return 'Insufficient funds'
    
76.         self.balance = self.balance - amount
    
77.         self.transactions.append(("withdraw", amount))
    
78.         return self.balance
    
79. 
    
80. # Q4
    
81. class BadBankAccount(Account):
    
82.     """ A subclass of bank account that allows an account holder to overdraw
    
83.     once, and then prevents them from withdrawing more money. You should also
    
84.     implement the property method overdrawn, which allows an account holder to
    
85.     check if they are overdrawn.
    
86. 
    
87.     >>> harold_account = BadBankAccount('Harold')
    
88.     >>> harold_account.deposit(100)   # depositing my paycheck for the week
    
89.     100
    
90.     >>> harold_account.withdraw(101)  # buying dinner
    
91.     -1
    
92.     >>> harold_account.overdrawn
    
93.     True
    
94.     >>> harold_account.withdraw(100000)
    
95.     You have overdrawn, please add more money!
    
96.     -1
    
97.     >>> harold_account.deposit(10)
    
98.     9
    
99.     >>> harold_account.overdrawn
    
100.     False
     
101.     """
     
102. 
     
103.     def withdraw(self, amount):
     
104.         """Decrease the account balance by amount and return the
     
105.         new balance.
     
106.         """
     
107.         "*** YOUR CODE HERE ***"
     
108.         if self.overdrawn:
     
109.             print("You have overdrawn, please add more money!")
     
110.         else:
     
111.             self.balance = self.balance - amount
     
112.         return self.balance
     
113. 
     
114.     "*** YOUR CODE HERE ***"
     
115. 
     
116.     @property
     
117.     def overdrawn(self):
     
118.         return self.balance <= 0
     

复制代码

## Object-Oriented Programming ##

# Q2
class Person(object):
    """Person class.

    >>> steven = Person("Steven")
    >>> steven.repeat()       # starts at whatever value you'd like
    'I squirreled it away before it could catch on fire.'
    >>> steven.say("Hello")
    'Hello'
    >>> steven.repeat()
    'Hello'
    >>> steven.greet()
    'Hello, my name is Steven'
    >>> steven.repeat()
    'Hello, my name is Steven'
    >>> steven.ask("preserve abstraction barriers")
    'Would you please preserve abstraction barriers'
    >>> steven.repeat()
    'Would you please preserve abstraction barriers'
    """
    def __init__(self, name):
        self.name = name
        self.saved = 'I squirreled it away before it could catch on fire.'
        "*** YOUR CODE HERE ***"

    def say(self, stuff):
        "*** YOUR CODE HERE ***"
        self.saved = stuff
        return stuff

    def ask(self, stuff):
        return self.say("Would you please " + stuff)

    def greet(self):
        return self.say("Hello, my name is " + self.name)

    def repeat(self):
        "*** YOUR CODE HERE ***"
        return self.saved

# Q3
class Account(object):
    """A bank account that allows deposits and withdrawals.

    >>> eric_account = Account('Eric')
    >>> eric_account.deposit(1000000)   # depositing my paycheck for the week
    1000000
    >>> eric_account.transactions
    [('deposit', 1000000)]
    >>> eric_account.withdraw(100)      # buying dinner
    999900
    >>> eric_account.transactions
    [('deposit', 1000000), ('withdraw', 100)]
    """

    interest = 0.02

    def __init__(self, account_holder):
        self.balance = 0
        self.holder = account_holder
        self.transactions = []
        "*** YOUR CODE HERE ***"

    def deposit(self, amount):
        """Increase the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        self.balance = self.balance + amount
        self.transactions += [('deposit', amount)]
        return self.balance

    def withdraw(self, amount):
        """Decrease the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        if amount > self.balance:
            return 'Insufficient funds'
        self.balance = self.balance - amount
        self.transactions += [('withdraw', amount)]
        return self.balance

# Q4
class BadBankAccount(Account):
    """ A subclass of bank account that allows an account holder to overdraw
    once, and then prevents them from withdrawing more money. You should also
    implement the property method overdrawn, which allows an account holder to
    check if they are overdrawn.

    >>> harold_account = BadBankAccount('Harold')
    >>> harold_account.deposit(100)   # depositing my paycheck for the week
    100
    >>> harold_account.withdraw(101)  # buying dinner
    -1
    >>> harold_account.overdrawn
    True
    >>> harold_account.withdraw(100000)
    You have overdrawn, please add more money!
    -1
    >>> harold_account.deposit(10)
    9
    >>> harold_account.overdrawn
    False
    """

    def withdraw(self, amount):
        """Decrease the account balance by amount and return the
        new balance.
        """
        "*** YOUR CODE HERE ***"
        if self.balance < 0:
            print ('You have overdrawn, please add more money!')
            return self.balance
        self.balance = self.balance - amount
        return self.balance

    "*** YOUR CODE HERE ***"
    @property
    def overdrawn(self):
        return self.balance < 0

## Extra Object-Oriented Programming questions ##

from lab06 import *

# Q7
class CheckingAccount(Account):
    """A bank account that charges for withdrawals.

    >>> check = Check("Steven", 42)  # 42 dollars, payable to Steven
    >>> steven_account = CheckingAccount("Steven")
    >>> eric_account = CheckingAccount("Eric")
    >>> eric_account.deposit_check(check)  # trying to steal steven's money
    The police have been notified.
    >>> eric_account.balance
    0
    >>> check.deposited
    False
    >>> steven_account.balance
    0
    >>> steven_account.deposit_check(check)
    42
    >>> check.deposited
    True
    >>> steven_account.deposit_check(check)  # can't cash check twice
    The police have been notified.
    """
    withdraw_fee = 1
    interest = 0.01

    def withdraw(self, amount):
        return Account.withdraw(self, amount + self.withdraw_fee)
    def deposit_check(account_holder, Check):
        if account_holder == Check.payable_to and Check.amount > 0:
            self.deposit(Check.amount)
            Check.amount = 0
            Check.deposited = True
            return self.balance
        else:
            return 'The police have been notified.'

class Check(object):
    "*** YOUR CODE HERE ***"
    def __init__(self, payable_to, amount):
        self.payable_to = payable_to
        self.amount = amount
        self.deposited = False


# Q8
class Keyboard:
    """A Keyboard takes in an arbitrary amount of buttons, and has a
    dictionary of positions as keys, and values as Buttons.

    >>> b1 = Button(0, "H")
    >>> b2 = Button(1, "I")
    >>> k = Keyboard(b1, b2)
    >>> k.buttons[0].key
    'H'
    >>> k.press(1)
    'I'
    >>> k.typing([0, 1])
    'HI'
    >>> k.typing([1, 0])
    'IH'
    >>> b1.pressed
    2
    >>> b2.pressed
    3
    """

    def __init__(self, *args):
        "*** YOUR CODE HERE ***"
        self.buttons = {buts.pos: buts for buts in args}

    def press(self, info):
        """Takes in a position of the button pressed, and
        returns that button's output"""
        "*** YOUR CODE HERE ***"
        if info in self.buttons.keys():
            self.buttons[info].pressed += 1
            return self.buttons[info].key
        return None

    def typing(self, typing_input):
        """Takes in a list of positions of buttons pressed, and
        returns the total output"""
        "*** YOUR CODE HERE ***"
        result = ''
        for pos in typing_input:
            result += self.press(pos)
        return result

class Button:
    def __init__(self, pos, key):
        self.pos = pos
        self.key = key
        self.pressed = 0