Modelling the game of poker

Being in Las Vegas, it's difficult to think about poker and not ask yourself "How does it really work? What are the odds of winning with a given hand?". Therefore, this post is devoted to an attempt at implementing a poker simulation.

Below, I collected a set of references that I have used while writing this post:

The card game model

To start off, we're going to need to model a card game. A deck of cards is modelled as a sequence of cards. I chose to model an individual card using a tuple containing the suite of the card and its value. There are four suits: clubs, diamonds, hearts and spades. The suite is coded using initials c, d, h and s. Then there are 13 ranks, which are coded by their number for cards 2-10 and 11-14 for jacks, queens, kings and the ace.

Based on this, we can write the following function, which generates a new game:

In [1]:
def new_card_game():
    game = []
    for suite in ('c', 'd', 'h', 's'):
        for rank in range(2, 15):
            game.append((suite, rank))
    return game
In [2]:
game = new_card_game()
game[:5]
Out[2]:
[('c', 2), ('c', 3), ('c', 4), ('c', 5), ('c', 6)]

To shuffle a card game, we simply use the built-in shuffle function.

In [3]:
from random import shuffle
In [4]:
shuffle(game)
game[:5]
Out[4]:
[('c', 6), ('s', 3), ('c', 4), ('h', 9), ('d', 10)]

We can thus define a new shuffled deck method:

In [5]:
def new_shuffled_card_game():
    game = new_card_game()
    shuffle(game)
    return game

Detecting poker hands

What we now need is a way to compare strenghts of different poker hands. To code this, I am following the advice found here: I will code a comparator that checks whether a given combination is present or not. To start, I'm going to code the elementary functions will detect the standard hands found in poker:

  • straight flush
  • four of a kind
  • full house
  • flush
  • straight
  • three of a kind
  • two pair
  • one pair
  • high card

I set myself the following specifications for the functions that will follow below:

  • each of these function takes a sequence of cards as an input (not necessarily five)
  • each function uses a tuple as output with two things
    • a boolean that says whether the category was detected in the cards
    • a rank linked to the category, that makes it possible to compare cards within their category

Let's start by inplementing how to check for a four of a kind. To do this, we count the number of occurences of a given card in the hand, using the built-in Python Counter.

In [6]:
from collections import Counter
In [7]:
def contains_four_of_a_kind(hand):
    if len(hand) < 4: 
        return (False, None)
    cnt = Counter([card[1] for card in hand])
    fours = filter(lambda item: item[1]==4, cnt.most_common())
    if fours != []:
        return (True, max(fours, key=lambda item: item[0])[0])
    else:
        return (False, None)
In [8]:
print contains_four_of_a_kind([('c', 4), ('c', 5), ('c', 6), ('c', 7), ('c', 8)])
print contains_four_of_a_kind([('c', 4), ('s', 4), ('d', 4), ('h', 4), ('c', 8)])
print contains_four_of_a_kind([('c', 4), ('s', 4), ('d', 4), ('h', 4), ('c', 8),
                               ('c', 9), ('s', 9), ('d', 9), ('h', 9), ('c', 11)])
(False, None)
(True, 4)
(True, 9)

To check for a full house, we proceed as with the previous function and count the occurences of cards in the hand, but verify that the two most common cards are present 3 and 2 times.

In [9]:
def contains_full_house(hand):
    if len(hand) < 5:
        return (False, None)
    cnt = Counter([card[1] for card in hand])
    most_common = cnt.most_common()
    threes = filter(lambda item: item[1]==3, most_common)
    twos = filter(lambda item: item[1]==2, most_common)
    if threes != [] and twos != []:
        return (True, max(threes, key=lambda item: item[1])[0])
    else:
        return (False, None)
In [10]:
print contains_full_house([('c', 4), ('s', 4), ('d', 5), ('h', 5), ('c', 5)])
print contains_full_house([('c', 4), ('s', 4), ('d', 5), ('h', 5), ('c', 5), 
                           ('d', 10), ('h', 10), ('c', 10)])
(True, 5)
(True, 10)

The flush is detected by counting the number of cards by suites and then making sure there are at least five of the most common suite.

In [11]:
def contains_flush(hand):
    if len(hand) < 5: 
        return (False, None)
    cnt = Counter([card[0] for card in hand])
    fives = filter(lambda item: item[1]==5, cnt.most_common())
    if fives != []:
        suite = max([item[0] for item in fives])
        return (True, max([item[1] for item in hand if item[0] == suite]))
    else:
        return (False, None)
In [12]:
print contains_flush([('c', 2), ('h', 14), ('d', 3), ('d', 4), ('d', 5)])
print contains_flush([('c', 2), ('c', 14), ('c', 3), ('c', 4), ('c', 5)])
(False, None)
(True, 14)

The straight is detected by sorting the cards on hand, then taking only unique cards using the Python built-in set (meaning only one 3, even if there are five of them) and finally checking whether there are five increasing numbers in a row, using the range function.

In [13]:
def contains_straight(hand):
    sorted_hand = sorted(set([card[1] for card in hand]))
    if len(sorted_hand) < 5:
        return (False, None)
    if 14 in sorted_hand: # taking into account that the ace can be a one
        sorted_hand.insert(0, 1)
    for shift in range(len(sorted_hand) - 4):
        if sorted_hand[shift: shift + 5] == range(sorted_hand[shift], sorted_hand[shift] + 5):
            return (True, sorted_hand[shift + 4])
    return (False, None)
In [14]:
print contains_straight([('d', 2), ('d', 3), ('d', 4), ('d', 5), ('d', 6)])
print contains_straight([('d', 2), ('h', 4), ('d', 3), ('d', 5), ('d', 6)])
print contains_straight([('d', 2), ('h', 14), ('d', 3), ('d', 5), ('d', 6)])
print contains_straight([('c', 2), ('h', 14), ('d', 3), ('d', 4), ('d', 5)]) # a hand with an ace
print contains_straight([('d', 13), ('s', 2), ('s', 13), ('c', 13), ('d', 2), ('c', 2), ('h', 13)]) # previously bugged
print contains_straight([('c', 5), ('c', 8), ('h', 12), ('h', 9), ('s', 5), 
                         ('s', 8), ('d', 8), ('d', 9), ('c', 9), ('s', 4)]) # previously bugged
(True, 6)
(True, 6)
(False, None)
(True, 5)
(False, None)
(False, None)

For three of a kind, we proceed in a similar fashion than for four of a kind.

In [15]:
def contains_three_of_a_kind(hand):
    if len(hand) < 3: 
        return (False, None)
    cnt = Counter([card[1] for card in hand])
    threes = filter(lambda item: item[1]==3, cnt.most_common())
    if threes != []:
        return (True, max([item[0] for item in threes]))
    else:
        return (False, None)
In [16]:
print contains_three_of_a_kind([('c', 2), ('h', 3), ('c', 3), ('d', 3), ('d', 5)])
print contains_three_of_a_kind([('c', 5), ('h', 5), ('c', 3), ('d', 3), ('d', 5)])
(True, 3)
(True, 5)

Let's move on to two pairs, which is inspired from the code for full house.

In [17]:
def contains_two_pairs(hand):
    if len(hand) < 4:
        return (False, None)
    cnt = Counter([card[1] for card in hand])
    pairs = filter(lambda item: item[1]==2, cnt.most_common())
    if len(pairs) > 1:
        return (True, max([item[0] for item in pairs])) 
    else:
        return (False, None)
In [18]:
print contains_two_pairs([('c', 4), ('h', 4), ('h', 11), ('s', 14), ('c', 14)])
print contains_two_pairs([('c', 4), ('h', 4), ('h', 11), ('s', 11), ('c', 14)])
print contains_two_pairs([('c', 4), ('h', 3), ('h', 11), ('s', 14), ('c', 14)])
(True, 14)
(True, 11)
(False, None)

One pair draws on a similar logic:

In [19]:
def contains_one_pair(hand):
    if len(hand) < 2:
        return (False, None)
    cnt = Counter([card[1] for card in hand])
    pairs = filter(lambda item: item[1]==2, cnt.most_common())
    if len(pairs) > 0:
        return (True, max([item[0] for item in pairs]))
    else:
        return (False, None)
In [20]:
print contains_one_pair([('c', 4), ('h', 4), ('h', 11), ('s', 14), ('c', 14)])
print contains_one_pair([('c', 4), ('h', 2), ('h', 11), ('s', 3), ('c', 7)])
(True, 14)
(False, None)

We also implement a function that returns a high card. Obviously, that function should always be true and return as a rank the highest observed card.

In [21]:
def contains_high_card(hand):
    return (True, max([card[1] for card in hand]))
In [22]:
print contains_high_card([('c', 3), ('h', 4), ('h', 11), ('s', 12), ('c', 14)])
print contains_high_card([('c', 3), ('h', 4), ('h', 11), ('s', 12), ('c', 10)])
(True, 14)
(True, 12)

We can finish this off by implementing the straight flush using the previously defined functions (even though this is not computationally optimal):

In [23]:
def contains_straight_flush(hand):
    straight = contains_straight(hand)
    flush = contains_flush(hand)
    if straight[0] and flush[0]:
        return (True, straight[1])
    else:
        return (False, None)
In [24]:
print contains_straight_flush([('c', 4), ('c', 5), ('c', 6), ('c', 7), ('c', 8)])
print contains_straight_flush([('c', 4), ('c', 5), ('c', 2), ('c', 3), ('c', 14)])
(True, 8)
(True, 5)

Writing the comparison function

Now that we have done this base work, we can move on to write the full hand comparison function. It works by assuming that you give at least two different hands as input and then checks in the right order whether a given hand is found among all hands. If not, it moves on to the next lower ranked hand, until

In [25]:
def compare_hands(hands):
    """ Determines highest hand from given hands. 
        Returns winning hand or tied hands
    """
    ranking_functions = [contains_straight_flush, 
                         contains_four_of_a_kind,
                         contains_full_house,
                         contains_flush,
                         contains_straight,
                         contains_three_of_a_kind,
                         contains_two_pairs,
                         contains_one_pair,
                         contains_high_card]
    
    for func in ranking_functions:
        ranks = [func(hand) + (hand,) for hand in hands]
        filtered_ranks = filter(lambda rank: rank[0], ranks)
        if filtered_ranks != []:
            if len(filtered_ranks) == 1: #only one hand wins
                return ('win', filtered_ranks[0][2], func.__name__)
            else: # more than one hand wins: need to compare according to strength
                strengths = sorted(filtered_ranks, key=lambda rank: rank[1])
                filtered_strengths = filter(lambda rank: rank[1]==strengths[-1][1], strengths)
                if len(filtered_strengths) == 1: #only one hand wins
                    return ('win', filtered_strengths[0][2], func.__name__)
                else:
                    return ('tie', [item[2] for item in filtered_strengths], func.__name__)

