If you're stuck read this:

https://en.wikipedia.org/wiki/How_to_Solve_It

Working with objects


In [14]:
class Card:
    
    def __init__(self, rank, suit):
        self.suit = suit
        self.rank = rank

In [20]:
card = Card("king", "clubs")
card.rank


Out[20]:
'king'

In [22]:
card2 = Card("King", "clubs")
card2


Out[22]:
'King'

In [ ]:


In [23]:
class Card:
    def __init__(self, suit=0, rank=0):
        self.suit = suit
        self.rank = rank

In [25]:
three_of_clubs = Card(0, 3)
card1 = Card(1, 11)
card1


Out[25]:
<__main__.Card at 0x7fd04c38ca20>

In [26]:
class Card:
    suits = ["Clubs", "Diamonds", "Hearts", "Spades"]
    ranks = ["narf", "Ace", "2", "3", "4", "5", "6", "7",
             "8", "9", "10", "Jack", "Queen", "King"]

    def __init__(self, suit=0, rank=0):
        self.suit = suit
        self.rank = rank

    def __str__(self):
        return (self.ranks[self.rank] + " of " + self.suits[self.suit])

In [27]:
card = Card()

In [37]:
(card.rank, card.suit)


Out[37]:
(0, 0)

In [42]:
class Card:
    suits = ["Clubs", "Diamonds", "Hearts", "Spades"]
    ranks = ["narf", "Ace", "2", "3", "4", "5", "6", "7",
             "8", "9", "10", "Jack", "Queen", "King"]

    def __init__(self, suit=0, rank=1):
        self.suit = suit
        self.rank = rank

    def __str__(self):
        return (self.ranks[self.rank] + " of " + self.suits[self.suit])

    def cmp(self, other):
        # Check the suits
        if self.suit > other.suit: return 1
        if self.suit < other.suit: return -1
        # Suits are the same... check ranks
        if self.rank > other.rank: return 1
        if self.rank < other.rank: return -1
        # Ranks are the same... it's a tie
        return 0

In [50]:
card = Card()
card2 = Card(3, 5)
card3 = Card(3, 6)
print(card, card2, card3)

card2 < card3


Ace of Clubs 5 of Spades 6 of Spades
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-50-0a599b1b2320> in <module>()
      4 print(card, card2, card3)
      5 
----> 6 card2 < card3

TypeError: unorderable types: Card() < Card()

In [52]:
class Card:
    suits = ["Clubs", "Diamonds", "Hearts", "Spades"]
    ranks = ["narf", "Ace", "2", "3", "4", "5", "6", "7",
             "8", "9", "10", "Jack", "Queen", "King"]

    def __init__(self, suit=0, rank=1):
        self.suit = suit
        self.rank = rank

    def __str__(self):
        return (self.ranks[self.rank] + " of " + self.suits[self.suit])

    def cmp(self, other):
        # Check the suits
        if self.suit > other.suit: return 1
        if self.suit < other.suit: return -1
        # Suits are the same... check ranks
        if self.rank > other.rank: return 1
        if self.rank < other.rank: return -1
        # Ranks are the same... it's a tie
        return 0

    def __eq__(self, other):
        return self.cmp(other) == 0

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

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

    def __gt__(self, other):
        return self.cmp(other) > 0

    def __lt__(self, other):
        return self.cmp(other) < 0

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

In [56]:
card = Card()
card2 = Card(3, 5)
card3 = Card(3, 6)
print(card, card2, card3)

card2 >= card3


Ace of Clubs 5 of Spades 6 of Spades
Out[56]:
False

In [57]:
class Deck:
    def __init__(self):
        self.cards = []
        for suit in range(4):
            for rank in range(1, 14):
                self.cards.append(Card(suit, rank))

In [60]:
deck = Deck()
deck.cards


Out[60]:
[<__main__.Card at 0x7fd04c3b7e10>,
 <__main__.Card at 0x7fd04c3b7e48>,
 <__main__.Card at 0x7fd04c3b7e80>,
 <__main__.Card at 0x7fd04c3b72b0>,
 <__main__.Card at 0x7fd04c3b7ba8>,
 <__main__.Card at 0x7fd04c3b7b00>,
 <__main__.Card at 0x7fd04c3b7d30>,
 <__main__.Card at 0x7fd04c3b7d68>,
 <__main__.Card at 0x7fd04c3b7da0>,
 <__main__.Card at 0x7fd04c3b7668>,
 <__main__.Card at 0x7fd04c3b76d8>,
 <__main__.Card at 0x7fd04c3b79e8>,
 <__main__.Card at 0x7fd04c3b77b8>,
 <__main__.Card at 0x7fd04c3b7048>,
 <__main__.Card at 0x7fd04c3b7080>,
 <__main__.Card at 0x7fd04c3b70b8>,
 <__main__.Card at 0x7fd04c3b70f0>,
 <__main__.Card at 0x7fd04c3b7908>,
 <__main__.Card at 0x7fd04c3b7550>,
 <__main__.Card at 0x7fd04c3b7518>,
 <__main__.Card at 0x7fd04c3b7400>,
 <__main__.Card at 0x7fd04c3b7160>,
 <__main__.Card at 0x7fd04c3b7128>,
 <__main__.Card at 0x7fd04c3b7208>,
 <__main__.Card at 0x7fd04c3b72e8>,
 <__main__.Card at 0x7fd04c3b7438>,
 <__main__.Card at 0x7fd04c3b7470>,
 <__main__.Card at 0x7fd04c3a2f28>,
 <__main__.Card at 0x7fd04c3a2e48>,
 <__main__.Card at 0x7fd04c3a2f60>,
 <__main__.Card at 0x7fd04c3a2d30>,
 <__main__.Card at 0x7fd04c3a2c88>,
 <__main__.Card at 0x7fd04c3a2908>,
 <__main__.Card at 0x7fd04c3a2940>,
 <__main__.Card at 0x7fd04c3a2b38>,
 <__main__.Card at 0x7fd04c3a29e8>,
 <__main__.Card at 0x7fd04c3a2b70>,
 <__main__.Card at 0x7fd04c3a2ba8>,
 <__main__.Card at 0x7fd04c3a2ac8>,
 <__main__.Card at 0x7fd04c3a24a8>,
 <__main__.Card at 0x7fd04c3a2a20>,
 <__main__.Card at 0x7fd04c3a2470>,
 <__main__.Card at 0x7fd04c3a2080>,
 <__main__.Card at 0x7fd04c3a2b00>,
 <__main__.Card at 0x7fd04c3a2a90>,
 <__main__.Card at 0x7fd04c3a2c18>,
 <__main__.Card at 0x7fd04c3a2be0>,
 <__main__.Card at 0x7fd04c3a2e80>,
 <__main__.Card at 0x7fd04c3a2ef0>,
 <__main__.Card at 0x7fd04c3a2eb8>,
 <__main__.Card at 0x7fd04c386a58>,
 <__main__.Card at 0x7fd04c386588>]

