תרגול מחלקות עם פתרון: חפיסת קלפים

import random


SUITS = {
    "clubs": "♣",
    "diamonds": "♦",
    "hearts": "♥",
    "spades": "♠",
    }


class Deck:
    def __init__(self, cards=None):
        if not cards:
            cards = self.create_deck_of_cards()
        self.cards = cards

    def __add__(self, other):
        return Deck(self.cards + other.cards)

    def __iter__(self):
        self.n = 0
        return self

    def __next__(self):
        if self.n >= len(self.cards):
            raise StopIteration
        else:
            self.n += 1
            return self.cards[self.n - 1]

    def __len__(self):
        return len(self.cards)

    def __repr__(self):
        return f'{self.cards}'

    def create_deck_of_cards(self):
        return [Card(value, suit) for suit in SUITS.values() for value in range(1, 14)]

    def shuffle(self):
        random.shuffle(self.cards)
        return True

    def draw_card(self):
        return self.cards.pop()

    def create_player_hands(self, number_of_players, number_of_cards_per_player):
        if len(self.cards) < number_of_players * number_of_cards_per_player:
            return False

        self.shuffle()
        player_hands = [
            [self.draw_card() for _ in range(number_of_cards_per_player)]
            for _ in range(number_of_players)
        ]
        return player_hands


class Card:
    def __init__(self, rank, suit):
        self.rank = rank
        self.suit = suit

    def __repr__(self):
        return f'{self.rank}{self.suit}'

    def __str__(self):
        return f'{self.rank}{self.suit}'

    def __eq__(self, other):
        return self.rank == other.rank

    def __ne__(self, other):
        return self.rank != other.rank

    def __lt__(self, other):
        return self.rank < other.rank

    def __gt__(self, other):
        return self.rank > other.rank

    def __le__(self, other):
        return self.rank <= other.rank

    def __ge__(self, other):
        return self.rank >= other.rank

import random


class Card:
    def __init__(self, value, suit):
        self.value = value
        self.suit = suit.upper()

    def __str__(self):
        return f'{self.value}{self.suit}'

    def __lt__(self, other):
        return self.value < other.value

    def __le__(self, other):
        return self.value <= other.value

    def __eq__(self, other):
        return self.value == other.value

    def __ne__(self, other):
        return self.value != other.value

    def __gt__(self, other):
        return self.value > other.value

    def __ge__(self, other):
        return self.value >= other.value


class Deck:
    def __init__(self, *cards):
        if cards:
            self.cards = list(cards)
        else:
            self.cards = [Card(value, suit) for suit in ['c', 'd', 'h', 's'] for value in range(1, 14)]

    def __str__(self):
        return str([str(card) for card in self.cards])

    def __add__(self, other):
        return Deck(*(self.cards + other.cards))

    def __len__(self):
        return len(self.cards)

    def __contains__(self, other):
        for card in self.cards:
            if card == other and card.suit == other.suit:
                return True
        return False

    def shuffle(self):
        random.shuffle(self.cards)

    def sort(self, by_value=False):
        self.cards.sort()
        self.cards.sort(key=lambda card: card.suit)
        if by_value:
            self.cards.sort()

    def draw(self):
        self.shuffle()
        return self.cards.pop()

    def deal(self, players, amount):
        return [Deck(*[self.draw() for _ in range(amount)]) for _ in range(players)]

import random

SHAPES = {‘C’: ‘Club’, ‘D’: ‘Diamond’, ‘H’: ‘Heart’, ‘S’: ‘Spade’}
VALUES = [‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘10’, ‘11’, ‘12’, ‘13’]

class Card:
def init(self, shape, value):
self.shape = shape
self.value = value

def __str__(self):
    return f"{self.shape}{self.value}"

def __lt__(self, other):
    return self.value < other.value

def __gt__(self, other):
    return self.value > other.value

def __le__(self, other):
    return self.value <= other.value

def __ge__(self, other):
    return self.value >= other.value

def __cmp__(self, other):
    return self.value == other.value

class Deck:
def init(self, deck=None):
if deck is None:
deck = [Card(x,y) for x in SHAPES for y in VALUES]
self.deck = deck

def merge(self, other):
    self.deck.extend(other.deck)

def __contains__(self, item):
    return item in self.deck

def __len__(self):
    return len(self.deck)

def shuffle(self):
    random.shuffle(self.deck)

def drow_card(self):
    return self.deck.pop()

def __str__(self):
    return str([str(x) for x in self.deck])