Let's sample the output from the previous function in a random two five card hands drawn against each other from a shuffled game.

In [26]:
shuffle(game)
hand1 = game[:5]
shuffle(game)
hand2 = game[:5]
compare_hands([hand1, hand2])
Out[26]:
('win',
 [('s', 12), ('h', 13), ('c', 13), ('h', 7), ('d', 2)],
 'contains_one_pair')

Let's also time the previous function to see how quick the process is.

In [27]:
%%timeit
shuffle(game)
hand1 = game[:5]
shuffle(game)
hand2 = game[:5]
compare_hands([hand1, hand2])
1000 loops, best of 3: 422 µs per loop

A first statistical simulation

Based on the previous work, we can already do a little bit of statistics. In the next example, we'll reuse the scenario we were considering: two players are playing against each other, each drawing five cards from a shuffled deck. They then compare their hands and thus determine the output. We will count the number of occurences of ties and wins, and also keep track of what the most common winning hand is.

In [28]:
%matplotlib inline
import pylab as pl
In [29]:
%%time
winners = Counter()
combinations = Counter()
for i in range(100000):
    game = new_card_game()
    shuffle(game)
    hand1 = game[:5]
    hand2 = game[5:10]
    outcome = compare_hands([hand1, hand2])
    if outcome[0] != 'tie':
        if outcome[1] == hand1:
            winners['player 1'] += 1
        else:
            winners['player 2'] += 1
    else:
        winners['tie'] += 1
    combinations[outcome[2]] += 1
Wall time: 29 s

This can be plotted in the following way:

In [30]:
combinations
Out[30]:
Counter({'contains_one_pair': 60214, 'contains_high_card': 25180, 'contains_two_pairs': 9000, 'contains_three_of_a_kind': 4116, 'contains_straight': 755, 'contains_flush': 376, 'contains_full_house': 297, 'contains_four_of_a_kind': 59, 'contains_straight_flush': 3})
In [31]:
pl.figure(figsize=(10, 4))
pl.subplot(121)
sorted_combinations = sorted(combinations.items(), key=lambda item: item[1])
pl.bar(range(len(sorted_combinations)),
    [item[1] for item in sorted_combinations])
ticks = pl.xticks()
pl.xticks(ticks[0] + 0.5, [item[0] for item in sorted_combinations], rotation='vertical')
pl.ylabel('number of occurences')
pl.title('wins by hands')

pl.subplot(122)
pl.bar(range(len(winners.keys())),
    winners.values()) 
pl.xticks([0.5, 1.5, 2.5], winners.keys())
pl.ylabel('number of occurences')
pl.title('wins by players')

pl.tight_layout()

As expected, the sequence of winning combinations appears as in the rules, which is indeed, after that test, its probability (from rare to frequent): straight flush, four of a kind, full house, flush, straight, three of a kind, two pairs, high card, one pair.

Actually, I'm surprised by one thing: why is the high card appearing less frequently than the two pairs?

Calculating the odds of winning with a given hand: convergence plots

Now that we have the backbone of our simulation tool coded, we can try to ask more elaborate questions. Suppose we have a given pair of cards dealt to us. How do the odds of winning change between the following situations:

  • pre-flop
  • post-flop
  • post-turn
  • post-river

The way we approach the problem is quite easy. We:

  • setup a table with n players
  • setup the card game so that we start with a given hand
  • deal cards to the other players
  • compare relative strengths of hands pre-flop, post-flop, post-turn, post-river
  • do this a great number of times to get average odds
In [32]:
def winning_odds(starting_hand, opponent_number, number_of_games=100):
    wins = Counter()

    for i in range(number_of_games):
        game = new_card_game()
        shuffle(game)
        for card in starting_hand:
            game.remove(card)
        opponent_cards = [[game.pop(), game.pop()] for player in range(opponent_number)]
        
        # pre-flop odds
        all_hands = [starting_hand] + opponent_cards
        outcome = compare_hands(all_hands)
        if outcome[0] == 'win' and outcome[1] == all_hands[0] or outcome[0] == 'tie' and all_hands[0] in outcome[1]:
            wins['pre-flop'] += 1
        
        # post-flop odds
        flop = [game.pop(), game.pop(), game.pop()]
        all_hands = [hand + flop for hand in all_hands]
        outcome = compare_hands(all_hands)
        if outcome[0] == 'win' and outcome[1] == all_hands[0] or outcome[0] == 'tie' and all_hands[0] in outcome[1]:
            wins['post-flop'] += 1
            
        # post-turn odds
        turn = [game.pop()]
        all_hands = [hand + turn for hand in all_hands]
        outcome = compare_hands(all_hands)
        if outcome[0] == 'win' and outcome[1] == all_hands[0] or outcome[0] == 'tie' and all_hands[0] in outcome[1]:
            wins['post-turn'] += 1
            
        # post-river odds
        river = [game.pop()]
        all_hands = [hand + river for hand in all_hands]
        outcome = compare_hands(all_hands)
        if outcome[0] == 'win' and outcome[1] == all_hands[0] or outcome[0] == 'tie' and all_hands[0] in outcome[1]:
            wins['post-river'] += 1
    return wins
In [33]:
winning_odds([('c', 14), ('d', 10)],
             3,
             number_of_games=1000)
Out[33]:
Counter({'pre-flop': 843, 'post-flop': 437, 'post-turn': 411, 'post-river': 390})
In [34]:
%%time
number_of_games = pl.linspace(10, 1000, num=20).astype(pl.int32)
results = [winning_odds([('c', 14), ('d', 10)],
                         4, n) for n in number_of_games]
pre_flop = [result['pre-flop'] / float(n) for (result, n) in zip(results, number_of_games)]
post_flop = [result['post-flop'] / float(n) for (result, n) in zip(results, number_of_games)]
post_turn = [result['post-turn'] / float(n) for (result, n) in zip(results, number_of_games)]
post_river = [result['post-river'] / float(n) for (result, n) in zip(results, number_of_games)]
Wall time: 15.1 s
In [35]:
pl.plot(number_of_games, pre_flop, label='pre-flop')
pl.plot(number_of_games, post_flop, label='post-flop')
pl.plot(number_of_games, post_turn, label='post-turn')
pl.plot(number_of_games, post_river, label='post-river')
pl.xlabel('number of games played')
pl.ylabel('odds of winning')
pl.title("hand: {0}, number of players: {1}".format([('c', 14), ('d', 10)], 4 + 1))
pl.xlim(0, number_of_games.max())
pl.ylim(0, 1)
pl.grid(True)
pl.legend(loc='center left')
Out[35]:
<matplotlib.legend.Legend at 0x54a3c30>

Now that we have tested this on a small scale, we can write a more general function that automates the previous computation for a given starting hand:

In [36]:
def plot_convergence(starting_hand, opponent_number, number_of_games):
    results = [winning_odds(starting_hand,
                         opponent_number, 
                         n) for n in number_of_games]
    pre_flop = [result['pre-flop'] / float(n) for (result, n) in zip(results, number_of_games)]
    post_flop = [result['post-flop'] / float(n) for (result, n) in zip(results, number_of_games)]
    post_turn = [result['post-turn'] / float(n) for (result, n) in zip(results, number_of_games)]
    post_river = [result['post-river'] / float(n) for (result, n) in zip(results, number_of_games)]
    pl.plot(number_of_games, pre_flop, "-o", label='pre-flop')
    pl.plot(number_of_games, post_flop, "-o", label='post-flop')
    pl.plot(number_of_games, post_turn, "-o", label='post-turn')
    pl.plot(number_of_games, post_river, "-o", label='post-river')
    pl.xlabel('number of games played')
    pl.ylabel('odds of winning')
    pl.title("hand: {0}, number of players: {1}".format(starting_hand, opponent_number + 1))
    pl.xlim(0, number_of_games.max())
    pl.ylim(0, 1)
    pl.grid(True)
    pl.legend(loc='center left')

For instance, in the plot below, we check that the odds are symmetric with respect to interchanging the two cards from the hand used in the previous plot.

In [37]:
%%time
plot_convergence([('d', 10), ('c', 14)], 4, pl.linspace(10, 1000, num=20).astype(pl.int32))
Wall time: 15.4 s

In the next plot, we examine the convergence plot of the odds for two different hands whose only difference is that one is of the same suite, the other is not.

In [38]:
%%time
pl.figure(figsize=(10, 6))
pl.subplot(121)
plot_convergence([('d', 14), ('c', 10)], 4, pl.array([10, 100, 1000, 2000, 5000]))
pl.subplot(122)
plot_convergence([('d', 14), ('d', 10)], 4, pl.array([10, 100, 1000, 2000, 5000]))
pl.tight_layout()
Wall time: 25.2 s

Well, it seems that the difference is subtle: pre-flop it should absolutely be the same, as there are only pairs that can be played. However we notice that the previous plot shows a little higher odds after the flop for the same As/10 of same suit.

A question that came up during my stay in Las Vegas was: how likely is it to lose with Ace/King (different suites)? During the tournament, this hand lost to a pair of Queens.

In [39]:
%%time
plot_convergence([('h', 14), ('s', 13)], 6, pl.array([10, 100, 500, 1000, 5000]))
Wall time: 13.4 s

Another interesting plot is below: the odds for winning with a pair of aces. In fact, if you have that pair, you should do everything you can to beat people out from the flop, because that's where you're most likely to win.

In [40]:
%%time
plot_convergence([('h', 14), ('s', 14)], 6, pl.array([10, 100, 500, 1000, 5000]))
Wall time: 14.4 s

A big table comparing stuff

Now that we have developed some tools to assess given hands, I want to move on to produce a table allowing to easily compare different hand behaviours between them. One thing I would like to know is whether a given hand is better pre-flop or better post-flop. To assess this, I'm going to compute a big table with all sorts of odds.

In [41]:
%%time
OPPONENT_NUMBER = 6
NUMBER_OF_GAMES = 1000

data = {}
first_cards = new_card_game()[:13]
second_cards = new_card_game()[13:26]
for first_card in first_cards:
    for second_card in second_cards:
        starting_hand = [first_card, second_card]
        result = winning_odds(starting_hand,
                         OPPONENT_NUMBER, 
                         NUMBER_OF_GAMES) 
        pre_flop = result['pre-flop'] / float(NUMBER_OF_GAMES)
        post_flop = result['post-flop'] / float(NUMBER_OF_GAMES)
        post_turn = result['post-turn'] / float(NUMBER_OF_GAMES)
        post_river = result['post-river'] / float(NUMBER_OF_GAMES)
        data[(first_card, second_card)] = [pre_flop, post_flop, post_turn, post_river]
