Private & Protected в ООП

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

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

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

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

Към профила на Цветелина Чакърова

Резултати

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

Код

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:
deck = []
def __init__(self, faces_in_deck=faces):
self.faces_in_deck = faces_in_deck
self.deck = []
for face in self.faces_in_deck:
for suit in suits:
self.deck.append(Card(suit, face))
def cut(self):
shift_position = random.randint(1, len(self.deck) - 1)
self.deck = self.deck[shift_position:] + self.deck[:shift_position]
def shuffle(self):
random.shuffle(self.deck)
def get_cards(self):
return self.deck
class Player:
players_cards = []
def __init__(self):
self.players_cards = []
def get_cards(self):
return self.players_cards
class Game:
players = []
deck = []
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.deck = Deck()
self.players = [Player() for _ in range(self.number_of_players)]
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.deck += player.get_cards()
player.players_cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, first_player):
if self.dealing_direction == 'rtl':
self.players.reverse()
index = self.players.index(first_player)
self.players = self.players[index:] + self.players[:index]
for instruction in self.dealing_instructions:
for player in self.players:
player.players_cards.extend(self.deck.deck[:instruction])
self.deck.deck = self.deck.deck[instruction:]
def get_deck(self):
return self.deck
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))

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

...............
----------------------------------------------------------------------
Ran 15 tests in 0.158s

OK

История (6 версии и 8 коментара)

Цветелина обнови решението на 10.11.2022 14:41 (преди над 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:
+ deck = []
+
+ def __init__(self, faces_in_deck=faces):
+ self.faces_in_deck = faces_in_deck
+ self.deck = []
+ for face in self.faces_in_deck:
+ for suit in suits:
+ self.deck.append(Card(suit, face))
+
+ def cut(self):
+ shift_position = random.randint(1, len(self.deck) - 1)
+ self.deck = self.deck[shift_position:] + self.deck[:shift_position]
+
+ def shuffle(self):
+ random.shuffle(self.deck)
+
+ def get_cards(self):
+ return self.deck
+
+ def get_and_remove_top_card(self):
+ return self.deck.pop(0)
+
+
+class Player:
+ players_cards = []
+
+ def __init__(self):
+ self.players_cards = []
+
+ def get_cards(self):
+ return self.players_cards
+
+
+class Game:
+ players = []
+
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions, deck=Deck()):
+ self.number_of_players = number_of_players
+ self.dealing_direction = dealing_direction
+ self.dealing_instructions = dealing_instructions
+ self.deck = deck
+ self.players = [Player() for index in range(self.number_of_players)]
+
+ def get_players(self):
+ return self.players
+
+ def prepare_deck(self):
+ for player in self.players:
+ self.deck.deck += player.get_cards()
+ player.players_cards = []
+ self.deck.shuffle()
+ self.deck.cut()
+
+ def deal(self, first_player):
+ if self.dealing_direction == 'rtl':
+ self.players.reverse()
+ self.players = self.players[self.players.index(first_player):] + self.players[:self.players.index(first_player)]
+
+ for instruction in self.dealing_instructions:
+ for player in self.players:
+ player.players_cards.extend(self.deck.deck[0:instruction])
+ self.deck.deck = self.deck.deck[instruction:]
+
+ def get_deck(self):
+ return self.deck
+
+
+class Belot(Game):
+ def __init__(self):
+ self.number_of_players = 4
+ self.dealing_direction = 'ltr'
+ self.dealing_instructions = 2, 3, 3
+ self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+ self.players = [Player() for index in range(self.number_of_players)]
+
+
+class Poker(Game):
+ def __init__(self):
+ self.number_of_players = 9
+ self.dealing_direction = 'rtl'
+ self.dealing_instructions = 1, 1, 1, 1, 1
+ self.players = [Player() for index in range(self.number_of_players)]

