## Poker Hands Value

*04.03.2021*

*by admin*

## Which poker stats are most important?

As a baseline we'd recommend raising three times the big blind with hand like like 22+/AT+/KJ+/89s-JQs/A2s-A5s. This is 15.5% of hands. If we have tight players on our left we can start to raise. This function starts checking the most valuable hands. After it checks the second to lowest hand (pair), it returns a value of 1. Unibet online tv. This value of 1 corresponds to the 'highest card' hand. Since I'm not comparing the relative value of hands, it doesn't matter what the highest card is, so the number just represents the type of hand that is the strongest.

Our poker HUD software offers a large amount of statistics. Knowing which ones are relevant and important can be overwhelming. If you are new to poker software you can initially ignore all statistics except the essential three poker statistics. Once you have understood how to use the basic statistics, you can add more depending on your style of play, and your chosen table size.

The big three poker statistics (and one bonus stat):

- Voluntarily Put $ in Pot (
**VPIP**) - Preflop Raise (
**PFR**) - Postflop Aggression Frequency (
**Agg**) - A bonus stat: Big blinds won/100 hands.

These three statistics are a great starting point to get an idea of a person’s playing style. They only require 25 hands or so to reliably give a good idea of a player's tendencies.

## Voluntarily Put $ in Pot (VPIP)

VPIP in poker measures how often you voluntarily pay money into a hand before seeing the flop. Paying the big blind, the small blind, or the ante is not considered voluntary. Therefore this percentage indicates how often you called, bet, or raised. The lower this value, the tighter your hand selection is. The higher, the looser. Only preflop betting is taken into account.

Good players know to only invest money in the pot when they have decent starting hands. A simple way to measure whether you are doing this is to keep your VPIP at a sensible value.

### What is a good number for VPIP?

**Simple answer**: between 15% and 20%. This assumes you want to play tightly, you are playing micro-stakes, and you are playing on full ring cash tables.

Now the more **complicated answer**: it depends a lot. If you are still learning to play good poker, then you should be very selective in which hands you play, so your VPIP might acceptably be a tad lower than 15%. The less people on the table, the more hands you can play. If you are on a table full of ultralight players, you can also loosen up. An experienced player who understands the subtleties of the game can get away with a VPIP between 20% and 27%. In 6-max or heads-up, most players have a much higher VPIP. In Pot Limit Omaha, VPIP values will be even higher.

## Preflop Raise (PFR)

The PFR statistic indicates how often you have raised before the flop is seen. A high value is an indicator of an aggressive player. A low value indicates a passive player. Good players are aggressive players.

Your PFR has a possible range between a minumum of 0% and a maximum equal to the value of your VPIP. That is, if your VPIP is 20%, then your PFR can’t be higher than 20%. Ideally it should be a little lower than your VPIP, but not much lower.

Poor players and beginners play timidly. They call too often preflop. Good players frequently fold or raise preflop, especially if no other players have yet raised. If you are not prepared to raise, then you should consider folding. Calling preflop just in case the flop is good for you is not a winning poker strategy.

### What is a good PFR range?

Between 2% and 3% lower than VPIP. If your VPIP is 15%, PFR should be about 12%. These two numbers in combination indicate that you are only playing quality hole cards, and you are predominantly raising with them pre-flop. In other words, you are playing how most poker books and poker forums say you should play.

## Postflop Aggression Frequency (Agg)

Agg indicates how aggressively you play postflop. The higher this number, the more aggressively you are playing. This must be interpreted in combination with VPIP. Players who see very few flops will naturally tend to have a higher aggression percentage because they are only playing top-quality hole cards.

### Poker Hands Same Value

Poor players play passively postflop. They’ll check or call too often. Good players know to play good hands aggressively postflop:

- because players with speculative hands are forced to fold before they get free cards
- because if they hit the flop or have a dominating hand, a bet or raise will increase their return

### What is a good Agg range?

50% to 60% is ideal, assuming that you have a VPIP of 15% to 20%. Much higher, and you are probably overplaying speculative hands and bad hands, and bluffing too much. Much lower and you are not playing your good hands strongly postflop.

