Private & Protected в ООП

Програмиране с Python

Курс във Факултета по Математика и Информатика към СУ

Решение на От ливадите до Лас Вегас (и назад) от Виктор Боев

Обратно към всички решения

Към профила на Виктор Боев

Резултати

  • 7 точки от тестове
  • 0 бонус точки
  • 7 точки общо
  • 11 успешни тест(а)
  • 4 неуспешни тест(а)

Код

import random
class Card:
def __init__(self, suit, face):
self._suit = suit
self._face = face
def get_suit(self):
return self._suit
def get_face(self):
return self._face
class Deck:
def __init__(self, cards):
self._cards = []
for card in cards:
for suit in ("clubs", "diamonds", "hearts", "spades"):
self._cards.append(Card(suit,card))
def cut(self):
cut_point = random.randrange(1, len(self._cards) - 1)
temp = self._cards[:cut_point]
self._cards = self._cards[cut_point:]
self._cards.extend(temp)
def shuffle(self):
random.shuffle(self._cards)
def get_cards(self):
return self._cards
def get_top_card(self):
card = self._cards[len(self._cards) - 1]
self._cards.pop()
return card
def extend(self, cards):
self._cards.extend(cards)
class Player:
def __init__(self):
self._hand = []
def get_cards(self):
return self._hand
def add_cards(self, list_cards):
self._hand.extend(list_cards)
def return_cards(self):
self._hand.clear()
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._players = []
for i in range (number_of_players):
self._players.append(Player())
self._deal_dir = dealing_direction
self._deal_inst = dealing_instructions
self._deck = Deck(['2','3','4','5','6','7','8','9','10','J','Q','K','A'])
def get_players(self):
return self._players
def prepare_deck(self):
self.collect_all_cards()

Не е логично при всяко раздаване на инициализираш ново тесте. Все едно в реална игра да вадиш нова кутия с карти. Не би трябвало да е проблем за тестовете, но е нелогично.

Георги
self._deck.shuffle()
self._deck.cut()
for player in self._players:
player.return_cards()
def get_n_cards_from_deck(self, n):
cards_to_add = []
for i in range(n):
cards_to_add.append(self._deck.get_top_card())
return cards_to_add
def deal(self, player):
for i, player_i in enumerate(self._players):
if player_i is player:
if self._deal_dir == "ltr":
for cnt_instr, instruction in enumerate(self._deal_inst) :
for cnt_pl, player_j in enumerate(self._players[i:]):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
for cnt_pl, player_j in enumerate(self._players[:i]):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
else:
for cnt_instr, instruction in enumerate(self._deal_inst):
for cnt_pl, player_j in reversed(list(enumerate (self._players[:i]))):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
for cnt_pl, player_j in reversed(list(enumerate (self._players[i:]))):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
def get_deck(self):
return self._deck
def collect_all_cards(self):
for pl in self._players:
self._deck.extend(pl.get_cards())
pl.return_cards()
class Belot(Game):
def __init__(self):
Game.__init__(self, 4, "ltr", (2, 3, 3))
self._deck = Deck(['7','8','9','10','J','Q','K','A'])
class Poker(Game):
def __init__(self):
Game.__init__(self, 9, "rtl", (1, 1, 1, 1, 1))

Лог от изпълнението

......EE..F...F
======================================================================
ERROR: test_init_regular (test.TestDeck)
Test initialized cards without filter.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
TypeError: Deck.__init__() missing 1 required positional argument: 'cards'

======================================================================
ERROR: test_shuffling_deck (test.TestDeck)
Test shuffling a deck.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
TypeError: Deck.__init__() missing 1 required positional argument: 'cards'

======================================================================
FAIL: test_dealing_rtl (test.TestGame)
Test dealing the cards right to left.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
AssertionError: {('clubs', 'Q'), ('clubs', 'K'), ('diamonds', 'K')} not found in ({('clubs', '4'), ('diamonds', '2'), ('clubs', '2')}, {('hearts', 'A'), ('spades', 'Q'), ('spades', 'A')})

