I need this project done in python

Instructions are pretty clear in uploaded files

Get Help With a similar task to - I need this project done in python

Login to view and/or buy answers.. or post an answer
Additional Instructions:

cards.py import random """ NOTE: If your terminal can't decode the unicode card suit symbols, set up the bash terminal language environment to "en_US.utf8", like this -- export LANG=en_US.utf8 You might also want to put this in your ~/.bashrc to make the change permanent accross the sessions. For tcsh or zsh, there are similar methods exist, please look them up. """ class Card( object ): """ Model a playing card. """ # Rank is an int (1-13), where aces are 1 and kings are 13. # Suit is an int (1-4), where clubs are 1 and spades are 4. # Value is an int (1-10), where aces are 1 and face cards are 10. # List to map int rank to printable character (index 0 used for no rank) rank_list = ['x','A','2','3','4','5','6','7','8','9','10','J','Q','K'] # List to map int suit to printable character (index 0 used for no suit) # 1 is clubs, 2 is diamonds, 3 is hearts, and 4 is spades # suit_list = ['x','c','d','h','s'] # for systems that cannot print Unicode symbols suit_list = ['x','\u2663','\u2666','\u2665','\u2660'] def __init__( self, rank=0, suit=0 ): """ Initialize card to specified rank (1-13) and suit (1-4). """ self.__rank = 0 self.__suit = 0 self.__face_up = None # Verify that rank and suit are ints and that they are within # range (1-13 and 1-4), then update instance variables if valid. if type(rank) == int and type(suit) == int: if rank in range(1,14) and suit in range(1,5): self.__rank = rank self.__suit = suit self.__face_up = True def rank( self ): """ Return card's rank (1-13). """ return self.__rank def value( self ): """ Return card's value (1 for aces, 2-9, 10 for face cards). """ # Use ternary expression to determine value. return self.__rank if self.__rank < 10 else 10 def suit( self ): """ Return card's suit (1-4). """ return self.__suit def is_face_up( self ): """ Returns True if card is facing up.""" return self.__face_up def flip_card( self ): """ Flips card between face-up and face-down""" self.__face_up = not self.__face_up def __str__( self ): """ Convert card into a string (usually for printing). """ # Use rank to index into rank_list; use suit to index into suit_list. if self.__face_up: return "{}{}".format( (self.rank_list)[self.__rank], \ (self.suit_list)[self.__suit] ) else: return "{}{}".format( "X", "X") def __repr__( self ): """ Convert card into a string for use in the shell. """ return self.__str__() def __eq__( self, other ): """ Return True, if Cards of equal rank and suit; False, otherwise. """ if not isinstance(other, Card): return False return self.rank() == other.rank() and self.suit() == other.suit() class Deck( object ): """ Model a deck of 52 playing cards. """ # Implement the deck as a list of cards. The last card in the list is # defined to be at the top of the deck. def __init__( self ): """ Initialize deck--Ace of clubs on bottom, King of spades on top. """ self.__deck = [Card(r,s) for s in range(1,5) for r in range(1,14)] def shuffle( self ): """ Shuffle deck using shuffle method in random module. """ random.shuffle(self.__deck) def deal( self ): """ Return top card from deck (return None if deck empty). """ # Use ternary expression to guard against empty deck. return self.__deck.pop() if len(self.__deck) else None def is_empty( self ): """ Return True if deck is empty; False, otherwise """ return len(self.__deck) == 0 def __len__( self ): """ Return number of cards remaining in deck. """ return len(self.__deck) def __str__( self ): """ Return string representing deck (usually for printing). """ return ", ".join([str(card) for card in self.__deck]) def __repr__( self ): """ Return string representing deck (for use in shell). """ return self.__str__() def display( self, cols=13 ): """ Column-oriented display of deck. """ for index, card in enumerate(self.__deck): if index%cols == 0: print() print("{:3s} ".format(str(card)), end="" ) print() print() cardsDemo.py import cards ''' The basic process is this: 1) You create a Deck instance, which is filled (automatically) with 52 Card instances 2) You can deal those cards out of the deck into hands, each hand a list of cards 3) You then manipulate cards as you add/remove them from a hand ''' my_deck = cards.Deck() print("======messy print a deck=====") print(my_deck) print("======pretty print a deck=====") my_deck.display() my_deck.shuffle() print("======shuffled deck=====") my_deck.display() a_card = my_deck.deal() print("Dealt card is:",a_card) print('How many cards left:',len(my_deck)) print("Is the deck empty?",my_deck.is_empty()) # deal some hands and print hand1_list=[] hand2_list=[] for i in range(5): hand1_list.append(my_deck.deal()) hand2_list.append(my_deck.deal()) print("\nHand 1:", hand1_list) print("Hand 2:", hand2_list) print() # take the last card dealt out of each hand last_card_hand1 = hand1_list.pop() last_card_hand2 = hand2_list.pop() print("Hand1 threw down",last_card_hand1, ", Hand2 threw down", last_card_hand2) print("Hands are now:",hand1_list, hand2_list) # check the compares if last_card_hand1 == last_card_hand2: print(last_card_hand1, last_card_hand2, "of equal rank") elif last_card_hand1.rank() > last_card_hand2.rank(): print(last_card_hand1.rank(), "of higher rank than",last_card_hand2.rank()) else: print(last_card_hand2.rank(), "of higher rank than",last_card_hand1.rank()) if last_card_hand1.value() == last_card_hand2.value(): print(last_card_hand1, last_card_hand2, "of equal value") elif last_card_hand1.value() > last_card_hand2.value(): print(last_card_hand1, "of higher value than",last_card_hand2) else: print(last_card_hand2, "of higher value than",last_card_hand1) if last_card_hand1.suit() == last_card_hand2.suit(): print(last_card_hand1,'of equal suit with',last_card_hand2) else: print(last_card_hand1,'of different suit than',last_card_hand2) # a foundation, a list of lists. 4 columns in this example foundation_list = [[],[],[],[]] column = 0 while not my_deck.is_empty(): foundation_list[column].append(my_deck.deal()) column += 1 if column % 4 == 0: column = 0 for i in range(4): print("foundation",i,foundation_list[i]) proj06.py import cards def less_than(c1,c2): '''Return True if c1 is smaller in rank, True if ranks are equal and c1 has a 'smaller' suit False otherwise''' if c1.rank() < c2.rank(): return True elif c1.rank() == c2.rank() and c1.suit() < c2.suit(): return True return False def min_in_list(L): '''Return the index of the mininmum card in L''' min_card = L[0] # first card min_index = 0 for i,c in enumerate(L): if less_than(c,min_card): # found a smaller card, c min_card = c min_index = i return min_index def cannonical(H): ''' Selection Sort: find smallest and swap with first in H, then find second smallest (smallest of rest) and swap with second in H, and so on...''' for i,c in enumerate(H): # get smallest of rest; +i to account for indexing within slice min_index = min_in_list(H[i:]) + i H[i], H[min_index] = H[min_index], c # swap return H def flush_7(H): '''Return a list of 5 cards forming a flush, if at least 5 of 7 cards form a flush in H, a list of 7 cards, False otherwise.''' pass def straight_7(H): '''Return a list of 5 cards forming a straight, if at least 5 of 7 cards form a straight in H, a list of 7 cards, False otherwise.''' pass def straight_flush_7(H): '''Return a list of 5 cards forming a straight flush, if at least 5 of 7 cards form a straight flush in H, a list of 7 cards, False otherwise.''' pass def four_7(H): '''Return a list of 4 cards with the same rank, if 4 of the 7 cards have the same rank in H, a list of 7 cards, False otherwise.''' pass def three_7(H): '''Return a list of 3 cards with the same rank, if 3 of the 7 cards have the same rank in H, a list of 7 cards, False otherwise. You may assume that four_7(H) is False.''' pass def two_pair_7(H): '''Return a list of 4 cards that form 2 pairs, if there exist two pairs in H, a list of 7 cards, False otherwise. You may assume that four_7(H) and three_7(H) are both False.''' pass def one_pair_7(H): '''Return a list of 2 cards that form a pair, if there exists exactly one pair in H, a list of 7 cards, False otherwise. You may assume that four_7(H), three_7(H) and two_pair(H) are False.''' pass def full_house_7(H): '''Return a list of 5 cards forming a full house, if 5 of the 7 cards form a full house in H, a list of 7 cards, False otherwise. You may assume that four_7(H) is False.''' pass def main(): D = cards.Deck() D.shuffle() while True: # create community cards # create Player 1 hand # create Player 2 hand print("-"*40) print("Let's play poker!\n") print("Community cards:",community_list) print("Player 1:",hand_1_list) print("Player 2:",hand_2_list) print() if __name__ == "__main__": main() project06.pdf CSE 231 Summer 2020 Programming Project #6 Assignment Overview This assignment focuses on the design, implementation and testing of a Python program which uses classes to solve the problem described below. Note: you are using a class we provide; you are not designing a class. It is worth 95 points (9.5% of course grade) and must be completed no later than 11:59 PM on Tuesday, June 23. Assignment Deliverable The deliverable for this assignment is the following file: proj06.py – the source code for your Python program Be sure to use the specified file name and to submit it for grading via the Mirmir system before the project deadline. Assignment Background The goal of this project is to gain practice with use of classes and creating functions. You will design and implement a Python program which plays simplified Texas Hold’em Poker. The program should deal two cards to two players (one card to each player, then a second card to each player), and then five community cards which players share to make their hands. A poker hand is the best five cards from the community cards plus the player’s cards (i.e., best 5 out of 7 cards total). The goal of this assignment is to find the category of each player’s hand and determine the winner. The rules of this game are relatively simple and you can find information about the game and about the poker hands in the links below. Keep in mind that you will only find the category of the hands and all nine cards can be dealt at once (a real poker game deals cards in stages to allow for betting, but we aren’t betting). http://en.wikipedia.org/wiki/Texas_holdem http://en.wikipedia.org/wiki/Poker_hands The categories in order from lowest to highest are: High card, 1 pair, 2 pair, 3 of a kind, straight, flush, full house, 4 of a kind, straight flush. You will not find a player’s hand’s value, but just the category of the hand. It is a tie if both players have hands in the same category. That is, if both of them have straights, it is considered a tie no matter who has the higher straight.Our game is simplified in two ways: 1. We only compare categories to determine the winner, not the value of the hands. For example, in a real poker game the winner of hands with exactly one pair would be determined by which http://en.wikipedia.org/wiki/Texas_holdem http://en.wikipedia.org/wiki/Poker_hands pair had the highest card rank. That is, a pair of 10s wins over a pair of 3s. In our game, two hands with exactly one pair is considered a tie with no consideration given to the card ranks. 2. The Card class ranks an Ace as the lowest card in a suit; whereas traditional poker ranks an Ace as highest. For simplicity, we will keep Aces as the lowest ranked card because we are only comparing categories not values. In particular, the cards 10h, Jh, Qh, Kh, Ah are not considered to make a straight in our game (they would under normal poker rules). Assignment Specifications 1. Your program will use the Card and Deck classes found in the file named cards.py. You may not modify the contents of that file: we will test your project using our copy of cards.py. We have included a cardsDemo.py program to illustrate how to use the Card and Deck classes. 2. Your program will be subdivided into meaningful functions. Use a function for each category (except that “high-card” doesn’t need a function). See hints below. 3. Your program will display each player’s dealt cards, the community cards, and announce the winner of the hand. Also, your program will display the winning combination (or either of the winning combinations, if a tie) as well as the category of the winning hand (see sample output below). For example, if the winning combination is “four-of-a-kind”, those four cards will be displayed; the fifth card in the hand will not be displayed. The display will be appropriately labeled and formatted. 4. After each run, the program will prompt the user if they want to see another hand: “do you want to continue: y or n”. The program should continue if user enters “y” or “Y”; otherwise, the program should halt. Also, if there are fewer than 9 cards left in the deck, the program should halt. Do not shuffle between hands; only shuffle at the beginning of the program. 5. Using dictionaries in this assignment is very useful as you can find how many cards have the same suit, or how many of them have the same rank. Most of my functions used a dictionary that had rank as the key, so I created a separate function to build such a dictionary from a hand. Hints 1. There are 9 categories of hands. For each category (except high-card), I wrote a function that would take as an argument a list of 7 cards and return either a sub-list of cards that satisfied that category or an empty list. That design let me use the functions in Boolean expressions since an empty list evaluates to False whereas a non-empty list evaluates to True. Returning a list of cards also allowed me to use functions within functions, e.g., a straight flush must be a flush. Returning a list of cards also made testing easier because I could see not only that the function had found a combination of that type, but I also could easily check that it was correct. By the way, the function to find a straight was the hardest function to write. 2. Finding a winner is simple: start with the highest category and work your way down the categories in a cascade of “if” and “elif” statements. The result is a long, but repetitive structure. (You do not need to check all possible combinations of hands because you are only trying to find the highest category that a hand fits.) 3. Think strategically for testing. Custom build a set of hands for testing by creating particular cards, e.g. H1 = [5c, 2c, 5h, 4s, 3d, 2h, 5d] can be used to test for a full house (I had to create each card first, e.g. c1 = cards.Card(5,1) to create the 5c card in H1. It took many lines to create the testing hands, but once built they proved useful.) Test each category function separately using the custom hands you created for testing. For example, result = full_house(H1) should yield a result [5c, 5h, 5d, 2c, 2h]. 4. I found dictionaries useful within functions. Sometimes using the rank as key worked best; other times using the suit as key was best. 5. In order for sort() and sorted() to work on any data type the less-than operation must be defined. That operation is not defined in the Cards class so neither sort() nor sorted() work on Cards. (We tried to make the Cards class as generic as possible to work with a wide variety of card games, and the ordering of cards considering both rank and suit varies across card games.) 6. Mirmir testing: these are arbitrary to match the tests in Mirmir. a. For ties print hand1. b. Dealing: common hand first, then hand 1, then hand 2 (I used list comprehension) c. I provided a function named connanical that orders hands to match Test 1 and Test 2 in Mirmir (individual Function Tests don’t care about order). If more than five cards are in a category, e.g. all seven cards are the same suit, I applied cannonical() before slicing off the first 5 cards. d. Since Mimir cannot handle the Unicode suit symbols, the suit_list was changed to characters. You don’t need to do anything—this is built into the cards.py used for testing on Mimir. When you look at the Mirmir output you will see characters rather than symbols for suits: suit_list = ['x','c','d','h','s'] Sample Output Test 1 ---------------------------------------- Let's play poker! Community cards: [9♠, 7♥, 6♥, 6♣, 4♠] Player 1: [4♣, 10♠] Player 2: [7♣, 10♣] TIE with two pairs: [4♣, 4♠, 6♣, 6♥] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [Q♣, K♦, K♣, K♠, 7♠] Player 1: [K♥, 10♦] Player 2: [Q♥, J♣] Player 1 wins with four of a kind: [K♣, K♦, K♥, K♠] Do you wish to play another hand?(Y or N) n Test 2 ---------------------------------------- Let's play poker! Community cards: [9♠, 7♥, 6♥, 6♣, 4♠] Player 1: [4♣, 10♠] Player 2: [7♣, 10♣] TIE with two pairs: [4♣, 4♠, 6♣, 6♥] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [Q♣, K♦, K♣, K♠, 7♠] Player 1: [K♥, 10♦] Player 2: [Q♥, J♣] Player 1 wins with four of a kind: [K♣, K♦, K♥, K♠] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [3♣, 6♦, A♣, 8♣, 2♣] Player 1: [9♣, 5♣] Player 2: [10♥, 4♣] TIE with a flush: [A♣, 2♣, 3♣, 5♣, 8♣] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [9♦, 8♦, 5♦, Q♠, Q♦] Player 1: [J♠, J♦] Player 2: [4♦, A♥] TIE with a flush: [5♦, 8♦, 9♦, J♦, Q♦] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [2♥, 3♥, A♠, 2♣, 3♠] Player 1: [2♦, A♦] Player 2: [8♠, A♣] Player 1 wins with a full house: [A♦, A♠, 2♣, 2♦, 2♥] Deck has too few cards so game is done. Scoring Rubric Scoring Summary General Requirements ______ 5 pts Coding Standard Implementation Fulfills specifications including the following: ______ (40 pts) 8 Category functions: High-card doesn't need one (5 pts each) ______ (15 pts) Main: all categories are considered ______ (15 pts) Test 1 ______ (20 pts) Test 2 CSE 231 Summer 2020