Leave the bluffing for the movies and for live play. At low stakes online play, bluffing is much less important than a good understanding of the probabilities of winning hands.

## Big blinds won/100 hands

The three stats I've presented so far mean nothing if you can't keep your win rate positive. A nice way to 'normalize' your win rate across different stake levels, table sizes, and opponents is to measure how much you won in terms of the big blind. If you are playing at a table where the big blind is $0.50, and you won $20, then think of this as winning 40 big blinds.

If this number is not positive, then you are losing money. The best remedy is to drop to a lower stake level, where the opponents are weaker. If, according to this stat, you consistently win over time, then you should consider going up to a higher stake level.

## Adjusting your play based on the villain's poker stats

This is where our poker HUD software gets really useful: analyzing and exploiting opponent weaknesses. Let's consider some hypothetical players:

**Tight Tim has VPIP of 5%, PFR of 5%, and Agg of 100%**

With such a low VPIP, we can guess that this player folds anything except the very best hands. And with a PFR equal to VPIP, when he gets premium hands, he raises. So if this player raises, and you are next to act, you know that you should fold every hand except the best few hands, such as AA, KK, QQ. You can be almost certain that if you go to the flop, he'll raise postflop. So play tighter than usual with this player. But when you do get a premium hand, and he comes along, you can be sure that player B will put plenty of chips into the pot. Your pot, hopefully.

**Passive Pete has VPIP of 20%, PFR of 16%, and Agg of 10%.**

This player seems take have a good handle on preflop play. But when he gets to the flop, he gets timid. He is probably going to give you a chance postflop to see the turn and river for free. If you go to the flop with him and raise, there is a good chance he'll fold. So you can play a bit more aggressively both preflop and postflop.

**Eddie the Eagle has VPIP of 22%, PFR of 19%, and Agg of 55%.**

Eddie has a good all-round balance between preflop and postflop play. Preflop, he plays tight and aggressively. Postflop, he balances between pushing hard with his good hands, and being willing to fold or check with his weaker hands. Eddie would be well-served to move on to understanding more advanced poker statistics.

## Tracking your poker stats

Poker players use poker software like Poker Copilot to automatically record their hands. Each hand is broken down into many statistics, which are then aggregated into simple percentages.

## Poker Statistics Guide

What’s next after you’ve understood the basic poker stats? Read our Poker Statistics Guide for a comprehensive explanation of understanding and using all the main poker statistics.

Last Updated on January 1, 2018

I recently took a Hackerrank challenge for a job application that involved poker. I'm not a poker player, so I had a brief moment of panic as I read over the problem the description. In this article I want to do some reflection on how I approached the problem.

The hackerrank question asked me to write a program that would determine the best poker hand possible in five-card draw poker. We are given 10 cards, the first 5 are the current hand, and the second 5 are the next five cards in the deck. We assume that we can see the next five cards (they are not hidden). We want to exchange any `n`

number of cards (where `n <= 5`

) in our hand for the next `n`

