How to perform a while loop without setting a range in Python 3?

As I understand the problem, you don't really need to store all of the previous values, just to sum them up until the current value. Besides, the difference between the values of consecutive iterations is always the last value itself (at iteration n you just add the last value to the sum), Therefore it is sufficient to check if the absolute value of the last iteration is smaller than the threshold. Finally, you don't really need to limit your self to any value of N, as this is an infinite series, and this is definitely not a production code. (This is why using While True is suitable, although it is not considered as best practice). All these conclusions are leading to the following modified code:

def pi():
    result = 0  # holds the sum until the current iteration
    k = 0
    while True:
        a = 4 * (-((-1)**(k+1))*(1/(2*k+1)))
        result += a
        if abs(a) < 0.00000000005:
            return result

        k += 1

You can try defining your own class instead of range. As per your question on how to implement with no modules or library.

class Range(object):
  def __init__(self, last, first=0):
    self.first = first
    self.last = last

  def advance(self):
    self.first +=1

  def __next__(self):
    if self.first == self.last:
      raise StopIteration
    else:
      answer = self.first
      self.advance()
      return answer

  def __iter__(self):
    return self

def pi(n):
  # when you use arrays they take up lot of space in ram, as the list increases
  sum_ = 0
  prev = 0
  present = 0
  diff = 0
  while abs(diff) <= 0.00000000005:
    try:
      range_obj = Range(n)
      k = next(range_obj) # getting the first value
      while k < n:
        if k==0:
          sum_ += -((-1)**(k+1))*(1/(2*k+1))
          prev = 4 * sum_
        else:
          sum_ += -((-1)**(k+1))*(1/(2*k+1))
          present = 4*sum_
          diff = present - prev
        print("k value", k)
        print(diff)
        k = next(range_obj)
    except StopIteration:
      pass
  if present:
    # where k>0
    return present
  else:
    # only one value k = 0 
    return prev


print("final", pi(10))

The itertools module provides a number of types and functions for working with infinite series.

from itertools import count, accumulate, cycle
from operator import truediv

def pi(tol):
    last = 0
    for current in accumulate(map(truediv, cycle([4, -4]), count(1, 2))):
        if abs(current - last) < tol:
            return last
        last = current

You start with a series of fractions whose numerators alternate between 1 and -1 (4 and -4 if you account for multiplication by 4 immediately) and whose denominators are the odd natural numbers.

4/1, -4/3, 4/5, -4/7, ...

The approximations of pi are the partial sums of series.

4/1 = 4
4/1 - 4/3 = 2.666666...
4/1 - 4/3 + 4/5 = 3.46666...
4/1 - 4/3 + 4/5 - 4/7 = 2.8952380...

This series is known to converge slowly. On my machine, I see the following increase in running times:

pi(0.0000005)  # ~2 seconds
pi(0.00000005)  # ~7 seconds
pi(0.000000005)  # ~60 seconds
pi(0.0000000005) # ~660 seconds
pi(0.00000000005)  # ???, estimated 100 minutes

At this rate, I wouldn't hold my breath waiting for pi(0.00000000005) to complete.