Speed up this code?

[aomighty]

I'm creating a program to calculate all primes numbers in a range of 0
to n, where n is whatever the user wants it to be. I've worked out the
algorithm and it works perfectly and is pretty fast, but the one thing
seriously slowing down the program is the following code:

def rmlist(original , deletions):
return [i for i in original if i not in deletions]

original will be a list of odd numbers and deletions will be numbers
that are not prime, thus this code will return all items in original
that are not in deletions. For n > 100,000 or so, the program takes a
very long time to run, whereas it's fine for numbers up to 10,000.

Does anybody know a faster way to do this? (finding the difference all
items in list a that are not in list b)?

Thanks,
Martin

[Ben Cartwright]

ao******@gmail. com wrote:

I'm creating a program to calculate all primes numbers in a range of 0
to n, where n is whatever the user wants it to be. I've worked out the
algorithm and it works perfectly and is pretty fast, but the one thing
seriously slowing down the program is the following code:

def rmlist(original , deletions):
return [i for i in original if i not in deletions]

original will be a list of odd numbers and deletions will be numbers
that are not prime, thus this code will return all items in original
that are not in deletions. For n > 100,000 or so, the program takes a
very long time to run, whereas it's fine for numbers up to 10,000.

Does anybody know a faster way to do this? (finding the difference all
items in list a that are not in list b)?

The "in" operator is expensive for lists because Python has to check,
on average, half the items in the list. Use a better data structure...
in this case, a set will do nicely. See the docs:

http://docs.python.org/lib/types-set.html
http://docs.python.org/tut/node7.htm...00000000000000

Oh, and you didn't ask for it, but I'm sure you're going to get a dozen
pet implementations of prime generators from other c.l.py'ers. So
here's mine. :-)

def primes():
"""Generate prime numbers using the sieve of Eratosthenes."" "
yield 2
marks = {}
cur = 3
while True:
skip = marks.pop(cur, None)
if skip is None:
# unmarked number must be prime
yield cur
# mark ahead
marks[cur*cur] = 2*cur
else:
n = cur + skip
while n in marks:
# x already marked as multiple of another prime
n += skip
# first unmarked multiple of this prime
marks[n] = skip
cur += 2

--Ben

[Tim Chase]

> def rmlist(original , deletions):

return [i for i in original if i not in deletions]

original will be a list of odd numbers and deletions will be numbers
that are not prime, thus this code will return all items in original
that are not in deletions. For n > 100,000 or so, the program takes a
very long time to run, whereas it's fine for numbers up to 10,000.

Does anybody know a faster way to do this? (finding the difference all
items in list a that are not in list b)?

Testing for membership in an unsorted list is an O(n) sort of
operation...the larger the list, the longer it takes.

I presume order doesn't matter, or that the results can be sorted
after the fact. If this is the case, it's quite efficient to use
sets which provide intersection/difference/union methods. If you
pass in sets rather than lists, you can simply

return original.differ ence(deletions)

It's almost not worth calling a function for :) There's also an
in-place version called difference_upda te().

Once you've found all the results you want, and done all the set
differences you want, you can just pass the resulting set to a
list and sort it, if sorted results matter.

-tkc

[Paul Rubin]

ao******@gmail. com writes:

Does anybody know a faster way to do this? (finding the difference all
items in list a that are not in list b)?

a = [3, 7, 16, 1, 2, 19, 13, 4, 0, 8] # random.sample(r ange(20),10)
b = [15, 11, 7, 2, 0, 3, 9, 1, 12, 16] # similar
sorted(set(a)-set(b))
[4, 8, 13, 19]

but you probably don't want to use that kind of implementation.

Here's a version using generators:

def sieve_all(n = 100):
# yield all primes up to n
stream = iter(xrange(2, n))
while True:
p = stream.next()
yield p
def s1(p, stream):
# yield all non-multiple of p
return (q for q in stream if q%p != 0)
stream = s1(p, stream)

# print all primes up to 100
print list(sieve_all( 100))

It's cute, but horrendous once you realize what it's doing ;-)

[aomighty]

I got it working using difference() and sets, thanks all! 100,000 takes
about 3 times the time of 10,000, which is what my math buddies told me
I should be getting, rather than an exponential increase :). Thanks,
all!

[Kent Johnson]

ao******@gmail. com wrote:

I'm creating a program to calculate all primes numbers in a range of 0
to n, where n is whatever the user wants it to be. I've worked out the
algorithm and it works perfectly and is pretty fast, but the one thing
seriously slowing down the program is the following code:

def rmlist(original , deletions):
return [i for i in original if i not in deletions]

original will be a list of odd numbers and deletions will be numbers
that are not prime, thus this code will return all items in original
that are not in deletions. For n > 100,000 or so, the program takes a
very long time to run, whereas it's fine for numbers up to 10,000.

Does anybody know a faster way to do this? (finding the difference all
items in list a that are not in list b)?

- Make deletions a set, testing for membership in a set is much faster
than searching a large list.

- Find a better algorithm ;)

Kent

[bearophileHUGS]

If you are interested in such programs, you can take a look at this one
too:
http://aspn.activestate.com/ASPN/Coo.../Recipe/366178

It requires more memory, but it's quite fast.

Bye,
bearophile

[Frank Millman]

be************@ lycos.com wrote:

If you are interested in such programs, you can take a look at this one
too:
http://aspn.activestate.com/ASPN/Coo.../Recipe/366178

It requires more memory, but it's quite fast.

Bye,
bearophile

I compared the speed of this one (A) with the speed of Paul Rubin's
above (B).

Primes from 1 to 100 -
A - 0.000118
B - 0.000007

Primes from 1 to 200 -
A - 0.000224
B - 0.000008

Primes from 1 to 300 -
A - 0.000278
B - 0.000008

Nice one, Paul.

Frank Millman

[Gregory Petrosyan]

# Paul Rubin's version
gregory@home:~$ python -mtimeit "import test2" "test2.primes(1 000)"
100 loops, best of 3: 14.3 msec per loop

# version from the Cookbook
gregory@home:~$ python -mtimeit "import test1" "test1.primes(1 000)"
1000 loops, best of 3: 528 usec per loop

[John Machin]

On 26/05/2006 11:25 PM, Frank Millman wrote:

be************@ lycos.com wrote:

If you are interested in such programs, you can take a look at this one
too:
http://aspn.activestate.com/ASPN/Coo.../Recipe/366178

It requires more memory, but it's quite fast.

Bye,
bearophile

I compared the speed of this one (A) with the speed of Paul Rubin's
above (B).

Primes from 1 to 100 -
A - 0.000118
B - 0.000007

Primes from 1 to 200 -
A - 0.000224
B - 0.000008

Primes from 1 to 300 -
A - 0.000278
B - 0.000008

Nice one, Paul.

Frank Millman

Nice one, Frank.

Go back and read Paul's code. Read what he wrote at the bottom: """It's
cute, but horrendous once you realize what it's doing ;-) """
Pax Heisenberg, it is innately horrendous, whether observers realise it
or not :-)