cards in the deck. For example, we can take out any combination of 2 cards from the hand we are given, but we must replace these two cards with the next two cards from the deck (we can't pick any two cards from the deck).

Suit and value make up the value of playing cards. For example, you can have a 3 of clubs. 3 is the value, clubs is the suit. We can represent this as `3C`

.

**Suits**

Clubs CSpades SHeart HDiamonds D

**Value (Rank)**

2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, Ace

## Hands

Here are the hands of poker

Royal flush (the problem didn't ask me to consider Royal Flush)

A, K, Q, J, 10, all the same suit.

Straight flush

Five cards in a sequence, all in the same suit.

**Ace can either come before 2 or come after King.**Four of a kind

All four cards of the same rank.

Full house

Three of a kind with a pair.

Flush

Any five cards of the same suit, but not in a sequence.

Straight

Five cards in a sequence, but not of the same suit.

Three of a kind

Three cards of the same rank.

Two pair

Two different pairs.

Pair

Two cards of the same rank.

High Card

When you haven't made any of the hands above, the highest card plays.In the example below, the jack plays as the highest card.

## Evaluating a hand of cards

A hand is five cards. The first thing I did was write out functions to evaluate if a group of 5 cards satisfies the conditions of one of the ten hands.

Here's a sample hand:

To write functions, I reached for using 2 important python features: `set`

and `defaultdict`

.

### Poker Hand Value Chart

Here's an example of a simple function to detect a flush, a hand with cards of all the same suit:

## Checking a flush

This function creates a list of the suits in our hand, and then counts the unique elements in that list by making it a set. If the length of the set is 1, then all the cards in the hand must be of the same suit.

But wait, what if we have a straight flush? Also, a hand that satisfies a flush could also be described as a two pair hand. The problem asked me to find the highest possible hand for a given set of cards, so I tried to keep things simple by writing a `check_hand()`

function that checks each hand starting from straight flush down to high card. As soon as a condition for a hand was satisfied, I returned a number that corresponded to the strength of the hand (1 for high card up to 10 for straight flush). The problem didn't include Royal flush, so I will not include that here.

### Printable Poker Hand

Here's the `check_hand`

function:

This function starts checking the most valuable hands. After it checks the second to lowest hand (pair), it returns a value of 1. This value of 1 corresponds to the 'highest card' hand. Since I'm not comparing the relative value of hands, it doesn't matter what the highest card is, so the number just represents the *type* of hand that is the strongest.

## Other hands

Here are the all of the functions I used to detect hands:

`defaultdict`

is a great built-in that is good to use when you don't know what elements will be in your dictionary, but you know what the initial values of any key that could be added should be. We don't need it here, but the alternative would be to write a very long dictionary where keys are the possible card values and the values of each key is 0.

It would certainly be cleaner and more efficient to write out the above functions into one large function, but I wanted to keep things simple as I was under time constraints.

The next step in the problem is to determine the best possible hand we can get given the hand we are dealt and the 5 cards on top of the deck. I decided to first solve this problem with brute force. Here was my logic for this part: use `itertools`

to get all combinations of groups of 0, 1, 2, 3, 4 and 5 cards from my hand and add the first `5 - n`

cards from the deck so we get a five card deck. For each combination of cards we can run `check_hand()`

and keep track of the highest rank hand, and then return that hand as the best hand. Here's the code I wrote for this part of the problem:

Lastly, I need to check each hand and print out the best hand possible. Here's the loop I wrote to do this:

This will accept one round of cards per line:

and it will output the following:

This was an interesting problem to deal with as the solution contained several parts that worked together. While solving the problem I aimed worked through to the end leaving some parts to come back to that I felt confident in solving. Instead of writing each function to check differnt hands at the beginning, I filled most of these functions with `pass`

and moved on to write the next part that involves checking each different combination of cards. Recently having worked through python's `itertools`

exercises on Hackerrank, the `combinations`

functions was fresh in my mind.

While I was able to arrive at a solution that satisfied the test cases, I did not have time to think about the efficiency or Big O analysis of the problem.

There is obviously some refactoring that I could do to make things cleaner. With more time I would take an object oriented approach by making classes for cards and hands, and adding class methods to evaluate the hands.

For each round, we have to run `check_hand()`

on each hand combination. Let's think about how many hands we have to evaluate:

We have to consider combinations of cards formed by taking out groups of 0, 1, 2, 3, 4 and 5 cards and adding the next number of cards in the deck that bring the total card count to 5, which means we have to do 5C0 + 5C1 + 5C2 + 5C3 + 5C4 + 5C5 calls to `check_hand()`

. So the sum of total calls is 1 + 5 + 10 + 10 + 5 + 1 = **32**.

For each of these 32 calls that happen when we run `play()`

, `check_hands()`

runs through each of the `check_`

functions starting with the highest value hand. As soon as it finds a 'match', `check_hands()`

returns a number value (`hand_value`

) corresponding to straight flush, four of a kind, etc. This value is then compared with the highest value that has been previously found (`best_hand`

) and replaces that value if the current hand's hand rank has a higher value.

I'm not sure if there is faster way to find the best hand than the brute force method I implemented.