Wall time: 8min 22s

Let's try to represent the previous data using an HTML table.

In [42]:
from IPython.display import HTML

from collections import defaultdict

def code_to_str(hand):
    suites = {'s': '&spades;', 'c': '&clubs;',
              'd': '&diams;', 'h': '&hearts;'}
    numbers = dict(zip(range(2, 15), map(str, range(2, 11)) + ['jack', 'queen', 'king', 'ace']))
    
    if hand[0][1] == hand[1][1]:
        return "Pair of " + numbers[hand[0][1]]
    else:
        [low, high] = sorted(hand, key=lambda item: item[1])
        return " ".join((suites[high[0]], 
                         numbers[high[1]],
                         suites[low[0]],
                         numbers[low[1]]))
src = """<table>
 <tr>
   <th>Hand</th>
   <th>Chance of winning pre-flop</th>
   <th>Chance of winning post-flop</th>
   <th>Chance of winning post-turn</th>
   <th>Chance of winning post-river</th>
 </tr>
   {0}
</table>""".format("".join(["""<tr><td>{0}</td>
                            <td>{1[0]}</td>
                            <td>{1[1]}</td>
                            <td>{1[2]}</td>
                            <td>{1[3]}</td>
                            </tr>""".format(code_to_str(item), data[item]) for item in sorted(data, 
                                                                                 key=lambda item: data[item][0], 
                                                                                 reverse=True)]))

HTML(src)
Out[42]:
Hand Chance of winning pre-flop Chance of winning post-flop Chance of winning post-turn Chance of winning post-river
Pair of ace 1.0 0.735 0.566 0.421
Pair of king 0.978 0.66 0.489 0.369
Pair of queen 0.945 0.591 0.449 0.349
Pair of jack 0.914 0.49 0.343 0.303
Pair of 10 0.87 0.404 0.297 0.271
Pair of 9 0.867 0.402 0.298 0.268
Pair of 8 0.837 0.306 0.247 0.24
Pair of 7 0.829 0.311 0.27 0.268
Pair of 6 0.79 0.257 0.222 0.227
Pair of 5 0.76 0.222 0.23 0.245
♦ ace ♣ 9 0.728 0.236 0.223 0.219
Pair of 4 0.722 0.202 0.207 0.228
♣ ace ♦ 5 0.72 0.227 0.2 0.208
Pair of 3 0.716 0.203 0.226 0.247
♣ ace ♦ 7 0.713 0.224 0.211 0.199
♣ ace ♦ 3 0.712 0.222 0.218 0.215
♦ ace ♣ 10 0.712 0.27 0.254 0.257
♦ ace ♣ queen 0.711 0.288 0.273 0.264
♦ ace ♣ 5 0.71 0.233 0.224 0.216
♣ ace ♦ 2 0.709 0.213 0.199 0.193
♣ ace ♦ queen 0.703 0.283 0.251 0.241
♣ ace ♦ 9 0.703 0.251 0.229 0.209
♦ ace ♣ king 0.699 0.298 0.284 0.266
♦ ace ♣ 7 0.697 0.226 0.197 0.21
♣ ace ♦ jack 0.697 0.26 0.259 0.233
♣ ace ♦ 6 0.696 0.23 0.214 0.179
♦ ace ♣ 8 0.695 0.24 0.215 0.199
♦ ace ♣ 4 0.689 0.218 0.195 0.205
Pair of 2 0.687 0.184 0.194 0.219
♦ ace ♣ 2 0.686 0.187 0.18 0.193
♣ ace ♦ king 0.679 0.295 0.278 0.246
♦ ace ♣ 6 0.678 0.232 0.193 0.19
♦ ace ♣ 3 0.673 0.218 0.207 0.213
♦ ace ♣ jack 0.671 0.297 0.282 0.237
♣ ace ♦ 4 0.671 0.229 0.217 0.204
♣ ace ♦ 8 0.67 0.25 0.228 0.209
♣ ace ♦ 10 0.659 0.242 0.224 0.213
♦ king ♣ jack 0.25 0.286 0.288 0.263
♦ king ♣ 9 0.241 0.227 0.224 0.23
♣ king ♦ 7 0.24 0.215 0.198 0.19
♦ king ♣ 10 0.238 0.253 0.229 0.226
♣ king ♦ 2 0.238 0.187 0.187 0.2
♦ king ♣ 2 0.232 0.152 0.156 0.164
♣ king ♦ 5 0.226 0.162 0.164 0.167
♣ king ♦ queen 0.221 0.279 0.269 0.272
♦ king ♣ 6 0.218 0.212 0.213 0.211
♦ king ♣ 4 0.218 0.195 0.187 0.18
♦ king ♣ 7 0.217 0.208 0.203 0.203
♣ king ♦ 10 0.217 0.245 0.242 0.236
♦ king ♣ 8 0.217 0.2 0.186 0.186
♣ king ♦ 9 0.216 0.218 0.202 0.19
♦ king ♣ 5 0.214 0.2 0.198 0.184
♣ king ♦ 6 0.209 0.185 0.169 0.176
♣ king ♦ jack 0.208 0.277 0.257 0.237
♣ king ♦ 8 0.208 0.213 0.2 0.176
♦ king ♣ 3 0.207 0.17 0.167 0.169
♦ king ♣ queen 0.205 0.245 0.254 0.256
♣ king ♦ 4 0.195 0.214 0.201 0.207
♣ king ♦ 3 0.191 0.196 0.181 0.186
♦ queen ♣ 6 0.072 0.196 0.182 0.198
♦ queen ♣ 5 0.072 0.185 0.177 0.178
♣ queen ♦ 10 0.065 0.221 0.245 0.247
♣ queen ♦ 7 0.062 0.176 0.186 0.182
♣ queen ♦ 3 0.061 0.158 0.156 0.164
♣ queen ♦ jack 0.059 0.234 0.243 0.242
♦ queen ♣ 9 0.059 0.213 0.203 0.188
♣ queen ♦ 9 0.056 0.22 0.199 0.206
♣ queen ♦ 4 0.056 0.175 0.156 0.17
♦ queen ♣ 2 0.056 0.165 0.145 0.156
♦ queen ♣ jack 0.056 0.224 0.232 0.239
♦ queen ♣ 4 0.054 0.191 0.18 0.183
♦ queen ♣ 7 0.054 0.181 0.173 0.165
♦ queen ♣ 10 0.053 0.231 0.234 0.238
♣ queen ♦ 8 0.053 0.211 0.177 0.171
♣ queen ♦ 2 0.051 0.169 0.162 0.162
♦ queen ♣ 3 0.051 0.165 0.159 0.165
♦ queen ♣ 8 0.05 0.198 0.192 0.187
♣ queen ♦ 5 0.049 0.192 0.171 0.163
♣ queen ♦ 6 0.047 0.191 0.165 0.189
♣ jack ♦ 6 0.017 0.16 0.162 0.159
♦ jack ♣ 2 0.015 0.143 0.142 0.149
♦ jack ♣ 3 0.014 0.145 0.123 0.129
♦ jack ♣ 5 0.014 0.152 0.138 0.149
♣ jack ♦ 4 0.014 0.162 0.158 0.167
♦ jack ♣ 9 0.014 0.217 0.191 0.215
♣ jack ♦ 2 0.013 0.126 0.132 0.16
♣ jack ♦ 3 0.013 0.163 0.144 0.165
♦ jack ♣ 10 0.013 0.204 0.2 0.219
♣ jack ♦ 10 0.013 0.207 0.205 0.224
♦ jack ♣ 6 0.012 0.158 0.148 0.156
♣ jack ♦ 5 0.012 0.156 0.154 0.159
♦ jack ♣ 8 0.012 0.2 0.185 0.204
♣ jack ♦ 9 0.012 0.209 0.191 0.203
♣ jack ♦ 8 0.01 0.184 0.172 0.179
♦ jack ♣ 7 0.009 0.185 0.177 0.181
♣ jack ♦ 7 0.009 0.192 0.168 0.187
♦ jack ♣ 4 0.009 0.147 0.146 0.166
♣ 10 ♦ 4 0.005 0.138 0.133 0.15
♣ 10 ♦ 8 0.005 0.177 0.163 0.178
♣ 10 ♦ 6 0.005 0.172 0.155 0.168
♣ 10 ♦ 7 0.005 0.193 0.194 0.187
♣ 10 ♦ 5 0.004 0.155 0.145 0.169
♦ 10 ♣ 9 0.004 0.226 0.205 0.22
♦ 10 ♣ 7 0.004 0.192 0.17 0.179
♦ 10 ♣ 4 0.003 0.145 0.15 0.158
♦ 10 ♣ 6 0.003 0.147 0.157 0.182
♦ 10 ♣ 8 0.003 0.207 0.197 0.21
♦ 10 ♣ 5 0.003 0.165 0.155 0.164
♣ 10 ♦ 3 0.002 0.149 0.148 0.162
♣ 10 ♦ 2 0.002 0.142 0.133 0.132
♦ 9 ♣ 4 0.002 0.149 0.148 0.15
♦ 9 ♣ 8 0.001 0.157 0.159 0.194
♦ 10 ♣ 3 0.001 0.134 0.137 0.147
♦ 9 ♣ 6 0.001 0.166 0.157 0.186
♣ 9 ♦ 8 0.001 0.184 0.184 0.194
♦ 9 ♣ 7 0.001 0.179 0.16 0.18
♦ 10 ♣ 2 0.001 0.125 0.144 0.161
♦ 8 ♣ 2 0.0 0.114 0.111 0.125
♦ 6 ♣ 3 0.0 0.123 0.13 0.161
♣ 4 ♦ 2 0.0 0.116 0.121 0.149
♣ 8 ♦ 5 0.0 0.128 0.149 0.165
♣ 7 ♦ 4 0.0 0.135 0.148 0.177
♣ 7 ♦ 2 0.0 0.122 0.107 0.137
♦ 7 ♣ 5 0.0 0.141 0.153 0.162
♦ 9 ♣ 2 0.0 0.142 0.122 0.142
♣ 9 ♦ 5 0.0 0.132 0.115 0.141
♦ 4 ♣ 3 0.0 0.11 0.13 0.168
♦ 5 ♣ 4 0.0 0.118 0.129 0.161
♣ 5 ♦ 3 0.0 0.126 0.128 0.148
♣ 6 ♦ 3 0.0 0.11 0.112 0.146
♦ 7 ♣ 2 0.0 0.133 0.136 0.135
♦ 5 ♣ 3 0.0 0.102 0.114 0.138
♣ 9 ♦ 6 0.0 0.145 0.141 0.136
♦ 7 ♣ 6 0.0 0.144 0.152 0.157
♣ 8 ♦ 2 0.0 0.114 0.109 0.124
♣ 7 ♦ 3 0.0 0.127 0.126 0.146
♦ 3 ♣ 2 0.0 0.083 0.086 0.12
♦ 9 ♣ 5 0.0 0.14 0.136 0.162
♦ 8 ♣ 4 0.0 0.129 0.123 0.141
♣ 6 ♦ 2 0.0 0.105 0.124 0.121
♣ 8 ♦ 4 0.0 0.136 0.132 0.16
♦ 6 ♣ 5 0.0 0.123 0.126 0.154
♣ 8 ♦ 7 0.0 0.175 0.173 0.184
♣ 9 ♦ 7 0.0 0.157 0.171 0.186
♦ 9 ♣ 3 0.0 0.139 0.117 0.122
♣ 5 ♦ 4 0.0 0.132 0.141 0.176
♣ 7 ♦ 5 0.0 0.153 0.142 0.175
♣ 5 ♦ 2 0.0 0.109 0.114 0.145
♣ 9 ♦ 2 0.0 0.12 0.122 0.142
♦ 8 ♣ 6 0.0 0.171 0.166 0.189
♦ 5 ♣ 2 0.0 0.104 0.12 0.156
♣ 6 ♦ 4 0.0 0.12 0.138 0.162
♦ 8 ♣ 3 0.0 0.123 0.106 0.118
♣ 6 ♦ 5 0.0 0.129 0.13 0.149
♦ 6 ♣ 4 0.0 0.116 0.129 0.14
♣ 8 ♦ 6 0.0 0.154 0.156 0.162
♣ 10 ♦ 9 0.0 0.204 0.189 0.198
♦ 8 ♣ 5 0.0 0.137 0.138 0.159
♦ 7 ♣ 3 0.0 0.121 0.122 0.133
♣ 8 ♦ 3 0.0 0.128 0.111 0.125
♣ 9 ♦ 4 0.0 0.128 0.116 0.127
♦ 8 ♣ 7 0.0 0.174 0.157 0.179
♣ 7 ♦ 6 0.0 0.147 0.153 0.191
♣ 4 ♦ 3 0.0 0.116 0.14 0.165
♣ 9 ♦ 3 0.0 0.132 0.135 0.158
♦ 7 ♣ 4 0.0 0.14 0.125 0.149
♣ 3 ♦ 2 0.0 0.106 0.12 0.137
♦ 4 ♣ 2 0.0 0.113 0.116 0.139
♦ 6 ♣ 2 0.0 0.105 0.119 0.145

