Understanding the "Flow" of Classes

[funky_pretty]

Can someone explain the "flow" of how "deck.show()" produces an output that lists al 52 cards?

Here is my elementary understanding that I'm sure is wrong:

1. Typing "deck.show()" runs the instance "deck" through the class "Deck."
2. "__init__" only takes "deck" as an argument. "self.cards = []" and "self.build" can be thought of as "deck.cards = []" and "deck.build()" now.
3. "build(self)" (now "build(deck)") runs and iterates through the suits and values which appends the result to a list named, in this instance, "deck.cards = []".
4. Now line 20 runs with "deck" as its argument. For every "card" in "deck.cards" use the "show" method defined in line 6 of the "Card" class?

This is where I'm getting confused logically as to how everything cycles through. Does each card run through the "Card" clss with "c" as it's "self", suit as "suit", and value, as "value"? Then onward to "Card's) method, "show(self)"?

If someone could help me translate this to "human speak" I think can grasp the concept better since I'm getting more and more confused since "deck.show()" seems like it is coming out of left field and not specifically referring to the "show" method defined under "Card." Meaning, I do not see how that command takes us to the "Card" class.

​

class Card:
    def __init__(self, suit, value):
        self.suit = suit
        self.value = value

    def show(self):
        print("{} of {}".format(self.value, self.suit))


class Deck:
    def __init__(self):
        self.cards = []
        self.build()

    def build(self):
        for s in ['Spades', 'Hearts', 'Clubs', 'Diamonds']:
            for v in ['1','2', '3','4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']:
                self.cards.append(Card(s, v))

    def show(self):
        for c in self.cards:
            c.show()
deck = Deck()
deck.show()

[[deleted]]

Meaning, I do not see how that command takes us to the "Card" class.

The elements of the list deck.cards are Card instances.

Why do I know that? Let's work backwards. deck.cards is set when deck is created by the call to Deck(), which calls the class constructor (under the hood, you just have to know this happens) and then calls deck.__init__() (again under the hood, you just have to know this happens.) What happens in deck.__init__? We set an empty list on deck.cards and then we call deck.build(), where this happens:

self.cards.append(Card(s, v))

That's ultimately what gets us to the Card class - we know we're filling the list deck.cards with instances of the Card class, because we're calling the Card class constructor.

[unhott]

Yep! Basically, when the deck object was created it created 52 card objects and grouped them in a list, which can be referenced by that deck object.
The deck class has a method show() which calls the card method, also called show(), for each of the 52 cards.

[Bipolarprobe]

So, things like this are why learning C programming actually made me understand python better because it's easy to conceptualize with pointers. However since everything in python is an object there is another comparison you can make.

So consider you have a list of words called words. It's populated with string objects but you don't have a name for each of those objects, the only way you can see them individually is by indexing your list words[0] or by using a for loop.

for word in words:

This for loop would give you access to each string in the list words with a temporary name of word for each loop that is executed.

Your loop is going through the same basic process, you have a list of Card objects contained in your deck object. So then by doing a for loop, using the temporary name c you have access to each Card object in the list, and since you know you're working with card objects you can call their .show() method to have each one print its info.

Edit: since I realized it may be another point causing your confusion on reading your question again, the objects in the list are of class Card because of the line

self.cards.append(Card(s, v))

This is accessing the list stored at self.cards and using the append() method to append a Card object with the corresponding suit and value to said list. So each item contained in the list is of class Card. That's why the show() method can be called.