Jak wygenerować wykładniczo rosnący zakres w Pythonie

Question

Chcę przetestować wydajność niektórych kodu przy użyciu wykładniczo rosnącej wartości. W związku z tym, że dodatkowa cyfra jest dodawana do numbers_size, przyrost jest mnożony przez 10. Tak to robię do tej pory, ale wygląda trochę na hakera. Sugestie dotyczące ulepszeń bez wprowadzania niestandardowych bibliotek?

numbers_size = 100 
increment = 100 
numbers_range = 1000000000 
while numbers_size < numbers_range: 
    t = time.time() 
    test(numbers_size) 
    taken_t = time.time() - t 
    print numbers_size, test, taken_t 

    increment = 10 ** (len(str(numbers_size))-1) 
    numbers_size += increment 

Answer 1

Aby wygenerować te same numery co Twój kod:

numbers_sizes = (i*10**exp for exp in range(2, 9) for i in range(1, 10)) 
for n in numbers_sizes: 
    test(n) 

Answer 2

przykładem 'nie czyta pytanie poprawnie' i 'NIE jak to zrobić'

for i in xrange(100, 1000000000, 100): 
    # timer 
    test(i) 
    # whatever 

jest tak proste, jak to się robi ... xrange dostosować odpowiednio

Answer 3

Najprostszą rzeczą do zrobienia jest użycie liniowej sekwencji wykładników:

for e in range(1, 90): 
    i = int(10**(e/10.0)) 
    test(i) 

Można streszczenie sekwencja do własnego generatora:

def exponent_range(max, nsteps): 
    max_e = math.log10(max) 
    for e in xrange(1, nsteps+1): 
     yield int(10**(e*max_e/nsteps)) 

for i in exponent_range(10**9, nsteps=100): 
    test(i) 

Answer 4

Dlaczego nie

for exponent in range(2, 10): 
    test(10 ** exponent) 

jeśli czytam intencję prawo.

Answer 5

Korzystanie wyrażenie prądotwórcze:

max_exponent = 100 
for i in (10**n for n in xrange(1, max_exponent)): 
    test(i) 

Answer 6

lubię odpowiedź Ned Batcheldor, ale chciałbym zrobić to nieco bardziej ogólnie:

def exp_range(start, end, mul): 
    while start < end: 
     yield start 
     start *= mul 

następnie kod staje

for sz in exp_range(100, 1000000000, 10): 
    t = time.time() 
    test(sz) 
    print sz, test(sz), time.time()-t 

Answer 7

Jeśli uważasz numpy za jeden ze standardów;), możesz użyć numpy.logspace, ponieważ właśnie to dokładnie powinno ... (uwaga: 100 = 10^2, 1000000000 = 10^9)

for n in numpy.logspace(2,9,num=9-2, endpoint=False): 
    test(n) 

Przykład 2 (uwaga: 100 = 10^2, 1000000000 = 10^9, chcesz iść na etapie 10x, to jest 9-2 + 1 punktów ...):

In[14]: np.logspace(2,9,num=9-2+1,base=10,dtype='int') 
Out[14]: 
array([  100,  1000,  10000,  100000, 1000000, 
     10000000, 100000000, 1000000000]) 

przykład 3:

In[10]: np.logspace(2,9,dtype='int') 
Out[10]: 
array([  100,  138,  193,  268,  372, 
       517,  719,  1000,  1389,  1930, 
      2682,  3727,  5179,  7196,  10000, 
      13894,  19306,  26826,  37275,  51794, 
      71968,  100000,  138949,  193069,  268269, 
      372759,  517947,  719685, 1000000, 1389495, 
      1930697, 2682695, 3727593, 5179474, 7196856, 
     10000000, 13894954, 19306977, 26826957, 37275937, 
     51794746, 71968567, 100000000, 138949549, 193069772, 
     268269579, 372759372, 517947467, 719685673, 1000000000]) 

w Twojej sprawie używamy endpoint=False, ponieważ nie chcesz uwzględniać punktu końcowego ... (np. np.logspace(2,9,num=9-2, endpoint=False))