The previous data was sorted by pre-flop chance of winning. But what about post-flop?

In [43]:
src = """<table>
 <tr>
   <th>Hand</th>
   <th>Chance of winning pre-flop</th>
   <th>Chance of winning post-flop</th>
   <th>Chance of winning post-turn</th>
   <th>Chance of winning post-river</th>
 </tr>
   {0}
</table>""".format("".join(["""<tr><td>{0}</td>
                            <td>{1[0]}</td>
                            <td>{1[1]}</td>
                            <td>{1[2]}</td>
                            <td>{1[3]}</td>
                            </tr>""".format(code_to_str(item), data[item]) for item in sorted(data, 
                                                                                 key=lambda item: data[item][1], 
                                                                                 reverse=True)]))

HTML(src)
Out[43]:
Hand Chance of winning pre-flop Chance of winning post-flop Chance of winning post-turn Chance of winning post-river
Pair of ace 1.0 0.735 0.566 0.421
Pair of king 0.978 0.66 0.489 0.369
Pair of queen 0.945 0.591 0.449 0.349
Pair of jack 0.914 0.49 0.343 0.303
Pair of 10 0.87 0.404 0.297 0.271
Pair of 9 0.867 0.402 0.298 0.268
Pair of 7 0.829 0.311 0.27 0.268
Pair of 8 0.837 0.306 0.247 0.24
♦ ace ♣ king 0.699 0.298 0.284 0.266
♦ ace ♣ jack 0.671 0.297 0.282 0.237
♣ ace ♦ king 0.679 0.295 0.278 0.246
♦ ace ♣ queen 0.711 0.288 0.273 0.264
♦ king ♣ jack 0.25 0.286 0.288 0.263
♣ ace ♦ queen 0.703 0.283 0.251 0.241
♣ king ♦ queen 0.221 0.279 0.269 0.272
♣ king ♦ jack 0.208 0.277 0.257 0.237
♦ ace ♣ 10 0.712 0.27 0.254 0.257
♣ ace ♦ jack 0.697 0.26 0.259 0.233
Pair of 6 0.79 0.257 0.222 0.227
♦ king ♣ 10 0.238 0.253 0.229 0.226
♣ ace ♦ 9 0.703 0.251 0.229 0.209
♣ ace ♦ 8 0.67 0.25 0.228 0.209
♦ king ♣ queen 0.205 0.245 0.254 0.256
♣ king ♦ 10 0.217 0.245 0.242 0.236
♣ ace ♦ 10 0.659 0.242 0.224 0.213
♦ ace ♣ 8 0.695 0.24 0.215 0.199
♦ ace ♣ 9 0.728 0.236 0.223 0.219
♣ queen ♦ jack 0.059 0.234 0.243 0.242
♦ ace ♣ 5 0.71 0.233 0.224 0.216
♦ ace ♣ 6 0.678 0.232 0.193 0.19
♦ queen ♣ 10 0.053 0.231 0.234 0.238
♣ ace ♦ 6 0.696 0.23 0.214 0.179
♣ ace ♦ 4 0.671 0.229 0.217 0.204
♦ king ♣ 9 0.241 0.227 0.224 0.23
♣ ace ♦ 5 0.72 0.227 0.2 0.208
♦ 10 ♣ 9 0.004 0.226 0.205 0.22
♦ ace ♣ 7 0.697 0.226 0.197 0.21
♣ ace ♦ 7 0.713 0.224 0.211 0.199
♦ queen ♣ jack 0.056 0.224 0.232 0.239
Pair of 5 0.76 0.222 0.23 0.245
♣ ace ♦ 3 0.712 0.222 0.218 0.215
♣ queen ♦ 10 0.065 0.221 0.245 0.247
♣ queen ♦ 9 0.056 0.22 0.199 0.206
♣ king ♦ 9 0.216 0.218 0.202 0.19
♦ ace ♣ 4 0.689 0.218 0.195 0.205
♦ ace ♣ 3 0.673 0.218 0.207 0.213
♦ jack ♣ 9 0.014 0.217 0.191 0.215
♣ king ♦ 7 0.24 0.215 0.198 0.19
♣ king ♦ 4 0.195 0.214 0.201 0.207
♦ queen ♣ 9 0.059 0.213 0.203 0.188
♣ king ♦ 8 0.208 0.213 0.2 0.176
♣ ace ♦ 2 0.709 0.213 0.199 0.193
♦ king ♣ 6 0.218 0.212 0.213 0.211
♣ queen ♦ 8 0.053 0.211 0.177 0.171
♣ jack ♦ 9 0.012 0.209 0.191 0.203
♦ king ♣ 7 0.217 0.208 0.203 0.203
♦ 10 ♣ 8 0.003 0.207 0.197 0.21
♣ jack ♦ 10 0.013 0.207 0.205 0.224
♦ jack ♣ 10 0.013 0.204 0.2 0.219
♣ 10 ♦ 9 0.0 0.204 0.189 0.198
Pair of 3 0.716 0.203 0.226 0.247
Pair of 4 0.722 0.202 0.207 0.228
♦ king ♣ 5 0.214 0.2 0.198 0.184
♦ jack ♣ 8 0.012 0.2 0.185 0.204
♦ king ♣ 8 0.217 0.2 0.186 0.186
♦ queen ♣ 8 0.05 0.198 0.192 0.187
♦ queen ♣ 6 0.072 0.196 0.182 0.198
♣ king ♦ 3 0.191 0.196 0.181 0.186
♦ king ♣ 4 0.218 0.195 0.187 0.18
♣ 10 ♦ 7 0.005 0.193 0.194 0.187
♣ queen ♦ 5 0.049 0.192 0.171 0.163
♣ jack ♦ 7 0.009 0.192 0.168 0.187
♦ 10 ♣ 7 0.004 0.192 0.17 0.179
♣ queen ♦ 6 0.047 0.191 0.165 0.189
♦ queen ♣ 4 0.054 0.191 0.18 0.183
♦ ace ♣ 2 0.686 0.187 0.18 0.193
♣ king ♦ 2 0.238 0.187 0.187 0.2
♣ king ♦ 6 0.209 0.185 0.169 0.176
♦ jack ♣ 7 0.009 0.185 0.177 0.181
♦ queen ♣ 5 0.072 0.185 0.177 0.178
♣ 9 ♦ 8 0.001 0.184 0.184 0.194
♣ jack ♦ 8 0.01 0.184 0.172 0.179
Pair of 2 0.687 0.184 0.194 0.219
♦ queen ♣ 7 0.054 0.181 0.173 0.165
♦ 9 ♣ 7 0.001 0.179 0.16 0.18
♣ 10 ♦ 8 0.005 0.177 0.163 0.178
♣ queen ♦ 7 0.062 0.176 0.186 0.182
♣ 8 ♦ 7 0.0 0.175 0.173 0.184
♣ queen ♦ 4 0.056 0.175 0.156 0.17
♦ 8 ♣ 7 0.0 0.174 0.157 0.179
♣ 10 ♦ 6 0.005 0.172 0.155 0.168
♦ 8 ♣ 6 0.0 0.171 0.166 0.189
♦ king ♣ 3 0.207 0.17 0.167 0.169
♣ queen ♦ 2 0.051 0.169 0.162 0.162
♦ 9 ♣ 6 0.001 0.166 0.157 0.186
♦ 10 ♣ 5 0.003 0.165 0.155 0.164
♦ queen ♣ 3 0.051 0.165 0.159 0.165
♦ queen ♣ 2 0.056 0.165 0.145 0.156
♣ jack ♦ 3 0.013 0.163 0.144 0.165
♣ jack ♦ 4 0.014 0.162 0.158 0.167
♣ king ♦ 5 0.226 0.162 0.164 0.167
♣ jack ♦ 6 0.017 0.16 0.162 0.159
♦ jack ♣ 6 0.012 0.158 0.148 0.156
♣ queen ♦ 3 0.061 0.158 0.156 0.164
♦ 9 ♣ 8 0.001 0.157 0.159 0.194
♣ 9 ♦ 7 0.0 0.157 0.171 0.186
♣ jack ♦ 5 0.012 0.156 0.154 0.159
♣ 10 ♦ 5 0.004 0.155 0.145 0.169
♣ 8 ♦ 6 0.0 0.154 0.156 0.162
♣ 7 ♦ 5 0.0 0.153 0.142 0.175
♦ jack ♣ 5 0.014 0.152 0.138 0.149
♦ king ♣ 2 0.232 0.152 0.156 0.164
♣ 10 ♦ 3 0.002 0.149 0.148 0.162
♦ 9 ♣ 4 0.002 0.149 0.148 0.15
♦ 10 ♣ 6 0.003 0.147 0.157 0.182
♣ 7 ♦ 6 0.0 0.147 0.153 0.191
♦ jack ♣ 4 0.009 0.147 0.146 0.166
♦ jack ♣ 3 0.014 0.145 0.123 0.129
♦ 10 ♣ 4 0.003 0.145 0.15 0.158
♣ 9 ♦ 6 0.0 0.145 0.141 0.136
♦ 7 ♣ 6 0.0 0.144 0.152 0.157
♦ jack ♣ 2 0.015 0.143 0.142 0.149
♦ 9 ♣ 2 0.0 0.142 0.122 0.142
♣ 10 ♦ 2 0.002 0.142 0.133 0.132
♦ 7 ♣ 5 0.0 0.141 0.153 0.162
♦ 9 ♣ 5 0.0 0.14 0.136 0.162
♦ 7 ♣ 4 0.0 0.14 0.125 0.149
♦ 9 ♣ 3 0.0 0.139 0.117 0.122
♣ 10 ♦ 4 0.005 0.138 0.133 0.15
♦ 8 ♣ 5 0.0 0.137 0.138 0.159
♣ 8 ♦ 4 0.0 0.136 0.132 0.16
♣ 7 ♦ 4 0.0 0.135 0.148 0.177
♦ 10 ♣ 3 0.001 0.134 0.137 0.147
♦ 7 ♣ 2 0.0 0.133 0.136 0.135
♣ 9 ♦ 5 0.0 0.132 0.115 0.141
♣ 5 ♦ 4 0.0 0.132 0.141 0.176
♣ 9 ♦ 3 0.0 0.132 0.135 0.158
♦ 8 ♣ 4 0.0 0.129 0.123 0.141
♣ 6 ♦ 5 0.0 0.129 0.13 0.149
♣ 8 ♦ 5 0.0 0.128 0.149 0.165
♣ 8 ♦ 3 0.0 0.128 0.111 0.125
♣ 9 ♦ 4 0.0 0.128 0.116 0.127
♣ 7 ♦ 3 0.0 0.127 0.126 0.146
♣ jack ♦ 2 0.013 0.126 0.132 0.16
♣ 5 ♦ 3 0.0 0.126 0.128 0.148
♦ 10 ♣ 2 0.001 0.125 0.144 0.161
♦ 6 ♣ 3 0.0 0.123 0.13 0.161
♦ 6 ♣ 5 0.0 0.123 0.126 0.154
♦ 8 ♣ 3 0.0 0.123 0.106 0.118
♣ 7 ♦ 2 0.0 0.122 0.107 0.137
♦ 7 ♣ 3 0.0 0.121 0.122 0.133
♣ 9 ♦ 2 0.0 0.12 0.122 0.142
♣ 6 ♦ 4 0.0 0.12 0.138 0.162
♦ 5 ♣ 4 0.0 0.118 0.129 0.161
♣ 4 ♦ 2 0.0 0.116 0.121 0.149
♦ 6 ♣ 4 0.0 0.116 0.129 0.14
♣ 4 ♦ 3 0.0 0.116 0.14 0.165
♦ 8 ♣ 2 0.0 0.114 0.111 0.125
♣ 8 ♦ 2 0.0 0.114 0.109 0.124
♦ 4 ♣ 2 0.0 0.113 0.116 0.139
♦ 4 ♣ 3 0.0 0.11 0.13 0.168
♣ 6 ♦ 3 0.0 0.11 0.112 0.146
♣ 5 ♦ 2 0.0 0.109 0.114 0.145
♣ 3 ♦ 2 0.0 0.106 0.12 0.137
♣ 6 ♦ 2 0.0 0.105 0.124 0.121
♦ 6 ♣ 2 0.0 0.105 0.119 0.145
♦ 5 ♣ 2 0.0 0.104 0.12 0.156
♦ 5 ♣ 3 0.0 0.102 0.114 0.138
♦ 3 ♣ 2 0.0 0.083 0.086 0.12

