Nathan Pinno said unto the world upon 2005-08-09 15:35:
> Hey all,
>
> I just fixed it so that it prints. The problem was that it returned the
> cards instead of printing them.
>
> Nathan
>
>> Hey Brian and all,
>>
>> Just coded in and tried your program Brian. Doesn't print a thing.
>>
Hi Nathan,
yes, I should have pointed out that I made it return the cards dealt
rather than printing them and explained why I made it do that. But, I
just did it out of force of habit, so I didn't notice I'd changed the
functionality. Sorry about that.
So, why do that? Well, it might not matter too much in this case, but
the idea is to make each function responsible for one thing. That has
several advantages. The two main ones IMO: 1) it keeps the functions
small which aids comprehension and debugging, and 2) it makes the
functions easier to string together to do other things.
For instance, if what you want right now is for the cards to be
printed, it is easy enough to use something like my code[*] and then
have another function which calls the dealing function and prints the
results. If later you should want to use the results of a deal in a
more elaborate manner than just printing them (like if you make a card
game which needs to know what was dealt) you've got the deal returned
and you can do with it what you want to. If you don't return and just
print from the sort of code I gave, new uses will probably require
changing the code rather than just adding new function to work with it.
One approach would say don't add it now; instead do the minimal thing
that meets your needs because just thinking you will need it later
doesn't mean you will. But, in the case at hand, the future need is
pretty likely, and the modularity of functions (one chunk doing the
generation, the other doing the processing of the results) also speaks
for doing it the return way.
[*] But don't use my code. I was doing by hand what Roel pointed out
can be done by the random module itself. (Thanks, Roel! I didn't know
about random.sample.) Since whoever added sample to random is a better
programmer than you or I, use sample :-)
>> I thought the odds were more like 6/52! or 1/(1.3443029195*10^84).
<snip>
>>> Good question. But notice that your code has the same problem. Nothing
>>> stops the (dramatically unlikely) even that a-u all get assigned the
>>> same
>>> card. Over 6 cards, it will certainly turn up that you have given the
>>> same
>>> card twice with this code, too. (The way I figure it:
>>>
>>> >>> ( (52**6) - (52*51*50*49*48*47.0) ) / (52**6)
>>> 0.25858966166881681
>>>
>>> 25% of the time.)
I don't think I got the math wrong. My thinking is there are 52**6
ways to choose 6 items from 52 if you don't care about duplicates, and
52*51*50*49*48*47 ways to choose if you do. (The first card can be any
one of 52, the second any one of the 51 left, etc. 52! by contrast
gives you all the ways 52 items can be ordered in a non-repeating
sequence.)
Here is a very quick (and I am sure not too efficient) bit of code to
give empirical support to my analysis:
<code>
import random
def get_choice(n, source):
'''Returns a sequence of n independent random choices from source'''
choice = []
for i in range(n):
choice.append(random.choice(source))
return choice
def has_dups(sequence):
'''Returns True if sequence contains duplicates, False otherwise'''
for i in sequence[:-1]:
# No point checking the last member
if sequence.count(i) > 1:
# We can bail, as duplicate found
return True
return False
def get_dup_percentage(runs, choice_length, source_length):
'''Returns percentage of duplicates in a series of choices over a
sequence.
The function make runs many choices of length choice_length from
a sequence
of length source_length and returns percentage of those choices that
contain duplication.'''
count = 0.0 # 0.0 for type coercion
dups = 0
source_sequence = range(source_length)
while count < runs:
choice_sequence = get_choice(choice_length, source_sequence)
if has_dups(choice_sequence):
dups += 1
count += 1
return dups / count * 100
print get_dup_percentage(100000, 6, 52)
</code>
Run that and I think you will find the values cluster around 25.85%.
(The code was written to be general. Play around with the values in
the final [print] line. I get that 9 choices are enough over a 52
termed sequence to give you more than 50% odds of duplicates.)
Best,
Brian vdB
_______________________________________________
Tutor maillist - Tutor@python.org
http://mail.python.org/mailman/listinfo/tutor
