哪种创建类属性的方法更好，为什么？

Question

Only a couple of months or so into programming (Python) and I'm trying to wrap my head around this so that I don't end up writing inefficient code.

Let's say I'm creating classes for default enemies in a game. I use 'ENEMY01' and 'HERO01' just for clarity purpose (they both can be consider the 'same' class written differently). Consider this pseudo code; if there are any errors, it's just because I missed them in this post and I'm not having problems with the code itself. If you have a more efficient way of writing what I wrote though, it will be appreciated.

Example 1-

class ENEMY01:
    attack = randint(0,20)
    defense = randint(1,20)
    health = 100

Example 2-

class HERO01:
    def __init__(self, attack=randint(1,20),defense=randint(1,20), health=100)
        self.attack = attack
        self.defense = defense
        self.health = health

It seems to me that Example 1 is better because it's shorter and easier to understand. With Example 2, because of the default values, you can either stick with the defaults or change them at instantiation. I understand that may be a minor benefit, but I noticed you can also change those default values right after creation with both examples anyway-

Jobo = ENEMY01()
Jobo.attack
10
Jobo.attack = 15
Jobo.attack
15

Bobo = HERO01()
Bobo.attack
10
Bobo.attack = 15
Bobo.attack
15

And if I wanted to add a new attribute to either (I think that's called instance attribute, since it doesn't change the class), there doesn't seem to be a limit on either-

Bobo.scream = 'Ouch'
Bobo.scream
'Ouch'
Jobo.scream = 'Ouch'
Jobo.scream
'Ouch'

My noob guess is that because Example 2 uses methods (as in 'function'), I could theoretically create instances of Example 2 that are capable of reacting to new 'information' by adding more capability to the function in the class (ways for it to react to certain attacks or conditions, for example). I'm thinking that if I go the Example 1 route, I would have to add that type of reactive code each time I need it where I need it, instead of letting it 'live' in the class method? Except couldn't I fix that problem by adding functions to Example 1?

So what are the pros and cons of Example 2 over Example 1 (or vice versa) as written or is there a better way to rewrite either to give one an impossible to match advantage over the other?

Sidenote - I'm going through a tutorial right now and it seems that even though he started with Example 1, and has moved on to the style in Example 2, that I can still accomplish everything he's doing with example one (except for the changing of values at instantiation), and yet he's making it seem (without explanation) that Example 2 is so much more superior and different. Hence my question. Maybe the ability to changes values at instantiation is more important than I'm giving it credit for?

Answer 1

Neither is "better," because they're different.

class ENEMY01:
    def __init__(self):
        self.attack = randint(0,20)
        self.defense = randint(1,20)
        self.health = 100

For the above, each new instance will have different random values.

class HERO01:
    def __init__(self, attack=randint(1,20),defense=randint(1,20), health=100)
        self.attack = attack
        self.defense = defense
        self.health = health

For the above, each new instance will get the same default values, changing on successive runs of the program. If it picks 12 for attack , every instance will have an attack of 12 . Next time you started the program, you'd get another single randomly-selected value applied to each instance. Maybe it would be 2 for every instance this time.

Also, class variables are substantively different from instance variables and you shouldn't use one to mimic the other.

Overall, you should match the __init__() to the manner in which you intend to call and use the class.