Александър обнови решението на 14.11.2022 21:07 (преди над 2 години)
+from random import shuffle as rand_shuffle
+from typing import List
+
+CUT_CARD_COUNTER = 3
+
+CARD_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+BELOT_FACES = ['7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+POKER_FACES = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+
+CARD_SUITES = ['clubs', 'diamonds', 'hearts', 'spades']
+
+DEALING_DIRECTIONS = {
+ "LEFT_TO_RIGHT": "ltr",
+ "RIGHT_TO_LEFT": "rtl",
+}
+
+
+class Card:
+
+ def __init__(self, suit: str, face: str) -> None:
+ self._set_suit(suit)
+ self._set_face(face)
+
+ def _set_suit(self, suit):
+ if suit in CARD_SUITES:
+ self._suit = suit
+ else:
+ raise ValueError("Unfitting card suit given.")
+
+ def _set_face(self, face):
+ if face in CARD_FACES:
+ self.face = face
+ else:
+ raise ValueError("Unfitting card face given.")
+
+ def __str__(self) -> str:
+ return f'{self.face} of {self._suit.capitalize()}'
+
+ def __repr__(self) -> str:
+ return f'{self.face} of {self._suit.capitalize()}'
+
+ def get_suit(self) -> str:
+ return self._suit
+
+ def get_face(self) -> str:
+ return self.face
+
+
+class Deck:
+
+ def __init__(self, face_filter: list[str] = []) -> None:
+ self._cards = []
+ self._set_cards(face_filter)
+
+ def _set_cards(self, face_filter):
+ self._cards.clear()
+ for card_face in face_filter:
+ if card_face in CARD_FACES:
+ for card_suit in CARD_SUITES:
+ self._cards.append(Card(card_suit, card_face))
+ else:
+ raise ValueError("Unfitting card face processed.")
+
+ def __len__(self) -> int:
+ return len(self._cards)
+
+ def __str__(self) -> str:
+ return f'Deck cards: {self._cards}'
+
+ def __repr__(self) -> str:
+ return f'Deck cards: {self._cards}'
+
+ def add_card(self, card: Card):
+ self._cards.append(card)
+
+ def cut(self):
+ cut_counter = min(CUT_CARD_COUNTER, len(self._cards) - 1)
+ while cut_counter > 0:
+ self._cards.append(self._cards.pop(0))
+ cut_counter -= 1
+
+ def shuffle(self):
+ rand_shuffle(self._cards)
+
+ def get_cards(self):
+ return self._cards
+
+
+class Player:
+
+ def __init__(self) -> None:
+ self._cards = []
+
+ def remove_card(self, card: Card):
+ self._cards.remove(card)
+
+ def add_card(self, card: Card):
+ self._cards.append(card)
+
+ def set_cards(self, cards: List[Card]):
+ self._cards = cards
+
+ def get_cards(self):
+ return self._cards
+
+ def __str__(self) -> str:
+ return f'Player cards: {self._cards}'
+
+ def __repr__(self) -> str:
+ return f'Player cards: {self._cards}'
+
+
+class Game:
+ def __init__(self, number_of_players: int, dealing_direction: str, dealing_instructions: tuple[int]) -> None:
+ self._set_players(number_of_players)
+ self._set_dealing_direction(dealing_direction)
+ self._set_dealing_instructions(dealing_instructions)
+ self._set_empty_deck()
+
+ def _set_players(self, number_of_players):
+ self._number_of_players = number_of_players
+ self._players = []
+ for _ in range(number_of_players):
+ self._players.append(Player())
+
+ def _set_dealing_direction(self, dealing_direction):
+ if dealing_direction in DEALING_DIRECTIONS.values():
+ self.dealing_direction = dealing_direction
+ else:
+ raise ValueError("Unfitting dealing direction given.")
+
+ def _set_dealing_instructions(self, dealing_instructions):
+ self._dealing_instructions = dealing_instructions
+
+ def _set_empty_deck(self):
+ self._deck = Deck()
+
+ def set_face_filtered_deck(self, face_filter):
+ self._deck = Deck(face_filter)
+
+ def get_players(self):
+ return self._players
+
+ def prepare_deck(self):
+ for player in self._players:
+ while player.get_cards():
+ self._deck.add_card(player.get_cards().pop(0))
+ self._deck.shuffle()
+ self._deck.cut()
+
+ def deal(self, player: Player):
+
+ def get_players_to_serve_ordered():
+ idx = self._players.index(player)
+ pre = self._players[:idx]
+ post = self._players[idx:]
+ players_to_serve_order = []
+ if self.dealing_direction == DEALING_DIRECTIONS["LEFT_TO_RIGHT"]:
+ players_to_serve_order = post + pre
+ elif self.dealing_direction == DEALING_DIRECTIONS["RIGHT_TO_LEFT"]:
+ players_to_serve_order = [post[0]] + pre[::-1] + post[:0:-1]
+ else:
+ raise ValueError("Unfitting dealing direction processed.")
+ return players_to_serve_order
+
+ players_to_serve_ordered = get_players_to_serve_ordered()
+ players_cards = {player: [] for player in players_to_serve_ordered}
+
+ for iteration in self._dealing_instructions:
+ for cur_player_idx in range(len(players_to_serve_ordered)):
+ player = players_to_serve_ordered[cur_player_idx]
+ for _ in range(iteration):
+ players_cards[player].append(self._deck.get_cards().pop(0))
+
+ for player, cards in players_cards.items():
+ self._players[self._players.index(player)].set_cards(cards)
+
+ def get_deck(self):
+ return self._deck
+
+
+class Belot(Game):
+ def __init__(self) -> None:
+ super().__init__(4, 'ltr', (2, 3, 3))
+ self.set_face_filtered_deck(BELOT_FACES)
+
+
+class Poker(Game):
+ def __init__(self) -> None:
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
+ self.set_face_filtered_deck(POKER_FACES)
+
+
+# ----------------------------------- DEBUG ZONE -------------------------------------
+'''
+def printer(game, cnt: int, *args):
+ print()
+ print(cnt, '//')
+ print('deck:', game.get_deck())
+ print('dupl:', [dupl for dupl in game.get_deck().get_cards()
+ if game.get_deck().get_cards().count(dupl) > 1])
+ print('size of deck:', len(game.get_deck()))
+ print(*args)
+
+
+belot = Belot()
+players = belot.get_players()
+printer(belot, 0)
+belot.prepare_deck()
+printer(belot, 1)
+belot.deal(players[0])
+printer(belot, 2, 'belot.players:', belot.get_players())
+# Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
+belot.prepare_deck()
+printer(belot, 3, 'belot.players:', belot.get_players())
+belot.deal(players[1])
+printer(belot, 4, 'belot.players:', belot.get_players())
+belot.prepare_deck()
+printer(belot, 5, 'belot.players:', belot.get_players())
+belot.deal(players[3])
+printer(belot, 6, 'belot.players:', belot.get_players())
+del belot
+
+# poker = Poker()
+# players = poker.get_players()
+# printer(poker, 0)
+# poker.prepare_deck()
+# printer(poker, 1)
+# poker.deal(players[0])
+# printer(poker, 2, 'poker.players:', poker.get_players())
+# # Play the game, argue about the rules, curse, fight, argue about who should deal the cards during second round...
+# poker.prepare_deck()
+# printer(poker, 3, 'poker.players:', poker.get_players())
+# poker.deal(players[1])
+# printer(poker, 4, 'poker.players:', poker.get_players())
+# del poker
+'''
Намирам за излишно да сменяш името на функцията при импорт, но щом така си решил..ок.
не искам да има конфликт с него и shuffle на Deck
Не би имало конфликт.
from random import shuffleпредставяshuffleкато глобално име, аshuffleвDeckе метод на класа и в глобалния скоуп еDeck.shuffle, така че би било наред.С един
forвместоwhileще си спестиш ръчно инкрементиране на брояч.обратните инкрементирания предпочитам да ги правя така, защото ми е по-четимо
С този коментар не мога да споря :)