Where would the best place to create Python objects be - python-3.x

Question

So I'm making an OOP based program in Python and I wanted to ask: Where would be the best place to create an object? Let's say I have this object from my program.
class Player(Item):
def __init__(self,Name,Diff,Money,Experience):
self.name = Name
self.diff = Diff
self.money = Money
self.experience = Experience
But I also have a main class game. Should I create the player object inside of class game, or maybe outside of all the classes so it is global? I don't know where I should make it so I can access it whenever I need it.

Answer 1

You're talking about where to define a class; this is a style question. Let's see what the Style Guide for Python Code (PEP 8) has to say about this:
Surround top-level function and class definitions with two blank lines.
Ok... That's not too helpful, because now I have to use my own knowledge to answer the question. Erm...
Well, I suppose it depends on what you're trying to say. If you've got this:
class Game:
class Player:
def __init__(self, name, difficulty, money=0, experience=0):
self.name = name
self.difficulty = difficulty
self.money = money
self.experience = experience
then that suggests that if you change the Game implementation you'll have to change the Player implementation, and you can't change the Player implementation without changing the Game implementation; i.e., they're tightly coupled. So the code might carry on like this:
def attack(self, game, other):
game.hurt(other, 1000 // self.difficulty)
if other.hp == 0:
self.money += other.money
other.money = 0
def hurt(self, enemy, damage):
enemy.hp -= damage // enemy.difficulty
if enemy.hp <= 0:
enemy.hp = 0
enemy.die(self)
self.player.experience += enemy.difficulty
This is not a great way of programming; everything's tied together too much and it's a big tangled mess. What's responsible for what? Instead, I'd have something more like this:
class Game:
def __init__(self):
self._entities = set()
def register(self, entity):
if entity not in self._entities:
self._entities.add(entity)
def unregister(self, entity):
if entity in self._entities:
self._entities.remove(entity)
def end(self):
print("Game over")
raise SystemExit(0)
class Entity:
def __init__(self, *args, game, **kwargs):
super().__init__(*args, **kwargs)
self.game = game
game.register(self)
def die(self):
self.game.unregister(self)
class Fighter(Entity):
def __init__(self, *args, difficulty, money=None, **kwargs):
super().__init__(*args, **kwargs)
if money is None:
money = (difficulty ** 2 - difficulty) // 2 + 1
self.difficulty = difficulty
self.money = money
self._hp = 1000
def attack(self, other):
money = other.hit(self, self.difficulty):
self.money += money
def hit(self, other, damage):
self._hp -= damage
if self._hp <= 0:
money = self.money
self.money = 0
self.die()
return money
# Didn't kill me, so gets no money
return 0
class Player(Fighter):
def __init__(self, *args, difficulty, money=None, experience=0, **kwargs):
if money is None:
money = 1000 // difficulty # You get less money the more skilled
# you are.
self.experience = experience
super().__init__(*args, difficulty=difficulty, money=money, **kwargs)
def die(self):
self.game.end()
def attack(self, other):
# Every time you attack an enemy, you get XP
self.experience += other.difficulty
super().attack(other)
This is crude and poorly designed, but you get the general idea. Each thing is in charge of dealing with its own stuff. Really the world should be in charge of checking whether all of the players are dead, but as it doesn't store players separately I couldn't show that in the example.