1. Computer Science 111 Fundamentals of Programming I More Data Modeling

2. More Modeling: a Bank Manages a set of accounts Operations –Add a new account –Remove an account –Access an account for deposits and withdrawals –Compute the interest on all accounts

3. Class Diagram Bank SavingsAccount * Describes the relationship between two classes A Bank object contains zero or more SavingsAccount objects

4. Bank() # Returns a new bank add(account) # Adds account to bank remove(name, pin) # Removes an account from bank get(name, pin) # Returns an account or None computeInterest() # Computes the interest and # deposits it in each account str(aBank) # Returns string rep of bank The Interface of the Bank Class

5. from bank import Bank wellsFargo = Bank() for pinNumber in range(1000, 1005): wellsFargo.add(SavingsAccount('Ken', str(pinNumber))) print(wellsFargo) account = wellsFargo.get('Ken', '1001') account.deposit(100) print(wellsFargo) account.withdraw(20) print(wellsFargo.computeInterest()) Example Use of the Bank Class

6. Defining a Bank Class Set up a data structure for the data Define methods to –Add a new account –Remove an account –Access an account for deposits and withdrawals –Compute the interest on all accounts

7. class Bank(object): """This class represents a bank.""" def __init__(self): self._accounts = {} # Other methods go here Defining the Bank Class Use a dictionary for the accounts, keyed by the name + pin

8. class Bank(object): """This class represents a bank.""" def __init__(self): self._accounts = {} def __str__(self): result = "" for account in self._accounts.values(): result += str(account) + "\n" return result Defining the Bank Class Always define __init__ and __str__ first

9. class Bank(object): """This class represents a bank.""" def __init__(self): self._accounts = {} def __str__(self): return "\n".join(map(str, self._accounts.values())) Defining the Bank Class Simplify, simplify!

10. class Bank(object): """This class represents a bank.""" def __init__(self): self._accounts = {} def add(self, account): key = account._name + account._pin self._accounts[key] = account Adding an Account An account is a value in the dictionary, keyed by its name and pin The remaining methods are similar

11. Class Variables An instance variable refers to storage owned by a single instance A class variable refers to storage owned by the class, and thus available to all of its instances For example, each savings account owns a separate balance, so that should be an instance variable But all savings accounts have the same interest rate, so that should be a class variable

12. Class and Instance Variables SavingsAccount a1a2 SavingsAccount.RATE self._balance from account import SavingsAccount a1 = SavingsAccount('Ken', '3322', 1000.00) a2 = SavingsAccount('Catherine', '3321', 10000.00) print(SavingsAccount.RATE)

13. account = SavingsAccount('Ken', '3322', 1000.00) print(account.computeInterest()) SavingsAccount.RATE = 0.06 print(account.computeInterest()) Using Class Variables

14. class SavingsAccount(object): """This class represents a savings account.""" RATE = 0.06 # Class variable def __init__(self, name, pin, balance = 0.0): self._name = name self._pin = pin self._balance = balance def computeInterest(self): interest = SavingsAccount.RATE * self._balance self.deposit(interest) return interest Defining a Class Variable Class variables are picked out using the class name as a prefix Their names are usually in uppercase

15. Another Example: Playing Cards Used in card games, such as War, Blackjack, Poker, and Crazy Eights A standard deck consists of 52 cards Each card has a rank (a number from 1-13, where Ace is 1 and face cards are 11-13) Each card has a suit (Spades, Hearts, Diamonds, Clubs)

16. A Card: State and Behavior State: –a rank –a suit Behavior: examine the values of the state variables, but don ’ t ever modify them

17. >>> card = Card(3, 'Spades') >>> print(str(card.rank) + ' of ' + card.suit) 3 of Spades >>> print(card) 3 of Spades Using the Card Class A Card object contains two data values, and these are never changed Thus, there is no need for accessor or mutator methods Just reference the card ’ s variables to get their values

18. class Card(object): SUITS = ('Spades', 'Hearts', 'Diamonds', 'Clubs') RANKS = tuple(range(1, 14)) def __init__(self, rank, suit): self.rank = rank self.suit = suit Defining the Card Class The Card class can specify the ranges of ranks and suits as class variables

19. class Card(object): … def __str__(self): """Returns the string representation of a card.""" if self.rank == 1: rank = 'Ace' elif self.rank == 11: rank = 'Jack' elif self.rank == 12: rank = 'Queen' elif self.rank == 13: rank = 'King' else: rank = self.rank return str(rank) + ' of ' + self.suit String Representation

20. for suit in Card.SUITS: for rank in Card.RANKS: card = Card(rank, suit) print(card) Create and Print all 52 Cards print automatically runs str to obtain an object ’ s string representation

21. A Deck: State and Behavior A deck initially contains 52 cards The user can –shuffle the deck –deal a single card from its top –check to see if there are more cards to deal Deck Card 0..52

22. Deck() shuffle() deal() # Removes and returns the top card isEmpty() str(aDeck) The Deck Interface and Its Use Interface

23. Deck() shuffle() deal() # Removes and returns the top card isEmpty() The Deck Interface and Its Use from cards import Deck deck = Deck() deck.shuffle() while not deck.isEmpty(): card = deck.deal() print(card) Interface Use

24. Application: The Game of War A simplified version with two players and a single war pile Each player has 2 piles of cards: –An unplayed pile –A winnings pile

25. Playing the Game of War Deal 26 cards to each player’s unplayed pile While both unplayed piles are not empty Each player moves the topmost card from the unplayed pile to the top of the game’s war pile If these cards do not have the same rank Move the cards from the game’s war pile to the winner’s winnings pile The player with the largest winnings pile wins

26. Additional Classes Player contains 2 piles of cards WarGame contains a deck, two players, and a single pile of cards; allows the user to step through the game On each step, the cards are drawn and the war pile is shifted if there is a winner

27. Classes and Relationships Deck Card 0..52 WarGame Player 2 cards.py: Card, Deck wargame.py: Player, WarGame

28. WarGame() # Creates a deck and 2 players deal() # Deals 26 cards to each player step() # Draws the cards and shifts the piles winner() # Returns None if the game is not over, # or the results as a string otherwise str(aGame) # The current state of the game as a string The WarGame Interface

29. WarGame() # Creates a deck and 2 players deal() # Deals 26 cards to each player step() # Draws the cards and shifts the piles winner() # Returns None if the game is not over, # or the results as a string otherwise str(aGame) # The current state of the game as a string Playing the Game def main(): game = WarGame() game.deal() while not game.winner(): game.step() print(game) print(game.winner())

30. For Wednesday Data Persistence