Private & Protected в ООП

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

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

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

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

Към профила на Ивана Дончевска

Резултати

  • 6 точки от тестове
  • 0 бонус точки
  • 6 точки общо
  • 9 успешни тест(а)
  • 6 неуспешни тест(а)

Код

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
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, face_filter=None):
self._list_of_cards = []
self._game_faces = []
self._game_faces = face_filter if face_filter is not None else faces
for face in self._game_faces:
for suit in suits:
self._list_of_cards.append(Card(suit, face))
def __getitem__(self, index):
return self._list_of_cards[index]
def cut(self):
random_number = random.randint(1, 52)
for _ in range(random_number):
self._list_of_cards.insert(0, self._list_of_cards[-1]) # Add last element from list to the first position
self._list_of_cards.pop() # Then remove it from the previous position
def shuffle(self):
random.shuffle(self._list_of_cards)
def get_cards(self):
return self._list_of_cards
class Player:
def __init__(self):
self.cards = []
def get_cards(self):
# Number of cards that player has at the beginning = 0
return self.cards
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._number_of_players = number_of_players
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._players = []
self._deck = Deck()
for _ in range(number_of_players):
self._players.append(Player())
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
if len(player.get_cards()) != 0: # If player has cards
for card in player.get_cards():
self._deck.get_cards().append(card)
player.get_cards().clear()
self._deck.cut()
self._deck.shuffle()
def deal(self, player):
player_index = players.index(player)
if self._dealing_direction == "ltr":
for _ in range(player_index - 1):
self._players.append(self._players[0]) # Append player on index 0
self._players.pop(0) # remove first player in list
elif self._dealing_direction == "rtl":
for _ in range(player_index, len(self._players)):
self._players.insert(0, self._players[-1])
self._players.pop(-1)
self._players.reverse()
for tuple_index in range(len(self._dealing_instructions)):
for player in self._players:
for _ in range(self._dealing_instructions[tuple_index]):
# Add card of the top of deck to the player's cards
player.cards.append(self._deck[-1])
self._deck.get_cards().pop() # Remove it from the deck
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.deck = Deck()

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

FE......EEE...E
======================================================================
ERROR: test_correct_direction_and_players_deal (test.TestBelot)
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
NameError: name 'players' is not defined

======================================================================
ERROR: test_collecting_cards_before_dealing (test.TestGame)
Test collecting the cards before a new deal.
----------------------------------------------------------------------
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
NameError: name 'players' is not defined

======================================================================
ERROR: test_dealing_ltr (test.TestGame)
Test dealing the cards left to right.
----------------------------------------------------------------------
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
NameError: name 'players' is not defined

======================================================================
ERROR: 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
NameError: name 'players' is not defined

======================================================================
ERROR: 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
NameError: name 'players' is not defined

======================================================================
FAIL: test_correct_deck_init (test.TestBelot)
Test initialization with correct 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
AssertionError: Items in the second set but not the first:
('spades', '5')
('diamonds', '5')
('clubs', '5')
('spades', '6')
('diamonds', '6')
('clubs', '6')
('spades', '4')
('hearts', '5')
('diamonds', '4')
('clubs', '4')
('spades', '2')
('diamonds', '2')
('hearts', '6')
('clubs', '2')
('hearts', '4')
('hearts', '2')
('spades', '3')
('diamonds', '3')
('clubs', '3')
('hearts', '3')

----------------------------------------------------------------------
Ran 15 tests in 0.219s

FAILED (failures=1, errors=5)

История (4 версии и 11 коментара)

Ивана обнови решението на 11.11.2022 18:17 (преди над 1 година)

+import random
+
+suits = ['clubs', 'diamonds', 'hearts', 'spades']
+faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+
+
+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, face_filter=None):
+ self.list_of_cards = []
+ if face_filter is not None:
+ for face_fil in face_filter:
+ for suit in suits:
+ self.list_of_cards.append(Card(face_fil, suit))
+ else:
+ for face in faces:
+ for suit in suits:
+ self.list_of_cards.append(Card(face, suit))
+
+ def __getitem__(self, index):
+ return self.list_of_cards[index]
+
+ def cut(self):
+ self.list_of_cards.insert(0, self.list_of_cards[-1]) # Add last element from list to the first position
+ self.list_of_cards.pop() # Then remove it from the previous position
+
+ def shuffle(self):
+ random.shuffle(self.list_of_cards)
+
+ def get_cards(self):
+ return self.list_of_cards
+
+
+class Player:
+ def __init__(self):
+ self.player_cards = []
+
+ def get_cards(self):
+ # Number of cards that player has at the beginning = 0
+ return self.player_cards
+
+
+class Game:
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self.number_of_players = number_of_players
+ self.dealing_direction = dealing_direction
+ self.dealing_instructions = dealing_instructions
+ self.players = []
+ self.deck = Deck()
+ for number in range(0, number_of_players):
+ self.players.append(Player())
+
+ def get_players(self):
+ return self.players
+
+ def prepare_deck(self):
+ for player in self.players:
+ if player.get_cards() != 0: # If player has cards
+ for card in player.get_cards():
+ self.deck.get_cards().append(card)
+ player.get_cards().clear()
+ self.deck.cut()
+ self.deck.shuffle()
+
+ def deal(self, player):
+ player_index = players.index(player)
+ if self.dealing_direction == "ltr":
+ for i in range(0, player_index - 1):
+ self.players.append(self.players[0]) # Append player on index 0

