I am writing a program that computes

$$n-n \cdot \left(\prod_{i=1}^n (1-p_i)\right)$$

which is rewritten in my code as:
    
$$\left(1-\left(\prod_{i=1}^n(1-p_i)\right)\right) \cdot n$$

There are lots of primes involved here especially as \$n\$ gets larger and larger. I do not want to use Atkin's method for generating them since my teacher and I will probably lose oversight as to what is going on, but would still like to optimize my algorithm for speed and accuracy (not sure if the latter can be better).



    i = 0
    j = 3
    old = 1.0
    primes = [2]
    while True:
	    if (j>240000): break
	    cont = True
	    enumerator = 0
	    for e in primes:
		    if j%e==0: cont = False
		    if enumerator>=len(primes)/2 + 1: break
		    enumerator += 1
	    if cont: primes.append(j)	
	    j+=2
    #print primes

    while True:
	    if (i>len(primes)-1): break
	    old = old * (1 - 1.0/primes[i])
	    print old
	    i+=1;
    primeslessthan = j-1
    amta = 1-old

    print "The convergence: " + str(primeslessthan)
    print "All the way up to the number: " + str(amta)
    print "The amount of active inhibitors are: " + str((1-amta)*primeslessthan)

I am open to multithreading, and to translating this to a different language like C++, but do not know what optimizations I could make there either.