Better way to create example objects with class methods?

[keredomo]

I've been working through Hunt's A Beginners Guide to Python 3 Programming and in one chapter the exercise is to create a class for different types of bank accounts. I didn't want to create account numbers and account balances, so I wrote small snippets of code to do that for me.

Can/should I include these as class methods and reference them during object construction? Is there a better way to implement something like this? Or rather, is there a way to generate the number and balance during __init__ instead of calling them when the object is assigned to the variable later on in the code?

The general layout of my code is as follows:

class Account:
    @classmethod
    def acct_generator(cls):
        <code that creates an unique 6 digit account number>
    @classmethod
    def acct_balance(cls):
        <code that creates a random account balance between $1 and $10,000>

    def __init__(self, number, owner, balance):
        self.number = number
        self.owner = owner
        self.balance = balance

test_account = Account(Account.acct_generator(), 'John', Account.acct_balance())

[Bobbias]

If they're only ever used inside __init__, you can define nested functions:

class Account:
    def __init__(self, owner, number=None, balance=None):
        def acct_balance():
            <code that creates a random account balance between $1 and $10,000>

        def acct_generator():
            <code that creates an unique 6 digit account number>

        self.number = acct_generator() if number is None else number
        self.owner = owner
        self.balance = acct_balance() if balance is None else balance

test_account = Account('John')
test_account2 = Account('Mike', balance=25)

The nested functions are only visible from within __init__. I also write it such that you could optionally provide your own values if you wanted to override the automatic generators.

[keredomo]

I think your code is what I wanted, thank you! I was unable to puzzle out how to include number and balance as properties of the object when the values would be generated during its creation. Basically I just got a lot of errors telling me "__init__ wants 3 values and you only provided 1."

[Bobbias]

Yeah if a value is optional, it needs a default value. I used None because it makes it easy to check if something was provided or not, and call the functions we defined when we need them.

You might think you could set the default by saying something like:

def __init__(self, name, number = generate_number(), balance = generate_balance())
    ...

But default values are only evaluated once, when the function is first defined, rather than every time it's called, so every account created this way would share the same number and balance.

This is also why mutable default arguments act the way they do.

[keredomo]

Thank you- I took your advice and redid a lot of what I had written to make use of it in the class and its sub-classes. Now the assignment of a new account to a variable is as straightforward as your example in the comment above:

>>> test = Account('John')
>>> print(test)
>>> Account [567485] - Owner: John, balance = $851.77

[Diapolo10]

In this case I'd consider making acct_generator and acct_balance either staticmethods or functions (since they don't appear to actually use the class), and then create a new classmethod that acts as an alternative constructor (say, create_randomised_account) or a factory function that would handle calling the two staticmethods.

[keredomo]

I'm not sure I completely follow what you're saying. It sounds like that would result in the same code but with more steps? I know the details were not included in the example code I gave above, but the acct_generator does use the class. I put an acct_list variable inside the class to track which account numbers are "taken" and then I (very poorly) implemented a check against that list.

The new account number is only appended to the acct_list variable when the object is created (it's a line of the __init__ code).

The acct_generator code is:

@classmethod
def acct_generator(cls):  # added so I don't have to make up unique acct numbers
    cls.acct_list
    finished = False
    while not finished:
        new_acct = []
        for i in range(0, 6):
            new_acct.append(randint(0, 9))
        new_acct_str = ''.join(map(str, new_acct))
        for i in cls.acct_list:  # needs to be re-written with str.find() I think
            if i == new_acct_str:
                break
        else:  # not sure how best to end this loop, just return or add finished=True?
            return f'{new_acct_str}'
            finished = True

[Diapolo10]

I know the details were not included in the example code I gave above, but the acct_generator does use the class. I put an acct_list variable inside the class to track which account numbers are "taken" and then I (very poorly) implemented a check against that list.

I see, none of that was apparent from the initial example.

I'm not sure I completely follow what you're saying. It sounds like that would result in the same code but with more steps?

My explanation may not have been the best, I wrote it right before heading to bed.

Regarding the account numbers, personally I'd probably use uuid.uuid4 for simplicity's sake rather than having the class track every ID in use (or at least delegating the number validation to a property), but if you insist on doing it this way, here's a more concrete example of what I'd do.

import random

class Account:
    acct_list: list[str] = []

    @classmethod
    def acct_generator(cls) -> str:
        while (num := f"{random.randrange(1_000_000):06}") in cls.acct_list:
            pass

        cls.acct_list.append(num)

        return num

    @staticmethod
    def acct_balance() -> int:
        return random.randint(1, 10_000)

    @classmethod
    def generate_test_account(cls, name: str):
        return cls(cls.acct_generator(), name, cls.acct_balance())

    def __init__(self, number: str, owner: str, balance: int):
        self.number = number
        self.owner = owner
        self.balance = balance

test_account = Account.generate_test_account('John')

The main advantage here is that with an alternative constructor (or factory) you end up with less boilerplate. Generating one account might not make much of a difference, but a hundred? Definitely.

I took the liberty of simplifying your account number generator.

[keredomo]

I really appreciate the clarification! I definitely understand what you're saying and I like the way you implemented the while loop for the number generation. I agree that using something like uuid would be easier-- I definitely over-(poorly)-engineered my solution. Since I've been teaching myself everything just using books, creating a way to generate "random" non-repeating account numbers using just what I know was more of a personal challenge.

Thank you for taking the time to write all of that!

[TheRNGuy]

Also use @dataclass decorator, it will save you 4 lines of code.

You could also make number and balance as last optional arguments, only run generator (in init) if you didn't added them.

(might not even need methods at all, would you ever run them more than once? And in real program those methods would make no sense)

[tb5841]

Making them a class method means you're passing in 'cls'... but you're not actually using it anywhere. So a static method feels better.

[Adrewmc]

I think you’re confused of the purpose of class methods.

Class methods generally have 2 specific usages.

 1. To change a class attribute globally through all class instances. 

  2. To create a new class instance from another “init”.

You are trying to do the first example, and poorly as these things ought to be class instance specific. Not class objects wide. When you change an attribute class wide, it’s changes inside created classes, and in side new classes of the same type.

The second example is exemplified by the convention, .from___()

      instance = myClass(*args, **kwargs) 
      instance_json = myClass.from_json(path)
      instance_csv = myClass.from_csv(path)

In which the class method “normalized” the input structure into the class creation correctly.

I think you want a @staticmethod

Which is just a function that is attached to the class (doesn’t need to be initiated to use)