По-скоро мисля, че е добра идея да запазиш реда на играчите в локална временна променлива, а не да правиш директни модификации по списъка от инстанцията.

Георги
+ self.players.pop(0) # remove first player in list
+ elif self.dealing_direction == "rtl":
+ for i in range(player_index, len(self.players)):
+ self.players.insert(0, self.players[-1])
+ self.players.pop(-1)
+ self.players.reverse()
+ for tuple_index in range(0, len(self.dealing_instructions)):
+ for player in self.players:
+ for i in range(0, self.dealing_instructions[tuple_index]):
+ # Add card of the top of deck to the player's cards
+ player.player_cards.append(self.deck[-1])
+ self.deck.get_cards().pop() # Remove it from the deck
+
+ def get_deck(self):
+ return self.deck.get_cards()
+
+
+class Belot(Game):
+ def __init__(self):
+ super().__init__(4, 'ltr', (2, 3, 3))
+ self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+
+
+class Poker(Game):
+ def __init__(self):
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
+ self.deck = Deck()

Ивана обнови решението на 14.11.2022 23:27 (преди над 1 година)

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
class Card:
def __init__(self, suit, face):
- self.suit = suit
- self.face = face
+ self._suit = suit
+ self._face = face
def get_suit(self):
- return self.suit
+ return self._suit
def get_face(self):
- return self.face
+ return self._face
class Deck:
def __init__(self, face_filter=None):
- self.list_of_cards = []
+ self._list_of_cards = []
+ self._game_faces = []
if face_filter is not None:
- for face_fil in face_filter:
- for suit in suits:
- self.list_of_cards.append(Card(face_fil, suit))
+ self._game_faces = face_filter
else:
- for face in faces:
- for suit in suits:
- self.list_of_cards.append(Card(face, suit))
+ self._game_faces = faces
+ for face in self._game_faces:
+ for suit in suits:
+ self._list_of_cards.append(Card(suit, face))
def __getitem__(self, index):
- return self.list_of_cards[index]
+ return self._list_of_cards[index]
def cut(self):
- self.list_of_cards.insert(0, self.list_of_cards[-1]) # Add last element from list to the first position
- self.list_of_cards.pop() # Then remove it from the previous position
+ random_number = random.randint(1, 52)
+ for _ in range(random_number):
+ self._list_of_cards.insert(0, self._list_of_cards[-1]) # Add last element from list to the first position
+ self._list_of_cards.pop() # Then remove it from the previous position
def shuffle(self):
- random.shuffle(self.list_of_cards)
+ random.shuffle(self._list_of_cards)
def get_cards(self):
- return self.list_of_cards
+ return self._list_of_cards
class Player:
def __init__(self):
- self.player_cards = []
+ self.cards = []
def get_cards(self):
# Number of cards that player has at the beginning = 0
- return self.player_cards
+ return self.cards
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
- self.number_of_players = number_of_players
- self.dealing_direction = dealing_direction
- self.dealing_instructions = dealing_instructions
- self.players = []
- self.deck = Deck()
- for number in range(0, number_of_players):
- self.players.append(Player())
+ self._number_of_players = number_of_players
+ self._dealing_direction = dealing_direction
+ self._dealing_instructions = dealing_instructions
+ self._players = []
+ self._deck = Deck()
+ for _ in range(number_of_players):
+ self._players.append(Player())
def get_players(self):
- return self.players
+ return self._players
def prepare_deck(self):
- for player in self.players:
- if player.get_cards() != 0: # If player has cards
+ for player in self._players:
+ if len(player.get_cards()) != 0: # If player has cards
for card in player.get_cards():
- self.deck.get_cards().append(card)
+ self._deck.get_cards().append(card)
player.get_cards().clear()
- self.deck.cut()
- self.deck.shuffle()
+ self._deck.cut()
+ self._deck.shuffle()
def deal(self, player):
player_index = players.index(player)
- if self.dealing_direction == "ltr":
- for i in range(0, player_index - 1):
- self.players.append(self.players[0]) # Append player on index 0
- self.players.pop(0) # remove first player in list
- elif self.dealing_direction == "rtl":
- for i in range(player_index, len(self.players)):
- self.players.insert(0, self.players[-1])
- self.players.pop(-1)
- self.players.reverse()
- for tuple_index in range(0, len(self.dealing_instructions)):
- for player in self.players:
- for i in range(0, self.dealing_instructions[tuple_index]):
+ if self._dealing_direction == "ltr":
+ for i in range(player_index - 1):
+ self._players.append(self._players[0]) # Append player on index 0
+ self._players.pop(0) # remove first player in list
+ elif self._dealing_direction == "rtl":
+ for i in range(player_index, len(self._players)):
+ self._players.insert(0, self._players[-1])
+ self._players.pop(-1)
+ self._players.reverse()
+ for tuple_index in range(0, len(self._dealing_instructions)):
+ for player in self._players:
+ for i in range(0, self._dealing_instructions[tuple_index]):
# Add card of the top of deck to the player's cards
- player.player_cards.append(self.deck[-1])
- self.deck.get_cards().pop() # Remove it from the deck
+ player.cards.append(self._deck[-1])
+ self._deck.get_cards().pop() # Remove it from the deck
def get_deck(self):
- return self.deck.get_cards()
+ return self._deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.deck = Deck()
+

