Simulate Blackjack Game - Card Generator

First of all, we define a abstract class for card. We implement the initialization function in base class, so every subclass will inherite such initial function. In the base class,

import abc

########################################
# card class
########################################
class Card:
    __metaclass__ = abc.ABCMeta
    """ rank is string: 'A', ‘1’， ‘J’ """
    """ suit is string: (Club, Diamond, Heart, Spade) """
    
    def __init__(self, rank_, suit_):
        self.rank = rank_
        self.suit = suit_
        self.hard, self.soft = self._points()
    
    def printinfo(self):
        print self.rank, self.suit
        
    @abc.abstractmethod
    def _points():
        """ Calculate hard and soft points"""
        return
        
class NumberCard(Card):
    def _points(self):
        return int(self.rank), int(self.rank)
        
class AceCard(Card):
    def _points(self):
        return 1, 11
        
class FaceCard(Card):
    def _points(self):
        return 10, 10
        
#########################################
# factory function
#########################################
def card(rank, suit):
    if rank == 1: 
        return AceCard('A', suit)
    elif 2 <= rank < 11: 
        return NumberCard(str(rank), suit)
    elif 11 <= rank < 14:
        name = {11:'J', 12:'Q', 13:'K'}[rank]
        return FaceCard(name, suit)
    else:
        raise Exception("Rank is out of range!")

We also define a factory function. We could use a class to fulfill such function, but because it is simple, a function is enough.

Another choice is to define a __init__() function for base class, and in subclass, use super().

import abc

########################################
# card class
########################################
class Card(object):
    def __init__(self, rank_, suit_, hard_, soft_):
        self.rank = rank_
        self.suit = suit_
        self.hard = hard_
        self.soft = soft_
    
    def printinfo(self):
        print self.rank, self.suit
        
        
class NumberCard(Card):
    def __init__(self, rank_, suit_):
        super(NumberCard, self).__init__(str(rank_), suit_, rank_, rank_)
        
class AceCard(Card):
    def __init__(self, rank_, suit_):
        super(AceCard, self).__init__('A', suit_, 1, 11) 
        
class FaceCard(Card):
    def __init__(self, rank_, suit_):
        super(FaceCard, self).__init__({11:'J',12:'Q',13:'K'}[rank_], suit_, 10, 10) 
        
        
#########################################
# factory function
#########################################
def card(rank, suit):
    if rank == 1: 
        return AceCard('A', suit)
    elif 2 <= rank < 11: 
        return NumberCard(str(rank), suit)
    elif 11 <= rank < 14:
        return FaceCard(rank, suit)
    else:
        raise Exception("Rank is out of range!")

Note that

class Card(object):

we need to let our base class Card inherit from object, becoming new type class, because super() only works with new type of class.

We also define class for deck and hand.

#########################################
# deck class
#########################################  
class Deck(list):
    def __init__(self, numdecks=1):
        super(Deck, self).__init__()
        for i in range(numdecks):
            self.extend([card(rank, suit) for rank in range(1,14) for suit in ('Club', 'Diamond', 'Heart', 'Spade')])  
        np.random.shuffle(self)
        burnin = np.random.randint(1, 52)
        for i in range(burnin):
            self.pop()   
        
#########################################
# hand class
#########################################
class Hand:
    def __init__(self, dealer_card_, *cards):
        self.dealer_card = dealer_card_
        self.cards = list(cards)
    
    def hard_total(self):
        return np.sum(c.hard for c in self.cards)
    
    def soft_total(self):
        return np.sum(c.soft for c in self.cards)

Note that we use *cards in class hand because we are not sure how many arguments might be passed to the initialization function.