Цветелина обнови решението на 10.11.2022 14:56 (преди над 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:
deck = []
def __init__(self, faces_in_deck=faces):
self.faces_in_deck = faces_in_deck
self.deck = []
for face in self.faces_in_deck:
for suit in suits:
self.deck.append(Card(suit, face))
def cut(self):
shift_position = random.randint(1, len(self.deck) - 1)
self.deck = self.deck[shift_position:] + self.deck[:shift_position]
def shuffle(self):
random.shuffle(self.deck)
def get_cards(self):
return self.deck
- def get_and_remove_top_card(self):
- return self.deck.pop(0)
-
class Player:
players_cards = []
def __init__(self):
self.players_cards = []
def get_cards(self):
return self.players_cards
class Game:
players = []
def __init__(self, number_of_players, dealing_direction, dealing_instructions, deck=Deck()):

deck = Deck() ще се евалюира само веднъж - при дефинирането на класа ти. Т.е този клас ще работи само при една инстанция. Повече инстанции ще го счупят, защото ще споделят едно и също тесте.

class Deck:
    pass

class Game:
    def __init__(self, deck=Deck()):
        self.deck = deck

game1 = Game()
game2 = Game()
print(game1.deck is game2.deck) # True
Георги
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction
self.dealing_instructions = dealing_instructions
self.deck = deck
self.players = [Player() for index in range(self.number_of_players)]
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.deck += player.get_cards()
player.players_cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, first_player):
if self.dealing_direction == 'rtl':
self.players.reverse()
self.players = self.players[self.players.index(first_player):] + self.players[:self.players.index(first_player)]
for instruction in self.dealing_instructions:
for player in self.players:
player.players_cards.extend(self.deck.deck[0:instruction])
self.deck.deck = self.deck.deck[instruction:]
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
self.number_of_players = 4
self.dealing_direction = 'ltr'
self.dealing_instructions = 2, 3, 3
self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
self.players = [Player() for index in range(self.number_of_players)]
class Poker(Game):
def __init__(self):
self.number_of_players = 9
self.dealing_direction = 'rtl'
self.dealing_instructions = 1, 1, 1, 1, 1
self.players = [Player() for index in range(self.number_of_players)]

Цветелина обнови решението на 11.11.2022 13:41 (преди над 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:
deck = []
def __init__(self, faces_in_deck=faces):
self.faces_in_deck = faces_in_deck
self.deck = []
for face in self.faces_in_deck:
for suit in suits:
self.deck.append(Card(suit, face))
def cut(self):
shift_position = random.randint(1, len(self.deck) - 1)
self.deck = self.deck[shift_position:] + self.deck[:shift_position]
def shuffle(self):
random.shuffle(self.deck)
def get_cards(self):
return self.deck
class Player:
players_cards = []
def __init__(self):
self.players_cards = []
def get_cards(self):
return self.players_cards
class Game:
players = []
def __init__(self, number_of_players, dealing_direction, dealing_instructions, deck=Deck()):
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction
self.dealing_instructions = dealing_instructions
self.deck = deck
- self.players = [Player() for index in range(self.number_of_players)]
+ self.players = [Player() for _ in range(self.number_of_players)]
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.deck += player.get_cards()
player.players_cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, first_player):
if self.dealing_direction == 'rtl':
self.players.reverse()
- self.players = self.players[self.players.index(first_player):] + self.players[:self.players.index(first_player)]
+ index = self.players.index(first_player)
+ self.players = self.players[index:] + self.players[:index]
for instruction in self.dealing_instructions:
for player in self.players:
- player.players_cards.extend(self.deck.deck[0:instruction])
+ player.players_cards.extend(self.deck.deck[:instruction])
self.deck.deck = self.deck.deck[instruction:]
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
self.number_of_players = 4
self.dealing_direction = 'ltr'
self.dealing_instructions = 2, 3, 3
self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
self.players = [Player() for index in range(self.number_of_players)]
class Poker(Game):
def __init__(self):
self.number_of_players = 9
self.dealing_direction = 'rtl'
self.dealing_instructions = 1, 1, 1, 1, 1
self.players = [Player() for index in range(self.number_of_players)]

