Blackjack game in Python 2.7

Question

Please review my game. I am learning Python now, so any suggestions are welcome. I am running this on a Linux machine, in Komodo and terminal.

#!/usr/bin/python
#encoding=utf8  
import random

# init global variables used for game
player = []
dealer = []

class Deck(object):
    def __init__(self,rank=[], suit=[], whole_deck=[], scrambled_deck=[]):
        self.rank = ['1','2','3','4','5','6','7','8','9','J','Q','K','A']
        self.suit = ['♠','♣','♥','♦︎︎']
        self.whole_deck = whole_deck
        self.scrambled_deck = scrambled_deck
        #construct deck from existing attributes
        def makedeck(self):
            self.whole_deck = []            
            i=0
            while i < 4:
                for r in self.rank:
                    self.whole_deck.append(r+self.suit[i])  
                i += 1
            return self.whole_deck
        self.whole_deck = makedeck(self)

    def draw_a_card(self):
        d=self.whole_deck.pop(random.choice(range(len(self.whole_deck))))
        return d

class Game(Deck):
    def __init__(self,credit=100, bet=10):
        Deck.__init__(self)
        self.credit = credit
        self.bet = bet
    def getcredit(self):
        while True:
            try:
                self.credit = int(raw_input("How many chips would you like to buy? "))
            except:
                print "You need to specify number"
                continue
            else:
                print str(self.credit) + ' Chips Purchased'
                print "Have fun!"
                break
        return self.credit
    def makebet(self):
        while True:
            try:
                self.bet = int(raw_input("How much do you want to bet? "))
            except:
                print "You need to specify number"
                continue
            if self.bet > self.credit:
                print 'You can\'t bet more than you have credit'
                continue
            else:
                print 'You are betting ' + str(self.bet) 
                break
    def deal(self, p_turn=0, d_turn=0):
        global dealer
        global player
        i = 0
        j = 0
        while i < p_turn:
            player.append(g.draw_a_card())
            i += 1
        while j < d_turn:
            dealer.append(g.draw_a_card())
            j += 1

def clear_screen():
    print '\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n'

####################Construct Cards####################
def makecard(dealer, player, hidden=0):
    card =   ['╔═══════╗\t','║ {}     ║\t','║       ║\t','║   {}   ║\t','║       ║\t','║     {} ║\t','╚═══════╝\t']
    h_card = ['╔═══════╗\t','║▓▓▓▓▓▓▓║\t' ,'║▒▒▒▒▒▒▒║\t','║▓▓▓▓▓▓▓║\t' ,'║▒▒▒▒▒▒▒║\t','║▓▓▓▓▓▓▓║\t' ,'╚═══════╝\t']

    global player_cards
    player_cards = ['' for i in player]
    c=0
    p=0
    while p < len(player):
        for c in range(0, len(card)):
            alter = [1,0,0,1,0,0,1]
            current_card=[player[p][:1], player[p][1:]]
            player_cards[p] += str(card[c]).format(current_card[alter[c]])
        player_cards[p] = player_cards[p].split("\t")
        p += 1

    global dealer_cards
    dealer_cards = ['' for i in dealer]
    c=0
    p=0 

    while p < len(dealer):
        for c in range(0, len(card)):
            alter = [1,0,0,1,0,0,1]
            current_card=[dealer[p][:1], dealer[p][1:]]
            dealer_cards[p] += str(card[c]).format(current_card[alter[c]])
        dealer_cards[p] = dealer_cards[p].split("\t")
        p += 1

    if  hidden == 1:
        dealer_cards[1]=''.join(h_card)
        dealer_cards[1] = dealer_cards[1].split("\t")

def printcards(dealer_cards, player_cards):
    for i in range(len(dealer_cards[0])):
        for j in range(len(dealer_cards)):
            print '{}'.format(dealer_cards[j][i]),
        print

    for i in range(len(player_cards[0])):
        for j in range(len(player_cards)):
            print '{}'.format(player_cards[j][i]),
        print
####################Construct Cards END####################

def makerank(who):
    i=0
    player_rank = []
    while i < len(who):
        player_rank.append(who[i][0])

        for ii in player_rank:
            player_rank = [10 if ii=='K' or ii=='Q' or ii=='J' else ii for ii in player_rank]

        for ii in player_rank:        
            if ii == 'A':
                tmp_suit = player_rank.pop()
    #            tmp_suit = player_rank.pop(player_rank.index(ii))            
                if sum([ int(x) for x in player_rank]) <= 10:
                    tmp_suit = 11
                    player_rank.append(tmp_suit)
                elif sum([ int(x) for x in player_rank]) > 10:
                    tmp_suit = 1
                    player_rank.append(tmp_suit)
        i += 1         

    player_rank = [ int(x) for x in player_rank ]
    return sum(player_rank)

