Calculate Hand Value in a Blackjack Hand

Question

I have built a Blackjack simulator in Python. I need to decrease the execution time. I have used a profiler to identify key bottlenecks in the execution. The following function is responsible for about 15% of the total run time.

def value(self):
    value = 0
    has_ace = False

    for card in self.cards:
        value += card.value

        if card.rank == "A":
            has_ace = True

    if has_ace and value <= 11:
        value += 10

    return value

The above function is used to calculate the score of a hand. A hand can have multiple cards. A card has a value and a rank.

In Blackjack, an Ace can be worth 1 or 11.

Is there a better way to go?

Answer 1

This function doesn't have any really obvious inefficiencies, so I assume we're looking to shave off every possible clock cycle...

Sometimes it's faster to use Python's built-in aggregation functions than to use a for loop. Here's how you could use sum and any:

def value(self) -> int:
    value = sum(card.value for card in self.cards)
    if value <= 11 and any(card.rank == "A" for card in self.cards):
        value += 10
    return value

Note the ordering of the and expression to make sure that the any iteration only happens if the value condition has already been met!

If you have flexibility over the representation of the cards, you might try making the rank an Enum with integer values. I'd expect comparing two integer enums to be just a smidge faster than comparing two strings.

Answer 2

In terms of playing the game, what is the use of the returned value?

For instance, A222 would have the value 17, and at that value, most people would stick and not ask for another card. But if it could be counted as 7, everyone would ask for another card.

To be useful, the result will need to be a list of possible values, (7,17) for this example.

Answer 3

I think that 10 and 11 are confusing values, and it might be more readable to have them either calculated or more explicitly expressed.

As you say, an ace can be either 1 or 11.

In addition, a valid hand cannot exceed 21.

I'd expect the code to have only those values hard coded (as constants or something similar).

If you want to implement it in an object oriented way (might not be the best idea here), then all of the cards are an instance of a class, which has the following methods:

• has_alternative_value
• get_regular_value
• get_alternative_value

Only the ace would return True to has_alternative_value and so forth.

Having it implemented like that, the code would only have to deal with the magic number 21, and you wouldn't have 10 and 11 magic numbers.

While this sounds like over-engineering, I think that the main idea could be implemented in a simpler way. I don't have the time to write the entire solution myself, but I hope you catch my drift.

Good luck :)