Private & Protected в ООП

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

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

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

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

Към профила на Даниела Дишлянова

Резултати

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

Код

import itertools
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:
_suits = ['clubs', 'diamonds', 'hearts', 'spades']
_faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
def __init__(self, face_filter=_faces):
all_cards_possible = list(itertools.product(self._suits, face_filter))
self._cards = []
for card in all_cards_possible:
self._cards.append(Card(*card))
def cut(self):
number_of_cards_top = random.randint(1, len(self._cards) - 1)
self._cards = self._cards[number_of_cards_top:] + self._cards[:number_of_cards_top]
def shuffle(self):
random.shuffle(self._cards)
def get_cards(self):
return self._cards
def add_cards(self, cards):
self._cards.extend(cards)
def give_cards(self, amount):
to_give = self._cards[:amount]
del self._cards[:amount]
return to_give
class Player:
def __init__(self):
self._cards = []
def get_cards(self):
return self._cards
def give_cards(self):
to_return = self._cards
self._cards = []
return to_return
def receive_cards(self, cards):
self._cards.extend(cards)
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._players = []
for _ in range(number_of_players):
self._players.append(Player())
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._deck = Deck()
def get_players(self):
random_player = random.choice(self._players)
players_to_random = itertools.dropwhile(lambda pl: pl != random_player,
itertools.cycle(self._players))
return list(itertools.islice(players_to_random, len(self._players)))
def prepare_deck(self):
for player in self._players:
self._deck.add_cards(player.give_cards())
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
deal_list = []
if self._dealing_direction == 'ltr':
players_to_player = itertools.dropwhile(lambda pl: pl != player,
itertools.cycle(self._players))
elif self._dealing_direction == 'rtl':
players_to_player = itertools.dropwhile(lambda pl: pl != player,
itertools.cycle(reversed(self._players)))
deal_list = list(itertools.islice(players_to_player, len(self._players)))
for amount in self._dealing_instructions:
for player in deal_list:
player.receive_cards(self._deck.give_cards(amount))
def get_deck(self):
return self._deck
def change_deck(self, deck):
self._deck = deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
bellot_deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
self.change_deck(bellot_deck)
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

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

...............
----------------------------------------------------------------------
Ran 15 tests in 0.166s

OK

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

Даниела обнови решението на 13.11.2022 13:31 (преди над 2 години)

+import itertools
+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:
+ _suits = ['clubs', 'diamonds', 'hearts', 'spades']
+ _faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
+
+ def __init__(self, face_filter=_faces):
+ all_cards_possible = list(itertools.product(self._suits, face_filter))
+ self.cards = []
+ for card in all_cards_possible:
+ self.cards.append(Card(*card))
+
+ def cut(self):
+ number_of_cards_top = random.randrange(0, len(self.cards)-1)
+ top_cards = self.cards[:number_of_cards_top]
+ del self.cards[:number_of_cards_top]
+ self.cards.extend(top_cards)
+
+ def shuffle(self):
+ random.shuffle(self.cards)
+
+ def get_cards(self):
+ return self.cards
+
+ def add_cards(self, cards):
+ self.cards.extend(cards)
+
+ def give_cards(self, amount):
+ to_give = self.cards[:amount]
+ del self.cards[:amount]
+ return to_give
+
+
+class Player:
+ def __init__(self):
+ self.cards = []
+
+ def get_cards(self):
+ return self.cards
+
+ def give_cards(self):
+ to_return = self.cards
+ self.cards = []
+ return to_return
+
+ def receive_cards(self, cards):
+ self.cards.extend(cards)
+
+
+class Game:
+ def __init__(self, number_of_players, dealing_direction, dealing_instructions):
+ self.players = []
+ for _ in range(number_of_players):
+ self.players.append(Player())
+ self.dealing_direction = dealing_direction
+ self.dealing_instructions = dealing_instructions
+ self.deck = Deck()
+
+ def get_players(self):
+ random_player = random.choice(self.players)
+ players_to_random = itertools.dropwhile(lambda pl: pl != random_player,
+ itertools.cycle(self.players))
+ return list(itertools.islice(players_to_random, len(self.players)))
+
+ def prepare_deck(self):
+ for player in self.players:
+ self.deck.add_cards(player.give_cards())
+ self.deck.shuffle()
+ self.deck.cut()
+
+ def deal(self, player):
+ deal_list = []
+ if self.dealing_direction == 'ltr':
+ players_to_player = itertools.dropwhile(lambda pl: pl != player,
+ itertools.cycle(self.players))
+ elif self.dealing_direction == 'rtl':
+ players_to_player = itertools.dropwhile(lambda pl: pl != player,
+ itertools.cycle(reversed(self.players)))
+ deal_list = list(itertools.islice(players_to_player, len(self.players)))
+ for amount in self.dealing_instructions:
+ for player in deal_list:
+ player.receive_cards(self.deck.give_cards(amount))
+
+ def get_deck(self):
+ return self.deck
+
+ def change_deck(self, deck):
+ self.deck = deck
+
+
+class Belot(Game):
+ def __init__(self):
+ super().__init__(4, 'ltr', (2, 3, 3))
+ bellot_deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
+ self.change_deck(bellot_deck)
+
+
+class Poker(Game):
+ def __init__(self):
+ super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