======================================================================
FAIL: test_correct_direction_and_players_deal (test.TestPoker)
Test dealing with correct direction and players.
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/storage/deedee/data/rails/pyfmi-2022/releases/20221115154139/lib/language/python/runner.py", line 67, in thread
    raise result
AssertionError: {('spades', '3'), ('hearts', '10'), ('diamonds', '8'), ('clubs', '6'), ('spades', 'Q')} not found in ({('clubs', 'J'), ('hearts', '6'), ('spades', '8'), ('clubs', '2'), ('diamonds', '4')}, {('spades', '5'), ('clubs', '8'), ('diamonds', '10'), ('spades', 'A'), ('hearts', 'Q')})

----------------------------------------------------------------------
Ran 15 tests in 0.209s

FAILED (failures=2, errors=2)

История (3 версии и 14 коментара)

Виктор обнови решението на 14.11.2022 21:50 (преди над 1 година)

+import random
+
+class Card :
+ def __init__(self, suit, face) :
+ self.suit = suit
+ self.face = face
+
+ def get_suit(self) :
+ return self.suit
+
+ def get_face(self) :
+ return self.face
+
+class Deck :
+
+ def __init__(self) :
+ self.cards = []
+
+ def face_filter(self, cards) :
+ self.cards = []
+ for card in cards :
+ self.cards.append(Card("clubs",card))
+ self.cards.append(Card("diamonds",card))
+ self.cards.append(Card("hearts",card))
+ self.cards.append(Card("spades",card))
+
+ def cut(self) :
+ cutPoint = random.randrange(1, 51)
+ temp = self.cards[0:cutPoint]
+ self.cards = [card for card in self.cards if card not in self.cards[0:cutPoint]]
+ self.cards.extend(temp)
+
+ def shuffle(self) :
+ random.shuffle(self.cards)
+
+ def get_cards(self) :
+ return self.cards
+
+ def get_top_card(self) :
+ return self.cards[len(self.cards) - 1]
+
+ def remove_top_card(self) :
+ self.cards.pop()
+
+class Player :
+
+ def __init__(self) :
+ self.cards = []
+ def get_cards(self) :
+ return self.cards
+ def add_cards(self, list_cards) :
+ self.cards.extend(list_cards)
+
+class Game :
+
+
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions) :
+ self.players = []
+
+ for i in range (0, number_of_players) :
+ self.players.append(Player())
+
+ self.deal_dir = dealing_direction
+ self.deal_inst = dealing_instructions
+ self.deck = Deck()
+
+ def get_players(self) :
+ return self.players
+
+ def prepare_deck(self) :
+ Game.collect_all_cards(self)
+ self.deck.shuffle()
+ self.deck.cut()
+
+ def get_n_cards_from_deck(self, n) :
+ cards_to_add = []
+ for i in range (0, n) :
+ cards_to_add.append(self.deck.get_top_card())
+ self.deck.remove_top_card()
+
+ return cards_to_add
+
+ def deal(self, player) :
+
+ for i in range (0, len(self.players)) :
+ if self.players[i] is player :
+
+ if self.deal_dir == "ltr" :
+ for k in range (0, len(self.deal_inst)) :
+
+ for j in range (i, len(self.players)) :
+ list = self.get_n_cards_from_deck(self.deal_inst[k])
+ self.players[j].add_cards(list)
+ for j in range (0, i) :
+ list = self.get_n_cards_from_deck(self.deal_inst[k])
+ self.players[j].add_cards(list)
+
+ elif self.deal_dir == "rtl" :
+ for k in range (0, len(self.deal_inst)) :
+
+ for j in reversed (range (0, i)) :
+ self.players[j].add_cards(self.get_n_cards_from_deck(self.deal_inst[k]))
+ for j in reversed (range (i, len(self.players))) :
+ self.players[j].add_cards(self.get_n_cards_from_deck(self.deal_inst[k]))
+
+ def get_deck(self) :
+ return self.deck
+
+ def collect_all_cards(self) :
+ self.deck.face_filter(['2', '3', '4', '5', '6', '7',
+ '8', '9', '10', 'J', 'Q', 'K', 'A'])
+
+
+class Belot(Game) :
+
+ def collect_all_cards(self) :
+ self.deck.face_filter(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+
+ def prepare_deck(self) :
+ Belot.collect_all_cards(self)
+ self.deck.shuffle()
+ self.deck.cut()
+
+ def __init__(self) :
+ Game.__init__(self, 4, "ltr", (2, 3, 3))
+ Belot.collect_all_cards(self)
+
+class Poker(Game) :
+
+ def __init__(self) :
+ Game.__init__(self, 9, "rtl", (1, 1, 1, 1, 1))
+ Poker.collect_all_cards(self)

Виктор обнови решението на 15.11.2022 09:38 (преди над 1 година)

import random
class Card :
def __init__(self, suit, face) :
self.suit = suit
self.face = face
def get_suit(self) :
return self.suit
def get_face(self) :
return self.face
class Deck :
-
def __init__(self) :
self.cards = []
def face_filter(self, cards) :
self.cards = []
for card in cards :
self.cards.append(Card("clubs",card))
self.cards.append(Card("diamonds",card))
self.cards.append(Card("hearts",card))
self.cards.append(Card("spades",card))
def cut(self) :
cutPoint = random.randrange(1, 51)
temp = self.cards[0:cutPoint]
self.cards = [card for card in self.cards if card not in self.cards[0:cutPoint]]
self.cards.extend(temp)
def shuffle(self) :
random.shuffle(self.cards)
def get_cards(self) :
return self.cards
def get_top_card(self) :

Този и следващият метод би било логично да са на едно място. Всеки път, когато искам да взема карта, ще искам и да я махна. Не е нужно да извикам два метода за това.

Георги
return self.cards[len(self.cards) - 1]
def remove_top_card(self) :
self.cards.pop()
class Player :
-
def __init__(self) :
self.cards = []
def get_cards(self) :
return self.cards
def add_cards(self, list_cards) :
self.cards.extend(list_cards)
+ def return_cards(self) :
+ self.cards.clear()
class Game :
-
-
def __init__(self, number_of_players, dealing_direction, dealing_instructions) :
self.players = []
for i in range (0, number_of_players) :
self.players.append(Player())
self.deal_dir = dealing_direction
self.deal_inst = dealing_instructions
self.deck = Deck()
def get_players(self) :
return self.players
def prepare_deck(self) :
- Game.collect_all_cards(self)
+ self.collect_all_cards()

Не е логично при всяко раздаване на инициализираш ново тесте. Все едно в реална игра да вадиш нова кутия с карти. Не би трябвало да е проблем за тестовете, но е нелогично.

Георги
self.deck.shuffle()
self.deck.cut()
+ for player in self.players :
+ player.return_cards()
def get_n_cards_from_deck(self, n) :
cards_to_add = []
for i in range (0, n) :
cards_to_add.append(self.deck.get_top_card())
self.deck.remove_top_card()
return cards_to_add
def deal(self, player) :
- for i in range (0, len(self.players)) :
- if self.players[i] is player :
+ for i, player_i in enumerate (self.players) :
+ if player_i is player :
if self.deal_dir == "ltr" :
- for k in range (0, len(self.deal_inst)) :
+ for k, instruction in enumerate (self.deal_inst) :
- for j in range (i, len(self.players)) :
- list = self.get_n_cards_from_deck(self.deal_inst[k])
- self.players[j].add_cards(list)
- for j in range (0, i) :
- list = self.get_n_cards_from_deck(self.deal_inst[k])
- self.players[j].add_cards(list)
+ for j, player_j in enumerate (self.players[i:]) :
+ player_j.add_cards(self.get_n_cards_from_deck(instruction))
- elif self.deal_dir == "rtl" :
- for k in range (0, len(self.deal_inst)) :
+ for j, player_j in enumerate (self.players[:i]) :
+ player_j.add_cards(self.get_n_cards_from_deck(instruction))
- for j in reversed (range (0, i)) :
- self.players[j].add_cards(self.get_n_cards_from_deck(self.deal_inst[k]))
- for j in reversed (range (i, len(self.players))) :
- self.players[j].add_cards(self.get_n_cards_from_deck(self.deal_inst[k]))
+ else :
+ for k, instruction in enumerate (self.deal_inst) :
+
+ for j, player_j in reversed(list(enumerate (self.players[:i]))) :
+ player_j.add_cards(self.get_n_cards_from_deck(instruction))
+
+ for j, player_j in reversed(list(enumerate (self.players[i:]))) :
+ player_j.add_cards(self.get_n_cards_from_deck(instruction))
+
def get_deck(self) :
return self.deck
def collect_all_cards(self) :
self.deck.face_filter(['2', '3', '4', '5', '6', '7',
'8', '9', '10', 'J', 'Q', 'K', 'A'])
class Belot(Game) :
def collect_all_cards(self) :
self.deck.face_filter(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
- def prepare_deck(self) :
- Belot.collect_all_cards(self)
- self.deck.shuffle()
- self.deck.cut()
-
def __init__(self) :
Game.__init__(self, 4, "ltr", (2, 3, 3))
- Belot.collect_all_cards(self)
class Poker(Game) :
def __init__(self) :
- Game.__init__(self, 9, "rtl", (1, 1, 1, 1, 1))
- Poker.collect_all_cards(self)
+ Game.__init__(self, 9, "rtl", (1, 1, 1, 1, 1))

Виктор обнови решението на 15.11.2022 13:10 (преди над 1 година)

import random
-class Card :
- def __init__(self, suit, face) :
- self.suit = suit
- self.face = face
+class Card:
+ def __init__(self, suit, face):
+ self._suit = suit
+ self._face = face
- def get_suit(self) :
- return self.suit
+ def get_suit(self):
+ return self._suit
- def get_face(self) :
- return self.face
+ def get_face(self):
+ return self._face
-class Deck :
- def __init__(self) :
- self.cards = []
+class Deck:
+ def __init__(self, cards):
+ self._cards = []
+ for card in cards:
+ for suit in ("clubs", "diamonds", "hearts", "spades"):
+ self._cards.append(Card(suit,card))
+
+ def cut(self):
+ cut_point = random.randrange(1, len(self._cards) - 1)
+ temp = self._cards[:cut_point]
+ self._cards = self._cards[cut_point:]
+ self._cards.extend(temp)
+
+ def shuffle(self):
+ random.shuffle(self._cards)
- def face_filter(self, cards) :
- self.cards = []
- for card in cards :
- self.cards.append(Card("clubs",card))
- self.cards.append(Card("diamonds",card))
- self.cards.append(Card("hearts",card))
- self.cards.append(Card("spades",card))
+ def get_cards(self):
+ return self._cards
+
+ def get_top_card(self):
+ card = self._cards[len(self._cards) - 1]
+ self._cards.pop()
+ return card
- def cut(self) :
- cutPoint = random.randrange(1, 51)
- temp = self.cards[0:cutPoint]
- self.cards = [card for card in self.cards if card not in self.cards[0:cutPoint]]
- self.cards.extend(temp)
-
- def shuffle(self) :
- random.shuffle(self.cards)
+ def extend(self, cards):
+ self._cards.extend(cards)
- def get_cards(self) :
- return self.cards
+class Player:
+ def __init__(self):
+ self._hand = []
- def get_top_card(self) :
- return self.cards[len(self.cards) - 1]
+ def get_cards(self):
+ return self._hand
- def remove_top_card(self) :
- self.cards.pop()
+ def add_cards(self, list_cards):
+ self._hand.extend(list_cards)
-class Player :
- def __init__(self) :
- self.cards = []
- def get_cards(self) :
- return self.cards
- def add_cards(self, list_cards) :
- self.cards.extend(list_cards)
- def return_cards(self) :
- self.cards.clear()
+ def return_cards(self):
+ self._hand.clear()
-class Game :
- def __init__(self, number_of_players, dealing_direction, dealing_instructions) :
- self.players = []
+class Game:
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self._players = []
- for i in range (0, number_of_players) :
- self.players.append(Player())
+ for i in range (number_of_players):
+ self._players.append(Player())
- self.deal_dir = dealing_direction
- self.deal_inst = dealing_instructions
- self.deck = Deck()
+ self._deal_dir = dealing_direction
+ self._deal_inst = dealing_instructions
+ self._deck = Deck(['2','3','4','5','6','7','8','9','10','J','Q','K','A'])
- def get_players(self) :
- return self.players
+ def get_players(self):
+ return self._players
- def prepare_deck(self) :
+ def prepare_deck(self):
self.collect_all_cards()
- self.deck.shuffle()
- self.deck.cut()
- for player in self.players :
+ self._deck.shuffle()
+ self._deck.cut()
+ for player in self._players:
player.return_cards()
- def get_n_cards_from_deck(self, n) :
+ def get_n_cards_from_deck(self, n):
cards_to_add = []
- for i in range (0, n) :
- cards_to_add.append(self.deck.get_top_card())
- self.deck.remove_top_card()
+ for i in range(n):
+ cards_to_add.append(self._deck.get_top_card())
return cards_to_add
- def deal(self, player) :
+ def deal(self, player):
- for i, player_i in enumerate (self.players) :
- if player_i is player :
+ for i, player_i in enumerate(self._players):
+ if player_i is player:
- if self.deal_dir == "ltr" :
- for k, instruction in enumerate (self.deal_inst) :
+ if self._deal_dir == "ltr":
+ for cnt_instr, instruction in enumerate(self._deal_inst) :
- for j, player_j in enumerate (self.players[i:]) :
+ for cnt_pl, player_j in enumerate(self._players[i:]):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
- for j, player_j in enumerate (self.players[:i]) :
+ for cnt_pl, player_j in enumerate(self._players[:i]):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
- else :
- for k, instruction in enumerate (self.deal_inst) :
+ else:
+ for cnt_instr, instruction in enumerate(self._deal_inst):
- for j, player_j in reversed(list(enumerate (self.players[:i]))) :
+ for cnt_pl, player_j in reversed(list(enumerate (self._players[:i]))):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
- for j, player_j in reversed(list(enumerate (self.players[i:]))) :
+ for cnt_pl, player_j in reversed(list(enumerate (self._players[i:]))):
player_j.add_cards(self.get_n_cards_from_deck(instruction))
- def get_deck(self) :
- return self.deck
+ def get_deck(self):
+ return self._deck
- def collect_all_cards(self) :
- self.deck.face_filter(['2', '3', '4', '5', '6', '7',
- '8', '9', '10', 'J', 'Q', 'K', 'A'])
+ def collect_all_cards(self):
+ for pl in self._players:
+ self._deck.extend(pl.get_cards())
+ pl.return_cards()
-
-class Belot(Game) :
-
- def collect_all_cards(self) :
- self.deck.face_filter(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+class Belot(Game):
- def __init__(self) :
+ def __init__(self):
Game.__init__(self, 4, "ltr", (2, 3, 3))
+ self._deck = Deck(['7','8','9','10','J','Q','K','A'])
-class Poker(Game) :
+class Poker(Game):
- def __init__(self) :
+ def __init__(self):
Game.__init__(self, 9, "rtl", (1, 1, 1, 1, 1))