Performance comparison "digits to int" e.g., [1,2,3] -> 123 on pypy

N=10 for-loop performance stats.txt

~ python -m perf timeit --rigorous --duplicate 10 --hist --stats -s $'N=10\ndigits = [d % 10 for d in range(N)]\ndef digits2int(digits):\n n = 0\n for d in digits:\n  n = 10*n + d\n return n' 'digits2int(digits)' 
.............
 89.4 ns:  1 ###
 90.0 ns:  1 ###
 90.7 ns:  3 #########
 91.3 ns:  7 ######################
 92.0 ns:  7 ######################
 92.7 ns: 11 ###################################
 93.3 ns: 15 ###############################################
 94.0 ns: 21 ##################################################################
 94.7 ns: 11 ###################################
 95.3 ns: 12 ######################################
 96.0 ns: 10 ###############################
 96.6 ns:  7 ######################
 97.3 ns:  6 ###################
 98.0 ns:  1 ###
 98.6 ns:  3 #########
 99.3 ns:  1 ###
100.0 ns:  1 ###
  101 ns:  0 |
  101 ns:  1 ###
  102 ns:  0 |
  103 ns:  1 ###

Total duration: 30.4 sec
Start date: 2016-12-21 17:03:05
End date: 2016-12-21 17:03:40
Raw sample minimum: 117 ms
Raw sample maximum: 135 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 1310720 (2^17 outer-loops x 10 inner-loops)

Minimum: 89.4 ns (-5%)
Median +- std dev: 94.5 ns +- 2.2 ns
Mean +- std dev: 94.8 ns +- 2.2 ns
Maximum: 103 ns (+9%)

Median +- std dev: 94.5 ns +- 2.2 ns

N=10 int("".join(map(str,..))) performance stats

~ python -m perf timeit --rigorous --duplicate 10 --hist --stats -s $'N=10\ndigits = [d % 10 for d in range(N)]\nfrom functools import reduce\ndigits2int = lambda digits: int("".join(map(str, digits)))' 'digits2int(digits)'
.............
 732 ns:  7 #########
 749 ns: 55 ###################################################################
 765 ns: 33 ########################################
 781 ns: 11 #############
 798 ns:  7 #########
 814 ns:  4 #####
 830 ns:  0 |
 846 ns:  0 |
 863 ns:  2 ##
 879 ns:  0 |
 895 ns:  0 |
 911 ns:  0 |
 928 ns:  0 |
 944 ns:  0 |
 960 ns:  0 |
 977 ns:  0 |
 993 ns:  0 |
1.01 us:  0 |
1.03 us:  0 |
1.04 us:  0 |
1.06 us:  1 #

Total duration: 31.0 sec
Start date: 2016-12-21 17:04:36
End date: 2016-12-21 17:05:12
Raw sample minimum: 122 ms
Raw sample maximum: 176 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 163840 (2^14 outer-loops x 10 inner-loops)

Minimum: 746 ns (-2%)
Median +- std dev: 764 ns +- 36 ns
Mean +- std dev: 772 ns +- 36 ns
Maximum: 1.07 us (+40%)

Median +- std dev: 764 ns +- 36 ns

N=10 reduce() performance stats.txt

 ~ python -m perf timeit --rigorous --duplicate 10 --hist --stats -s $'N=10\ndigits = [d % 10 for d in range(N)]\nfrom functools import reduce\ndigits2int = lambda digits:reduce(lambda n,d:10*n+d, digits)' 'digits2int(digits)'
.............
467 ns:  6 #####################################
476 ns:  5 ###############################
485 ns:  4 #########################
493 ns:  7 ###########################################
502 ns:  1 ######
511 ns:  9 ########################################################
520 ns: 11 ####################################################################
529 ns:  6 #####################################
538 ns:  5 ###############################
546 ns:  7 ###########################################
555 ns:  4 #########################
564 ns:  7 ###########################################
573 ns:  9 ########################################################
582 ns:  9 ########################################################
590 ns:  5 ###############################
599 ns:  8 #################################################
608 ns:  6 #####################################
617 ns:  6 #####################################
626 ns:  2 ############
634 ns:  2 ############
643 ns:  1 ######

Total duration: 1 min 13.8 sec
Start date: 2016-12-21 16:53:28
End date: 2016-12-21 16:54:50
Raw sample minimum: 306 ms
Raw sample maximum: 422 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 11
Loop iterations per sample: 655360 (2^16 outer-loops x 10 inner-loops)

Minimum: 467 ns (-16%)
Median +- std dev: 554 ns +- 47 ns
Mean +- std dev: 553 ns +- 47 ns
Maximum: 644 ns (+16%)

Median +- std dev: 554 ns +- 47 ns

N=1000 for-loop performance stats.txt