Добро и чисто решение. Хареса ми, че използваш self.cards.append(Card(*card)). Доста от операциите, за които използваш itertools могат да се направят с вградена Питонска функционалност, и то може би по-кратко, но пък показваш, че си разгледала модула в дълбочина и решенията са иновативни (спрямо това, което видях от останалите колеги). Поради посочените причини, получаваш бонус точка.

Даниела обнови решението на 13.11.2022 20:44 (преди над 2 години)

import itertools
import random
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:
_suits = ['clubs', 'diamonds', 'hearts', 'spades']
_faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
def __init__(self, face_filter=_faces):
all_cards_possible = list(itertools.product(self._suits, face_filter))
- self.cards = []
+ self._cards = []
for card in all_cards_possible:
- self.cards.append(Card(*card))
+ self._cards.append(Card(*card))
def cut(self):
- number_of_cards_top = random.randrange(0, len(self.cards)-1)
- top_cards = self.cards[:number_of_cards_top]
- del self.cards[:number_of_cards_top]
- self.cards.extend(top_cards)
+ number_of_cards_top = random.randrange(0, len(self._cards) - 1)
+ self._cards = self._cards[number_of_cards_top:] + self._cards[:number_of_cards_top]
def shuffle(self):
- random.shuffle(self.cards)
+ random.shuffle(self._cards)
def get_cards(self):
- return self.cards
+ return self._cards
def add_cards(self, cards):
- self.cards.extend(cards)
+ self._cards.extend(cards)
def give_cards(self, amount):
- to_give = self.cards[:amount]
- del self.cards[:amount]
+ to_give = self._cards[:amount]
+ del self._cards[:amount]
return to_give
class Player:
def __init__(self):
- self.cards = []
+ self._cards = []
def get_cards(self):
- return self.cards
+ return self._cards
def give_cards(self):
- to_return = self.cards
- self.cards = []
+ to_return = self._cards
+ self._cards = []
return to_return
def receive_cards(self, cards):
- self.cards.extend(cards)
+ self._cards.extend(cards)
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
- self.players = []
+ self._players = []
for _ in range(number_of_players):
- self.players.append(Player())
- self.dealing_direction = dealing_direction
- self.dealing_instructions = dealing_instructions
- self.deck = Deck()
+ self._players.append(Player())
+ self._dealing_direction = dealing_direction
+ self._dealing_instructions = dealing_instructions
+ self._deck = Deck()
def get_players(self):
- random_player = random.choice(self.players)
+ random_player = random.choice(self._players)
players_to_random = itertools.dropwhile(lambda pl: pl != random_player,
- itertools.cycle(self.players))
- return list(itertools.islice(players_to_random, len(self.players)))
+ itertools.cycle(self._players))
+ return list(itertools.islice(players_to_random, len(self._players)))
def prepare_deck(self):
- for player in self.players:
- self.deck.add_cards(player.give_cards())
- self.deck.shuffle()
- self.deck.cut()
+ for player in self._players:
+ self._deck.add_cards(player.give_cards())
+ self._deck.shuffle()
+ self._deck.cut()
def deal(self, player):
deal_list = []
- if self.dealing_direction == 'ltr':
+ if self._dealing_direction == 'ltr':
players_to_player = itertools.dropwhile(lambda pl: pl != player,
- itertools.cycle(self.players))
- elif self.dealing_direction == 'rtl':
+ itertools.cycle(self._players))
+ elif self._dealing_direction == 'rtl':
players_to_player = itertools.dropwhile(lambda pl: pl != player,
- itertools.cycle(reversed(self.players)))
- deal_list = list(itertools.islice(players_to_player, len(self.players)))
- for amount in self.dealing_instructions:
+ itertools.cycle(reversed(self._players)))
+ deal_list = list(itertools.islice(players_to_player, len(self._players)))
+ for amount in self._dealing_instructions:
for player in deal_list:
- player.receive_cards(self.deck.give_cards(amount))
+ player.receive_cards(self._deck.give_cards(amount))
def get_deck(self):
- return self.deck
+ return self._deck
def change_deck(self, deck):
- self.deck = deck
+ self._deck = deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
bellot_deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
self.change_deck(bellot_deck)
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))

