如何在 Python 中实现这个 for 循环

Question

Im trying to implement Radix Sort in Python. In the main Radix Sort function there is a for loop like this:

m = Maximum element in a given array
for(p = 1; m/p > 0; p*10)
{
    do stuff;
}

i did implement it using a while loop like below:

p = 1
while m / p > 0:
    p *= 10
    do stuff;

But since for loop is faster than while loop, I wonder how to implement that pseudocode in Python with a for loop. Any suggestions?

Note: Radix Sort uses counting sort to sort based on digits starting from the right most digit (p=1) to the last digit and that's why for loop is used.

Answer 1

Logarithms are probably your answer. Don't be surprised though, if it wants to repeat like 13.0983 times or something. Also, unless m changes values, the while loop will forever run because it never will be 0 (unless there is rounding).

You also could just do:

for i in int((large p number calculated with while loop)/m):
    #code

Answer 2

Edit 1:

So I was curious and implemented the three discussed approches:

import time 
import dis
import math

m = 100
p = 1.0
print(f'm:{m}, p:{p}')

print('-- For range - log')
c = 0
start = time.process_time()
for _ in range(int(math.log10(m))+1):
    c += 1
end = time.process_time() - start
print(f'c: {c}')
print(f'time: {end}')
c = compile('for _ in range(int(math.log10(m))+1):\n\tc += 1', '<string>', 'exec')
dis.dis(c)

print('-- For range - str len')
c = 0
start = time.process_time()
for _ in range(len(str(int(m)))):
    c += 1
end = time.process_time() - start
print(f'c: {c}')
print(f'time: {end}')
c = compile('for _ in range(len(str(int(m)))):\n\tc += 1', '<string>', 'exec')
dis.dis(c)

print('-- While loop')
c = 0
start = time.process_time()
while int(m / p) > 0:
    p *= 10
    c += 1
end = time.process_time() - start
print(f'c: {c}')
print(f'time: {end}')
c = compile('while int(m / p) > 0:\n\tp *= 10\n\tc += 1', '<string>', 'exec')
dis.dis(c)

Which results on my machine to:

  -- For range - log
  c: 3
  time: 7.000000000000062e-06
    1           0 LOAD_NAME                0 (range)
                2 LOAD_NAME                1 (int)
                4 LOAD_NAME                2 (math)
                6 LOAD_METHOD              3 (log10)
                8 LOAD_NAME                4 (m)
               10 CALL_METHOD              1
               12 CALL_FUNCTION            1
               14 LOAD_CONST               0 (1)
               16 BINARY_ADD
               18 CALL_FUNCTION            1
               20 GET_ITER
          >>   22 FOR_ITER                12 (to 36)
               24 STORE_NAME               5 (_)

    2          26 LOAD_NAME                6 (c)
               28 LOAD_CONST               0 (1)
               30 INPLACE_ADD
               32 STORE_NAME               6 (c)
               34 JUMP_ABSOLUTE           22
          >>   36 LOAD_CONST               1 (None)
               38 RETURN_VALUE
  -- For range - str len
  c: 3
  time: 2.9999999999960614e-06
    1           0 LOAD_NAME                0 (range)
                2 LOAD_NAME                1 (len)
                4 LOAD_NAME                2 (str)
                6 LOAD_NAME                3 (int)
                8 LOAD_NAME                4 (m)
               10 CALL_FUNCTION            1
               12 CALL_FUNCTION            1
               14 CALL_FUNCTION            1
               16 CALL_FUNCTION            1
               18 GET_ITER
          >>   20 FOR_ITER                12 (to 34)
               22 STORE_NAME               5 (_)

    2          24 LOAD_NAME                6 (c)
               26 LOAD_CONST               0 (1)
               28 INPLACE_ADD
               30 STORE_NAME               6 (c)
               32 JUMP_ABSOLUTE           20
          >>   34 LOAD_CONST               1 (None)
               36 RETURN_VALUE
  -- While loop
  c: 3
  time: 2.9999999999960614e-06
    1     >>    0 LOAD_NAME                0 (int)
                2 LOAD_NAME                1 (m)
                4 LOAD_NAME                2 (p)
                6 BINARY_TRUE_DIVIDE
                8 CALL_FUNCTION            1
               10 LOAD_CONST               0 (0)
               12 COMPARE_OP               4 (>)
               14 POP_JUMP_IF_FALSE       34

    2          16 LOAD_NAME                2 (p)
               18 LOAD_CONST               1 (10)
               20 INPLACE_MULTIPLY
               22 STORE_NAME               2 (p)

    3          24 LOAD_NAME                3 (c)
               26 LOAD_CONST               2 (1)
               28 INPLACE_ADD
               30 STORE_NAME               3 (c)
               32 JUMP_ABSOLUTE            0
          >>   34 LOAD_CONST               3 (None)
               36 RETURN_VALUE

Seems like the generator approach with string count as opposed to logarithm calculation is the fastes. My intution was that the while loop might be faster than the generator functions. Turns out, its about 3 times slower.

Fascinating.

Original Answer:

I assume the statement that for loops are faster than while loops is an untested hypothesis. So why not test it?

Put your implementations in a timed block:

import time
start = time.process_time()

# your code here    

end = time.process_time() - start
print(end)

Answer 3

Well after doing a research on the loops topic, i found that using a string instead of doing calculation is much faster. It is not the correct answer but it is the fastest implementation in Python.

for _ in range(len(str(m)):
    do stuff