And post-turn?

In [44]:
src = """<table>
 <tr>
   <th>Hand</th>
   <th>Chance of winning pre-flop</th>
   <th>Chance of winning post-flop</th>
   <th>Chance of winning post-turn</th>
   <th>Chance of winning post-river</th>
 </tr>
   {0}
</table>""".format("".join(["""<tr><td>{0}</td>
                            <td>{1[0]}</td>
                            <td>{1[1]}</td>
                            <td>{1[2]}</td>
                            <td>{1[3]}</td>
                            </tr>""".format(code_to_str(item), data[item]) for item in sorted(data, 
                                                                                 key=lambda item: data[item][2], 
                                                                                 reverse=True)]))

HTML(src)
Out[44]:
Hand Chance of winning pre-flop Chance of winning post-flop Chance of winning post-turn Chance of winning post-river
Pair of ace 1.0 0.735 0.566 0.421
Pair of king 0.978 0.66 0.489 0.369
Pair of queen 0.945 0.591 0.449 0.349
Pair of jack 0.914 0.49 0.343 0.303
Pair of 9 0.867 0.402 0.298 0.268
Pair of 10 0.87 0.404 0.297 0.271
♦ king ♣ jack 0.25 0.286 0.288 0.263
♦ ace ♣ king 0.699 0.298 0.284 0.266
♦ ace ♣ jack 0.671 0.297 0.282 0.237
♣ ace ♦ king 0.679 0.295 0.278 0.246
♦ ace ♣ queen 0.711 0.288 0.273 0.264
Pair of 7 0.829 0.311 0.27 0.268
♣ king ♦ queen 0.221 0.279 0.269 0.272
♣ ace ♦ jack 0.697 0.26 0.259 0.233
♣ king ♦ jack 0.208 0.277 0.257 0.237
♦ king ♣ queen 0.205 0.245 0.254 0.256
♦ ace ♣ 10 0.712 0.27 0.254 0.257
♣ ace ♦ queen 0.703 0.283 0.251 0.241
Pair of 8 0.837 0.306 0.247 0.24
♣ queen ♦ 10 0.065 0.221 0.245 0.247
♣ queen ♦ jack 0.059 0.234 0.243 0.242
♣ king ♦ 10 0.217 0.245 0.242 0.236
♦ queen ♣ 10 0.053 0.231 0.234 0.238
♦ queen ♣ jack 0.056 0.224 0.232 0.239
Pair of 5 0.76 0.222 0.23 0.245
♦ king ♣ 10 0.238 0.253 0.229 0.226
♣ ace ♦ 9 0.703 0.251 0.229 0.209
♣ ace ♦ 8 0.67 0.25 0.228 0.209
Pair of 3 0.716 0.203 0.226 0.247
♦ king ♣ 9 0.241 0.227 0.224 0.23
♦ ace ♣ 5 0.71 0.233 0.224 0.216
♣ ace ♦ 10 0.659 0.242 0.224 0.213
♦ ace ♣ 9 0.728 0.236 0.223 0.219
Pair of 6 0.79 0.257 0.222 0.227
♣ ace ♦ 3 0.712 0.222 0.218 0.215
♣ ace ♦ 4 0.671 0.229 0.217 0.204
♦ ace ♣ 8 0.695 0.24 0.215 0.199
♣ ace ♦ 6 0.696 0.23 0.214 0.179
♦ king ♣ 6 0.218 0.212 0.213 0.211
♣ ace ♦ 7 0.713 0.224 0.211 0.199
♦ ace ♣ 3 0.673 0.218 0.207 0.213
Pair of 4 0.722 0.202 0.207 0.228
♦ 10 ♣ 9 0.004 0.226 0.205 0.22
♣ jack ♦ 10 0.013 0.207 0.205 0.224
♦ king ♣ 7 0.217 0.208 0.203 0.203
♦ queen ♣ 9 0.059 0.213 0.203 0.188
♣ king ♦ 9 0.216 0.218 0.202 0.19
♣ king ♦ 4 0.195 0.214 0.201 0.207
♦ jack ♣ 10 0.013 0.204 0.2 0.219
♣ king ♦ 8 0.208 0.213 0.2 0.176
♣ ace ♦ 5 0.72 0.227 0.2 0.208
♣ queen ♦ 9 0.056 0.22 0.199 0.206
♣ ace ♦ 2 0.709 0.213 0.199 0.193
♣ king ♦ 7 0.24 0.215 0.198 0.19
♦ king ♣ 5 0.214 0.2 0.198 0.184
♦ ace ♣ 7 0.697 0.226 0.197 0.21
♦ 10 ♣ 8 0.003 0.207 0.197 0.21
♦ ace ♣ 4 0.689 0.218 0.195 0.205
Pair of 2 0.687 0.184 0.194 0.219
♣ 10 ♦ 7 0.005 0.193 0.194 0.187
♦ ace ♣ 6 0.678 0.232 0.193 0.19
♦ queen ♣ 8 0.05 0.198 0.192 0.187
♦ jack ♣ 9 0.014 0.217 0.191 0.215
♣ jack ♦ 9 0.012 0.209 0.191 0.203
♣ 10 ♦ 9 0.0 0.204 0.189 0.198
♦ king ♣ 4 0.218 0.195 0.187 0.18
♣ king ♦ 2 0.238 0.187 0.187 0.2
♦ king ♣ 8 0.217 0.2 0.186 0.186
♣ queen ♦ 7 0.062 0.176 0.186 0.182
♦ jack ♣ 8 0.012 0.2 0.185 0.204
♣ 9 ♦ 8 0.001 0.184 0.184 0.194
♦ queen ♣ 6 0.072 0.196 0.182 0.198
♣ king ♦ 3 0.191 0.196 0.181 0.186
♦ ace ♣ 2 0.686 0.187 0.18 0.193
♦ queen ♣ 4 0.054 0.191 0.18 0.183
♦ jack ♣ 7 0.009 0.185 0.177 0.181
♣ queen ♦ 8 0.053 0.211 0.177 0.171
♦ queen ♣ 5 0.072 0.185 0.177 0.178
♣ 8 ♦ 7 0.0 0.175 0.173 0.184
♦ queen ♣ 7 0.054 0.181 0.173 0.165
♣ jack ♦ 8 0.01 0.184 0.172 0.179
♣ queen ♦ 5 0.049 0.192 0.171 0.163
♣ 9 ♦ 7 0.0 0.157 0.171 0.186
♦ 10 ♣ 7 0.004 0.192 0.17 0.179
♣ king ♦ 6 0.209 0.185 0.169 0.176
♣ jack ♦ 7 0.009 0.192 0.168 0.187
♦ king ♣ 3 0.207 0.17 0.167 0.169
♦ 8 ♣ 6 0.0 0.171 0.166 0.189
♣ queen ♦ 6 0.047 0.191 0.165 0.189
♣ king ♦ 5 0.226 0.162 0.164 0.167
♣ 10 ♦ 8 0.005 0.177 0.163 0.178
♣ jack ♦ 6 0.017 0.16 0.162 0.159
♣ queen ♦ 2 0.051 0.169 0.162 0.162
♦ 9 ♣ 7 0.001 0.179 0.16 0.18
♦ 9 ♣ 8 0.001 0.157 0.159 0.194
♦ queen ♣ 3 0.051 0.165 0.159 0.165
♣ jack ♦ 4 0.014 0.162 0.158 0.167
♦ 10 ♣ 6 0.003 0.147 0.157 0.182
♦ 9 ♣ 6 0.001 0.166 0.157 0.186
♦ 8 ♣ 7 0.0 0.174 0.157 0.179
♣ queen ♦ 3 0.061 0.158 0.156 0.164
♣ queen ♦ 4 0.056 0.175 0.156 0.17
♦ king ♣ 2 0.232 0.152 0.156 0.164
♣ 8 ♦ 6 0.0 0.154 0.156 0.162
♣ 10 ♦ 6 0.005 0.172 0.155 0.168
♦ 10 ♣ 5 0.003 0.165 0.155 0.164
♣ jack ♦ 5 0.012 0.156 0.154 0.159
♦ 7 ♣ 5 0.0 0.141 0.153 0.162
♣ 7 ♦ 6 0.0 0.147 0.153 0.191
♦ 7 ♣ 6 0.0 0.144 0.152 0.157
♦ 10 ♣ 4 0.003 0.145 0.15 0.158
♣ 8 ♦ 5 0.0 0.128 0.149 0.165
♣ 7 ♦ 4 0.0 0.135 0.148 0.177
♣ 10 ♦ 3 0.002 0.149 0.148 0.162
♦ jack ♣ 6 0.012 0.158 0.148 0.156
♦ 9 ♣ 4 0.002 0.149 0.148 0.15
♦ jack ♣ 4 0.009 0.147 0.146 0.166
♣ 10 ♦ 5 0.004 0.155 0.145 0.169
♦ queen ♣ 2 0.056 0.165 0.145 0.156
♣ jack ♦ 3 0.013 0.163 0.144 0.165
♦ 10 ♣ 2 0.001 0.125 0.144 0.161
♦ jack ♣ 2 0.015 0.143 0.142 0.149
♣ 7 ♦ 5 0.0 0.153 0.142 0.175
♣ 9 ♦ 6 0.0 0.145 0.141 0.136
♣ 5 ♦ 4 0.0 0.132 0.141 0.176
♣ 4 ♦ 3 0.0 0.116 0.14 0.165
♦ jack ♣ 5 0.014 0.152 0.138 0.149
♣ 6 ♦ 4 0.0 0.12 0.138 0.162
♦ 8 ♣ 5 0.0 0.137 0.138 0.159
♦ 10 ♣ 3 0.001 0.134 0.137 0.147
♦ 7 ♣ 2 0.0 0.133 0.136 0.135
♦ 9 ♣ 5 0.0 0.14 0.136 0.162
♣ 9 ♦ 3 0.0 0.132 0.135 0.158
♣ 10 ♦ 4 0.005 0.138 0.133 0.15
♣ 10 ♦ 2 0.002 0.142 0.133 0.132
♣ jack ♦ 2 0.013 0.126 0.132 0.16
♣ 8 ♦ 4 0.0 0.136 0.132 0.16
♦ 6 ♣ 3 0.0 0.123 0.13 0.161
♦ 4 ♣ 3 0.0 0.11 0.13 0.168
♣ 6 ♦ 5 0.0 0.129 0.13 0.149
♦ 5 ♣ 4 0.0 0.118 0.129 0.161
♦ 6 ♣ 4 0.0 0.116 0.129 0.14
♣ 5 ♦ 3 0.0 0.126 0.128 0.148
♣ 7 ♦ 3 0.0 0.127 0.126 0.146
♦ 6 ♣ 5 0.0 0.123 0.126 0.154
♦ 7 ♣ 4 0.0 0.14 0.125 0.149
♣ 6 ♦ 2 0.0 0.105 0.124 0.121
♦ jack ♣ 3 0.014 0.145 0.123 0.129
♦ 8 ♣ 4 0.0 0.129 0.123 0.141
♦ 9 ♣ 2 0.0 0.142 0.122 0.142
♣ 9 ♦ 2 0.0 0.12 0.122 0.142
♦ 7 ♣ 3 0.0 0.121 0.122 0.133
♣ 4 ♦ 2 0.0 0.116 0.121 0.149
♦ 5 ♣ 2 0.0 0.104 0.12 0.156
♣ 3 ♦ 2 0.0 0.106 0.12 0.137
♦ 6 ♣ 2 0.0 0.105 0.119 0.145
♦ 9 ♣ 3 0.0 0.139 0.117 0.122
♣ 9 ♦ 4 0.0 0.128 0.116 0.127
♦ 4 ♣ 2 0.0 0.113 0.116 0.139
♣ 9 ♦ 5 0.0 0.132 0.115 0.141
♦ 5 ♣ 3 0.0 0.102 0.114 0.138
♣ 5 ♦ 2 0.0 0.109 0.114 0.145
♣ 6 ♦ 3 0.0 0.11 0.112 0.146
♦ 8 ♣ 2 0.0 0.114 0.111 0.125
♣ 8 ♦ 3 0.0 0.128 0.111 0.125
♣ 8 ♦ 2 0.0 0.114 0.109 0.124
♣ 7 ♦ 2 0.0 0.122 0.107 0.137
♦ 8 ♣ 3 0.0 0.123 0.106 0.118
♦ 3 ♣ 2 0.0 0.083 0.086 0.12