Даниела обнови решението на 15.11.2022 14:08 (преди над 2 години)

import itertools
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:
_suits = ['clubs', 'diamonds', 'hearts', 'spades']
_faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
def __init__(self, face_filter=_faces):
all_cards_possible = list(itertools.product(self._suits, face_filter))
self._cards = []
for card in all_cards_possible:
self._cards.append(Card(*card))
def cut(self):
- number_of_cards_top = random.randrange(0, len(self._cards) - 1)
+ number_of_cards_top = random.randint(1, len(self._cards) - 1)
self._cards = self._cards[number_of_cards_top:] + self._cards[:number_of_cards_top]
def shuffle(self):
random.shuffle(self._cards)
def get_cards(self):
return self._cards
def add_cards(self, cards):
self._cards.extend(cards)
def give_cards(self, amount):
to_give = self._cards[:amount]
del self._cards[:amount]
return to_give
class Player:
def __init__(self):
self._cards = []
def get_cards(self):
return self._cards
def give_cards(self):
to_return = self._cards
self._cards = []
return to_return
def receive_cards(self, cards):
self._cards.extend(cards)
class Game:
def __init__(self, number_of_players, dealing_direction, dealing_instructions):
self._players = []
for _ in range(number_of_players):
self._players.append(Player())
self._dealing_direction = dealing_direction
self._dealing_instructions = dealing_instructions
self._deck = Deck()
def get_players(self):
random_player = random.choice(self._players)
players_to_random = itertools.dropwhile(lambda pl: pl != random_player,
itertools.cycle(self._players))
return list(itertools.islice(players_to_random, len(self._players)))
def prepare_deck(self):
for player in self._players:
self._deck.add_cards(player.give_cards())
self._deck.shuffle()
self._deck.cut()
def deal(self, player):
deal_list = []
if self._dealing_direction == 'ltr':
players_to_player = itertools.dropwhile(lambda pl: pl != player,
itertools.cycle(self._players))
elif self._dealing_direction == 'rtl':
players_to_player = itertools.dropwhile(lambda pl: pl != player,
itertools.cycle(reversed(self._players)))
deal_list = list(itertools.islice(players_to_player, len(self._players)))
for amount in self._dealing_instructions:
for player in deal_list:
player.receive_cards(self._deck.give_cards(amount))
def get_deck(self):
return self._deck
def change_deck(self, deck):
self._deck = deck
class Belot(Game):
def __init__(self):
super().__init__(4, 'ltr', (2, 3, 3))
bellot_deck = Deck(['7', '8', '9', '10', 'J', 'Q', 'K', 'A'])
self.change_deck(bellot_deck)
class Poker(Game):
def __init__(self):
super().__init__(9, 'rtl', (1, 1, 1, 1, 1))