Golfed square root v2

# More efficient, 58 bytes (+ function name)

def square_root(x,i):
 v=x
 while(v*v-x)*i:v=v/2+x/v/2;i-=1
 return v

# Inefficient, 51 bytes (+ function name)

def square_root_b(x,i):
 v=x
 while i:v=v/2+x/v/2;i-=1
 return v

# Lambda oneliner, 87 bytes (+ function name)

square_root_c=lambda x,i:(lambda f,*a:f(f,*a))(lambda f,v,x,i:f(f,v/2+x/v/2,x,i-1)if i else v,x,x,i)

# Benchmark

import time, math, sys
sys.setrecursionlimit(100000)
size = 10000
r = range(1, size + 1)
a = [0] * (size + 1)
b = [0] * (size + 1)
c = [0] * (size + 1)
# Processor warmup
print("Warming up...", end = "")
for i in range(1, 10001):
    square_root(i, 1000)
    square_root_b(i, 1000)
    square_root_c(i, 1000)
    if i % 100 == 1:
        print("\rWarming up... %s%%" % (i // 100 + 1), end="")
print("\rWarming up... Done")
# Efficient method
print("Benchmarking efficient method... ", end = "")
time_a = time.perf_counter()
for i in r:
    a[i] = square_root(i, 1000)
time_b = time.perf_counter()
print("Done")
# Inefficient method
print("Benchmarking inefficient method... ", end = "")
time_c = time.perf_counter()
for i in r:
    b[i] = square_root_b(i, 1000)
time_d = time.perf_counter()
print("Done")
# Inefficient method
print("Benchmarking lambda oneliner... ", end = "")
time_e = time.perf_counter()
for i in r:
    c[i] = square_root_c(i, 1000)
time_f = time.perf_counter()
print("Done")
# Result
err_a = err_b = err_c = 0
for i in r:
    err_a += abs(a[i] - math.sqrt(i))
    err_b += abs(b[i] - math.sqrt(i))
    err_c += abs(c[i] - math.sqrt(i))
print("Efficient method:   %d roots in %.3fms, total error %.8f" % (size, (time_b - time_a) * 1000, err_a))
print("Inefficient method: %d roots in %.3fms, total error %.8f" % (size, (time_d - time_c) * 1000, err_b))
print("Lambda oneliner:    %d roots in %.3fms, total error %.8f" % (size, (time_f - time_e) * 1000, err_c))