Ch6 and Ch10: Designs with functions and classes

def square(x):
    """Returns the square of x."""
    return x * x

result = square(5)  # result = 25

calculate_tax(income) 

is_strong_password(password) 

# General method - works for any range
def summation(lower, upper):
    # Works for (1,10), (5,20), (100,200), etc.

def get_user_input():
    # Just gets input
    
def process_data(data):
    # Just processes data
    
def display_results(results):
    # Just displays results
    
def main():
    data = get_user_input()
    results = process_data(data)
    display_results(results)

def countdown(n):
    if n <= 0:              # Base case
        print("Blastoff!")
    else:                   # Recursive step
        print(n)
        countdown(n - 1)

def displayRange(lower, upper):
    while lower <= upper:
        print(lower)
        lower += 1

def displayRange(lower, upper):
    if lower <= upper:           # Base case check
        print(lower)
        displayRange(lower + 1, upper)  # Recursive call

def summation(lower, upper):
    """Returns sum of numbers from lower through upper"""
    if lower > upper:
        return 0                # Base case
    else:
        return lower + summation(lower + 1, upper)  # Recursive step

# summation(1, 4) = 1 + 2 + 3 + 4 = 10

def summation(lower, upper, margin):
    blanks = " " * margin
    print(blanks, lower, upper)
    
    if lower > upper:
        print(blanks, 0)
        return 0
    else:
        result = lower + summation(lower + 1, upper, margin + 4)
        print(blanks, result)
        return result

# Output for summation(1, 4, 0):
# 1 4
#     2 4
#         3 4
#             4 4
#                 5 4
#                 0
#             4
#         7
#     9
# 10

def factorial(n):
    if n < 0:
        raise ValueError("Factorial is not defined for negative numbers")
    if n == 0:
        return 1
    return n * factorial(n - 1)

def runForever(n):
    if n > 0:
        runForever(n)        # n never changes!
    else:
        runForever(n - 1)    # n is already not > 0

runForever(1)  # RecursionError!

replacements = {"I": "you", "me": "you"}  # Module variable

def changePerson(sentence):                # sentence = parameter
    words = sentence.split()              # words = temporary
    replyWords = []                        # replyWords = temporary
    for word in words:
        replyWords.append(replacements.get(word, word))
    return " ".join(replyWords)

x = 5                    # Module variable (global)

def f():
    x = 10               # Creates NEW temporary x
    print(x)             # Prints 10

f()                      # Call function
print(x)                 # Prints 5 (global unchanged!)

count = 0                # Module variable

def increment():
    # This creates a NEW local variable!
    count = count + 1    # Error: local 'count' referenced before assignment
    return count

# To modify global variable:
def increment_global():
    global count         # Tell Python we mean the global one
    count += 1
    return count

print("Hello World!")
print("Hello World!", end = " ") # change default from "\n" to " "

def create_student(name, scores):
    return {"name": name, "scores": scores}

def get_average(student):
    return sum(student["scores"]) / len(student["scores"])

class Student:
    def __init__(self, name):
        self.name = name
        self.scores = []
    
    def get_average(self):
        return sum(self.scores) / len(self.scores)

# Creating objects from the Student class
student1 = Student("Maria", 5)
student2 = Student("Juan", 5)

# Each object has its own state
student1.setScore(1, 100)  # Maria's first score = 100
student2.setScore(1, 85)   # Juan's first score = 85

# Same method, different objects, different results
print(student1.getAverage())  # 20.0
print(student2.getAverage())  # 17.0

class <class name>(<parent class>):
    """Docstring describing the class"""
    
    def method1(self, arg1):
        """Method docstring"""
        # method body
    
    def method2(self, arg2):
        # method body

class Student(object):
    """Represents a student with test scores"""
    
    def __init__(self, name, number):
        """Creates a student with given name and number of scores"""
        self.name = name
        self.scores = []
        for count in range(number):
            self.scores.append(0)
    
    def getName(self):
        """Returns the student's name"""
        return self.name
    
    def getScore(self, i):
        """Returns the ith score (1-indexed)"""
        return self.scores[i - 1]