~ python -m perf timeit --rigorous --hist --stats -s $'N=1000\ndigits = [d % 10 for d in range(N)]\ndef digits2int(digits):\n n = 0\n for d in digits:\n  n = 10*n + d\n return n' 'digits2int(digits)'           
.............
182 us:  3 ###########
183 us: 13 ###############################################
184 us: 18 ################################################################
185 us: 17 #############################################################
186 us: 19 ####################################################################
187 us:  8 #############################
188 us:  8 #############################
189 us: 11 #######################################
190 us: 10 ####################################
191 us:  3 ###########
192 us:  4 ##############
193 us:  0 |
194 us:  1 ####
195 us:  0 |
196 us:  2 #######
197 us:  2 #######
198 us:  0 |
199 us:  0 |
200 us:  0 |
201 us:  0 |
202 us:  1 ####

Total duration: 46.6 sec
Start date: 2016-12-21 17:07:40
End date: 2016-12-21 17:08:32
Raw sample minimum: 187 ms
Raw sample maximum: 208 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 1024

Minimum: 183 us (-2%)
Median +- std dev: 186 us +- 4 us
Mean +- std dev: 187 us +- 4 us
Maximum: 203 us (+9%)

Median +- std dev: 186 us +- 4 us

N=1000 int("".join(map(str,..))) performance stats

~ python -m perf timeit --rigorous --hist --stats -s $'N=1000\ndigits = [d % 10 for d in range(N)]\nfrom functools import reduce\ndigits2int = lambda digits: int("".join(map(str, digits)))' 'digits2int(digits)'
.............
42.0 us:  2 ######
42.3 us:  7 ####################
42.6 us: 18 ####################################################
42.9 us: 23 ###################################################################
43.2 us: 13 ######################################
43.5 us: 12 ###################################
43.8 us:  4 ############
44.1 us:  4 ############
44.4 us:  6 #################
44.7 us:  4 ############
45.0 us:  5 ###############
45.3 us:  3 #########
45.6 us:  2 ######
45.9 us:  6 #################
46.2 us:  2 ######
46.5 us:  0 |
46.8 us:  2 ######
47.1 us:  2 ######
47.4 us:  2 ######
47.6 us:  1 ###
47.9 us:  2 ######

Total duration: 44.1 sec
Start date: 2016-12-21 17:09:25
End date: 2016-12-21 17:10:14
Raw sample minimum: 173 ms
Raw sample maximum: 197 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 4096

Minimum: 42.3 us (-3%)
Median +- std dev: 43.4 us +- 1.4 us
Mean +- std dev: 44.0 us +- 1.4 us
Maximum: 48.2 us (+11%)

Median +- std dev: 43.4 us +- 1.4 us

N=1000 reduce() performance stats.txt

~ python -m perf timeit --rigorous --hist --stats -s $'N=1000\ndigits = [d % 10 for d in range(N)]\nfrom functools import reduce\ndigits2int = lambda digits:reduce(lambda n,d:10*n+d, digits)' 'digits2int(digits)'
.............
226 us:  2 ##########
228 us:  2 ##########
230 us:  6 ###############################
232 us:  6 ###############################
234 us: 11 ##########################################################
236 us:  8 ##########################################
238 us:  8 ##########################################
239 us:  4 #####################
241 us:  5 ##########################
243 us: 12 ###############################################################
245 us: 13 ####################################################################
247 us:  9 ###############################################
249 us:  5 ##########################
251 us:  7 #####################################
253 us:  7 #####################################
255 us:  3 ################
257 us:  2 ##########
259 us:  4 #####################
261 us:  2 ##########
262 us:  2 ##########
264 us:  2 ##########

Total duration: 29.2 sec
Start date: 2016-12-21 17:06:15
End date: 2016-12-21 17:06:49
Raw sample minimum: 116 ms
Raw sample maximum: 136 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 512

Minimum: 227 us (-7%)
Median +- std dev: 244 us +- 9 us
Mean +- std dev: 244 us +- 9 us
Maximum: 266 us (+9%)

Median +- std dev: 244 us +- 9 us

N=10000 for-loop performance stats.txt

~ python -m perf timeit --rigorous --hist --stats -s $'N=10000\ndigits = [d % 10 for d in range(N)]\ndef digits2int(digits):\n n = 0\n for d in digits:\n  n = 10*n + d\n return n' 'digits2int(digits)'
.............
12.8 ms:  2 ##########
12.8 ms: 13 ##############################################################
12.9 ms: 10 ################################################
13.0 ms: 10 ################################################
13.1 ms: 10 ################################################
13.1 ms: 14 ###################################################################
13.2 ms:  8 ######################################
13.3 ms: 11 #####################################################
13.3 ms:  3 ##############
13.4 ms:  8 ######################################
13.5 ms:  6 #############################
13.5 ms:  4 ###################
13.6 ms:  5 ########################
13.7 ms:  3 ##############
13.7 ms:  6 #############################
13.8 ms:  0 |
13.9 ms:  3 ##############
13.9 ms:  2 ##########
14.0 ms:  0 |
14.1 ms:  1 #####
14.2 ms:  1 #####

Total duration: 26.3 sec
Start date: 2016-12-21 17:52:45
End date: 2016-12-21 17:53:16
Raw sample minimum: 102 ms
Raw sample maximum: 113 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 8