def newdeck(mindecksize):
    d = Deck()
    if len(g.whole_deck) < mindecksize: 
        g.whole_deck = d.whole_deck

def cards(z):
    if z == 0:
        makecard(dealer, player, 0)
        printcards(dealer_cards, player_cards)
    elif z == 1:
        makecard(dealer, player, 1)
        printcards(dealer_cards, player_cards)

def winlose(who):
    if who == 'p':
        g.credit = g.credit + g.bet
        print 'You win!'
        print 'Your credit is: ' + str(g.credit)
    elif who == 'd':
        g.credit = g.credit - g.bet
        print 'Dealer wins!'
        print 'Your credit is: ' + str(g.credit)       
    elif who == 'dr':
        print 'Push'
        print 'Your credit is: ' + str(g.credit)               

def dealerplay():
    while makerank(dealer) < 17:
        g.deal(0,1)

#Debug functions, can be removed at any time

def debug_printset():
    i=0
    while i < len(player):
        print player[i]
        i += 1

# Functions end here
g = Game()

def play():
    d = Deck()
    global g
    global player
    global dealer
    i = 0
    clear_screen()
    g.getcredit()
    while True: #Whole game loop
        player = []
        dealer = []      
        g.deal(2,2)
        i += 1
        clear_screen()
        g.makebet()
        cards(1)
        newdeck(5)
        #########################Is it blackjack?#########################
        if makerank(player) == 21: 
            if i == 1 and makerank(dealer) != 21:
                print 'Blackjack!'
                winlose('p')
                break
            elif i == 1 and makerank(dealer) == 21:
                winlose('dr')
                break
        #########################Is it blackjack? END#########################        
        while True: #hand loop              
            player_input = str(raw_input("Press 'h' to hit, or 's' to stand \n"))
            if player_input == 'h':
                newdeck(1)
                g.deal(1)
                if makerank(player) > 21:
                    clear_screen()
                    cards(0)
                    print 'Busted!'
                    winlose('d')
                    break
                elif makerank(player) < 21:
                    clear_screen()
                    cards(1)
                    continue
                elif makerank(player) == 21:
                    clear_screen()
                    cards(0)
                    dealerplay()
                    if makerank(dealer) == 21:
                        winlose('dr')
                        break
                    elif makerank(dealer) < 21:
                        winlose('p')
                        break

            elif player_input == 's':
                dealerplay()
                clear_screen()
                cards(0)
                if  makerank(dealer) > 21:
                    winlose('p')
                    break
                elif makerank(dealer) > makerank(player):
                    winlose('d')
                    break
                elif makerank(dealer) < makerank(player):
                    winlose('p')
                    break
                elif makerank(dealer) == makerank(player):
                    winlose('dr')
                    break
###############Gameover?####################
        if g.credit == 0:
            print "Game Over"
            exit()  
###############Play again?##################            
        while True: 
            print len(g.whole_deck)
            print 'press \'d\' to deal again, or \'c\' to close'
            deal = str(raw_input())
            if deal == 'd':
                i -= 1
                break
            elif deal == 'c':
                print 'Game ended. Your remaining credit is: ' + str(g.credit)
                exit()
            else:
                print "Incorrect input, please input 'd' to Deal again, 'c' to close the game"
                continue
###############Play again? END##################            

play()

Answer 1

In general, I think you did a good job overall. That is, getting the game logic to run without serious issue. There were a couple of errors that caused the game to not run correctly. One was if the player gets a blackjack the game exits without prompting the user for further action:

LOGIC

while True: #Whole game loop
    player = []
    dealer = []      
    .....
    if makerank(player) == 21: 
        if i == 1 and makerank(dealer) != 21:
            print 'Blackjack!'
            winlose('p')
            break
        elif i == 1 and makerank(dealer) == 21:
            winlose('dr')
            break       
    while True: #hand loop              
    ..........

I shortened the code up here but you can see since you do your check outside of "hand-loop" and call break you will exit the program. This goes for if there is a push on blackjack too.

Exhausting the deck, where you only reset the deck if the player hits. This is because of how you are drawing cards by calling .pop.

.....
if player_input == 'h':
    newdeck(1)

.....
def draw_a_card(self):
    d=self.whole_deck.pop(random.choice(range(len(self.whole_deck))))
    return d