Цветелина обнови решението на 11.11.2022 14:07 (преди над 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:
deck = []
def __init__(self, faces_in_deck=faces):
self.faces_in_deck = faces_in_deck
self.deck = []
for face in self.faces_in_deck:
for suit in suits:
self.deck.append(Card(suit, face))
def cut(self):
shift_position = random.randint(1, len(self.deck) - 1)
self.deck = self.deck[shift_position:] + self.deck[:shift_position]
def shuffle(self):
random.shuffle(self.deck)
def get_cards(self):
return self.deck
class Player:
players_cards = []
def __init__(self):
self.players_cards = []
def get_cards(self):
return self.players_cards
class Game:
players = []
def __init__(self, number_of_players, dealing_direction, dealing_instructions, deck=Deck()):
self.number_of_players = number_of_players
self.dealing_direction = dealing_direction
self.dealing_instructions = dealing_instructions
self.deck = deck
self.players = [Player() for _ in range(self.number_of_players)]
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.deck += player.get_cards()
player.players_cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, first_player):
if self.dealing_direction == 'rtl':
self.players.reverse()
index = self.players.index(first_player)
self.players = self.players[index:] + self.players[:index]
for instruction in self.dealing_instructions:
for player in self.players:
player.players_cards.extend(self.deck.deck[:instruction])
self.deck.deck = self.deck.deck[instruction:]
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
- self.number_of_players = 4
- self.dealing_direction = 'ltr'
- self.dealing_instructions = 2, 3, 3
- self.deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
- self.players = [Player() for index in range(self.number_of_players)]
+ Game.__init__(self, 4, 'ltr', (2, 3, 3), Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A']))
class Poker(Game):
def __init__(self):
- self.number_of_players = 9
- self.dealing_direction = 'rtl'
+ Game.__init__(self, 9, 'rtl', (1, 1, 1, 1, 1))
- self.dealing_instructions = 1, 1, 1, 1, 1
+
- self.players = [Player() for index in range(self.number_of_players)]

Цветелина обнови решението на 11.11.2022 15:43 (преди над 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

Може, но според мен protected е достатъчно. Рядко искаш да си толкова стриктна в Python. protected в повечете случаи е напълно достатъчно. Все пак така или иначе можеш да достъпиш и двете.

Георги
self.face = face
def get_suit(self):
return self.suit
def get_face(self):
return self.face
class Deck:
deck = []
def __init__(self, faces_in_deck=faces):
self.faces_in_deck = faces_in_deck
self.deck = []
for face in self.faces_in_deck:
for suit in suits:
self.deck.append(Card(suit, face))
def cut(self):
shift_position = random.randint(1, len(self.deck) - 1)
self.deck = self.deck[shift_position:] + self.deck[:shift_position]
def shuffle(self):
random.shuffle(self.deck)
def get_cards(self):
return self.deck
class Player:
players_cards = []
def __init__(self):
self.players_cards = []
def get_cards(self):
return self.players_cards
class Game:
players = []
+ deck = []
- def __init__(self, number_of_players, dealing_direction, dealing_instructions, deck=Deck()):
+ 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.deck = deck
+ self.deck = Deck()
self.players = [Player() for _ in range(self.number_of_players)]
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.deck += player.get_cards()
player.players_cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, first_player):
if self.dealing_direction == 'rtl':
self.players.reverse()
index = self.players.index(first_player)
self.players = self.players[index:] + self.players[:index]
for instruction in self.dealing_instructions:
for player in self.players:
player.players_cards.extend(self.deck.deck[:instruction])
self.deck.deck = self.deck.deck[instruction:]
def get_deck(self):
return self.deck
class Belot(Game):
def __init__(self):
- Game.__init__(self, 4, 'ltr', (2, 3, 3), Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A']))
+ 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))
-
+

Цветелина обнови решението на 13.11.2022 22:04 (преди над 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:
deck = []
def __init__(self, faces_in_deck=faces):
self.faces_in_deck = faces_in_deck
self.deck = []
for face in self.faces_in_deck:
for suit in suits:
self.deck.append(Card(suit, face))
def cut(self):
shift_position = random.randint(1, len(self.deck) - 1)
self.deck = self.deck[shift_position:] + self.deck[:shift_position]
def shuffle(self):
random.shuffle(self.deck)
def get_cards(self):
return self.deck
class Player:
players_cards = []
def __init__(self):
self.players_cards = []
def get_cards(self):
return self.players_cards
class Game:
players = []
deck = []
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.deck = Deck()
self.players = [Player() for _ in range(self.number_of_players)]
def get_players(self):
return self.players
def prepare_deck(self):
for player in self.players:
self.deck.deck += player.get_cards()
player.players_cards = []
self.deck.shuffle()
self.deck.cut()
def deal(self, first_player):
if self.dealing_direction == 'rtl':
self.players.reverse()
index = self.players.index(first_player)
self.players = self.players[index:] + self.players[:index]
for instruction in self.dealing_instructions:
for player in self.players:
player.players_cards.extend(self.deck.deck[:instruction])
self.deck.deck = self.deck.deck[instruction:]
def get_deck(self):
return self.deck
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))
-