Ивана обнови решението на 14.11.2022 23:45 (преди над 1 година)

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
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, face_filter=None):
self._list_of_cards = []
self._game_faces = []
if face_filter is not None:
self._game_faces = face_filter
else:
self._game_faces = faces
for face in self._game_faces:
for suit in suits:
self._list_of_cards.append(Card(suit, face))
def __getitem__(self, index):
return self._list_of_cards[index]
def cut(self):
random_number = random.randint(1, 52)
for _ in range(random_number):
self._list_of_cards.insert(0, self._list_of_cards[-1]) # Add last element from list to the first position
self._list_of_cards.pop() # Then remove it from the previous position
def shuffle(self):
random.shuffle(self._list_of_cards)
def get_cards(self):
return self._list_of_cards
class Player:
def __init__(self):
self.cards = []
def get_cards(self):
# Number of cards that player has at the beginning = 0
return self.cards
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._number_of_players = number_of_players
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._players = []
self._deck = Deck()
for _ in range(number_of_players):
self._players.append(Player())
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
if len(player.get_cards()) != 0: # If player has cards
for card in player.get_cards():
self._deck.get_cards().append(card)
player.get_cards().clear()
self._deck.cut()
self._deck.shuffle()
def deal(self, player):
player_index = players.index(player)
if self._dealing_direction == "ltr":
- for i in range(player_index - 1):
+ for _ in range(player_index - 1):
self._players.append(self._players[0]) # Append player on index 0
self._players.pop(0) # remove first player in list
elif self._dealing_direction == "rtl":
- for i in range(player_index, len(self._players)):
+ for _ in range(player_index, len(self._players)):
self._players.insert(0, self._players[-1])
self._players.pop(-1)
self._players.reverse()
- for tuple_index in range(0, len(self._dealing_instructions)):
+ for tuple_index in range(len(self._dealing_instructions)):
for player in self._players:
- for i in range(0, self._dealing_instructions[tuple_index]):
+ for _ in range(self._dealing_instructions[tuple_index]):
# Add card of the top of deck to the player's cards
player.cards.append(self._deck[-1])
self._deck.get_cards().pop() # Remove it from the deck
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.deck = Deck()

Ивана обнови решението на 15.11.2022 11:58 (преди над 1 година)

import random
suits = ['clubs', 'diamonds', 'hearts', 'spades']
faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
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, face_filter=None):
self._list_of_cards = []
self._game_faces = []
- if face_filter is not None:
- self._game_faces = face_filter
- else:
- self._game_faces = faces
+ self._game_faces = face_filter if face_filter is not None else faces
for face in self._game_faces:
for suit in suits:
self._list_of_cards.append(Card(suit, face))
def __getitem__(self, index):
return self._list_of_cards[index]
def cut(self):
random_number = random.randint(1, 52)
for _ in range(random_number):
self._list_of_cards.insert(0, self._list_of_cards[-1]) # Add last element from list to the first position
self._list_of_cards.pop() # Then remove it from the previous position
def shuffle(self):
random.shuffle(self._list_of_cards)
def get_cards(self):
return self._list_of_cards
class Player:
def __init__(self):
self.cards = []
def get_cards(self):
# Number of cards that player has at the beginning = 0
return self.cards
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._number_of_players = number_of_players
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._players = []
self._deck = Deck()
for _ in range(number_of_players):
self._players.append(Player())
def get_players(self):
return self._players
def prepare_deck(self):
for player in self._players:
if len(player.get_cards()) != 0: # If player has cards
for card in player.get_cards():
self._deck.get_cards().append(card)
player.get_cards().clear()
self._deck.cut()
self._deck.shuffle()
def deal(self, player):
player_index = players.index(player)
if self._dealing_direction == "ltr":
for _ in range(player_index - 1):
self._players.append(self._players[0]) # Append player on index 0
self._players.pop(0) # remove first player in list
elif self._dealing_direction == "rtl":
for _ in range(player_index, len(self._players)):
self._players.insert(0, self._players[-1])
self._players.pop(-1)
self._players.reverse()
for tuple_index in range(len(self._dealing_instructions)):
for player in self._players:
for _ in range(self._dealing_instructions[tuple_index]):
# Add card of the top of deck to the player's cards
player.cards.append(self._deck[-1])
self._deck.get_cards().pop() # Remove it from the deck
def get_deck(self):
return self._deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))
self.deck = Deck()