In [68]:
class Deck:

    def __init__(self):
        self.cards = []
        for suit in range(4):
            for rank in range(1, 14):
                self.cards.append(Card(suit, rank))

    def __str__(self):
        s = ""
        for i in range(len(self.cards)):
            s = s + " " * i + str(self.cards[i]) + "\n"
        return s

In [69]:
deck = Deck()
print(deck)


Ace of Clubs
 2 of Clubs
  3 of Clubs
   4 of Clubs
    5 of Clubs
     6 of Clubs
      7 of Clubs
       8 of Clubs
        9 of Clubs
         10 of Clubs
          Jack of Clubs
           Queen of Clubs
            King of Clubs
             Ace of Diamonds
              2 of Diamonds
               3 of Diamonds
                4 of Diamonds
                 5 of Diamonds
                  6 of Diamonds
                   7 of Diamonds
                    8 of Diamonds
                     9 of Diamonds
                      10 of Diamonds
                       Jack of Diamonds
                        Queen of Diamonds
                         King of Diamonds
                          Ace of Hearts
                           2 of Hearts
                            3 of Hearts
                             4 of Hearts
                              5 of Hearts
                               6 of Hearts
                                7 of Hearts
                                 8 of Hearts
                                  9 of Hearts
                                   10 of Hearts
                                    Jack of Hearts
                                     Queen of Hearts
                                      King of Hearts
                                       Ace of Spades
                                        2 of Spades
                                         3 of Spades
                                          4 of Spades
                                           5 of Spades
                                            6 of Spades
                                             7 of Spades
                                              8 of Spades
                                               9 of Spades
                                                10 of Spades
                                                 Jack of Spades
                                                  Queen of Spades
                                                   King of Spades


In [11]:
class Deck:
    ...
    def remove(self, card):
        if card in self.cards:
            self.cards.remove(card)
            return True
        else:
            return False

In [12]:
class Deck:
    ...
    def pop(self):
        return self.cards.pop()

In [13]:
class Deck:
    ...
    def is_empty(self):
        return self.cards == []

In [70]:
class Deck:

    def __init__(self):
        self.cards = []
        for suit in range(4):
            for rank in range(1, 14):
                self.cards.append(Card(suit, rank))

    def __str__(self):
        s = ""
        for i in range(len(self.cards)):
            s = s + " " * i + str(self.cards[i]) + "\n"
        return s
    
    def remove(self, card):
        if card in self.cards:
            self.cards.remove(card)
            return True
        else:
            return False
        
    def pop(self):
        return self.cards.pop()
    
    def is_empty(self):
        return self.cards == []

In [77]:
deck = Deck()
card = Card(1,2)
print(card)
deck.remove(card)


2 of Diamonds
Out[77]:
True

In [80]:
print(deck.pop())


Queen of Spades

In [81]:
print(deck)


Ace of Clubs
 2 of Clubs
  3 of Clubs
   4 of Clubs
    5 of Clubs
     6 of Clubs
      7 of Clubs
       8 of Clubs
        9 of Clubs
         10 of Clubs
          Jack of Clubs
           Queen of Clubs
            King of Clubs
             Ace of Diamonds
              3 of Diamonds
               4 of Diamonds
                5 of Diamonds
                 6 of Diamonds
                  7 of Diamonds
                   8 of Diamonds
                    9 of Diamonds
                     10 of Diamonds
                      Jack of Diamonds
                       Queen of Diamonds
                        King of Diamonds
                         Ace of Hearts
                          2 of Hearts
                           3 of Hearts
                            4 of Hearts
                             5 of Hearts
                              6 of Hearts
                               7 of Hearts
                                8 of Hearts
                                 9 of Hearts
                                  10 of Hearts
                                   Jack of Hearts
                                    Queen of Hearts
                                     King of Hearts
                                      Ace of Spades
                                       2 of Spades
                                        3 of Spades
                                         4 of Spades
                                          5 of Spades
                                           6 of Spades
                                            7 of Spades
                                             8 of Spades
                                              9 of Spades
                                               10 of Spades
                                                Jack of Spades


In [ ]: