Develop Reference

How to add a Value to Each Card in a Deck of Cards

So I have been stuck on this for a few days I have the deck of cards created and it works but I don't know how I would make each card have a value without using 52 if/elif statements for a BlackJack game. How would i make 10 of spades = 10, 9 of clubs = 9 etc.
import random
#card class to take suit and value self
class Card:
def __init__(self, suit, val):
self.suit = suit
self.value = val
def show(self):
print (f"{self.value} of {self.suit}")
#creates the deck class
class Deck:
def __init__(self):
self.cards = []
self.build()
#appends each suit and each val of the card to give us 52 cards (4 * 13 = 52)
def build(self):
for s in ["Spades", "Clubs", "Diamonds", "Hearts"]:
for v in range (1,14):
if v == 1:
self.cards.append(Card(s,"Ace")) #code that turns 1s into aces
elif v == 11:
self.cards.append(Card(s,"Queen")) #code that turns 11 into queens
elif v == 12:
self.cards.append(Card(s, "King")) #code that turns 12 into kings
elif v == 13:
self.cards.append(Card(s,"Jack")) #code that turns 13 into Jacks
else:
self.cards.append(Card(s,v))
def show(self):
for c in self.cards:
c.show()
#shuffle method using the Fisher Yates Shuffle Algorithm
def shuffle(self):
for i in range(len(self.cards) - 1, 0, -1):
r = random.randint(0, i)
self.cards[i], self.cards[r] = self.cards[r], self.cards[i]
def drawCard(self):
return self.cards.pop()
#dealer class
class Dealer:
global currentCard
def __init__(self, name):
self.name = name
self.hand = []
def draw(self,deck):
self.hand.append(deck.drawCard())
return self
def showHand(self):
for card in self.hand:
currentCard = card.show()
deck = Deck()
deck.shuffle()
dealer = Dealer("Dealer")
dealer.draw(deck)
dealer.showHand()

In term of the value you should first figure out where you want to handle that functionality. In terms of generally naming the cards you could assume them to be ordered in a pattern so that they are defined by their number and use modulo to get the suit and value. For example:
for i in range(0,52)
Card(suit=i//13,val=i%13)
The modulo operator % just gives you "the rest" of a division, so if you operate with whole numbers (no decimal fractions) then 10//3 is 3 and a rest of 1 because 3*3+1 = 10. So if you use modulo 13 (cards in a suit), that should give you a number between 0 and 12 (or 1 and 13 if you add 1) while i//13 rounds down to the nearest whole number which would give you a number between 0 and 3 (or 1 and 4) which can be used for the suits.
And once you have that you can use a dictionary or just a list with suits and card names that translate the numbers to names. Now in terms of values you could either derive them from the card names in a similar fashion but I'd rather deal with them on the level of the game logic as for example and ace could be both a 1 and an 11 (right?) so dealing with that when it's necessary would make more sense than to assign a value at initialization.

Every card needs two attributes - a suit and a value. The value will depend on the type of card game you're "playing". A common approach would be to assign values in the range 2->14
Consider this and note the absence of cumbersome if/else constructs:
import random
class CARD:
suits = ['Clubs', 'Diamonds', 'Hearts', 'Spades']
names = {2: 'Two',
3: 'Three',
4: 'Four',
5: 'Five',
6: 'Six',
7: 'Seven',
8: 'Eight',
9: 'Nine',
10: 'Ten',
11: 'Jack',
12: 'Queen',
13: 'King',
14: 'Ace'}
def __init__(self, suit, value):
self.suit = suit
self.value = value
def __str__(self):
return f'{CARD.names[self.value]} of {self.suit} has a value of {self.value}'
class DECK:
def __init__(self):
self.cards = None
def get_cards(self):
if self.cards is None:
self.cards = [CARD(CARD.suits[n % 4], n % 13 + 2) for n in range(52)]
return self.cards
def get_random_card(self):
return random.choice(self.get_cards())
D = DECK()
# pick some cards at random
for _ in range(5):
print(D.get_random_card())
Output (similar to):
Queen of Spades has a value of 12
Five of Diamonds has a value of 5
Nine of Diamonds has a value of 9
Four of Clubs has a value of 4
Three of Clubs has a value of 3

Why is my nested loop only picking up some items?

I'm trying to get the loop to go through all suits then all of the card numbers to create a deck of cards but it seems to be pulling alternating values. I have the range set at the bottom as 26 because I was getting out of range errors going any higher.
import random
# actual deck creation using Card class
class Deck:
def __init__(self):
suits = ["Spades", "Clubs", "Hearts", "Diamonds"]
numbers = {"two": ["Two", 2], "three": ["Three", 3], "four": ["Four", 4], "five": ["Five", 5],
"six": ["Six", 6],
"seven": ["Seven", 7], "eight": ["Eight", 8], "nine": ["Nine", 9], "ten": ["Ten", 10],
"jack": ["Jack", 10], "queen": ["Queen", 10], "king": ["King", 10], "ace": ["Ace", 1]}
self.cards = []
for suit in suits:
for number in numbers.values():
self.cards.append(Card(suit, number))
def shuffledeck(self):
random.shuffle(self.cards)
return self.cards
def cleardeck(self):
self.cards = []
return self.cards
class Card:
def __init__(self, suit, value):
self.suit = suit
self.value = value
# card print statement
def __str__(self):
return self.value + " of " + self.suit
class Game:
def __init__(self):
self.deck = []
def play(self):
self.deck = Deck()
#self.deck.shuffledeck()
game = Game()
game.play()
#testing area
blah = []
for i in range(26):
card = (game.deck.cards.pop(i))
print(card.suit)
blah.append(card.value)
print(str(blah))

You are popping an item at a specific index, while increasing the index; this will not exhaust all the items in game.deck.cards. Try instead, for example,
for i in range(52):
card = (game.deck.cards.pop())
Or pop(0) if you want to preserve the order, although this is said to be slower than pop(). If you really don't need to empty game.deck.cards, then the following might be simpler:
for card in game.deck.cards:
print(card.suit)
blah.append(card.value)

Is there a way to sort objects created through classes that is made up of both strings and integers in Python?

I have an assignment to create a deck of cards through the use of a class with methods that deal, shuffle, fan, order and checks if the deck is in order but I am having trouble creating the last one. The deck must be ordered by their values in each suit, and the suits ordered as Clubs, Diamonds, Hearts, and then Spades. My code up to this point is found below:
import random
class Card():
def __init__(self, value, suit):
self.value = value
self.suit = suit
def show_card(self):
print(str(self.value)+ " of " + str(self.suit))
class Deck():
deck_of_cards = []
cards_in_play = []
draw_card = None
def __init__(self):
self.make_deck()
def make_deck(self):
for suit in ['Clubs', 'Diamonds', 'Hearts', 'Spades']:
for value in [2, 3, 4, 5, 6, 7, 8, 9, 10, 'Jack', 'Queen', 'King', 'Ace']:
self.deck_of_cards.append(Card(value,suit))
self.cards_in_play.append(Card(value, suit))
def shuffle(self):
self.shuffled_deck = random.shuffle(self.cards_in_play)
def fan(self):
for card in self.cards_in_play:
card.show_card()
def deal(self):
draw_card=self.cards_in_play.pop()
draw_card.show_card()
def order(self):
for suit in ['Club', 'Diamonds', 'Hearts', 'Spades']:
for value in [2, 3, 4, 5, 6, 7, 8, 9, 10, 'Jack', 'Queen', 'King', 'Ace']:
self.deck_of_cards.append(Card(value, suit))
self.cards_in_play.append(Card(value, suit))

Some code fixes before we go on:
Universalize the suits and values list so that it can be used by all classes if needed.
Move deck_of_cards and cards_in_play inside the __init__ function. If you do not, this is called a "class attribute" and will make it so every class has that value if not initialized (likely something you do not intend).
class Test:
a = 10
t1 = Test
t2 = Test
t1.a = 11
print(t2.a) # >>> 11
random.shuffle() is a function that runs in place. In other words, it returns None, but modifies the list given to it.
import random
l = ["a", "b", "c"]
print(random.shuffle(l)) # >>> None
print(l) # >>> [b, c, a]
Don't print things -- return them. It will make your code not only clearer, but also more useful. If you want to print something that a function returns, just simply print the return.
def deal(self):
draw_card = self.cards_in_play.pop()
return draw_card
Familiarize yourself with sort and the __lt__ (detail below).
import random
suits = ['Clubs', 'Diamonds', 'Hearts', 'Spades']
values = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'Jack', 'Queen', 'King', 'Ace']
class Card:
def __init__(self, value, suit):
self.suit = suit
self.value = value
def __lt__(self, other):
if suits.index(self.suit) > suits.index(other.suit):
return False
if values.index(self.value) > values.index(other.value):
return False
return True
def __repr__(self):
return f"{self.value} of {self.suit}"
class Deck:
def __init__(self):
self.deck_of_cards = []
self.cards_in_play = []
self.make_deck()
def make_deck(self):
for suit in suits:
for value in values:
self.deck_of_cards.append(Card(value,suit))
self.cards_in_play.append(Card(value, suit))
def shuffle(self):
random.shuffle(self.cards_in_play)
def fan(self):
for card in self.cards_in_play:
print(card)
def deal(self):
draw_card = self.cards_in_play.pop()
return draw_card
def order(self):
self.cards_in_play.sort()
def __repr__(self):
return repr(self.cards_in_play)
Utilizing the magic method __lt__ (less than), we can use the function sort to automatically sort a class. To make the point more clear, notice the following:
# Your new `order` function.
def order(self):
self.cards_in_play.sort()
# Implementing __lt__ now allows us to do the following comparison (which is what sort will use to sort your list of Card objects):
print(Card("Clubs", 2) > Card("Clubs", 3)) # True
# If you notice on docs, __ge__ (greater than), __eq__ (equal than), etc. can also be implemented to give you full flexibility.
Notice I also added the __repr__ function to both Deck and Card so that you can instead more simply do:
card = Card("Clubs", 2)
print(card) # >>> 2 of Clubs
Edit: #Discussion below.
suits = ['Clubs', 'Diamonds', 'Hearts', 'Spades']
values = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'Jack', 'Queen', 'King', 'Ace']
class Card:
def __init__(self, value, suit):
self.suit = suit
self.value = value
def __lt__(self, other):
if suits.index(self.suit) > suits.index(other.suit):
return False
if values.index(self.value) > values.index(other.value):
return False
return True
def __eq__(self, other):
if self.suit == other.suit and self.value == other.value:
return True
else:
return False
def __repr__(self):
return f"{self.value} of {self.suit}"
With the new __eq__ method, we can use the == sign between classes.
c1 = Card(2, "Clubs")
c2 = Card(2, "Diamonds")
c3 = Card(2, "Diamonds")
print(c1 == c2) # False
print(c1 > c2) # False
print(c1 < c2) # True
print(c2 == c3) # True
This allows us to compare the Cards with ease.

You can initialize your Card class as follows:
values = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'Jack', 'Queen', 'King', 'Ace']
suits = ['Clubs', 'Diamonds', 'Hearts', 'Spades']
class Card:
def __init__(self, value, suit):
self.suit = suit
self.value = value
#if value order matters in first place
self.rank = 4*values.index(self.value) + suits.index(self.suit)
#else
self.rank = 13*suits.index(self.suit) + values.index(self.value)
and create the check function as follows:
class Deck:
def check(self):
rank_before = self.cards_in_play[0].rank
for card in self.cards_in_play[1:]:
rank = card.rank
if rank > rank_before:
rank_before = rank
else:
return False
return True

The canonical way to handle this is to realize that you have two identities for the card: its play value and its display value. You need a simple cognate to the __repr__ function.
Very simply, value value with a simple rank integer, card_rank, 0-12. The display value, what you print any time a human refers to it, is handled with a trivial translation list:
print_value = (
'2', '3', '4', '5', '6', '7', '8', '9', '10',
'Jack', 'Queen', 'King', 'Ace'
)
Whenever you need to output a value, you simply use print_value[card_rank]. Put this into the __repr__ function of your Card class.
With this partitioning of functionality, sorting by card_rank solves your problem without further ado.

Python random shuffle not working in my even though it should

Hello guys first time posting here.
I have a problem i cant explain. I am trying to replicate poker but my deck shuffle function isnt working
First my code
class Start(object):
openCards = []
def __init__(self, numofplayer):
print("started")
finished = False
self.deck = Deck()
self.deck.shuffle()
for card in self.deck:
card.isshowing = True
print(card)
self.players = []
i = 0
while i < numofplayer:
player = Player()
self.players.append(player)
i = i + 1
class Deck(list):
def __init__(self):
self.cards = []
suits = ["Herz", "Piek", "Karo", "Kreuz"]
values = {
"zwei": 2,
"drei": 3,
"vier": 4,
"fünf": 5,
"sechs": 6,
"sieben": 7,
"acht": 8,
"neun": 9,
"zehn": 10,
"bube": 11,
"dame": 12,
"könig": 13,
"ass": 14
}
for value in values:
for suit in suits:
self.cards.append(Card(value, suit))
def shuffle(self):
random.shuffle(self)
print("Karten gemischt")
def __repr__(self):
cardsleft = len(self.cards)
return "Es sind noch {0} karten übrig".format(cardsleft)
def deal(self):
return self.cards.pop(0)
Ok so my problem at self.deck.shuffle() as i think this should randomize the order of my deck but if i take a look at the variable in debug mode its still in ist standard order. why?

As everyone is saying, you probably don't want to inherit from list if your cards are defined as a list within your class.
import random
class Card:
def __init__(self, value, suit):
self.suit = suit
self.value = value
def __repr__(self):
return f'{self.value} von {self.suit}'
class Start:
openCards = []
def __init__(self, numofplayer):
self.deck = Deck()
self.deck.shuffle()
# here we iterate through the cards rather than the deck object
for card in self.deck.cards:
card.isshowing = True
print(card)
self.players = []
class Deck():
def __init__(self):
self.cards = []
suits = ["Herz", "Piek", "Karo", "Kreuz"]
values = {
"zwei": 2,
"drei": 3,
"vier": 4,
"fünf": 5,
"sechs": 6,
"sieben": 7,
"acht": 8,
"neun": 9,
"zehn": 10,
"bube": 11,
"dame": 12,
"könig": 13,
"ass": 14
}
for value in values:
for suit in suits:
self.cards.append(Card(value, suit))
def shuffle(self):
# we also shuffle the cards sins that's what they're assigned to
random.shuffle(self.cards)
print("Karten gemischt")
def __repr__(self):
# we also show the length of the cards
cardsleft = len(self.cards)
return "Es sind noch {0} karten übrig".format(cardsleft)
Start(5)
If you really want to inherit from list you can do it like so.
import random
class Card:
def __init__(self, value, suit):
self.suit = suit
self.value = value
def __repr__(self):
return f'{self.value} von {self.suit}'
class Start:
openCards = []
def __init__(self, numofplayer):
self.deck = Deck()
self.deck.shuffle()
# inheriting from list allows you to iterate through the deck object
# since it inherits a __next__ method from list
for card in self.deck:
card.isshowing = True
print(card)
self.players = []
class Deck(list):
def __init__(self):
# we send a super call to lists constructor
super().__init__()
suits = ["Herz", "Piek", "Karo", "Kreuz"]
values = {
"zwei": 2,
"drei": 3,
"vier": 4,
"fünf": 5,
"sechs": 6,
"sieben": 7,
"acht": 8,
"neun": 9,
"zehn": 10,
"bube": 11,
"dame": 12,
"könig": 13,
"ass": 14
}
for value in values:
for suit in suits:
# here we simply use the append method we inherited from list
self.append(Card(value, suit))
def shuffle(self):
# doing it this way allows us to shuffle self
random.shuffle(self)
print("Karten gemischt")
def __repr__(self):
# we also need to show the length of self
cardsleft = len(self)
return "Es sind noch {0} karten übrig".format(cardsleft)
Start(5)