Minimum: 12.8 ms (-3%)
Median +- std dev: 13.2 ms +- 0.3 ms
Mean +- std dev: 13.3 ms +- 0.3 ms
Maximum: 14.2 ms (+7%)

Median +- std dev: 13.2 ms +- 0.3 ms

N=10000 int("".join(map(str,..))) performance stats

~ python -m perf timeit --rigorous --hist --stats -s $'N=10000\ndigits = [d % 10 for d in range(N)]\ndigits2int = lambda digits: int("".join(map(str, digits)))' 'digits2int(digits)' 
.............
 858 us: 10 ################################
 867 us: 21 ###################################################################
 876 us: 19 #############################################################
 884 us: 16 ###################################################
 893 us: 20 ################################################################
 902 us:  8 ##########################
 911 us:  8 ##########################
 919 us:  2 ######
 928 us:  5 ################
 937 us:  1 ###
 946 us:  3 ##########
 954 us:  3 ##########
 963 us:  1 ###
 972 us:  1 ###
 981 us:  0 |
 989 us:  1 ###
 998 us:  0 |
1.01 ms:  0 |
1.02 ms:  0 |
1.02 ms:  0 |
1.03 ms:  1 ###

Total duration: 28.5 sec
Start date: 2016-12-21 17:50:41
End date: 2016-12-21 17:51:14
Raw sample minimum: 111 ms
Raw sample maximum: 133 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 128

Minimum: 864 us (-3%)
Median +- std dev: 890 us +- 29 us
Mean +- std dev: 896 us +- 29 us
Maximum: 1.04 ms (+17%)

Median +- std dev: 890 us +- 29 us

N=10000 reduce() performance stats.txt

~ python -m perf timeit --rigorous --hist --stats -s $'N=10000\ndigits = [d % 10 for d in range(N)]\nfrom functools import reduce\ndigits2int = lambda digits:reduce(lambda n,d:10*n+d, digits)' 'digits2int(digits)'
.............
13.1 ms:  1 ###
13.2 ms:  4 ##########
13.4 ms: 23 ###########################################################
13.5 ms: 26 ###################################################################
13.7 ms: 19 #################################################
13.8 ms: 12 ###############################
14.0 ms: 16 #########################################
14.1 ms:  2 #####
14.3 ms:  7 ##################
14.4 ms:  2 #####
14.6 ms:  1 ###
14.7 ms:  3 ########
14.9 ms:  1 ###
15.0 ms:  0 |
15.1 ms:  0 |
15.3 ms:  1 ###
15.4 ms:  0 |
15.6 ms:  0 |
15.7 ms:  0 |
15.9 ms:  0 |
16.0 ms:  2 #####

Total duration: 27.1 sec
Start date: 2016-12-21 17:53:42
End date: 2016-12-21 17:54:14
Raw sample minimum: 106 ms
Raw sample maximum: 129 ms

Number of runs: 13
Total number of samples: 120
Number of samples per run: 10
Number of warmups per run: 10
Loop iterations per sample: 8

Minimum: 13.2 ms (-4%)
Median +- std dev: 13.7 ms +- 0.5 ms
Mean +- std dev: 13.8 ms +- 0.5 ms
Maximum: 16.1 ms (+18%)

Median +- std dev: 13.7 ms +- 0.5 ms

summary.org

pypy

• N=10:

digits2int(digits)	Median, ns	std dev, ns	ratio
$’n = 0\nfor d in digits:\n n = 10*n + d\n return n’	94.5	2.2	1.00
reduce(lambda n,d:10*n+d, digits)	554	47	5.86
int(“”.join(map(str, digits)))	764	36	8.08

• N=1000:

digits2int(digits)	Median, us	std dev, us	ratio
int(“”.join(map(str, digits)))	43.4	1.4	1.00
$’n = 0\nfor d in digits:\n n = 10*n + d\n return n’	186	4	4.29
reduce(lambda n,d:10*n+d, digits)	244	9	5.62

• N=10000:

digits2int(digits)	Median, ms	std dev, ms	ratio
int(“”.join(map(str, digits)))	0.890	0.029	1.00
$’n = 0\nfor d in digits:\n n = 10*n + d\n return n’	13.2	0.3	14.83
reduce(lambda n,d:10*n+d, digits)	13.7	0.5	15.39

python3.6

• N=10:

digits2int(digits)	Median, us	std dev, us	ratio
$’n = 0\nfor d in digits:\n n = 10*n + d\n return n’	1.04	0.07	1.00
reduce(lambda n,d:10*n+d, digits)	2.14	0.1	2.06
int(“”.join(map(str, digits)))	3.46	0.1	3.33

• N=10000:

digits2int(digits)	Median, ms	std dev, ms	ratio
int(“”.join(map(str, digits)))	3.05	0.15	1.00
$’n = 0\nfor d in digits:\n n = 10*n + d\n return n’	17.4	0.4	5.70
reduce(lambda n,d:10*n+d, digits)	18.9	0.6	6.20