And post-river?

In [45]:
src = """<table>
 <tr>
   <th>Hand</th>
   <th>Chance of winning pre-flop</th>
   <th>Chance of winning post-flop</th>
   <th>Chance of winning post-turn</th>
   <th>Chance of winning post-river</th>
 </tr>
   {0}
</table>""".format("".join(["""<tr><td>{0}</td>
                            <td>{1[0]}</td>
                            <td>{1[1]}</td>
                            <td>{1[2]}</td>
                            <td>{1[3]}</td>
                            </tr>""".format(code_to_str(item), data[item]) for item in sorted(data, 
                                                                                 key=lambda item: data[item][3], 
                                                                                 reverse=True)]))

HTML(src)
Out[45]:
Hand Chance of winning pre-flop Chance of winning post-flop Chance of winning post-turn Chance of winning post-river
Pair of ace 1.0 0.735 0.566 0.421
Pair of king 0.978 0.66 0.489 0.369
Pair of queen 0.945 0.591 0.449 0.349
Pair of jack 0.914 0.49 0.343 0.303
♣ king ♦ queen 0.221 0.279 0.269 0.272
Pair of 10 0.87 0.404 0.297 0.271
Pair of 9 0.867 0.402 0.298 0.268
Pair of 7 0.829 0.311 0.27 0.268
♦ ace ♣ king 0.699 0.298 0.284 0.266
♦ ace ♣ queen 0.711 0.288 0.273 0.264
♦ king ♣ jack 0.25 0.286 0.288 0.263
♦ ace ♣ 10 0.712 0.27 0.254 0.257
♦ king ♣ queen 0.205 0.245 0.254 0.256
♣ queen ♦ 10 0.065 0.221 0.245 0.247
Pair of 3 0.716 0.203 0.226 0.247
♣ ace ♦ king 0.679 0.295 0.278 0.246
Pair of 5 0.76 0.222 0.23 0.245
♣ queen ♦ jack 0.059 0.234 0.243 0.242
♣ ace ♦ queen 0.703 0.283 0.251 0.241
Pair of 8 0.837 0.306 0.247 0.24
♦ queen ♣ jack 0.056 0.224 0.232 0.239
♦ queen ♣ 10 0.053 0.231 0.234 0.238
♣ king ♦ jack 0.208 0.277 0.257 0.237
♦ ace ♣ jack 0.671 0.297 0.282 0.237
♣ king ♦ 10 0.217 0.245 0.242 0.236
♣ ace ♦ jack 0.697 0.26 0.259 0.233
♦ king ♣ 9 0.241 0.227 0.224 0.23
Pair of 4 0.722 0.202 0.207 0.228
Pair of 6 0.79 0.257 0.222 0.227
♦ king ♣ 10 0.238 0.253 0.229 0.226
♣ jack ♦ 10 0.013 0.207 0.205 0.224
♦ 10 ♣ 9 0.004 0.226 0.205 0.22
♦ ace ♣ 9 0.728 0.236 0.223 0.219
♦ jack ♣ 10 0.013 0.204 0.2 0.219
Pair of 2 0.687 0.184 0.194 0.219
♦ ace ♣ 5 0.71 0.233 0.224 0.216
♣ ace ♦ 3 0.712 0.222 0.218 0.215
♦ jack ♣ 9 0.014 0.217 0.191 0.215
♦ ace ♣ 3 0.673 0.218 0.207 0.213
♣ ace ♦ 10 0.659 0.242 0.224 0.213
♦ king ♣ 6 0.218 0.212 0.213 0.211
♦ ace ♣ 7 0.697 0.226 0.197 0.21
♦ 10 ♣ 8 0.003 0.207 0.197 0.21
♣ ace ♦ 8 0.67 0.25 0.228 0.209
♣ ace ♦ 9 0.703 0.251 0.229 0.209
♣ ace ♦ 5 0.72 0.227 0.2 0.208
♣ king ♦ 4 0.195 0.214 0.201 0.207
♣ queen ♦ 9 0.056 0.22 0.199 0.206
♦ ace ♣ 4 0.689 0.218 0.195 0.205
♣ ace ♦ 4 0.671 0.229 0.217 0.204
♦ jack ♣ 8 0.012 0.2 0.185 0.204
♦ king ♣ 7 0.217 0.208 0.203 0.203
♣ jack ♦ 9 0.012 0.209 0.191 0.203
♣ king ♦ 2 0.238 0.187 0.187 0.2
♦ ace ♣ 8 0.695 0.24 0.215 0.199
♣ ace ♦ 7 0.713 0.224 0.211 0.199
♦ queen ♣ 6 0.072 0.196 0.182 0.198
♣ 10 ♦ 9 0.0 0.204 0.189 0.198
♦ 9 ♣ 8 0.001 0.157 0.159 0.194
♣ 9 ♦ 8 0.001 0.184 0.184 0.194
♦ ace ♣ 2 0.686 0.187 0.18 0.193
♣ ace ♦ 2 0.709 0.213 0.199 0.193
♣ 7 ♦ 6 0.0 0.147 0.153 0.191
♣ king ♦ 7 0.24 0.215 0.198 0.19
♣ king ♦ 9 0.216 0.218 0.202 0.19
♦ ace ♣ 6 0.678 0.232 0.193 0.19
♣ queen ♦ 6 0.047 0.191 0.165 0.189
♦ 8 ♣ 6 0.0 0.171 0.166 0.189
♦ queen ♣ 9 0.059 0.213 0.203 0.188
♦ queen ♣ 8 0.05 0.198 0.192 0.187
♣ jack ♦ 7 0.009 0.192 0.168 0.187
♣ 10 ♦ 7 0.005 0.193 0.194 0.187
♦ 9 ♣ 6 0.001 0.166 0.157 0.186
♣ king ♦ 3 0.191 0.196 0.181 0.186
♣ 9 ♦ 7 0.0 0.157 0.171 0.186
♦ king ♣ 8 0.217 0.2 0.186 0.186
♦ king ♣ 5 0.214 0.2 0.198 0.184
♣ 8 ♦ 7 0.0 0.175 0.173 0.184
♦ queen ♣ 4 0.054 0.191 0.18 0.183
♦ 10 ♣ 6 0.003 0.147 0.157 0.182
♣ queen ♦ 7 0.062 0.176 0.186 0.182
♦ jack ♣ 7 0.009 0.185 0.177 0.181
♦ king ♣ 4 0.218 0.195 0.187 0.18
♦ 9 ♣ 7 0.001 0.179 0.16 0.18
♣ jack ♦ 8 0.01 0.184 0.172 0.179
♦ 10 ♣ 7 0.004 0.192 0.17 0.179
♣ ace ♦ 6 0.696 0.23 0.214 0.179
♦ 8 ♣ 7 0.0 0.174 0.157 0.179
♣ 10 ♦ 8 0.005 0.177 0.163 0.178
♦ queen ♣ 5 0.072 0.185 0.177 0.178
♣ 7 ♦ 4 0.0 0.135 0.148 0.177
♣ king ♦ 6 0.209 0.185 0.169 0.176
♣ 5 ♦ 4 0.0 0.132 0.141 0.176
♣ king ♦ 8 0.208 0.213 0.2 0.176
♣ 7 ♦ 5 0.0 0.153 0.142 0.175
♣ queen ♦ 8 0.053 0.211 0.177 0.171
♣ queen ♦ 4 0.056 0.175 0.156 0.17
♦ king ♣ 3 0.207 0.17 0.167 0.169
♣ 10 ♦ 5 0.004 0.155 0.145 0.169
♦ 4 ♣ 3 0.0 0.11 0.13 0.168
♣ 10 ♦ 6 0.005 0.172 0.155 0.168
♣ jack ♦ 4 0.014 0.162 0.158 0.167
♣ king ♦ 5 0.226 0.162 0.164 0.167
♦ jack ♣ 4 0.009 0.147 0.146 0.166
♣ 8 ♦ 5 0.0 0.128 0.149 0.165
♣ jack ♦ 3 0.013 0.163 0.144 0.165
♦ queen ♣ 3 0.051 0.165 0.159 0.165
♣ 4 ♦ 3 0.0 0.116 0.14 0.165
♦ queen ♣ 7 0.054 0.181 0.173 0.165
♣ queen ♦ 3 0.061 0.158 0.156 0.164
♦ king ♣ 2 0.232 0.152 0.156 0.164
♦ 10 ♣ 5 0.003 0.165 0.155 0.164
♣ queen ♦ 5 0.049 0.192 0.171 0.163
♦ 7 ♣ 5 0.0 0.141 0.153 0.162
♣ 10 ♦ 3 0.002 0.149 0.148 0.162
♦ 9 ♣ 5 0.0 0.14 0.136 0.162
♣ queen ♦ 2 0.051 0.169 0.162 0.162
♣ 6 ♦ 4 0.0 0.12 0.138 0.162
♣ 8 ♦ 6 0.0 0.154 0.156 0.162
♦ 6 ♣ 3 0.0 0.123 0.13 0.161
♦ 5 ♣ 4 0.0 0.118 0.129 0.161
♦ 10 ♣ 2 0.001 0.125 0.144 0.161
♣ jack ♦ 2 0.013 0.126 0.132 0.16
♣ 8 ♦ 4 0.0 0.136 0.132 0.16
♣ jack ♦ 6 0.017 0.16 0.162 0.159
♣ jack ♦ 5 0.012 0.156 0.154 0.159
♦ 8 ♣ 5 0.0 0.137 0.138 0.159
♦ 10 ♣ 4 0.003 0.145 0.15 0.158
♣ 9 ♦ 3 0.0 0.132 0.135 0.158
♦ 7 ♣ 6 0.0 0.144 0.152 0.157
♦ jack ♣ 6 0.012 0.158 0.148 0.156
♦ 5 ♣ 2 0.0 0.104 0.12 0.156
♦ queen ♣ 2 0.056 0.165 0.145 0.156
♦ 6 ♣ 5 0.0 0.123 0.126 0.154
♣ 10 ♦ 4 0.005 0.138 0.133 0.15
♦ 9 ♣ 4 0.002 0.149 0.148 0.15
♣ 4 ♦ 2 0.0 0.116 0.121 0.149
♦ jack ♣ 5 0.014 0.152 0.138 0.149
♦ jack ♣ 2 0.015 0.143 0.142 0.149
♣ 6 ♦ 5 0.0 0.129 0.13 0.149
♦ 7 ♣ 4 0.0 0.14 0.125 0.149
♣ 5 ♦ 3 0.0 0.126 0.128 0.148
♦ 10 ♣ 3 0.001 0.134 0.137 0.147
♣ 6 ♦ 3 0.0 0.11 0.112 0.146
♣ 7 ♦ 3 0.0 0.127 0.126 0.146
♣ 5 ♦ 2 0.0 0.109 0.114 0.145
♦ 6 ♣ 2 0.0 0.105 0.119 0.145
♦ 9 ♣ 2 0.0 0.142 0.122 0.142
♣ 9 ♦ 2 0.0 0.12 0.122 0.142
♣ 9 ♦ 5 0.0 0.132 0.115 0.141
♦ 8 ♣ 4 0.0 0.129 0.123 0.141
♦ 6 ♣ 4 0.0 0.116 0.129 0.14
♦ 4 ♣ 2 0.0 0.113 0.116 0.139
♦ 5 ♣ 3 0.0 0.102 0.114 0.138
♣ 7 ♦ 2 0.0 0.122 0.107 0.137
♣ 3 ♦ 2 0.0 0.106 0.12 0.137
♣ 9 ♦ 6 0.0 0.145 0.141 0.136
♦ 7 ♣ 2 0.0 0.133 0.136 0.135
♦ 7 ♣ 3 0.0 0.121 0.122 0.133
♣ 10 ♦ 2 0.002 0.142 0.133 0.132
♦ jack ♣ 3 0.014 0.145 0.123 0.129
♣ 9 ♦ 4 0.0 0.128 0.116 0.127
♦ 8 ♣ 2 0.0 0.114 0.111 0.125
♣ 8 ♦ 3 0.0 0.128 0.111 0.125
♣ 8 ♦ 2 0.0 0.114 0.109 0.124
♦ 9 ♣ 3 0.0 0.139 0.117 0.122
♣ 6 ♦ 2 0.0 0.105 0.124 0.121
♦ 3 ♣ 2 0.0 0.083 0.086 0.12
♦ 8 ♣ 3 0.0 0.123 0.106 0.118

