Blackjack / 21 in Python3
It's hard to make small tweaks to this code to make it do what you want, so I'm going to give some pointers on how to do a wholesale rewrite.
Before you can write a card game, you need to write a data model for a deck of cards.  Picking the right data model makes everything else easy (part of why your program was hard to write and is hard to fix that the cards were modeled in a way that didn't make the rest of the program easy).  Here's how I'd do it:
from enum import auto, Enum
from random import shuffle
from typing import List, NamedTuple

class Rank(Enum):
    ACE = 1
    TWO = 2
    THREE = 3
    FOUR = 4
    FIVE = 5
    SIX = 6
    SEVEN = 7
    EIGHT = 8
    NINE = 9
    TEN = 10
    JACK = 10
    QUEEN = 10
    KING = 10

class Suit(Enum):
    SPADES = auto()
    CLUBS = auto()
    DIAMONDS = auto()
    HEARTS = auto()

class Card(NamedTuple):
    rank: Rank
    suit: Suit
    def __repr__(self) -&gt; str:
        &quot;&quot;&quot;Pretty-print the name of the card, e.g. 'Queen of Hearts'&quot;&quot;&quot;
        return f&quot;{self.rank.name.title()} of {self.suit.name.title()}&quot;

There's my Card class -- every card has a rank and suit.  Enums have the convenient built-in functions name and value that I can use for pretty-printing and also for scoring (I set the value of my Rank enum to correspond to standard scoring numbers).
A NamedTuple is an easy way to build a class that contains multiple other values that never change; it automatically implements a constructor to set its member variables and in many cases you don't need to do anything other than declare what those variables are, but you can also add other methods to it.  My Card implements a magic __repr__ function so that anywhere we print one (including inside a list) it will get formatted as something like Queen of Hearts rather than the default NamedTuple formatting of Card(rank=Rank.QUEEN, suit=Suit.HEARTS).
And here's a really quick example of how you could use this class to implement a game like blackjack.  This isn't an actual blackjack game, I've just implemented the dealer part to demonstrate how building a deck, shuffling, and dealing would work, but hopefully you can play with this code and see how simple everything is when you have a nice data model.  In particular something like the best_value function is going to be really important to a blackjack game (and it's a lot easier to define it as its own function and then be able to call it in a bunch of places).
deck = [Card(rank, suit) for suit in Suit for rank in Rank]
print(&quot;Here's our deck fresh from the factory: &quot;, deck)
shuffle(deck)
print(&quot;Here it is all shuffled: &quot;, deck)

def best_value(hand: List[Card]) -&gt; int:
    &quot;&quot;&quot;Get the best blackjack value for a hand of cards (highest without busting)&quot;&quot;&quot;
    value = sum([card.rank.value for card in hand])
    if value &lt; 12 and any([card.rank == Rank.ACE for card in hand]):
        # Count one of our aces as 11, adding 10 to the total.
        value += 10
    return value

print()
print(&quot;Deal me two!&quot;)
hand = [deck.pop(), deck.pop()]
print(f&quot;My hand is {hand}, which is worth {best_value(hand)}&quot;)

while best_value(hand) &lt; 17:
    print(&quot;Hit me!&quot;)
    card = deck.pop()
    hand.append(card)
    print(&quot;I got &quot;, card)

if best_value(hand) &gt; 21:
    print(&quot;Bust!&quot;)
print(f&quot;{hand} = {best_value(hand)}&quot;)

Run this code, read through it, understand how it works, then take another crack at writing a blackjack program and hopefully it'll be easier this time around.  :)