class CreditCard:
    """A consumer credit card"""

    def __init__(self, customer, bank, actn, limit):
        """Create a new credit card instance.
        The initial balance is zero.

        customer the name of the customer (e.g., John Bowman )
        bank the name of the bank (e.g., California Savings )
        acnt the acount identifier (e.g., 5391 0375 9387 5309 )
        limit credit limit (measured in dollars)
        """
        self._customer = customer
        self._bank = bank
        self._account = actn
        self._limit = limit
        self._balance = 0

    def get_customer(self):
        """Return the name of the customer"""
        return(self._customer)

    def get_bank(self):
        """Return the bank's name"""
        return(self._bank)

    def get_account(self):
        """Return the card identifying number (stored as a string)"""
        return(self._account)

    def get_limit(self):
        """Return the current credit limit"""
        return(self._limit)

    def get_balance(self):
        """Return the current balance"""
        return self._balance

    def charge(self, price):
        """Charge given price to the card, assuming suﬃcient credit limit.
            Return True if charge was processed; False if charge was denied.
        """
        if price+self._balance > self._limit:
            return(False)
        else:
            self._balance += price
            return(True)

    def make_payment(self, amount):
        """Process customer payment that reduces the balance"""
        self._balance -= amount

if __name__ == '__main__':
    wallet = []
    wallet.append(CreditCard('John Bowman', 'California Savings', '56 5391 0375 9387 5309' , 2500))
    wallet.append(CreditCard('John Bowman', 'California Federal', '58 3485 0399 3395 1954' , 3500))
    wallet.append(CreditCard('John Bowman', 'California Finance', '60 5391 0375 9387 5309' , 5000))

    for val in range(17):
        wallet[0].charge(val)
        wallet[1].charge(2*val)
        wallet[2].charge(3*val)

    for c in range(3):
        print('Customer =' , wallet[c].get_customer())
        print('Bank =', wallet[c].get_bank())
        print('Account =', wallet[c].get_account())
        print('Limit =', wallet[c].get_limit())
        print('Balance =', wallet[c].get_balance())
        while(wallet[c].get_balance() > 100):
            wallet[c].make_payment(100)
            print('New balance = ', wallet[c].get_balance())
        print()

    # Try accessing the nonpublic data member balance
    print(wallet[0]._balance)
    wallet[0]._balance += 100
    print(wallet[0]._balance)
    # We observe that it is not enforced strictly

Customer = John Bowman
Bank = California Savings
Account = 56 5391 0375 9387 5309
Limit = 2500
Balance = 136
New balance =  36

Customer = John Bowman
Bank = California Federal
Account = 58 3485 0399 3395 1954
Limit = 3500
Balance = 272
New balance =  172
New balance =  72

Customer = John Bowman
Bank = California Finance
Account = 60 5391 0375 9387 5309
Limit = 5000
Balance = 408
New balance =  308
New balance =  208
New balance =  108
New balance =  8

36
136

class Vector:
    """Represents a vector in a multidimensional space"""

    def __init__(self, d):
        """Create d-dimensional vectors of zeros"""    
        self._coords = [0]*d

    def __len__(self):
        """Return the dimension of the vector"""
        return len(self._coords)

    def __getitem__(self, j):
        """Return the j^th coordinate of the vector"""
        return self._coords[j]

    def __setitem__(self, j, val):
        """Set the j^th coordinate to a given value"""
        self._coords[j] = val

    def __add__(self, other):
        """Return the sum of two vectors"""
        if len(self) != len(other):
            raise ValueError('dimensions must agree for sum')
        result = Vector(len(self)) # Create a result vector of zeros
        for j in range(len(self)):
            result[j] = self._coords[j] + other[j] # other[j] uses the __getitem__ method
        return result

    def __eq__(self, other):
        """return True if the vector has all the coordinates same as the other"""
        return self._coords == other._coords

    def __ne__(self, other):
        """return True if the vector differs from the other"""
        return not self == other # This relies on the __eq__ method

    def __str__(self):
        """return the string representation of the vector"""
        return '<' + str(self._coords)[1:-1] + '>'

v = Vector(5) #create a 5-dimensional vector initialized to zeros
print(v)
v[1] = 23        # based on use of __setitem__
print(v)
v[-1] = 45
print(v)
print(v[4])
u = v + v
print(u)
total = 0
for coordinate in v:       # implicit iteration via __len__ and __getitem__
    total += coordinate
print(total)

<0, 0, 0, 0, 0>
<0, 23, 0, 0, 0>
<0, 23, 0, 0, 45>
45
<0, 46, 0, 0, 90>
68

class SequenceIterator:
    """An iterator for any Python sequence type"""

    def __init__(self, sequence):
        """create an iterator for the given sequence"""
        self._seq = sequence     # keep a reference to the underlying data
        self._k = -1             # will increment to 0 on first call to next

    def __next__(self):
        """Return the next element, or else raise StopIteration error."""
        self._k += 1             # Advance to the next index
        if self._k < len(self._seq):
            return(self._seq[self._k])     #return the data element
        else:
            raise StopIteration()          #there are no more elements

    def __iter__(self):
        """By convention, an iterator must return itself as an iterator."""
        return self

v = Vector(10)
print(v)
v[0], v[1], v[2], v[3], v[4], v[5] = 1, 2, 3, 4, 5, 6
v[6], v[7], v[8], v[9] = 7, 8, 9, 10
print(v)
sequence = SequenceIterator(v)
for i in sequence:
    print(i, end=", ")

<0, 0, 0, 0, 0, 0, 0, 0, 0, 0>
<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

class Range:
    """A class that mimic s the built-in range class."""

    def __init__(self, start, stop=None, step=1):
        """Initialize a Range instance... similar to range"""
        if step == 0:
            raise ValueError('Step cannot be 0')
        if stop is None:              #special case of range(n)
            start, stop = 0, start    #should be treated as if range(0,n)
        # calculate the eﬀective length once
        self._length = max(0, (stop - start + step - 1)//step)

        #need knowledge of start and step (but not stop) to support __getitem__
        self._start = start
        self._step = step

    def __len__(self):
        """return the number of entries in the range"""
        return self._length

    def __getitem__(self, k):
        """Return entry at index k (using standard interpretation if negative)."""
        if k < 0:
            k += len(self)     # attempt to convert negative index
        if not 0 <= k <= self._length:
            raise IndexError('index out of range')

        return self._start + k * self._step

if __name__ == '__main__':
    for i in Range(1, 20, 3):print(i, end=", ")
    i = Range(2, 40, 5)
    print("\n", i[5])

1, 4, 7, 10, 13, 16, 19, 22, 
 27

ACOL106: Data Structures

(Recap: Python Module 4)

1. Object-oriented programming: Goals and principles

Design Goals

Object-oriented design principles

2. Software Development

3. Class Definitions

3.1 Example: CreditCard Class

The self Identifier

The Constructor

Encapsulation

Additional methods

Error checking

Testing the class

3.2 Operator Overloading and Python’s Special Methods

Non-operator overloads

Implied methods

Example: A Multidimensional Vector Class

3.3 Iterators

Example: Range class

Module Endnote