A last table is obtained by filtering by mean chance of winning, for all three columns:

In [46]:
src = """<table>
 <tr>
   <th>Hand</th>
   <th>Chance of winning pre-flop</th>
   <th>Chance of winning post-flop</th>
   <th>Chance of winning post-turn</th>
   <th>Chance of winning post-river</th>
 </tr>
   {0}
</table>""".format("".join(["""<tr><td>{0}</td>
                            <td>{1[0]}</td>
                            <td>{1[1]}</td>
                            <td>{1[2]}</td>
                            <td>{1[3]}</td>
                            </tr>""".format(code_to_str(item), data[item]) for item in sorted(data, 
                                                                                 key=lambda item: sum(data[item][:]), 
                                                                                 reverse=True)]))

HTML(src)
Out[46]:
Hand Chance of winning pre-flop Chance of winning post-flop Chance of winning post-turn Chance of winning post-river
Pair of ace 1.0 0.735 0.566 0.421
Pair of king 0.978 0.66 0.489 0.369
Pair of queen 0.945 0.591 0.449 0.349
Pair of jack 0.914 0.49 0.343 0.303
Pair of 10 0.87 0.404 0.297 0.271
Pair of 9 0.867 0.402 0.298 0.268
Pair of 7 0.829 0.311 0.27 0.268
Pair of 8 0.837 0.306 0.247 0.24
♦ ace ♣ king 0.699 0.298 0.284 0.266
♦ ace ♣ queen 0.711 0.288 0.273 0.264
♣ ace ♦ king 0.679 0.295 0.278 0.246
Pair of 6 0.79 0.257 0.222 0.227
♦ ace ♣ 10 0.712 0.27 0.254 0.257
♦ ace ♣ jack 0.671 0.297 0.282 0.237
♣ ace ♦ queen 0.703 0.283 0.251 0.241
Pair of 5 0.76 0.222 0.23 0.245
♣ ace ♦ jack 0.697 0.26 0.259 0.233
♦ ace ♣ 9 0.728 0.236 0.223 0.219
♣ ace ♦ 9 0.703 0.251 0.229 0.209
Pair of 3 0.716 0.203 0.226 0.247
♦ ace ♣ 5 0.71 0.233 0.224 0.216
♣ ace ♦ 3 0.712 0.222 0.218 0.215
Pair of 4 0.722 0.202 0.207 0.228
♣ ace ♦ 8 0.67 0.25 0.228 0.209
♣ ace ♦ 5 0.72 0.227 0.2 0.208
♦ ace ♣ 8 0.695 0.24 0.215 0.199
♣ ace ♦ 7 0.713 0.224 0.211 0.199
♣ ace ♦ 10 0.659 0.242 0.224 0.213
♦ ace ♣ 7 0.697 0.226 0.197 0.21
♣ ace ♦ 4 0.671 0.229 0.217 0.204
♣ ace ♦ 6 0.696 0.23 0.214 0.179
♣ ace ♦ 2 0.709 0.213 0.199 0.193
♦ ace ♣ 3 0.673 0.218 0.207 0.213
♦ ace ♣ 4 0.689 0.218 0.195 0.205
♦ ace ♣ 6 0.678 0.232 0.193 0.19
Pair of 2 0.687 0.184 0.194 0.219
♦ ace ♣ 2 0.686 0.187 0.18 0.193
♦ king ♣ jack 0.25 0.286 0.288 0.263
♣ king ♦ queen 0.221 0.279 0.269 0.272
♣ king ♦ jack 0.208 0.277 0.257 0.237
♦ king ♣ queen 0.205 0.245 0.254 0.256
♦ king ♣ 10 0.238 0.253 0.229 0.226
♣ king ♦ 10 0.217 0.245 0.242 0.236
♦ king ♣ 9 0.241 0.227 0.224 0.23
♦ king ♣ 6 0.218 0.212 0.213 0.211
♣ king ♦ 7 0.24 0.215 0.198 0.19
♦ king ♣ 7 0.217 0.208 0.203 0.203
♣ king ♦ 9 0.216 0.218 0.202 0.19
♣ king ♦ 4 0.195 0.214 0.201 0.207
♣ king ♦ 2 0.238 0.187 0.187 0.2
♣ king ♦ 8 0.208 0.213 0.2 0.176
♦ king ♣ 5 0.214 0.2 0.198 0.184
♦ king ♣ 8 0.217 0.2 0.186 0.186
♦ king ♣ 4 0.218 0.195 0.187 0.18
♣ queen ♦ jack 0.059 0.234 0.243 0.242
♣ queen ♦ 10 0.065 0.221 0.245 0.247
♦ queen ♣ 10 0.053 0.231 0.234 0.238
♣ king ♦ 3 0.191 0.196 0.181 0.186
♦ queen ♣ jack 0.056 0.224 0.232 0.239
♣ king ♦ 6 0.209 0.185 0.169 0.176
♣ king ♦ 5 0.226 0.162 0.164 0.167
♦ king ♣ 3 0.207 0.17 0.167 0.169
♦ king ♣ 2 0.232 0.152 0.156 0.164
♣ queen ♦ 9 0.056 0.22 0.199 0.206
♦ queen ♣ 9 0.059 0.213 0.203 0.188
♦ 10 ♣ 9 0.004 0.226 0.205 0.22
♣ jack ♦ 10 0.013 0.207 0.205 0.224
♦ queen ♣ 6 0.072 0.196 0.182 0.198
♦ jack ♣ 9 0.014 0.217 0.191 0.215
♦ jack ♣ 10 0.013 0.204 0.2 0.219
♦ queen ♣ 8 0.05 0.198 0.192 0.187
♦ 10 ♣ 8 0.003 0.207 0.197 0.21
♣ jack ♦ 9 0.012 0.209 0.191 0.203
♣ queen ♦ 8 0.053 0.211 0.177 0.171
♦ queen ♣ 5 0.072 0.185 0.177 0.178
♦ queen ♣ 4 0.054 0.191 0.18 0.183
♣ queen ♦ 7 0.062 0.176 0.186 0.182
♦ jack ♣ 8 0.012 0.2 0.185 0.204
♣ queen ♦ 6 0.047 0.191 0.165 0.189
♣ 10 ♦ 9 0.0 0.204 0.189 0.198
♣ 10 ♦ 7 0.005 0.193 0.194 0.187
♣ queen ♦ 5 0.049 0.192 0.171 0.163
♦ queen ♣ 7 0.054 0.181 0.173 0.165
♣ 9 ♦ 8 0.001 0.184 0.184 0.194
♣ queen ♦ 4 0.056 0.175 0.156 0.17
♣ jack ♦ 7 0.009 0.192 0.168 0.187
♦ jack ♣ 7 0.009 0.185 0.177 0.181
♣ jack ♦ 8 0.01 0.184 0.172 0.179
♦ 10 ♣ 7 0.004 0.192 0.17 0.179
♣ queen ♦ 2 0.051 0.169 0.162 0.162
♦ queen ♣ 3 0.051 0.165 0.159 0.165
♣ queen ♦ 3 0.061 0.158 0.156 0.164
♣ 8 ♦ 7 0.0 0.175 0.173 0.184
♦ 8 ♣ 6 0.0 0.171 0.166 0.189
♣ 10 ♦ 8 0.005 0.177 0.163 0.178
♦ queen ♣ 2 0.056 0.165 0.145 0.156
♦ 9 ♣ 7 0.001 0.179 0.16 0.18
♣ 9 ♦ 7 0.0 0.157 0.171 0.186
♦ 9 ♣ 8 0.001 0.157 0.159 0.194
♦ 9 ♣ 6 0.001 0.166 0.157 0.186
♦ 8 ♣ 7 0.0 0.174 0.157 0.179
♣ jack ♦ 4 0.014 0.162 0.158 0.167
♣ 10 ♦ 6 0.005 0.172 0.155 0.168
♣ jack ♦ 6 0.017 0.16 0.162 0.159
♣ 7 ♦ 6 0.0 0.147 0.153 0.191
♦ 10 ♣ 6 0.003 0.147 0.157 0.182
♦ 10 ♣ 5 0.003 0.165 0.155 0.164
♣ jack ♦ 3 0.013 0.163 0.144 0.165
♣ jack ♦ 5 0.012 0.156 0.154 0.159
♦ jack ♣ 6 0.012 0.158 0.148 0.156
♣ 10 ♦ 5 0.004 0.155 0.145 0.169
♣ 8 ♦ 6 0.0 0.154 0.156 0.162
♣ 7 ♦ 5 0.0 0.153 0.142 0.175
♦ jack ♣ 4 0.009 0.147 0.146 0.166
♣ 10 ♦ 3 0.002 0.149 0.148 0.162
♣ 7 ♦ 4 0.0 0.135 0.148 0.177
♦ 10 ♣ 4 0.003 0.145 0.15 0.158
♦ 7 ♣ 5 0.0 0.141 0.153 0.162
♦ jack ♣ 5 0.014 0.152 0.138 0.149
♦ 7 ♣ 6 0.0 0.144 0.152 0.157
♣ 5 ♦ 4 0.0 0.132 0.141 0.176
♦ jack ♣ 2 0.015 0.143 0.142 0.149
♦ 9 ♣ 4 0.002 0.149 0.148 0.15
♣ 8 ♦ 5 0.0 0.128 0.149 0.165
♦ 9 ♣ 5 0.0 0.14 0.136 0.162
♦ 8 ♣ 5 0.0 0.137 0.138 0.159
♣ jack ♦ 2 0.013 0.126 0.132 0.16
♦ 10 ♣ 2 0.001 0.125 0.144 0.161
♣ 8 ♦ 4 0.0 0.136 0.132 0.16
♣ 10 ♦ 4 0.005 0.138 0.133 0.15
♣ 9 ♦ 3 0.0 0.132 0.135 0.158
♣ 9 ♦ 6 0.0 0.145 0.141 0.136
♣ 4 ♦ 3 0.0 0.116 0.14 0.165
♣ 6 ♦ 4 0.0 0.12 0.138 0.162
♦ 10 ♣ 3 0.001 0.134 0.137 0.147
♦ 6 ♣ 3 0.0 0.123 0.13 0.161
♦ 7 ♣ 4 0.0 0.14 0.125 0.149
♦ jack ♣ 3 0.014 0.145 0.123 0.129
♣ 10 ♦ 2 0.002 0.142 0.133 0.132
♦ 4 ♣ 3 0.0 0.11 0.13 0.168
♦ 5 ♣ 4 0.0 0.118 0.129 0.161
♣ 6 ♦ 5 0.0 0.129 0.13 0.149
♦ 9 ♣ 2 0.0 0.142 0.122 0.142
♦ 7 ♣ 2 0.0 0.133 0.136 0.135
♦ 6 ♣ 5 0.0 0.123 0.126 0.154
♣ 5 ♦ 3 0.0 0.126 0.128 0.148
♣ 7 ♦ 3 0.0 0.127 0.126 0.146
♦ 8 ♣ 4 0.0 0.129 0.123 0.141
♣ 9 ♦ 5 0.0 0.132 0.115 0.141
♣ 4 ♦ 2 0.0 0.116 0.121 0.149
♦ 6 ♣ 4 0.0 0.116 0.129 0.14
♣ 9 ♦ 2 0.0 0.12 0.122 0.142
♦ 5 ♣ 2 0.0 0.104 0.12 0.156
♦ 9 ♣ 3 0.0 0.139 0.117 0.122
♦ 7 ♣ 3 0.0 0.121 0.122 0.133
♣ 9 ♦ 4 0.0 0.128 0.116 0.127
♦ 6 ♣ 2 0.0 0.105 0.119 0.145
♣ 6 ♦ 3 0.0 0.11 0.112 0.146
♣ 5 ♦ 2 0.0 0.109 0.114 0.145
♦ 4 ♣ 2 0.0 0.113 0.116 0.139
♣ 7 ♦ 2 0.0 0.122 0.107 0.137
♣ 8 ♦ 3 0.0 0.128 0.111 0.125
♣ 3 ♦ 2 0.0 0.106 0.12 0.137
♦ 5 ♣ 3 0.0 0.102 0.114 0.138
♦ 8 ♣ 2 0.0 0.114 0.111 0.125
♣ 6 ♦ 2 0.0 0.105 0.124 0.121
♣ 8 ♦ 2 0.0 0.114 0.109 0.124
♦ 8 ♣ 3 0.0 0.123 0.106 0.118
♦ 3 ♣ 2 0.0 0.083 0.086 0.12

Conclusions

I hope this post has given you a little bit of new knowledge about poker. What I have learned while writing it is that poker is extremely dynamic: a given hand can be good at various stages and does not have an absolute strenght. If you take into account the human factor, this gives a good idea of why the game can be so difficult and at the same time, exhilarating

Comments