How to Play Smart Roulette using Python
I like Python, I like math, and I like the casino, so I might as well combine all that to make a little program to model a roulette wheel and calculate probabilities, right?
This program will allow simulating a roulette game a lot of times in order to calculate probabilities and to find the best strategies to use according to a winning goal!
Obviously, I am not encouraging anyone to play roulette, I am just doing this program for fun!
Now, let’s dive into coding. I’ve made a Git repo, you can find the code here on my GitHub.
Roulette
The Roulette class is used to model roulette, not as the game, but as the object.
This class allows us to spin the wheel, get the current number, the roulette history, and the pockets. The pockets are used to define what happens when the ball land on a number, for example, if the ball lands on 0, then the color is green.
PocketsBuilder
To model the pocket, I’ve chosen to use a dictionary. Each key is a number, and the values are the colors, the parity, etc…
Bets
To model the bets, I’ve created a generic Bet class. A bet has a type (color, number, dozen, etc…) and an amount. It also implements a method to calculate the winnings using the current number of the roulette and the multiplier of the bet.
Each bet type is described by an Enum . For those who don’t know, an Enum is a base class used to create enumerations like in many other languages.
Player
What would be roulette without players? Even if we make simulations, let’s create a Player class.
A player is defined by a name, a strategy, and a starting balance. I’ve also added some attributes to the class to track statistics, such as the cash history, or the winnings history of the player.
A player can pay, receive winnings, win, lose, and make bets. These methods are easy to implement. Also, the win , lose , and make_bets methods will be defined in the strategy, but the Playerclass should provide an access to these methods.
A last method is implemented to reset the player’s state if needed.
RouletteGame
Before diving into the strategies, we can create a RouletteGame class used to model roulette as the game (not as the object like before).
This class is just used to allow several players to play, and to collect their winnings when they win.
Strategies
This concept of strategies was the hardest thing for me to model. I wasn’t very sure how to do it in an efficient way.
I’ll show you the base strategy class, and explain how a strategy works.
First, a strategy is initialized with an initial bet. Indeed, for a lot of strategies, an initial bet is needed. For example, with Martingale, you have an initial bet you increase every time you lose.
Then, a strategy decides what bets it should make. For example, a strategy can decide to always put the initial bet on black.
Then, a strategy should define methods to know what to change when it wins or loses. These methods may require the player and the roulette history in parameters.
Lastly, a strategy should be resettable, so it needs a reset method.
Now, an example. Let’s implement the Martingale strategy. Here are the rules:
- If we lose, we double the last bet.
- If we win, we go back to the initial bet.
- To make things simple, we always bet on red.
And here is how we can implement it in our program:
Do you see how easy it is? That’s exactly what I wanted with this program, I wanted the strategies to be easily implemented.
Another example, to show how to implement a random strategy. Here are the rules.
- If we win, nothing happens.
- If we lose, nothing happens.
- We bet on a random number.
I’ve not done it, but we can also implement strategies working with several bets, that’s why make_bets returns a list.
AutoRoulette
We want to work with a lot of simulations to calculate probabilities, so we need an auto roulette.
In fact, we don’t need such a class, we can do it easily with conditions. But to keep things organized, I prefer to create a class for this purpose.
I’ve implemented only 2 conditions, you can add more if you want! One condition to play n times, and the other to play until a player has reached a specific amount.
ProbabilitiesCalculator
This class is used to calculate the probabilities depending on conditions. For example, what is the probability of reaching 1000€ starting with 500€ using Martingale? This class is used to answer this question.
To calculate probabilities, we just have to repeat a condition n times. An example of a condition is: “If the player is ruined before reaching the objective, then it’s considered a failure. Else, it’s a success”. If for 100 000 simulations, I have 10 000 failures and 90 000 successes, the probability of reaching this objective with this strategy is 90%.
I’ve added a method to find the best strategy to reach an objective among a list of strategies. The best strategy is described as the one with the higher probability.
I’ve also added some methods to plot probabilities. It’s useless, but I love charts.
Analyzers
Before trying our program, I added classes to analyze data, such as the max winning streak of the player, the max drawdown, etc...
They inherit from a base class:
The following classes are not so important, you can skip to the following section if you want. They are just useful if you like statistics, or if you like to have more metrics about the performance of your strategies.
Let’s Play Smart!
Now we have everything required to test our strategies. Let’s create a small script to calculate the probability of reaching x dollars with a specific strategy:
As you can see, the script is very short and easy. That’s why having a lot of classes and separating the concerns is useful.
In the script, I’ve chosen to calculate the probability of reaching 2000€ with a 1000€ starting balance, using Martingale with a 1€ initial bet.
Let’s see what happens when I run the script:
Probability of reaching 2000 with Martingale(1) is 0.2609
26%… It’s a bit risky. And if we change the initial bet to something like 100€?
strategy = Martingale(100)
...
Probability of reaching 2000 with Martingale(100) is 0.3281It’s a bit better…
But now, we want to find the best strategy among a lot of strategies, so let’s create another script:
As you can see, I’ve implemented some famous strategies. I won’t explain them, but you can find them on my GitHub in this article’s repo, whose link is at the top of the article.
Let’s run the code!
Best strategy to reach 2000 is AllIn(0) with a probability of 0.469
Whaaaat??? Is the best strategy really all in? Well, if you want to double your balance, yes, it’s obvious. Because the more you play, the more you lose. So the best thing to do is to play just one time, all in is perfect for that.
And if the objective is something like 1100€?
Best strategy to reach 1100 is Dalembert(100, 1000) with a probability of 0.888
Perfect! That’s how we play smart roulette!
Final Note
Making this program was a good exercise because it’s not that easy to model a roulette in Python. And it’s useful because it shows you that you can only lose money if you gamble! (for those who didn’t know that yet)
Maybe later I’ll try something similar with other games such as Black Jack, I don’t know.
To explore more of my Python stories, click here! You can also access all my content by checking this page.
If you want to be notified every time I publish a new story, subscribe to me via email by clicking here!
If you’re not subscribed to medium yet and wish to support me or get access to all my stories, you can use my link:
