def Prime(x):
  n=2
  if x > 972: #My upper limit is 972 and my lower limit is x,  
      print "end"        #how do I make the upper limit a function of x
  elif x == 1:                # when I have to recur Prime(x+1)?
    Prime(x+1)
  elif x == 2:
    print (2)
    Prime(x+1) 
  elif x <= 0:
    print ("Number must be a positive integer")
  else:
    while n < n+1:
      if n > int(x/n):
        print(x)
        break
      elif x%n==0:
        break
      else:
        n=n+1
    Prime(x+1)

def Prime(x,y):
  n=2
  if x == 1:
    Prime(x+1,y)
  elif x == 2:
    print (2)
    Prime(x+1,y)
  elif x <= 0:
    print ("Number must be a positive integer")
  else:
    while n < n+1:
      if n > int(x/n):
        print(x)
        x=x+1
        n=2
      elif x > y:
       print("end")
       break
      elif x%n==0:
        x=x+1
        n=2
      else:
        n=n+1

def fast_primes(n):
    """
    uses an Eratosthenes sieve to return a list of
    prime numbers from 2 to < n
    """
    siv = range(n+1)
    siv[1] = 0
    sqn = int(n**0.5)
    for i in range(2, sqn+1):
        if siv[i] != 0:
            siv[2*i:n//i*i+1:i] = [0]*(n//i-1)
    return filter(None, siv)

def Prime(x,y):
    n=2
    if x == 1:
       Prime(x+1,y)
   elif x == 2:
      print (2)
      Prime(x+1,y)
   elif x <= 0:
      print ("Number must be a positive integer"
   else:
      while n < n+1:     ## <=====

# exploring Python's slicing operator
# can be used with any indexed sequence like strings, lists, ...
# syntax --> seq[begin : end : step]
# step is optional
# defaults are index begin=0, index end=len(seq)-1, step=1
# -begin or -end --> count from the end backwards
# step = -1 reverses sequence
# if you feel lost, put in the defaults in your mind
 
# use a list as a test sequence
a = [0, 1, 2, 3, 4, 5, 6, 7, 8]
 
print( a[3:6] )   # [3,4,5]
# if either index is omitted, beginning or end of sequence is assumed 
print( a[:3] )    # [0,1,2]
print( a[5:] )    # [5,6,7,8]
 
# negative index is taken from the end of the sequence
print( a[2:-2] )  # [2,3,4,5,6]
print( a[-4:] )   # [5,6,7,8]
 
# extract every second element
print( a[::2] )   # [0, 2, 4, 6, 8]
 
# step=-1 will reverse the sequence
print( a[::-1] )  # [8, 7, 6, 5, 4, 3, 2, 1, 0]
 
# no indices just makes a copy (which is sometimes useful)
b = a[:]
print( b )    # [0, 1, 2, 3, 4, 5, 6, 7, 8]
 
# slice in a few elements starting at index 3
b[3:] = [9, 9, 9, 9] + b[3:]
print( a )    # [0, 1, 2, 3, 4, 5, 6, 7, 8]
print( b )    # [0, 1, 2, 9, 9, 9, 9, 3, 4, 5, 6, 7, 8]

print( [0]*5 )  # [0, 0, 0, 0, 0]

# prevents the list of primes from getting too large
# and taxing the computer's memory
# tested with Python2 and Python3  by vegaseat
 
def primes_range(low=2, high=100):
    """
    returns a list of primes in range low to high
    """
    if low == 2:
        prime_list = [2]
    else:
        prime_list = []
    # make sure start is an odd number
    start = low
    if start % 2 == 0:
        start += 1
    # range() needs to do odd numbers only ...
    for n in range(start, high+1, 2):
        prime = True
        for divisor in range(3, int(n**0.5)+1, 2):
            if n % divisor == 0:
                prime = False
                break
        if prime and n >= low:
            prime_list.append(n)
    return prime_list
 
low = 1000000
high = low + 100
print( primes_range(low, high) )
 
"""result for primes_range(1000000, 1000100) -->
[1000003, 1000033, 1000037, 1000039, 1000081, 1000099]
"""
 
print('-'*60)
 
low = 1000000000
high = low + 100
print( primes_range(low, high) )
 
"""result for primes_range(1000000000, 1000000100) -->
[1000000007, 1000000009, 1000000021, 1000000033, 1000000087,
1000000093, 1000000097]
"""
 
print('-'*60)
 
low = 1000000000000
high = low + 100
print( primes_range(low, high) )
 
"""result for primes_range(1000000000000, 1000000000100) -->
Python 2.5.4
[1000000000039L, 1000000000061L, 1000000000063L, 1000000000091L]
Python 3.1.1
[1000000000039, 1000000000061, 1000000000063, 1000000000091]
"""