Class Level Variables python

Question

I am having trouble with class level variables. I am trying to figure all I can do with classes. I decided to create a bank account classes and eventually sub-classes but I got hung up on trying to create unique bank accounts.

class BankAccount(object):
    """Creates Bank Account and Functions"""
    account_names = []

    ### Bank Account
import random

class BankAccount(object):
    """Creates Bank Account and Functions"""
    account_names = []

    def __init__(self, name, balance = 0):
        try: # because account_name doesn't exit until the first instnace
            for people in account_names: #iterate account names
                if people == name: #check if name is in class_var
                    print "Name already exists!"
                    break #end instantiation
                else: # its a unque name add to the class and object
                    self.name = name 
                    self.account_names.append(self.name)
        except: #First intantition
            self.name = name
            self.account_names.append(self.name)

        self.balance = float(balance)

If I could verify unique self.account data than I can implement a payment mechanism between bank account holders. However, I can figure out the way to do this. I thought class level vars would do the trick but my out put is:

['Bernie', 'Jerry']
['Bernie', 'Jerry']
['Bernie', 'Jerry', 'Jerry']

Which implies it just appends and therefore an exception has occurred (correct?) why am I still getting an exception the variable exits since it is getting appended to.

Here is a link to the gist

Your variable is exactly what you called it: a class-level variable. It belongs to the class, not to an instance of the class. self.account_names is actually BankAccount.account_names, so all instances of BankAccount share exactly the same account_names list. Create your list in the __init__ method and it'll be an instance variable. — Blender
– Blender, Commented Oct 1, 2014 at 1:21
How would I call it inside of the class: class. or cls. instead of self? — Grouchy
– Grouchy, Commented Oct 1, 2014 at 2:10
You don't want it to be a part of the class, so put self.account_names = [] at the top of the __init__ method. — Blender
– Blender, Commented Oct 1, 2014 at 2:55

Simon Boudrias · Accepted Answer · 2014-10-01 06:53:27Z

1

Class variables are attached to the class, not the instance. This mean they're shared between instances (so in this case the list is the same for all instances).

You can create instances specific variables inside the __init__ method. A simple example:

class BankAccount(object):
    def __init__(self):
        self.account_names = []

Usually, you won't see the differences between class-level variables and instances-level if you simply use immutables types as class variables (like str, tuple, etc). It's usually a good idea to never set mutable types, like dict or list, as class variables.

answered Oct 1, 2014 at 6:53

Simon Boudrias

44.9k16 gold badges109 silver badges137 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Burhan Khalid · Accepted Answer · 2014-10-01 06:55:23Z

At a (real) bank, the bank knows information about all of its accounts. Each account has information about the account holder, and the account balance, and transactions; but it doesn't know anything about other customers/accounts.

To transfer money from one account to another, the bank has to be involved.

You need to implement similar things here. Your "bank" can be a class, that holds a collection of other accounts.

class Bank(object):
    def __init__(self, name):
       self.name = name
       self.accounts = []  # Note - this is at the instance level
                           # so multiple banks don't share each other's accounts

    def add_account(self, account):
       self.accounts.append(account)

    def delete_account(self, account):
       try:
           self.accounts.remove(account)
       except ValueError:
           print('{} is already deleted.'.format(account))

    def transfer(self, from_acct, to_acct, amount):
       if amount < from_account.get_balance():
           print('{} is less than the balance of the from account'.format(amount))
       to_account.credit(amount)
       from_account.debit(amount)

Now, each account holds its own information

class Account(object):

    def __init__(self, name, balance):
        self.name = name
        self.balance = balance

    def credit(self, amount):
        self.balance += amount

    def debit(self, amount):
        self.balance -= amount

    def get_balance():
        return self.balance

Now you can do this:

account_one = Account('John Smith', 500)
account_two = Account('Jane Smith', 100)

bank = Bank("The Bank O'Money")
bank.add_account(account_one)
bank.add_account(account_two)
bank.transfer(account_one, account_two, 10)
bank.accounts # <-- this will be a list of two objects

another_bank = Bank("The Bank of Even More Money")
another_bank.accounts # <-- this will be empty

This kind of pattern - where a bunch of objects should be referred to as one is called the composite pattern because the object is composed of other objects.

The Bank is just a way to refer to a bunch of accounts together.

This is very help. I just learned about composition and this makes a lot of sense to have two separate classes.

Collectives™ on Stack Overflow

Class Level Variables python

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related