How to print the Value in hand in game of BlackJack

In the BlackJack game, I am trying to catch the summation of the cards' values in hand and print the same. I want to know about the mistake in my code keeping the same logic that I am working with.
I am returning a Tuple from the init_deal() method of the Deck class and calling the same in the next class i.e Hand. Inside add() function of Hand class, I am trying to sum up the values of the Cards to calculate the total value in hand.
import random
suits = ('Hearts', 'Diamonds', 'Spades', 'Clubs')
ranks = ('Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine',
'Ten', 'Jack', 'Queen', 'King', 'Ace')
values = {'Two':2, 'Three':3, 'Four':4, 'Five':5, 'Six':6, 'Seven':7,
'Eight':8, 'Nine':9, 'Ten':10, 'Jack':10, 'Queen':10, 'King':10, 'Ace':11}
class Card:
def __init__(self,suit,rank):
self.suit= suit
self.rank= rank
def __str__(self):
return (f'{self.rank} of {self.suit}')
class Deck:
def __init__(self):
self.deck=[]
self.computer=[]
self.player=[]
for suit in suits:
for rank in ranks:
self.deck.append(Card(suit,rank))
def init_deal(self):
count=1
while count<5:
if count%2==0:
comp=self.deck.pop()
self.computer.append(comp)
count+=1
elif count%2!=0:
playr=self.deck.pop()
self.player.append(playr)
count+=1
else:
break
return (self.computer,self.player)
class Hand(Deck):
def __init__(self):
self.hand=Deck().init_deal()
self.hand_com=self.hand[0]
self.hand_playr=self.hand[1]
self.value_comp = 0
self.value_player = 0
self.val_comp=''
self.val_player=''
self.aces = 0
def add(self):
self.val_comp=' '.join(val.split()[0] for val in self.hand_com)
self.val_player=' '.join(val.split()[0] for val in self.hand_playr)
self.val_comp_lst=self.val_comp.split()
self.val_player_lst=self.val_player.split()
print(self.val_comp_lst)
print(self.val_player_lst)
for val in self.val_comp_lst:
self.value_comp += values[val]
for val in self.val_player_lst:
self.value_player += values[val]
return (self.val_comp,self.val_player)
print(self.value_comp)
print(self.value_player)
def __str__():
pass #Some logic here
x=Deck()
x.init_deal()
y=Hand(x)
y.add()
Lets assume
Deck().init_deal()
returns
(['Two of Hearts','Eight of Diamonds'],['Five of Spades','Six of Diamonds'])
So as per my code's expected result:
self.hand_com=['Two of Hearts','Eight of Diamonds']
self.hand_playr=['Five of Spades','Six of Diamonds']
val_comp_lst=['Two','Eight']
val_player_lst=['Five','Six']
So the ultimate expected result (which actually I am unable to print):
self.value_comp = 10
self.value_player = 11
But now if I run the code I am getting an error as "AttributeError: 'Card' object has no attribute 'split'"
Please help me to understand the mistake I am doing in this code

You could have a dictionary that you use to map the word to the numeric value and then use a list comp and sum to sum up those values:
val_comp_lst=['Two','Eight']
nums = {'One': 1, 'Two': 2 ...}
sum([nums[x] for x in val_comp_lst])

It's probably easiest to add a value property to Card.
class Card:
_values = {1: 11, 11: 10, 12: 10, 13: 10}
def __init__(self, suit, rank):
self.suit= suit
self.rank= rank
def __str__(self):
return (f'{self.rank} of {self.suit}')
#property
def value(self):
# returns the value from _values, or the rank of the card
return self._values.get(self.rank, self.rank)
Then sum the value of the cards in the hand. However be aware that aces are counted as either 11 or 1, so you might have to fudge with those numbers afterwards!
An aside: I'm confused on your class structure. You write class Hand(Deck), but that implies that a Hand is a Deck, which seems unlikely. Are you sure this is what you want?