Simulateur de paris martingale
Le script simule la stratégie de pari Martingale consistant à miser un montant fixe jusqu'à ce qu'une perte se produise, auquel moment le parieur double le pari pour compenser la perte. Cela continue jusqu'à ce qu'une victoire se produise. Après une victoire, le pari est réinitialisé à la valeur de mise d'origine. J'ai mis les chances d'imiter le Blackjack (49% de chances de gagner). Pour plus de simplicité, le montant gagné ou perdu dans un tour est égal au pari. La simulation se termine lorsque le nombre spécifié de tours s'est écoulé, que la taille du pari suivant est supérieure aux fonds actuellement disponibles, que les fonds disponibles atteignent 0 ou que l'objectif de profit est atteint.
Je suis tout nouveau dans Python et le codage en général, donc tout commentaire serait apprécié.
import random
class MartGame:
def __init__(self, bet=25, starting_funds=5000, goal_profit=1000, round_n=0, rng_v=0.00,
wins=0, losses=0, loss_run=0, win_run=0):
self.bet = bet
self.starting_funds = starting_funds
self.goal_profit = goal_profit
self.round_n = round_n
self.rng_v = rng_v
self.wins = wins
self.losses = losses
self.los_run = loss_run
self.win_run = win_run
self.original_bet = bet
self.current_funds = self.starting_funds
def rng(self):
"""Generates random number"""
self.rng_v = random.random()
def winloss_generator(self):
"""Generates win/loss condition"""
if self.rng_v <= .49:
return 'win'
else:
return 'loss'
def increase_winloss(self):
"""Increases wins or losses variable based on winloss_generator output"""
if self.winloss_generator() == 'win':
self.wins += 1
return 'win'
elif self.winloss_generator() == 'loss':
self.losses += 1
return 'loss'
else:
print('error')
def increase_round(self):
"""Increases round number by 1"""
self.round_n += 1
def change_current_funds(self):
"""Increases or decreases current_funds based on winloss_generator output"""
if self.winloss_generator() == 'win':
self.current_funds += self.bet
elif self.winloss_generator() == 'loss':
self.current_funds -= self.bet
else:
print('error')
def change_bet(self):
"""If outcome is a win, bet is reset to original value. If outcome is a loss bet is doubled"""
if self.winloss_generator() == 'win':
self.bet = self.original_bet
elif self.winloss_generator() == 'loss':
self.bet = self.bet * 2
def running_profit(self):
"""Returns running profit"""
return self.current_funds - self.starting_funds
def current_funds(self):
"""Returns running total of funds"""
return self.current_funds
def print_current_record(self):
"""Prints current win/loss record to screen"""
print('Current Record: ', self.wins, 'wins, ', self.losses, 'losses')
def print_winloss(self):
"""Prints win/loss condition to screen"""
print(self.winloss_generator())
def print_profit(self):
"""Prints running profit to screen"""
print(self.running_profit(), 'running_profit'.upper())
def print_running_total(self):
"""Prints running total to the screen"""
print(self.current_funds, 'current funds'.upper())
def print_round(self):
"""Prints current round"""
print('Round:', self.round_n)
def print_current_bet(self):
"""Prints current bet"""
print('Bet:', self.bet)
def run(self, rounds, each=False):
"""Runs simulation for specified number of rounds. 'each' argument indicates
whether each round should be displayed. False will only display the final results"""
while self.running_profit() < self.goal_profit and \
self.round_n < rounds and self.current_funds > 0 \
and self.current_funds > self.bet:
self.increase_round()
self.rng()
self.winloss_generator()
self.increase_winloss()
self.change_current_funds()
if each is True:
self.print_round()
self.print_current_bet()
self.print_winloss()
self.print_running_total()
self.print_profit()
self.print_current_record()
print()
self.change_bet()
print()
self.end_script()
def end_script(self):
"""Prints final outcome of the simulation and summary of the results"""
if self.running_profit() == self.goal_profit:
print('YOU WIN!')
else:
print('YOU LOSE')
print("Total Rounds:", self.round_n)
print('Win/Loss Record: ', self.wins, 'Wins', self.losses, 'Losses')
print('Ending Funds:', self.current_funds)
print('Goal Profit:', self.goal_profit)
print("Ending Profit:", self.running_profit())
inst = MartGame(25, 5000, 1000)
inst.run(1000, True)
```
Réponses
Les classes sont utiles lorsque vous souhaitez créer plusieurs objets à partir de la même classe ou créer et détruire des objets lors de l'exécution. Dans ce cas, vous n'avez qu'un seul objet.
Ce n'est pas le genre de programme où vous avez besoin d'un cours. Si vous n'utilisez pas de classe, vous pourriez avoir exactement le même programme, mais supprimer tous les éléments self.de votre code, ce qui le rend plus court et plus facile à lire et à écrire.
Tout cela n'est pas nécessaire non plus (lorsque vous n'utilisez pas de classe) puisque les variables seront simplement globales dans le script, ou locales dans votre main()fonction si vous en avez une.
self.bet = bet
self.starting_funds = starting_funds
self.goal_profit = goal_profit
self.round_n = round_n
self.rng_v = rng_v
self.wins = wins
self.losses = losses
self.los_run = loss_run
self.win_run = win_run
self.original_bet = bet
self.current_funds = self.starting_funds
La fonction ci-dessous n'a pas non plus de sens, que vous utilisiez une classe ou non. Il n'est utilisé qu'à un seul endroit du code, ce qui permettrait au développeur d'économiser des lignes de code et de l'intelligence pour simplement incrémenter la variable directement à cet endroit, et non via une fonction.
def increase_round(self):
"""Increases round number by 1"""
self.round_n += 1
La fonction ci-dessous est encore plus inutile. Il n'est même pas appelé puisque vous faites (correctement) référence à la variable directement là où elle est utilisée. Elle porte également le même nom que la variable current_funds, ce qui peut entraîner des problèmes.
def current_funds(self):
"""Returns running total of funds"""
return self.current_funds
Le dessous semble bizarre. Pourquoi n'imprimez-vous pas 'RUNNING_PROFIT'?
'running_profit'.upper()