cards.py import random """ NOTE: If your terminal can't decode the unicode card suit symbols, set up the bash terminal language environment to "en_US.utf8", like this -- export LANG=en_US.utf8 You might also want to put this in your ~/.bashrc to make the change permanent accross the sessions. For tcsh or zsh, there are similar methods exist, please look them up. """ class Card( object ): """ Model a playing card. """ # Rank is an int (1-13), where aces are 1 and kings are 13. # Suit is an int (1-4), where clubs are 1 and spades are 4. # Value is an int (1-10), where aces are 1 and face cards are 10. # List to map int rank to printable character (index 0 used for no rank) rank_list = ['x','A','2','3','4','5','6','7','8','9','10','J','Q','K'] # List to map int suit to printable character (index 0 used for no suit) # 1 is clubs, 2 is diamonds, 3 is hearts, and 4 is spades # suit_list = ['x','c','d','h','s'] # for systems that cannot print Unicode symbols suit_list = ['x','\u2663','\u2666','\u2665','\u2660'] def __init__( self, rank=0, suit=0 ): """ Initialize card to specified rank (1-13) and suit (1-4). """ self.__rank = 0 self.__suit = 0 self.__face_up = None # Verify that rank and suit are ints and that they are within # range (1-13 and 1-4), then update instance variables if valid. if type(rank) == int and type(suit) == int: if rank in range(1,14) and suit in range(1,5): self.__rank = rank self.__suit = suit self.__face_up = True def rank( self ): """ Return card's rank (1-13). """ return self.__rank def value( self ): """ Return card's value (1 for aces, 2-9, 10 for face cards). """ # Use ternary expression to determine value. return self.__rank if self.__rank < 10 else 10 def suit( self ): """ Return card's suit (1-4). """ return self.__suit def is_face_up( self ): """ Returns True if card is facing up.""" return self.__face_up def flip_card( self ): """ Flips card between face-up and face-down""" self.__face_up = not self.__face_up def __str__( self ): """ Convert card into a string (usually for printing). """ # Use rank to index into rank_list; use suit to index into suit_list. if self.__face_up: return "{}{}".format( (self.rank_list)[self.__rank], \ (self.suit_list)[self.__suit] ) else: return "{}{}".format( "X", "X") def __repr__( self ): """ Convert card into a string for use in the shell. """ return self.__str__() def __eq__( self, other ): """ Return True, if Cards of equal rank and suit; False, otherwise. """ if not isinstance(other, Card): return False return self.rank() == other.rank() and self.suit() == other.suit() class Deck( object ): """ Model a deck of 52 playing cards. """ # Implement the deck as a list of cards. The last card in the list is # defined to be at the top of the deck. def __init__( self ): """ Initialize deck--Ace of clubs on bottom, King of spades on top. """ self.__deck = [Card(r,s) for s in range(1,5) for r in range(1,14)] def shuffle( self ): """ Shuffle deck using shuffle method in random module. """ random.shuffle(self.__deck) def deal( self ): """ Return top card from deck (return None if deck empty). """ # Use ternary expression to guard against empty deck. return self.__deck.pop() if len(self.__deck) else None def is_empty( self ): """ Return True if deck is empty; False, otherwise """ return len(self.__deck) == 0 def __len__( self ): """ Return number of cards remaining in deck. """ return len(self.__deck) def __str__( self ): """ Return string representing deck (usually for printing). """ return ", ".join([str(card) for card in self.__deck]) def __repr__( self ): """ Return string representing deck (for use in shell). """ return self.__str__() def display( self, cols=13 ): """ Column-oriented display of deck. """ for index, card in enumerate(self.__deck): if index%cols == 0: print() print("{:3s} ".format(str(card)), end="" ) print() print() cardsDemo.py import cards ''' The basic process is this: 1) You create a Deck instance, which is filled (automatically) with 52 Card instances 2) You can deal those cards out of the deck into hands, each hand a list of cards 3) You then manipulate cards as you add/remove them from a hand ''' my_deck = cards.Deck() print("======messy print a deck=====") print(my_deck) print("======pretty print a deck=====") my_deck.display() my_deck.shuffle() print("======shuffled deck=====") my_deck.display() a_card = my_deck.deal() print("Dealt card is:",a_card) print('How many cards left:',len(my_deck)) print("Is the deck empty?",my_deck.is_empty()) # deal some hands and print hand1_list=[] hand2_list=[] for i in range(5): hand1_list.append(my_deck.deal()) hand2_list.append(my_deck.deal()) print("\nHand 1:", hand1_list) print("Hand 2:", hand2_list) print() # take the last card dealt out of each hand last_card_hand1 = hand1_list.pop() last_card_hand2 = hand2_list.pop() print("Hand1 threw down",last_card_hand1, ", Hand2 threw down", last_card_hand2) print("Hands are now:",hand1_list, hand2_list) # check the compares if last_card_hand1 == last_card_hand2: print(last_card_hand1, last_card_hand2, "of equal rank") elif last_card_hand1.rank() > last_card_hand2.rank(): print(last_card_hand1.rank(), "of higher rank than",last_card_hand2.rank()) else: print(last_card_hand2.rank(), "of higher rank than",last_card_hand1.rank()) if last_card_hand1.value() == last_card_hand2.value(): print(last_card_hand1, last_card_hand2, "of equal value") elif last_card_hand1.value() > last_card_hand2.value(): print(last_card_hand1, "of higher value than",last_card_hand2) else: print(last_card_hand2, "of higher value than",last_card_hand1) if last_card_hand1.suit() == last_card_hand2.suit(): print(last_card_hand1,'of equal suit with',last_card_hand2) else: print(last_card_hand1,'of different suit than',last_card_hand2) # a foundation, a list of lists. 4 columns in this example foundation_list = [[],[],[],[]] column = 0 while not my_deck.is_empty(): foundation_list[column].append(my_deck.deal()) column += 1 if column % 4 == 0: column = 0 for i in range(4): print("foundation",i,foundation_list[i]) proj06.py import cards def less_than(c1,c2): '''Return True if c1 is smaller in rank, True if ranks are equal and c1 has a 'smaller' suit False otherwise''' if c1.rank() < c2.rank(): return True elif c1.rank() == c2.rank() and c1.suit() < c2.suit(): return True return False def min_in_list(L): '''Return the index of the mininmum card in L''' min_card = L[0] # first card min_index = 0 for i,c in enumerate(L): if less_than(c,min_card): # found a smaller card, c min_card = c min_index = i return min_index def cannonical(H): ''' Selection Sort: find smallest and swap with first in H, then find second smallest (smallest of rest) and swap with second in H, and so on...''' for i,c in enumerate(H): # get smallest of rest; +i to account for indexing within slice min_index = min_in_list(H[i:]) + i H[i], H[min_index] = H[min_index], c # swap return H def flush_7(H): '''Return a list of 5 cards forming a flush, if at least 5 of 7 cards form a flush in H, a list of 7 cards, False otherwise.''' pass def straight_7(H): '''Return a list of 5 cards forming a straight, if at least 5 of 7 cards form a straight in H, a list of 7 cards, False otherwise.''' pass def straight_flush_7(H): '''Return a list of 5 cards forming a straight flush, if at least 5 of 7 cards form a straight flush in H, a list of 7 cards, False otherwise.''' pass def four_7(H): '''Return a list of 4 cards with the same rank, if 4 of the 7 cards have the same rank in H, a list of 7 cards, False otherwise.''' pass def three_7(H): '''Return a list of 3 cards with the same rank, if 3 of the 7 cards have the same rank in H, a list of 7 cards, False otherwise. You may assume that four_7(H) is False.''' pass def two_pair_7(H): '''Return a list of 4 cards that form 2 pairs, if there exist two pairs in H, a list of 7 cards, False otherwise. You may assume that four_7(H) and three_7(H) are both False.''' pass def one_pair_7(H): '''Return a list of 2 cards that form a pair, if there exists exactly one pair in H, a list of 7 cards, False otherwise. You may assume that four_7(H), three_7(H) and two_pair(H) are False.''' pass def full_house_7(H): '''Return a list of 5 cards forming a full house, if 5 of the 7 cards form a full house in H, a list of 7 cards, False otherwise. You may assume that four_7(H) is False.''' pass def main(): D = cards.Deck() D.shuffle() while True: # create community cards # create Player 1 hand # create Player 2 hand print("-"*40) print("Let's play poker!\n") print("Community cards:",community_list) print("Player 1:",hand_1_list) print("Player 2:",hand_2_list) print() if __name__ == "__main__": main() project06.pdf CSE 231 Summer 2020 Programming Project #6 Assignment Overview This assignment focuses on the design, implementation and testing of a Python program which uses classes to solve the problem described below. Note: you are using a class we provide; you are not designing a class. It is worth 95 points (9.5% of course grade) and must be completed no later than 11:59 PM on Tuesday, June 23. Assignment Deliverable The deliverable for this assignment is the following file: proj06.py – the source code for your Python program Be sure to use the specified file name and to submit it for grading via the Mirmir system before the project deadline. Assignment Background The goal of this project is to gain practice with use of classes and creating functions. You will design and implement a Python program which plays simplified Texas Hold’em Poker. The program should deal two cards to two players (one card to each player, then a second card to each player), and then five community cards which players share to make their hands. A poker hand is the best five cards from the community cards plus the player’s cards (i.e., best 5 out of 7 cards total). The goal of this assignment is to find the category of each player’s hand and determine the winner. The rules of this game are relatively simple and you can find information about the game and about the poker hands in the links below. Keep in mind that you will only find the category of the hands and all nine cards can be dealt at once (a real poker game deals cards in stages to allow for betting, but we aren’t betting). http://en.wikipedia.org/wiki/Texas_holdem http://en.wikipedia.org/wiki/Poker_hands The categories in order from lowest to highest are: High card, 1 pair, 2 pair, 3 of a kind, straight, flush, full house, 4 of a kind, straight flush. You will not find a player’s hand’s value, but just the category of the hand. It is a tie if both players have hands in the same category. That is, if both of them have straights, it is considered a tie no matter who has the higher straight.Our game is simplified in two ways: 1. We only compare categories to determine the winner, not the value of the hands. For example, in a real poker game the winner of hands with exactly one pair would be determined by which http://en.wikipedia.org/wiki/Texas_holdem http://en.wikipedia.org/wiki/Poker_hands pair had the highest card rank. That is, a pair of 10s wins over a pair of 3s. In our game, two hands with exactly one pair is considered a tie with no consideration given to the card ranks. 2. The Card class ranks an Ace as the lowest card in a suit; whereas traditional poker ranks an Ace as highest. For simplicity, we will keep Aces as the lowest ranked card because we are only comparing categories not values. In particular, the cards 10h, Jh, Qh, Kh, Ah are not considered to make a straight in our game (they would under normal poker rules). Assignment Specifications 1. Your program will use the Card and Deck classes found in the file named cards.py. You may not modify the contents of that file: we will test your project using our copy of cards.py. We have included a cardsDemo.py program to illustrate how to use the Card and Deck classes. 2. Your program will be subdivided into meaningful functions. Use a function for each category (except that “high-card” doesn’t need a function). See hints below. 3. Your program will display each player’s dealt cards, the community cards, and announce the winner of the hand. Also, your program will display the winning combination (or either of the winning combinations, if a tie) as well as the category of the winning hand (see sample output below). For example, if the winning combination is “four-of-a-kind”, those four cards will be displayed; the fifth card in the hand will not be displayed. The display will be appropriately labeled and formatted. 4. After each run, the program will prompt the user if they want to see another hand: “do you want to continue: y or n”. The program should continue if user enters “y” or “Y”; otherwise, the program should halt. Also, if there are fewer than 9 cards left in the deck, the program should halt. Do not shuffle between hands; only shuffle at the beginning of the program. 5. Using dictionaries in this assignment is very useful as you can find how many cards have the same suit, or how many of them have the same rank. Most of my functions used a dictionary that had rank as the key, so I created a separate function to build such a dictionary from a hand. Hints 1. There are 9 categories of hands. For each category (except high-card), I wrote a function that would take as an argument a list of 7 cards and return either a sub-list of cards that satisfied that category or an empty list. That design let me use the functions in Boolean expressions since an empty list evaluates to False whereas a non-empty list evaluates to True. Returning a list of cards also allowed me to use functions within functions, e.g., a straight flush must be a flush. Returning a list of cards also made testing easier because I could see not only that the function had found a combination of that type, but I also could easily check that it was correct. By the way, the function to find a straight was the hardest function to write. 2. Finding a winner is simple: start with the highest category and work your way down the categories in a cascade of “if” and “elif” statements. The result is a long, but repetitive structure. (You do not need to check all possible combinations of hands because you are only trying to find the highest category that a hand fits.) 3. Think strategically for testing. Custom build a set of hands for testing by creating particular cards, e.g. H1 = [5c, 2c, 5h, 4s, 3d, 2h, 5d] can be used to test for a full house (I had to create each card first, e.g. c1 = cards.Card(5,1) to create the 5c card in H1. It took many lines to create the testing hands, but once built they proved useful.) Test each category function separately using the custom hands you created for testing. For example, result = full_house(H1) should yield a result [5c, 5h, 5d, 2c, 2h]. 4. I found dictionaries useful within functions. Sometimes using the rank as key worked best; other times using the suit as key was best. 5. In order for sort() and sorted() to work on any data type the less-than operation must be defined. That operation is not defined in the Cards class so neither sort() nor sorted() work on Cards. (We tried to make the Cards class as generic as possible to work with a wide variety of card games, and the ordering of cards considering both rank and suit varies across card games.) 6. Mirmir testing: these are arbitrary to match the tests in Mirmir. a. For ties print hand1. b. Dealing: common hand first, then hand 1, then hand 2 (I used list comprehension) c. I provided a function named connanical that orders hands to match Test 1 and Test 2 in Mirmir (individual Function Tests don’t care about order). If more than five cards are in a category, e.g. all seven cards are the same suit, I applied cannonical() before slicing off the first 5 cards. d. Since Mimir cannot handle the Unicode suit symbols, the suit_list was changed to characters. You don’t need to do anything—this is built into the cards.py used for testing on Mimir. When you look at the Mirmir output you will see characters rather than symbols for suits: suit_list = ['x','c','d','h','s'] Sample Output Test 1 ---------------------------------------- Let's play poker! Community cards: [9♠, 7♥, 6♥, 6♣, 4♠] Player 1: [4♣, 10♠] Player 2: [7♣, 10♣] TIE with two pairs: [4♣, 4♠, 6♣, 6♥] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [Q♣, K♦, K♣, K♠, 7♠] Player 1: [K♥, 10♦] Player 2: [Q♥, J♣] Player 1 wins with four of a kind: [K♣, K♦, K♥, K♠] Do you wish to play another hand?(Y or N) n Test 2 ---------------------------------------- Let's play poker! Community cards: [9♠, 7♥, 6♥, 6♣, 4♠] Player 1: [4♣, 10♠] Player 2: [7♣, 10♣] TIE with two pairs: [4♣, 4♠, 6♣, 6♥] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [Q♣, K♦, K♣, K♠, 7♠] Player 1: [K♥, 10♦] Player 2: [Q♥, J♣] Player 1 wins with four of a kind: [K♣, K♦, K♥, K♠] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [3♣, 6♦, A♣, 8♣, 2♣] Player 1: [9♣, 5♣] Player 2: [10♥, 4♣] TIE with a flush: [A♣, 2♣, 3♣, 5♣, 8♣] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [9♦, 8♦, 5♦, Q♠, Q♦] Player 1: [J♠, J♦] Player 2: [4♦, A♥] TIE with a flush: [5♦, 8♦, 9♦, J♦, Q♦] Do you wish to play another hand?(Y or N) y ---------------------------------------- Let's play poker! Community cards: [2♥, 3♥, A♠, 2♣, 3♠] Player 1: [2♦, A♦] Player 2: [8♠, A♣] Player 1 wins with a full house: [A♦, A♠, 2♣, 2♦, 2♥] Deck has too few cards so game is done. Scoring Rubric Scoring Summary General Requirements ______ 5 pts Coding Standard Implementation Fulfills specifications including the following: ______ (40 pts) 8 Category functions: High-card doesn't need one (5 pts each) ______ (15 pts) Main: all categories are considered ______ (15 pts) Test 1 ______ (20 pts) Test 2 CSE 231 Summer 2020

Related Questions

Similar orders to I need this project done in python
8
Views
0
Answers
Java Customer Program
Problem 1: Customer Max has opened his own pet supply store so he can help himself to treats and toys whenever he wishes. In order to encourage customers to shop at his store more, he is implementing a customer loyalty program. For every $100 spent, the c...
12
Views
0
Answers
Literature Review for Smart Case for tracking monitoring and tracing packages being delivered
They're three attachments below one being the handbook to help guidance during this progress another being the first proposal of the project and then the assignment that needs completing, the Literature review....
15
Views
0
Answers
c++ lab 1 intro lab
P ROBLEM STATEMENT: A review and extension of cs132: sort a file with 120 records. However, due to memory restrictions only 20 records may be placed into memory. You are to implement a “quasi” external sort CODE/DIRECTIONS: For the sake of si...
19
Views
0
Answers
Cryptography Assignment C
1. Write two programs that use some of the build-in Cryptographic APIs a. Write one C program that uses Symmetric-Key algorithm b. Write one C program that used Asymmetric-key algorithm c. Use C programming language to write your code d. Make sure tha...