>>> from student import Student
>>> s = Student("Maria", 5)
>>> print(s.getName())
Maria
>>> s.setScore(1, 100)
>>> print(s.getScore(1))
100
>>> print(s.getAverage())
20.0
>>> print(s.getHighScore())
100

def __init__(self, name, number):
    """All scores are initially 0"""
    self.name = name           # Instance variable
    self.scores = []           # Instance variable
    for count in range(number):
        self.scores.append(0)

# Called automatically:
s = Student("Maria", 5)        # __init__ runs here

class Student:
    def __init__(self, name, number):
        self.name = name        # Each student has own name
        self.scores = []        # Each student has own scores
    
    def someMethod(self):
        # Can access instance variables anywhere in class
        print(self.name)        # OK
        print(self.scores)      # OK

def __str__(self):
    """Returns string representation of the student"""
    result = "Name: " + self.name + "\n"
    result += "Scores: " + " ".join(map(str, self.scores))
    return result

# Usage:
s = Student("Maria", 5)
print(s)  # Calls __str__ automatically
# Output:
# Name: Maria
# Scores: 0 0 0 0 0

def getName(self):
    return self.name           # Just returns value

def getAverage(self):
    return sum(self.scores) / len(self.scores)

def setScore(self, i, score):
    self.scores[i - 1] = score   # Changes state

def deposit(self, amount):
    self.balance += amount       # Changes state

class Student(object):
    """Represents a student with test scores"""
    
    def __init__(self, name, number):
        self.name = name
        self.scores = []
        for count in range(number):
            self.scores.append(0)
    
    def __str__(self):
        return "Name: " + self.name + "\nScores: " + \
               " ".join(map(str, self.scores))
    
    def getName(self):
        return self.name
    
    def getScore(self, i):
        return self.scores[i - 1]
    
    def setScore(self, i, score):
        self.scores[i - 1] = score
    
    def getAverage(self):
        return sum(self.scores) / len(self.scores)
    
    def getHighScore(self):
        return max(self.scores)

class Rational(object):
    """Represents a rational number (numerator/denominator)"""
    
    def __init__(self, numerator, denominator):
        self.numer = numerator
        self.denom = denominator
    
    def __str__(self):
        return str(self.numer) + "/" + str(self.denom)

# Usage:
oneHalf = Rational(1, 2)
oneSixth = Rational(1, 6)
print(oneHalf)   # 1/2

def __add__(self, other):
    """Returns sum of two rational numbers"""
    newNumer = self.numer * other.denom + other.numer * self.denom
    newDenom = self.denom * other.denom
    return Rational(newNumer, newDenom)

# Usage:
oneHalf = Rational(1, 2)
oneSixth = Rational(1, 6)
print(oneHalf + oneSixth)  # 8/12 (could be reduced)

def __eq__(self, other):
    """Tests for equality"""
    if self is other:                    # Same object?
        return True
    elif type(self) != type(other):      # Different types?
        return False
    else:
        # Compare cross-multiplied values
        return self.numer * other.denom == other.numer * self.denom

# Usage:
oneHalf = Rational(1, 2)
twoFourths = Rational(2, 4)
print(oneHalf == twoFourths)  # True (1/2 == 2/4)

def __lt__(self, other):
    """Less than comparison"""
    return self.numer * other.denom < other.numer * self.denom

def __le__(self, other):
    """Less than or equal"""
    return self < other or self == other

def __gt__(self, other):
    """Greater than"""
    return not (self < other or self == other)

# Usage:
print(Rational(1, 2) > Rational(1, 3))   # True
print(Rational(1, 2) < Rational(1, 3))   # False

class SavingsAccount(object):
    """Represents a bank account with owner, PIN, and balance"""
    
    RATE = 0.02  # Class variable - same for all accounts!
    
    def __init__(self, name, pin, balance=0.0):
        self.name = name
        self.pin = pin
        self.balance = balance
    
    def __str__(self):
        result = "Name: " + self.name + "\n"
        result += "PIN: " + self.pin + "\n"
        result += "Balance: " + str(self.balance)
        return result

