# Constructor problem

Larry Bates lbates at syscononline.com
Fri Oct 29 00:16:02 CEST 2004

```Nick wrote:
> I'm writing a simple class to represent a deck of cards. Here is the
> stripped down version. Notice classes Deck and Deck2. Class Deck works,
> Deck2 does not. My thinking is that it should be more efficient (a la
> Deck2) to pre-create the list, and then modify it, rather than appending
> Cards as in Deck.
>
> # --------------------snip--------------
> class Card:
>     def __init__(self, rank=0, suit=0):
>         self.rank=rank
>         self.suit=suit
>
>     def __repr__(self):
>         r = "A23456789TJQK"[self.rank]
>         s = "SHCD"[self.suit]
>         return r+s
>
>
> class Deck:
>     def __init__(self):
>         self.deck = []
>         for r in range(13):
>             for s in range(4):
>                 self.deck.append(Card(r,s))
>
> class Deck2:
>     def __init__(self):
>         self.deck = 52 * [Card()]
>         n = 0
>         for r in range(13):
>             for s in range(4):
>                 self.deck[n].rank = r
>                 self.deck[n].suit = s
>                 n = n + 1
>
>
> a = Deck()
> print "A --> ", a.deck
> b = Deck2()
> print "B --> ", b.deck
> # ------------snap---------------------
>
> Deck A looks right, 52 cards, one of each. Deck B, on the other hand, is
> 52 of the same card, all rank 12, suit 3.
>
> What am I missing???
>
> Thanks!
> Nick.

self.deck = 52 * [Card()]

Problem is with this line.  It doesn't do what you want.

Try this from interpreter prompt:

class card:
pass

deck=52*[card()]
id(deck[0])
id(deck[1])
...

You will notice that all 52 entries in the list point
to the same instance of the card class.

As far as performance is concerned you are doing what
is commonly called as premature optimization.  I set
up a loop and complete deck creation takes only 0.00015
seconds (that's 0.15 milliseconds) on my machine.  I
wouldn't worry about optimizing this part of the program.

-Larry

```