Simulate the shuffling of cards

shuffler.py

SUITS = ["clubs", "diamonds", "hearts", "spades"]

class Card(object):

    one_to_fifty_two = None
    number = None
    suit = None
    positions = None
    
    def __init__(self, number, suit, value):
        self.number = number
        self.suit = suit
        self.one_to_fifty_two = value
        self.positions = Positions()
        
        
class Deck(object):

    cards = list()
    
    def __init__(self):
        suitcount = 0
        for card in range(52):
            if card > 0 and card % 13 == 0:
                suitcount += 1
            self.cards.append(Card(card % 13 + 1, SUITS[suitcount], card + 1))
            
    def reorder(self):
        self.cards.sort(key=lambda x: x.one_to_fifty_two)
                    
    def riffle(self, variance=4):
        '''
        Riffle deck once
        :param variance: Starting distribution of cards, 4 could be 22-30
        '''
        from random import randrange
        half_1 = len(self.cards) / 2 - variance + randrange(0, variance * 2 + 1)
        deck_1 = list()
        deck_2 = list()
        deck_1_marker = 0
        deck_2_marker = 0
        for count, each in enumerate(self.cards):
            if count < half_1:
                deck_1.append(each)
            else:
                deck_2.append(each)
        deck_1.reverse()
        deck_2.reverse()
        new_deck = list()
        for each in range(len(self.cards)):
            if len(deck_1) > deck_1_marker and randrange(0, 2) == 0:
                new_deck.append(deck_1[deck_1_marker])
                deck_1_marker += 1
            elif len(deck_2) > deck_2_marker:
                new_deck.append(deck_2[deck_2_marker])
                deck_2_marker += 1
            elif len(deck_1) > deck_1_marker:
                new_deck.append(deck_1[deck_1_marker])
                deck_1_marker += 1
        new_deck.reverse()
        self.cards = new_deck
        
    def cut(self, variance=8):
        from random import randrange
        half_1 = len(self.cards) / 2 - variance + randrange(0, variance * 2 + 1)
        deck_1 = list()
        deck_2 = list()
        deck_1_marker = 0
        deck_2_marker = 0
        for count, each in enumerate(self.cards):
            if count < half_1:
                deck_1.append(each)
            else:
                deck_2.append(each)
        self.cards = deck_2 + deck_1
        
    def show_cards(self, suits=True):
        for each in self.cards:
            if suits:
                print str(each.number) + " " + str(each.suit)
            else:
                print str(each.one_to_fifty_two)
                
    def set_positions(self):
        for count, each in enumerate(self.cards):
            each.positions.add_pos(count + 1)
                
    
class Positions(object):

    def __init__(self):
        self.card_pos = dict()
        for each in range(52):
            self.card_pos[each + 1] = 0
            
    def add_pos(self, pos):
        self.card_pos[pos] += 1
            
            
if __name__ == '__main__':
    '''
    Riffle the deck three times, cut it, riffle again
    Makes a distribution table of where the cards from starting position end up
    '''

    deck = Deck()
    for each in range(1000000):
        for shuffle in range(3):
           deck.riffle()
        deck.cut()
        deck.riffle()
        deck.set_positions()
        deck.reorder()
        
    temp_deck = []
    for each in range(52):
        temp_deck.append(deck.cards[each].positions.card_pos)
    
    outcome = dict()
    for each in range(52):
        deck[each + 1] = list()
    for each in range(52):
        for thing in temp_deck[each]:
            outcome[thing].append(temp_deck[each][thing])
            
    for each in outcome:
        print outcome[each]