class SavingsAccount:
    RATE = 0.02        # Class variable - one copy
    
    def computeInterest(self):
        # Access via class name
        interest = self.balance * SavingsAccount.RATE
        return interest

def __init__(self, name, pin, balance):
    self.name = name     # Instance variable - separate per object
    self.pin = pin       # Instance variable
    self.balance = balance

def deposit(self, amount):
    """Deposits amount and returns None"""
    self.balance += amount
    return None

def withdraw(self, amount):
    """Withdraws amount, returns None or error message"""
    if amount < 0:
        return "Amount must be >= 0"
    elif self.balance < amount:
        return "Insufficient funds"
    else:
        self.balance -= amount
        return None

def computeInterest(self):
    """Computes, deposits, and returns interest"""
    interest = self.balance * SavingsAccount.RATE
    self.deposit(interest)
    return interest

class Bank(object):
    """Represents a collection of savings accounts"""
    
    def __init__(self, fileName=None):
        self.accounts = {}      # Dictionary: PIN → Account
        self.fileName = fileName
    
    def add(self, account):
        """Adds account to bank"""
        self.accounts[account.getPin()] = account
    
    def get(self, name, pin):
        """Returns account if name/pin match, else None"""
        for account in self.accounts.values():
            if account.getName() == name and account.getPin() == pin:
                return account
        return None

>>> from bank import Bank
>>> from savingsaccount import SavingsAccount
>>> bank = Bank()
>>> bank.add(SavingsAccount("Wilma", "1001", 4000.00))
>>> bank.add(SavingsAccount("Fred", "1002", 1000.00))
>>> print(bank)
Name: Fred
PIN: 1002
Balance: 1000.00
Name: Wilma
PIN: 1001
Balance: 4000.00
>>> account = bank.get("Wilma", "1001")
>>> account.deposit(25.00)
>>> print(account)
Name: Wilma
PIN: 1001
Balance: 4025.00

import pickle

def save(self, fileName=None):
    """Saves pickled accounts to a file"""
    if fileName != None:
        self.fileName = fileName
    elif self.fileName == None:
        return
    
    fileObj = open(self.fileName, "wb")  # 'wb' = write binary
    for account in self.accounts.values():
        pickle.dump(account, fileObj)
    fileObj.close()

def __init__(self, fileName=None):
    self.accounts = {}
    self.fileName = fileName
    
    if fileName != None:
        fileObj = open(fileName, "rb")   # 'rb' = read binary
        while True:
            try:
                account = pickle.load(fileObj)
                self.add(account)
            except EOFError:              # End of file reached
                fileObj.close()
                break

class Card(object):
    """A playing card with suit and rank"""
    
    RANKS = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
    SUITS = ("Spades", "Diamonds", "Hearts", "Clubs")
    
    def __init__(self, rank, suit):
        self.rank = rank
        self.suit = suit
    
    def __str__(self):
        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

>>> threeOfSpades = Card(3, "Spades")
>>> jackOfSpades = Card(11, "Spades")
>>> print(jackOfSpades)
Jack of Spades
>>> threeOfSpades.rank < jackOfSpades.rank
True
>>> print(jackOfSpades.rank, jackOfSpades.suit)
11 Spades

import random

class Deck(object):
    """A deck of 52 playing cards"""
    
    def __init__(self):
        self.cards = []
        for suit in Card.SUITS:
            for rank in Card.RANKS:
                self.cards.append(Card(rank, suit))
    
    def shuffle(self):
        """Shuffles the deck"""
        random.shuffle(self.cards)
    
    def deal(self):
        """Removes and returns the top card"""
        return self.cards.pop()
    
    def __len__(self):
        """Returns number of cards remaining"""
        return len(self.cards)

>>> deck = Deck()
>>> deck.shuffle()
>>> len(deck)
52
>>> card = deck.deal()
>>> print(card)
Queen of Hearts
>>> len(deck)
51
>>> while len(deck) > 0:
...     print(deck.deal())

class Grid(object):
    """Represents a 2D grid with rows and columns"""
    
    def __init__(self, rows, columns, fillValue=None):
        """Creates a grid with given dimensions"""
        self.data = []
        for row in range(rows):
            self.data.append([fillValue] * columns)
    
    def __str__(self):
        """Returns string representation"""
        result = ""
        for row in self.data:
            result += " ".join(map(str, row)) + "\n"
        return result
    
    def __getitem__(self, index):
        """Returns the row at given index"""
        return self.data[index]