If you keep standing on every turn you will eventually get an IndexError. You could just call random.choice on the deck and not have to worry about it while using some other condition to reset the deck:

def draw_a_card(self):
    return random.choice(self.whole_deck)

STYLE

There are some style issues here too. These usually come down to personal preferences but if you are having others read your code its best to stay close to pep8 which is a general consesus for helpful style choices.

OOP

You also make use of global variables quite a bit. Usually using globals are considered bad practice. What you could do is think about where each one of these functions and variables would logically make sense to be grouped together. Then create a class to encapsulate the variables and functions, adhering to good OOP principles. You do this to a certain degree but you could further it by adding in the globals too:

class Game(Deck):
    def __init__(self,credit=100, bet=10):
        Deck.__init__(self)
        self.credit = credit
        self.bet = bet
        # make an attribute for hands
        self.player = []
        self.dealer = []

CODE DUPLICATION

You also have several spots of code duplication. Keeping with DRY (don't repeat yourself) you could use a loop or recursion to cut down on some of this:

def printcards(dealer_cards, player_cards):
    for i in range(len(dealer_cards[0])):
        for j in range(len(dealer_cards)):
            print '{}'.format(dealer_cards[j][i]),
        print

    for i in range(len(player_cards[0])):
        for j in range(len(player_cards)):
            print '{}'.format(player_cards[j][i]),
        print

Where you could pass in a list or any other kind of iterable and loop for them:

def printcards(hands): # where hands have both player and dealer cards
    for hand in hands:
        for i in range(len(hand[0]):
        .....

There are places where you are using counters too where iterating over the list itself or a range would be fine:

p=0
...
while p < len(dealer):
    for c in range(0, len(card)):
        alter = [1,0,0,1,0,0,1]
        current_card=[dealer[p][:1], dealer[p][1:]]
        dealer_cards[p] += str(card[c]).format(current_card[alter[c]])
    dealer_cards[p] = dealer_cards[p].split("\t")
    p += 1

would be:

for p in range(len(dealer)):
    for c in range(0, len(card)):
        alter = [1,0,0,1,0,0,1]
        current_card=[dealer[p][:1], dealer[p][1:]]
        dealer_cards[p] += str(card[c]).format(current_card[alter[c]])
    dealer_cards[p] = dealer_cards[p].split("\t")

STANDARD LIBRARY

One of the great things about Python is that there are a rich collection of libraries/modules already made by really intelligent people. Use this to your advantage and get to know different modules and what they offer:

self.whole_deck = []            
i=0
while i < 4:
    for r in self.rank:
        self.whole_deck.append(r+self.suit[i])  
    i += 1

becomes:

from itertools import product
.....
return [''.join(c) for c in product(self.rank, self.suit)]

Where you can use itertools.product to create a cartesian product

I re-wrote your program by creating a different game-loop and making a couple of different classes:

#!/usr/bin/python
#encoding=utf8  

import random


card =   ['╔═══════╗\t',
          '║ {}     ║\t',
          '║       ║\t',
          '║   {}   ║\t',
          '║       ║\t',
          '║     {} ║\t',
          '╚═══════╝\t'
         ]

h_card = ['╔═══════╗\t',
          '║▓▓▓▓▓▓▓║\t',
          '║▒▒▒▒▒▒▒║\t',
          '║▓▓▓▓▓▓▓║\t',
          '║▒▒▒▒▒▒▒║\t',
          '║▓▓▓▓▓▓▓║\t',
          '╚═══════╝\t'
         ]

def make_rank(hand):
    hand_rank = 0
    hand_str = ''.join(card[0] for card in hand)
    for card in hand_str:
        if card.isdigit():
            hand_rank += int(card)
        else:
            hand_rank += 10 if card in 'KQJ' else 11
    if hand_rank > 21 and 'A' in hand_str:
        hand_rank -= 10
    return hand_rank

def make_cards(hand, hidden=False):
    cards = [''.join(card).format(*c).split('\t') for c in hand]
    if hidden:
        cards[1] = ''.join(h_card).split('\t')
    return cards

def print_cards(hands, hidden=False):
    for pos, hand in enumerate(hands):
        cards = make_cards(hand, (not pos) & hidden)
        for card in zip(*cards):
            print(''.join(card))
        print

def clear_screen(func):
    def wrapper(*args, **kwargs):
        print '\n' * 66
        return func(*args)
    return wrapper

@clear_screen
def get_credit():
    while True:
        try:
            credit = int(raw_input("How many chips would you like to buy? "))
        except:
            print "You need to specify number"
            continue
        print '{} Chips Purchased'.format(credit)
        print "Have fun!"
        break
    return credit

@clear_screen
def make_bet(player):
    while True:
        try:
            bet = int(raw_input("How much do you want to bet? "))
        except:
            print "You need to specify number"
            continue
        if bet > player.credit:
            print 'You can\'t bet more than you have credit'
            continue
        print 'You are betting {}'.format(bet) 
        break
    player.credit -= bet
    return bet

def deal_again(option=''):
    if option == 'c':
        return False
    elif option == 'd':
        return True
    if option:
        print 'Incorrect input, please input "d" to Deal again, "c" to close the game'
    print 'press \'d\' to deal again, or \'c\' to close'
    option = raw_input()
    return deal_again(option)

class Deck(object):

    def __init__(self,rank=[], suit=[], whole_deck=[], scrambled_deck=[]):
        self.rank = ['2','3','4','5','6','7','8','9','J','Q','K','A']
        self.suit = ['♠','♣','♥','♦︎︎']
        self.whole_deck = whole_deck
        self.scrambled_deck = scrambled_deck
        def makedeck(self):
            return [(r, s, r) for r in self.rank for s in self.suit]
        self.whole_deck = makedeck(self)

    def draw_a_card(self):
        return random.choice(self.whole_deck)


class Player(object):

    def __init__(self, dealer):
        self.hand = []
        self.credit = 0
        self.dealer = dealer


class Dealer(object):

    def __init__(self, bet=10):
        self.deck = Deck()
        self.bet = bet
        self.hand = []
        self.table_hands = [self.hand]

    def add_player(self, player):
        self.table_hands.append(player)

    @property
    def clear_cards(self):
        self.table_hands = [[] for hand in self.table_hands]

    def deal_hand(self):
        self.clear_cards
        self.deal(self.table_hands, 2)

    def deal(self, hands, turn):
        for _ in range(turn):
            for hand in hands:
                hand.append(self.deck.draw_a_card())

    def winlose(self, who):
        payout = 0
        if who == 'p':
            print 'You win!'
            payout = self.bet * 2
        elif who == 'd':
            print 'Dealer wins!'
        else:
            print 'Push'
            payout = self.bet
        return payout

    @clear_screen
    def dealer_play(self, rank):
        dealer_hand = self.table_hands[0]
        if rank > 16:
            return rank
        self.deal([dealer_hand], 1)
        rank = make_rank(dealer_hand)
        print_cards(self.table_hands)
        return self.dealer_play(rank)

    @clear_screen
    def player_play(self, rank, option=''):
        player_hand = self.table_hands[1]
        if option == 'h':
            self.deal([player_hand], 1)
            rank = make_rank(player_hand)
        print_cards(self.table_hands, True)
        if rank >= 21 or option == 's':
            return rank
        player_input = raw_input('Press "h" to hit, or "s" to stand \n')
        return self.player_play(rank, player_input)


def play_hand(dealer, player):
    dealer.deal_hand()
    print_cards(dealer.table_hands, True)
    d_rank, p_rank = map(make_rank, dealer.table_hands)
    msg = ''
    if p_rank == 21 or d_rank == 21:
        msg = 'BlackJack!'
        winner = 'p' if p_rank == 21 and d_rank != 21 else \
                 'd' if p_rank != 21 else 'dr'
    else:
        p_rank = dealer.player_play(p_rank)
        if p_rank > 21:
            msg = 'Bust'
            winner = 'd'
        else:
            d_rank = dealer.dealer_play(d_rank)
            if d_rank > 21 or p_rank <= 21 and d_rank < p_rank:
                winner = 'p'
            elif p_rank < 21 and d_rank > p_rank:
                winner = 'd'
            else:
                winner = 'dr'
    clear_screen(lambda:None)()
    if msg:
        print msg
    player.credit += dealer.winlose(winner)
    print_cards(dealer.table_hands)
    print 'Your credit is: {}'.format(player.credit)

def take_seat_at_table():
    dealer = Dealer()
    player = Player(dealer)
    PLAYING = True
    player.credit = get_credit()
    dealer.add_player(player.hand)
    while PLAYING:
        dealer.bet = make_bet(player)
        play_hand(dealer, player)
        if player.credit == 0:
            print 'Game Over'
            PLAYING = False
        else:
            PLAYING = deal_again()
    print 'Game ended. Your remaining credit is: {}'.format(player.credit)

if __name__ == '__main__':
    take_seat_at_table()

Answer 2

As noted in a similar question, the deck should be constructed using a list comprehension. There is no rank "1", but there should be a "10".