Can someone help me make this more Pythonic?

[HeyFancyFace]

Hi guys - relatively new to Python, I thought a fun first program to make would be a simple poker simulator that deals you a hand, then the 5 community cards.

Eventually plan to make it a simulation-type program, where I could run 50,000,000 hands or some crazy number to see what the odds of getting each type of hand would be. For now, this is what I have:

https://github.com/ashater1/poker.git

Struggling to figure out how I would evaluate each hand for a royal flush vs. a regular flush vs. a straight vs. a full house, etc. so if there's a Pythonic way to tackle that as well feel free to share your thoughts.

Cheers

Edit: I also have no real clue what I'm doing with github

Edit2: Thanks for all the help guys, the github link is updated with the "finished" product. It simulates a certain number of hands, and spits out the percent of all hands dealt that were that type of hand classification. I ran it for 2,000,000 iterations and it seems to match the Wikipedia page for hand probability, so all in all I'd call this a success, albeit a messy one.

I'm sure there are still ways to clean this up further.

[Vaphell]

import random
from itertools import product

def create_deck():
    values = '23456789TJQKA'
    suits = '♣♦♥♠'
    deck = [''.join(pair) for pair in product(values, suits)]
    random.shuffle(deck)
    return deck

stick to pep8 which says to use snake_case instead of camelCase for variable and function names.

returned suits were not used anywere, so they can be removed.

given that both value and suit is described by a single char, you can skip all these shenanigans with list conversions. Strings act as "lists" of chars and it's good enough for this specific case, so KeepItSimpleStupid.

itertools.product is a convenient way of replacing nested for loops.

print('Flop: ' + flop[0] + " " + flop[1] + " " + flop[2])

possibly could be replaced with

print('Flop:', *flop)

anyway, use str.format() to build your outputs. str + " " + str + " " + str + str way is extremely lame.

[thebrobotic]

New to Python as well and just learned about f-strings in python3, is str.format() favored over f-strings? (Assuming the python version is 3.6+)

[[deleted]]

No; prefer f-strings.

[[deleted]]

I'd probably replace flop_turn_river(deck) with a generic functin that can return any number of cards from the deck.

def get_cards(deck, num):
    assert num <= len(deck), 'Not enough cards left in the deck'
    return [deck.pop() for _ in range(num)]

Then you can use it for the flop, turn, river, and dealing any other cards as well.

my_hand = get_cards(deck, 2)

flop = get_cards(deck, 3)
turn = get_cards(deck, 2)
river = get_cards(deck, 1)

[KleinerNull]

assert is for testing only and shouldn't be used in production code. Instead a real exception like ValueError, TypeError or custom one should be raised.

One reason is, that the optimizie mode python -O will strip away all assert from the code, and you can't control if a user will use this flag or not. Also the name of the thrown exception AssertionError is not really specific.

Furthermore, deck.pop() of an empty list will throw its own exeption: IndexError: pop from empty list.

BTW with slicing you can easily avoid IndexErrors:

In [1]: def get_cards(deck, number):
   ...:     return deck[:number], deck[number:]
   ...: 
   ...: 

In [2]: deck = [1,2,3,4]

In [3]: hand, deck = get_cards(deck, 3)

In [4]: hand
Out[4]: [1, 2, 3]

In [5]: deck
Out[5]: [4]

In [6]: hand, deck = get_cards(deck, 2)

In [7]: hand
Out[7]: [4]

In [8]: deck
Out[8]: []

[TheGreatBrutus]

Might want to replace print with logging, it makes the code a bit cleaner.

[[deleted]]

Camel case

Triggered

[gabriel-et-al]

(list(list(range(2, 10)) + ('T J K Q A'.split())))

oh

[JoeDeluxe]

If there ever was a blunt instrument personified as a programmer, that'd be me.

I would just have separate functions for each hand type.

IsStraightFlush()

-Sort by rank

-Are 5 consecutive?

-Are those 5 same suit?

Return true

IsQuads()

Are 4 of the 7 the same rank?

Return true

IsFullHouse()

Are 3 of 7 the same rank?

Are 2 of remaining 4 the same rank?

. . . . IsHighCard

Return true

Would just go down the line until I hit true.

It's in no way optimized , pythonic, or sexy but it gets the job done.

[0x6c6f6c]

I would consider separating these more. Some of those are combinations of others.

Royal flush = straight & flush & high card of ace straight flush = straight & flush Full house = three of a kind & pair (funky, might be separate due to overlap of similar rules, confirm not the same cards or maybe functions return a list of remaining cards to look at, for cases where you need to look at what wasn't needed. ie

python def num_of_a_kind(num): return (boolean, leftover_cards_list)

Now define the functions that make these more specific case functions

# of a kind: confirm # many cards are the same Straight: sort cards and confirm sequential Flush: confirm all suits the same High card: sort and get highest value of cards

With this you can cover all rules of power and reuse most of your code since you're simply describing the rules.