>>> grid = Grid(3, 4, 0)
>>> print(grid)
0 0 0 0
0 0 0 0
0 0 0 0

>>> grid[1][2] = 99
>>> print(grid)
0 0 0 0
0 0 99 0
0 0 0 0

>>> for row in range(grid.getHeight()):
...     for col in range(grid.getWidth()):
...         print(grid[row][col])

class RestrictedSavingsAccount(SavingsAccount):
    """Account with limited monthly withdrawals"""
    
    def __init__(self, name, pin, balance=0.0):
        super().__init__(name, pin, balance)  # Call parent constructor
        self.withdrawals = 0                  # Add new attribute
        self.MAX_WITHDRAWALS = 3
    
    def withdraw(self, amount):
        """Override withdraw with limit check"""
        if self.withdrawals >= self.MAX_WITHDRAWALS:
            return "No more withdrawals this month"
        else:
            self.withdrawals += 1
            return super().withdraw(amount)   # Call parent method
    
    def resetCounter(self):
        """Resets withdrawal counter"""
        self.withdrawals = 0

>>> account = RestrictedSavingsAccount("Ken", "1001", 500.00)
>>> print(account)               # Inherited __str__
Name: Ken
PIN: 1001
Balance: 500.0

>>> account.getBalance()         # Inherited method
500.0

>>> for count in range(3):
...     account.withdraw(100)    # Works fine (3 times)
>>> account.withdraw(50)         # Fourth withdrawal fails
'No more withdrawals this month'

>>> account.resetCounter()       # New method
>>> account.withdraw(50)         # Works again!

class Child(Parent):
    def __init__(self, arg1, arg2, extra_arg):
        # Call parent constructor first
        super().__init__(arg1, arg2)   # Initialize parent part
        self.extra = extra_arg          # Initialize new part
    
    def overridden_method(self):
        # Do something new
        result = super().overridden_method()  # Call parent version
        return result + something_extra

class Animal:
    def speak(self):
        return "???"

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Cow(Animal):
    def speak(self):
        return "Moo!"

# Polymorphism in action
animals = [Dog(), Cat(), Cow()]
for animal in animals:
    print(animal.speak())  # Different output for each!
# Woof!
# Meow!
# Moo!

def make_sound(animal):
    if type(animal) == Dog:
        return "Woof!"
    elif type(animal) == Cat:
        return "Meow!"
    elif type(animal) == Cow:
        return "Moo!"

def make_sound(animal):
    return animal.speak()   # Works for any Animal subclass!

class Blackjack(object):
    """Manages a game of Blackjack"""
    
    def play(self):
        """Runs one game of Blackjack"""
        deck = Deck()
        deck.shuffle()
        
        player = Player()
        dealer = Dealer()
        
        # Deal initial cards
        player.addCard(deck.deal())
        player.addCard(deck.deal())
        dealer.addCard(deck.deal())
        
        # Player's turn
        while player.getPoints() < 21:
            print("Player:", player)
            print("Points:", player.getPoints())
            
            if input("Hit? (y/n): ").lower() != 'y':
                break
            
            player.addCard(deck.deal())
        
        # Dealer's turn
        while dealer.getPoints() < 17:
            dealer.addCard(deck.deal())
        
        # Determine winner
        self.determineWinner(player, dealer)

def calculate_tax(income):
    if income < 50000:
        return income * 0.10
    else:
        return income * 0.20

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance
    
    def deposit(self, amount):
        self.balance += amount
    
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount

def create_student(name):
    return {"name": name, "grades": []}

def add_grade(student, grade):
    student["grades"].append(grade)

def get_average(student):
    return sum(student["grades"]) / len(student["grades"])

class Student:
    def __init__(self, name):
        self.name = name
        self.grades = []
    
    def add_grade(self, grade):
        self.grades.append(grade)
    
    def get_average(self):
        return sum(self.grades) / len(self.grades)