| # Various microbenchmarks comparing unicode and byte string performance | |
| # Please keep this file both 2.x and 3.x compatible! | |
| import timeit | |
| import itertools | |
| import operator | |
| import re | |
| import sys | |
| import datetime | |
| import optparse | |
| VERSION = '2.0' | |
| def p(*args): | |
| sys.stdout.write(' '.join(str(s) for s in args) + '\n') | |
| if sys.version_info >= (3,): | |
| BYTES = bytes_from_str = lambda x: x.encode('ascii') | |
| UNICODE = unicode_from_str = lambda x: x | |
| else: | |
| BYTES = bytes_from_str = lambda x: x | |
| UNICODE = unicode_from_str = lambda x: x.decode('ascii') | |
| class UnsupportedType(TypeError): | |
| pass | |
| p('stringbench v%s' % VERSION) | |
| p(sys.version) | |
| p(datetime.datetime.now()) | |
| REPEAT = 1 | |
| REPEAT = 3 | |
| #REPEAT = 7 | |
| if __name__ != "__main__": | |
| raise SystemExit("Must run as main program") | |
| parser = optparse.OptionParser() | |
| parser.add_option("-R", "--skip-re", dest="skip_re", | |
| action="store_true", | |
| help="skip regular expression tests") | |
| parser.add_option("-8", "--8-bit", dest="bytes_only", | |
| action="store_true", | |
| help="only do 8-bit string benchmarks") | |
| parser.add_option("-u", "--unicode", dest="unicode_only", | |
| action="store_true", | |
| help="only do Unicode string benchmarks") | |
| _RANGE_1000 = list(range(1000)) | |
| _RANGE_100 = list(range(100)) | |
| _RANGE_10 = list(range(10)) | |
| dups = {} | |
| def bench(s, group, repeat_count): | |
| def blah(f): | |
| if f.__name__ in dups: | |
| raise AssertionError("Multiple functions with same name: %r" % | |
| (f.__name__,)) | |
| dups[f.__name__] = 1 | |
| f.comment = s | |
| f.is_bench = True | |
| f.group = group | |
| f.repeat_count = repeat_count | |
| return f | |
| return blah | |
| def uses_re(f): | |
| f.uses_re = True | |
| ####### 'in' comparisons | |
| @bench('"A" in "A"*1000', "early match, single character", 1000) | |
| def in_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| for x in _RANGE_1000: | |
| s2 in s1 | |
| @bench('"B" in "A"*1000', "no match, single character", 1000) | |
| def in_test_no_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("B") | |
| for x in _RANGE_1000: | |
| s2 in s1 | |
| @bench('"AB" in "AB"*1000', "early match, two characters", 1000) | |
| def in_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| for x in _RANGE_1000: | |
| s2 in s1 | |
| @bench('"BC" in "AB"*1000', "no match, two characters", 1000) | |
| def in_test_no_match_two_character(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("BC") | |
| for x in _RANGE_1000: | |
| s2 in s1 | |
| @bench('"BC" in ("AB"*300+"C")', "late match, two characters", 1000) | |
| def in_test_slow_match_two_characters(STR): | |
| s1 = STR("AB" * 300+"C") | |
| s2 = STR("BC") | |
| for x in _RANGE_1000: | |
| s2 in s1 | |
| @bench('s="ABC"*33; (s+"E") in ((s+"D")*300+s+"E")', | |
| "late match, 100 characters", 100) | |
| def in_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = (m+d)*300 + m+e | |
| s2 = m+e | |
| for x in _RANGE_100: | |
| s2 in s1 | |
| # Try with regex | |
| @uses_re | |
| @bench('s="ABC"*33; re.compile(s+"D").search((s+"D")*300+s+"E")', | |
| "late match, 100 characters", 100) | |
| def re_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = (m+d)*300 + m+e | |
| s2 = m+e | |
| pat = re.compile(s2) | |
| search = pat.search | |
| for x in _RANGE_100: | |
| search(s1) | |
| #### same tests as 'in' but use 'find' | |
| @bench('("A"*1000).find("A")', "early match, single character", 1000) | |
| def find_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_find = s1.find | |
| for x in _RANGE_1000: | |
| s1_find(s2) | |
| @bench('("A"*1000).find("B")', "no match, single character", 1000) | |
| def find_test_no_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("B") | |
| s1_find = s1.find | |
| for x in _RANGE_1000: | |
| s1_find(s2) | |
| @bench('("AB"*1000).find("AB")', "early match, two characters", 1000) | |
| def find_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_find = s1.find | |
| for x in _RANGE_1000: | |
| s1_find(s2) | |
| @bench('("AB"*1000).find("BC")', "no match, two characters", 1000) | |
| def find_test_no_match_two_character(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("BC") | |
| s1_find = s1.find | |
| for x in _RANGE_1000: | |
| s1_find(s2) | |
| @bench('("AB"*1000).find("CA")', "no match, two characters", 1000) | |
| def find_test_no_match_two_character_bis(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("CA") | |
| s1_find = s1.find | |
| for x in _RANGE_1000: | |
| s1_find(s2) | |
| @bench('("AB"*300+"C").find("BC")', "late match, two characters", 1000) | |
| def find_test_slow_match_two_characters(STR): | |
| s1 = STR("AB" * 300+"C") | |
| s2 = STR("BC") | |
| s1_find = s1.find | |
| for x in _RANGE_1000: | |
| s1_find(s2) | |
| @bench('("AB"*300+"CA").find("CA")', "late match, two characters", 1000) | |
| def find_test_slow_match_two_characters_bis(STR): | |
| s1 = STR("AB" * 300+"CA") | |
| s2 = STR("CA") | |
| s1_find = s1.find | |
| for x in _RANGE_1000: | |
| s1_find(s2) | |
| @bench('s="ABC"*33; ((s+"D")*500+s+"E").find(s+"E")', | |
| "late match, 100 characters", 100) | |
| def find_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = (m+d)*500 + m+e | |
| s2 = m+e | |
| s1_find = s1.find | |
| for x in _RANGE_100: | |
| s1_find(s2) | |
| @bench('s="ABC"*33; ((s+"D")*500+"E"+s).find("E"+s)', | |
| "late match, 100 characters", 100) | |
| def find_test_slow_match_100_characters_bis(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = (m+d)*500 + e+m | |
| s2 = e+m | |
| s1_find = s1.find | |
| for x in _RANGE_100: | |
| s1_find(s2) | |
| #### Same tests for 'rfind' | |
| @bench('("A"*1000).rfind("A")', "early match, single character", 1000) | |
| def rfind_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_1000: | |
| s1_rfind(s2) | |
| @bench('("A"*1000).rfind("B")', "no match, single character", 1000) | |
| def rfind_test_no_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("B") | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_1000: | |
| s1_rfind(s2) | |
| @bench('("AB"*1000).rfind("AB")', "early match, two characters", 1000) | |
| def rfind_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_1000: | |
| s1_rfind(s2) | |
| @bench('("AB"*1000).rfind("BC")', "no match, two characters", 1000) | |
| def rfind_test_no_match_two_character(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("BC") | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_1000: | |
| s1_rfind(s2) | |
| @bench('("AB"*1000).rfind("CA")', "no match, two characters", 1000) | |
| def rfind_test_no_match_two_character_bis(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("CA") | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_1000: | |
| s1_rfind(s2) | |
| @bench('("C"+"AB"*300).rfind("CA")', "late match, two characters", 1000) | |
| def rfind_test_slow_match_two_characters(STR): | |
| s1 = STR("C" + "AB" * 300) | |
| s2 = STR("CA") | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_1000: | |
| s1_rfind(s2) | |
| @bench('("BC"+"AB"*300).rfind("BC")', "late match, two characters", 1000) | |
| def rfind_test_slow_match_two_characters_bis(STR): | |
| s1 = STR("BC" + "AB" * 300) | |
| s2 = STR("BC") | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_1000: | |
| s1_rfind(s2) | |
| @bench('s="ABC"*33; ("E"+s+("D"+s)*500).rfind("E"+s)', | |
| "late match, 100 characters", 100) | |
| def rfind_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = e+m + (d+m)*500 | |
| s2 = e+m | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_100: | |
| s1_rfind(s2) | |
| @bench('s="ABC"*33; (s+"E"+("D"+s)*500).rfind(s+"E")', | |
| "late match, 100 characters", 100) | |
| def rfind_test_slow_match_100_characters_bis(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = m+e + (d+m)*500 | |
| s2 = m+e | |
| s1_rfind = s1.rfind | |
| for x in _RANGE_100: | |
| s1_rfind(s2) | |
| #### Now with index. | |
| # Skip the ones which fail because that would include exception overhead. | |
| @bench('("A"*1000).index("A")', "early match, single character", 1000) | |
| def index_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_index = s1.index | |
| for x in _RANGE_1000: | |
| s1_index(s2) | |
| @bench('("AB"*1000).index("AB")', "early match, two characters", 1000) | |
| def index_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_index = s1.index | |
| for x in _RANGE_1000: | |
| s1_index(s2) | |
| @bench('("AB"*300+"C").index("BC")', "late match, two characters", 1000) | |
| def index_test_slow_match_two_characters(STR): | |
| s1 = STR("AB" * 300+"C") | |
| s2 = STR("BC") | |
| s1_index = s1.index | |
| for x in _RANGE_1000: | |
| s1_index(s2) | |
| @bench('s="ABC"*33; ((s+"D")*500+s+"E").index(s+"E")', | |
| "late match, 100 characters", 100) | |
| def index_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = (m+d)*500 + m+e | |
| s2 = m+e | |
| s1_index = s1.index | |
| for x in _RANGE_100: | |
| s1_index(s2) | |
| #### Same for rindex | |
| @bench('("A"*1000).rindex("A")', "early match, single character", 1000) | |
| def rindex_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_rindex = s1.rindex | |
| for x in _RANGE_1000: | |
| s1_rindex(s2) | |
| @bench('("AB"*1000).rindex("AB")', "early match, two characters", 1000) | |
| def rindex_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_rindex = s1.rindex | |
| for x in _RANGE_1000: | |
| s1_rindex(s2) | |
| @bench('("C"+"AB"*300).rindex("CA")', "late match, two characters", 1000) | |
| def rindex_test_slow_match_two_characters(STR): | |
| s1 = STR("C" + "AB" * 300) | |
| s2 = STR("CA") | |
| s1_rindex = s1.rindex | |
| for x in _RANGE_1000: | |
| s1_rindex(s2) | |
| @bench('s="ABC"*33; ("E"+s+("D"+s)*500).rindex("E"+s)', | |
| "late match, 100 characters", 100) | |
| def rindex_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = e + m + (d+m)*500 | |
| s2 = e + m | |
| s1_rindex = s1.rindex | |
| for x in _RANGE_100: | |
| s1_rindex(s2) | |
| #### Same for partition | |
| @bench('("A"*1000).partition("A")', "early match, single character", 1000) | |
| def partition_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_partition = s1.partition | |
| for x in _RANGE_1000: | |
| s1_partition(s2) | |
| @bench('("A"*1000).partition("B")', "no match, single character", 1000) | |
| def partition_test_no_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("B") | |
| s1_partition = s1.partition | |
| for x in _RANGE_1000: | |
| s1_partition(s2) | |
| @bench('("AB"*1000).partition("AB")', "early match, two characters", 1000) | |
| def partition_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_partition = s1.partition | |
| for x in _RANGE_1000: | |
| s1_partition(s2) | |
| @bench('("AB"*1000).partition("BC")', "no match, two characters", 1000) | |
| def partition_test_no_match_two_character(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("BC") | |
| s1_partition = s1.partition | |
| for x in _RANGE_1000: | |
| s1_partition(s2) | |
| @bench('("AB"*300+"C").partition("BC")', "late match, two characters", 1000) | |
| def partition_test_slow_match_two_characters(STR): | |
| s1 = STR("AB" * 300+"C") | |
| s2 = STR("BC") | |
| s1_partition = s1.partition | |
| for x in _RANGE_1000: | |
| s1_partition(s2) | |
| @bench('s="ABC"*33; ((s+"D")*500+s+"E").partition(s+"E")', | |
| "late match, 100 characters", 100) | |
| def partition_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = (m+d)*500 + m+e | |
| s2 = m+e | |
| s1_partition = s1.partition | |
| for x in _RANGE_100: | |
| s1_partition(s2) | |
| #### Same for rpartition | |
| @bench('("A"*1000).rpartition("A")', "early match, single character", 1000) | |
| def rpartition_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_rpartition = s1.rpartition | |
| for x in _RANGE_1000: | |
| s1_rpartition(s2) | |
| @bench('("A"*1000).rpartition("B")', "no match, single character", 1000) | |
| def rpartition_test_no_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("B") | |
| s1_rpartition = s1.rpartition | |
| for x in _RANGE_1000: | |
| s1_rpartition(s2) | |
| @bench('("AB"*1000).rpartition("AB")', "early match, two characters", 1000) | |
| def rpartition_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_rpartition = s1.rpartition | |
| for x in _RANGE_1000: | |
| s1_rpartition(s2) | |
| @bench('("AB"*1000).rpartition("BC")', "no match, two characters", 1000) | |
| def rpartition_test_no_match_two_character(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("BC") | |
| s1_rpartition = s1.rpartition | |
| for x in _RANGE_1000: | |
| s1_rpartition(s2) | |
| @bench('("C"+"AB"*300).rpartition("CA")', "late match, two characters", 1000) | |
| def rpartition_test_slow_match_two_characters(STR): | |
| s1 = STR("C" + "AB" * 300) | |
| s2 = STR("CA") | |
| s1_rpartition = s1.rpartition | |
| for x in _RANGE_1000: | |
| s1_rpartition(s2) | |
| @bench('s="ABC"*33; ("E"+s+("D"+s)*500).rpartition("E"+s)', | |
| "late match, 100 characters", 100) | |
| def rpartition_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = e + m + (d+m)*500 | |
| s2 = e + m | |
| s1_rpartition = s1.rpartition | |
| for x in _RANGE_100: | |
| s1_rpartition(s2) | |
| #### Same for split(s, 1) | |
| @bench('("A"*1000).split("A", 1)', "early match, single character", 1000) | |
| def split_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_split = s1.split | |
| for x in _RANGE_1000: | |
| s1_split(s2, 1) | |
| @bench('("A"*1000).split("B", 1)', "no match, single character", 1000) | |
| def split_test_no_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("B") | |
| s1_split = s1.split | |
| for x in _RANGE_1000: | |
| s1_split(s2, 1) | |
| @bench('("AB"*1000).split("AB", 1)', "early match, two characters", 1000) | |
| def split_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_split = s1.split | |
| for x in _RANGE_1000: | |
| s1_split(s2, 1) | |
| @bench('("AB"*1000).split("BC", 1)', "no match, two characters", 1000) | |
| def split_test_no_match_two_character(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("BC") | |
| s1_split = s1.split | |
| for x in _RANGE_1000: | |
| s1_split(s2, 1) | |
| @bench('("AB"*300+"C").split("BC", 1)', "late match, two characters", 1000) | |
| def split_test_slow_match_two_characters(STR): | |
| s1 = STR("AB" * 300+"C") | |
| s2 = STR("BC") | |
| s1_split = s1.split | |
| for x in _RANGE_1000: | |
| s1_split(s2, 1) | |
| @bench('s="ABC"*33; ((s+"D")*500+s+"E").split(s+"E", 1)', | |
| "late match, 100 characters", 100) | |
| def split_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = (m+d)*500 + m+e | |
| s2 = m+e | |
| s1_split = s1.split | |
| for x in _RANGE_100: | |
| s1_split(s2, 1) | |
| #### Same for rsplit(s, 1) | |
| @bench('("A"*1000).rsplit("A", 1)', "early match, single character", 1000) | |
| def rsplit_test_quick_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("A") | |
| s1_rsplit = s1.rsplit | |
| for x in _RANGE_1000: | |
| s1_rsplit(s2, 1) | |
| @bench('("A"*1000).rsplit("B", 1)', "no match, single character", 1000) | |
| def rsplit_test_no_match_single_character(STR): | |
| s1 = STR("A" * 1000) | |
| s2 = STR("B") | |
| s1_rsplit = s1.rsplit | |
| for x in _RANGE_1000: | |
| s1_rsplit(s2, 1) | |
| @bench('("AB"*1000).rsplit("AB", 1)', "early match, two characters", 1000) | |
| def rsplit_test_quick_match_two_characters(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("AB") | |
| s1_rsplit = s1.rsplit | |
| for x in _RANGE_1000: | |
| s1_rsplit(s2, 1) | |
| @bench('("AB"*1000).rsplit("BC", 1)', "no match, two characters", 1000) | |
| def rsplit_test_no_match_two_character(STR): | |
| s1 = STR("AB" * 1000) | |
| s2 = STR("BC") | |
| s1_rsplit = s1.rsplit | |
| for x in _RANGE_1000: | |
| s1_rsplit(s2, 1) | |
| @bench('("C"+"AB"*300).rsplit("CA", 1)', "late match, two characters", 1000) | |
| def rsplit_test_slow_match_two_characters(STR): | |
| s1 = STR("C" + "AB" * 300) | |
| s2 = STR("CA") | |
| s1_rsplit = s1.rsplit | |
| for x in _RANGE_1000: | |
| s1_rsplit(s2, 1) | |
| @bench('s="ABC"*33; ("E"+s+("D"+s)*500).rsplit("E"+s, 1)', | |
| "late match, 100 characters", 100) | |
| def rsplit_test_slow_match_100_characters(STR): | |
| m = STR("ABC"*33) | |
| d = STR("D") | |
| e = STR("E") | |
| s1 = e + m + (d+m)*500 | |
| s2 = e + m | |
| s1_rsplit = s1.rsplit | |
| for x in _RANGE_100: | |
| s1_rsplit(s2, 1) | |
| #### Benchmark the operator-based methods | |
| @bench('"A"*10', "repeat 1 character 10 times", 1000) | |
| def repeat_single_10_times(STR): | |
| s = STR("A") | |
| for x in _RANGE_1000: | |
| s * 10 | |
| @bench('"A"*1000', "repeat 1 character 1000 times", 1000) | |
| def repeat_single_1000_times(STR): | |
| s = STR("A") | |
| for x in _RANGE_1000: | |
| s * 1000 | |
| @bench('"ABCDE"*10', "repeat 5 characters 10 times", 1000) | |
| def repeat_5_10_times(STR): | |
| s = STR("ABCDE") | |
| for x in _RANGE_1000: | |
| s * 10 | |
| @bench('"ABCDE"*1000', "repeat 5 characters 1000 times", 1000) | |
| def repeat_5_1000_times(STR): | |
| s = STR("ABCDE") | |
| for x in _RANGE_1000: | |
| s * 1000 | |
| # + for concat | |
| @bench('"Andrew"+"Dalke"', "concat two strings", 1000) | |
| def concat_two_strings(STR): | |
| s1 = STR("Andrew") | |
| s2 = STR("Dalke") | |
| for x in _RANGE_1000: | |
| s1+s2 | |
| @bench('s1+s2+s3+s4+...+s20', "concat 20 strings of words length 4 to 15", | |
| 1000) | |
| def concat_many_strings(STR): | |
| s1=STR('TIXSGYNREDCVBHJ') | |
| s2=STR('PUMTLXBZVDO') | |
| s3=STR('FVZNJ') | |
| s4=STR('OGDXUW') | |
| s5=STR('WEIMRNCOYVGHKB') | |
| s6=STR('FCQTNMXPUZH') | |
| s7=STR('TICZJYRLBNVUEAK') | |
| s8=STR('REYB') | |
| s9=STR('PWUOQ') | |
| s10=STR('EQHCMKBS') | |
| s11=STR('AEVDFOH') | |
| s12=STR('IFHVD') | |
| s13=STR('JGTCNLXWOHQ') | |
| s14=STR('ITSKEPYLROZAWXF') | |
| s15=STR('THEK') | |
| s16=STR('GHPZFBUYCKMNJIT') | |
| s17=STR('JMUZ') | |
| s18=STR('WLZQMTB') | |
| s19=STR('KPADCBW') | |
| s20=STR('TNJHZQAGBU') | |
| for x in _RANGE_1000: | |
| (s1 + s2+ s3+ s4+ s5+ s6+ s7+ s8+ s9+s10+ | |
| s11+s12+s13+s14+s15+s16+s17+s18+s19+s20) | |
| #### Benchmark join | |
| def get_bytes_yielding_seq(STR, arg): | |
| if STR is BYTES and sys.version_info >= (3,): | |
| raise UnsupportedType | |
| return STR(arg) | |
| @bench('"A".join("")', | |
| "join empty string, with 1 character sep", 100) | |
| def join_empty_single(STR): | |
| sep = STR("A") | |
| s2 = get_bytes_yielding_seq(STR, "") | |
| sep_join = sep.join | |
| for x in _RANGE_100: | |
| sep_join(s2) | |
| @bench('"ABCDE".join("")', | |
| "join empty string, with 5 character sep", 100) | |
| def join_empty_5(STR): | |
| sep = STR("ABCDE") | |
| s2 = get_bytes_yielding_seq(STR, "") | |
| sep_join = sep.join | |
| for x in _RANGE_100: | |
| sep_join(s2) | |
| @bench('"A".join("ABC..Z")', | |
| "join string with 26 characters, with 1 character sep", 1000) | |
| def join_alphabet_single(STR): | |
| sep = STR("A") | |
| s2 = get_bytes_yielding_seq(STR, "ABCDEFGHIJKLMnOPQRSTUVWXYZ") | |
| sep_join = sep.join | |
| for x in _RANGE_1000: | |
| sep_join(s2) | |
| @bench('"ABCDE".join("ABC..Z")', | |
| "join string with 26 characters, with 5 character sep", 1000) | |
| def join_alphabet_5(STR): | |
| sep = STR("ABCDE") | |
| s2 = get_bytes_yielding_seq(STR, "ABCDEFGHIJKLMnOPQRSTUVWXYZ") | |
| sep_join = sep.join | |
| for x in _RANGE_1000: | |
| sep_join(s2) | |
| @bench('"A".join(list("ABC..Z"))', | |
| "join list of 26 characters, with 1 character sep", 1000) | |
| def join_alphabet_list_single(STR): | |
| sep = STR("A") | |
| s2 = [STR(x) for x in "ABCDEFGHIJKLMnOPQRSTUVWXYZ"] | |
| sep_join = sep.join | |
| for x in _RANGE_1000: | |
| sep_join(s2) | |
| @bench('"ABCDE".join(list("ABC..Z"))', | |
| "join list of 26 characters, with 5 character sep", 1000) | |
| def join_alphabet_list_five(STR): | |
| sep = STR("ABCDE") | |
| s2 = [STR(x) for x in "ABCDEFGHIJKLMnOPQRSTUVWXYZ"] | |
| sep_join = sep.join | |
| for x in _RANGE_1000: | |
| sep_join(s2) | |
| @bench('"A".join(["Bob"]*100)', | |
| "join list of 100 words, with 1 character sep", 1000) | |
| def join_100_words_single(STR): | |
| sep = STR("A") | |
| s2 = [STR("Bob")]*100 | |
| sep_join = sep.join | |
| for x in _RANGE_1000: | |
| sep_join(s2) | |
| @bench('"ABCDE".join(["Bob"]*100))', | |
| "join list of 100 words, with 5 character sep", 1000) | |
| def join_100_words_5(STR): | |
| sep = STR("ABCDE") | |
| s2 = [STR("Bob")]*100 | |
| sep_join = sep.join | |
| for x in _RANGE_1000: | |
| sep_join(s2) | |
| #### split tests | |
| @bench('("Here are some words. "*2).split()', "split whitespace (small)", 1000) | |
| def whitespace_split(STR): | |
| s = STR("Here are some words. "*2) | |
| s_split = s.split | |
| for x in _RANGE_1000: | |
| s_split() | |
| @bench('("Here are some words. "*2).rsplit()', "split whitespace (small)", 1000) | |
| def whitespace_rsplit(STR): | |
| s = STR("Here are some words. "*2) | |
| s_rsplit = s.rsplit | |
| for x in _RANGE_1000: | |
| s_rsplit() | |
| @bench('("Here are some words. "*2).split(None, 1)', | |
| "split 1 whitespace", 1000) | |
| def whitespace_split_1(STR): | |
| s = STR("Here are some words. "*2) | |
| s_split = s.split | |
| N = None | |
| for x in _RANGE_1000: | |
| s_split(N, 1) | |
| @bench('("Here are some words. "*2).rsplit(None, 1)', | |
| "split 1 whitespace", 1000) | |
| def whitespace_rsplit_1(STR): | |
| s = STR("Here are some words. "*2) | |
| s_rsplit = s.rsplit | |
| N = None | |
| for x in _RANGE_1000: | |
| s_rsplit(N, 1) | |
| @bench('("Here are some words. "*2).partition(" ")', | |
| "split 1 whitespace", 1000) | |
| def whitespace_partition(STR): | |
| sep = STR(" ") | |
| s = STR("Here are some words. "*2) | |
| s_partition = s.partition | |
| for x in _RANGE_1000: | |
| s_partition(sep) | |
| @bench('("Here are some words. "*2).rpartition(" ")', | |
| "split 1 whitespace", 1000) | |
| def whitespace_rpartition(STR): | |
| sep = STR(" ") | |
| s = STR("Here are some words. "*2) | |
| s_rpartition = s.rpartition | |
| for x in _RANGE_1000: | |
| s_rpartition(sep) | |
| human_text = """\ | |
| Python is a dynamic object-oriented programming language that can be | |
| used for many kinds of software development. It offers strong support | |
| for integration with other languages and tools, comes with extensive | |
| standard libraries, and can be learned in a few days. Many Python | |
| programmers report substantial productivity gains and feel the language | |
| encourages the development of higher quality, more maintainable code. | |
| Python runs on Windows, Linux/Unix, Mac OS X, Amiga, Palm | |
| Handhelds, and Nokia mobile phones. Python has also been ported to the | |
| Java and .NET virtual machines. | |
| Python is distributed under an OSI-approved open source license that | |
| makes it free to use, even for commercial products. | |
| """*25 | |
| human_text_bytes = bytes_from_str(human_text) | |
| human_text_unicode = unicode_from_str(human_text) | |
| def _get_human_text(STR): | |
| if STR is UNICODE: | |
| return human_text_unicode | |
| if STR is BYTES: | |
| return human_text_bytes | |
| raise AssertionError | |
| @bench('human_text.split()', "split whitespace (huge)", 10) | |
| def whitespace_split_huge(STR): | |
| s = _get_human_text(STR) | |
| s_split = s.split | |
| for x in _RANGE_10: | |
| s_split() | |
| @bench('human_text.rsplit()', "split whitespace (huge)", 10) | |
| def whitespace_rsplit_huge(STR): | |
| s = _get_human_text(STR) | |
| s_rsplit = s.rsplit | |
| for x in _RANGE_10: | |
| s_rsplit() | |
| @bench('"this\\nis\\na\\ntest\\n".split("\\n")', "split newlines", 1000) | |
| def newlines_split(STR): | |
| s = STR("this\nis\na\ntest\n") | |
| s_split = s.split | |
| nl = STR("\n") | |
| for x in _RANGE_1000: | |
| s_split(nl) | |
| @bench('"this\\nis\\na\\ntest\\n".rsplit("\\n")', "split newlines", 1000) | |
| def newlines_rsplit(STR): | |
| s = STR("this\nis\na\ntest\n") | |
| s_rsplit = s.rsplit | |
| nl = STR("\n") | |
| for x in _RANGE_1000: | |
| s_rsplit(nl) | |
| @bench('"this\\nis\\na\\ntest\\n".splitlines()', "split newlines", 1000) | |
| def newlines_splitlines(STR): | |
| s = STR("this\nis\na\ntest\n") | |
| s_splitlines = s.splitlines | |
| for x in _RANGE_1000: | |
| s_splitlines() | |
| ## split text with 2000 newlines | |
| def _make_2000_lines(): | |
| import random | |
| r = random.Random(100) | |
| chars = list(map(chr, range(32, 128))) | |
| i = 0 | |
| while i < len(chars): | |
| chars[i] = " " | |
| i += r.randrange(9) | |
| s = "".join(chars) | |
| s = s*4 | |
| words = [] | |
| for i in range(2000): | |
| start = r.randrange(96) | |
| n = r.randint(5, 65) | |
| words.append(s[start:start+n]) | |
| return "\n".join(words)+"\n" | |
| _text_with_2000_lines = _make_2000_lines() | |
| _text_with_2000_lines_bytes = bytes_from_str(_text_with_2000_lines) | |
| _text_with_2000_lines_unicode = unicode_from_str(_text_with_2000_lines) | |
| def _get_2000_lines(STR): | |
| if STR is UNICODE: | |
| return _text_with_2000_lines_unicode | |
| if STR is BYTES: | |
| return _text_with_2000_lines_bytes | |
| raise AssertionError | |
| @bench('"...text...".split("\\n")', "split 2000 newlines", 10) | |
| def newlines_split_2000(STR): | |
| s = _get_2000_lines(STR) | |
| s_split = s.split | |
| nl = STR("\n") | |
| for x in _RANGE_10: | |
| s_split(nl) | |
| @bench('"...text...".rsplit("\\n")', "split 2000 newlines", 10) | |
| def newlines_rsplit_2000(STR): | |
| s = _get_2000_lines(STR) | |
| s_rsplit = s.rsplit | |
| nl = STR("\n") | |
| for x in _RANGE_10: | |
| s_rsplit(nl) | |
| @bench('"...text...".splitlines()', "split 2000 newlines", 10) | |
| def newlines_splitlines_2000(STR): | |
| s = _get_2000_lines(STR) | |
| s_splitlines = s.splitlines | |
| for x in _RANGE_10: | |
| s_splitlines() | |
| ## split text on "--" characters | |
| @bench( | |
| '"this--is--a--test--of--the--emergency--broadcast--system".split("--")', | |
| "split on multicharacter separator (small)", 1000) | |
| def split_multichar_sep_small(STR): | |
| s = STR("this--is--a--test--of--the--emergency--broadcast--system") | |
| s_split = s.split | |
| pat = STR("--") | |
| for x in _RANGE_1000: | |
| s_split(pat) | |
| @bench( | |
| '"this--is--a--test--of--the--emergency--broadcast--system".rsplit("--")', | |
| "split on multicharacter separator (small)", 1000) | |
| def rsplit_multichar_sep_small(STR): | |
| s = STR("this--is--a--test--of--the--emergency--broadcast--system") | |
| s_rsplit = s.rsplit | |
| pat = STR("--") | |
| for x in _RANGE_1000: | |
| s_rsplit(pat) | |
| ## split dna text on "ACTAT" characters | |
| @bench('dna.split("ACTAT")', | |
| "split on multicharacter separator (dna)", 10) | |
| def split_multichar_sep_dna(STR): | |
| s = _get_dna(STR) | |
| s_split = s.split | |
| pat = STR("ACTAT") | |
| for x in _RANGE_10: | |
| s_split(pat) | |
| @bench('dna.rsplit("ACTAT")', | |
| "split on multicharacter separator (dna)", 10) | |
| def rsplit_multichar_sep_dna(STR): | |
| s = _get_dna(STR) | |
| s_rsplit = s.rsplit | |
| pat = STR("ACTAT") | |
| for x in _RANGE_10: | |
| s_rsplit(pat) | |
| ## split with limits | |
| GFF3_example = "\t".join([ | |
| "I", "Genomic_canonical", "region", "357208", "396183", ".", "+", ".", | |
| "ID=Sequence:R119;note=Clone R119%3B Genbank AF063007;Name=R119"]) | |
| @bench('GFF3_example.split("\\t")', "tab split", 1000) | |
| def tab_split_no_limit(STR): | |
| sep = STR("\t") | |
| s = STR(GFF3_example) | |
| s_split = s.split | |
| for x in _RANGE_1000: | |
| s_split(sep) | |
| @bench('GFF3_example.split("\\t", 8)', "tab split", 1000) | |
| def tab_split_limit(STR): | |
| sep = STR("\t") | |
| s = STR(GFF3_example) | |
| s_split = s.split | |
| for x in _RANGE_1000: | |
| s_split(sep, 8) | |
| @bench('GFF3_example.rsplit("\\t")', "tab split", 1000) | |
| def tab_rsplit_no_limit(STR): | |
| sep = STR("\t") | |
| s = STR(GFF3_example) | |
| s_rsplit = s.rsplit | |
| for x in _RANGE_1000: | |
| s_rsplit(sep) | |
| @bench('GFF3_example.rsplit("\\t", 8)', "tab split", 1000) | |
| def tab_rsplit_limit(STR): | |
| sep = STR("\t") | |
| s = STR(GFF3_example) | |
| s_rsplit = s.rsplit | |
| for x in _RANGE_1000: | |
| s_rsplit(sep, 8) | |
| #### Count characters | |
| @bench('...text.with.2000.newlines.count("\\n")', | |
| "count newlines", 10) | |
| def count_newlines(STR): | |
| s = _get_2000_lines(STR) | |
| s_count = s.count | |
| nl = STR("\n") | |
| for x in _RANGE_10: | |
| s_count(nl) | |
| # Orchid sequences concatenated, from Biopython | |
| _dna = """ | |
| CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGGGTT | |
| AATCTGGAGGATCTGTTTACTTTGGTCACCCATGAGCATTTGCTGTTGAAGTGACCTAGAATTGCCATCG | |
| AGCCTCCTTGGGAGCTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGCAGTTTTGCTCCAAGTCGTT | |
| TGACACATAATTGGTGAAGGGGGTGGCATCCTTCCCTGACCCTCCCCCAACTATTTTTTTAACAACTCTC | |
| AGCAACGGAGACTCAGTCTTCGGCAAATGCGATAAATGGTGTGAATTGCAGAATCCCGTGCACCATCGAG | |
| TCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCTGCCTGGGCATTGCGAGTCATAT | |
| CTCTCCCTTAACGAGGCTGTCCATACATACTGTTCAGCCGGTGCGGATGTGAGTTTGGCCCCTTGTTCTT | |
| TGGTACGGGGGGTCTAAGAGCTGCATGGGCTTTTGATGGTCCTAAATACGGCAAGAGGTGGACGAACTAT | |
| GCTACAACAAAATTGTTGTGCAGAGGCCCCGGGTTGTCGTATTAGATGGGCCACCGTAATCTGAAGACCC | |
| TTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGGCCATTTGGTTGCGACCCCAGGTCAG | |
| GTGAGCAACAGCTGTCGTAACAAGGTTTCCGTAGGGTGAACTGCGGAAGGATCATTGTTGAGATCACATA | |
| ATAATTGATCGAGTTAATCTGGAGGATCTGTTTACTTGGGTCACCCATGGGCATTTGCTGTTGAAGTGAC | |
| CTAGATTTGCCATCGAGCCTCCTTGGGAGCATCCTTGTTGGCGATATCTAAACCCTCAATTTTTCCCCCA | |
| ATCAAATTACACAAAATTGGTGGAGGGGGTGGCATTCTTCCCTTACCCTCCCCCAAATATTTTTTTAACA | |
| ACTCTCAGCAACGGATATCTCAGCTCTTGCATCGATGAAGAACCCACCGAAATGCGATAAATGGTGTGAA | |
| TTGCAGAATCCCGTGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACG | |
| CCTGCCTGGGCATTGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACATACTGTTCAGCCGGTGCG | |
| GATGTGAGTTTGGCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGATGCATGGGCTTTTGATGGTCCTAA | |
| ATACGGCAAGAGGTGGACGAACTATGCTACAACAAAATTGTTGTGCAAAGGCCCCGGGTTGTCGTATAAG | |
| ATGGGCCACCGATATCTGAAGACCCTTTTGGACCCCATTGGAGCCCATCAACCCATGTCAGTTGATGGCC | |
| ATTCGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGA | |
| GTTAATCTGGAGGATCTGTTTACTTGGGTCACCCATGGGCATTTGCTGTTGAAGTGACCTAGATTTGCCA | |
| TCGAGCCTCCTTGGGAGCTTTCTTGTTGGCGATATCTAAACCCTTGCCCGGCAGAGTTTTGGGAATCCCG | |
| TGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCTGCCTGGGCAT | |
| TGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACACACCTGTTCAGCCGGTGCGGATGTGAGTTTG | |
| GCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGCTGCATGGGCTTTTGATGGTCCTAAATACGGCAAGAG | |
| GTGGACGAACTATGCTACAACAAAATTGTTGTGCAAAGGCCCCGGGTTGTCGTATTAGATGGGCCACCAT | |
| AATCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGGCCATTTGGTTGC | |
| GACCCAGTCAGGTGAGGGTAGGTGAACCTGCGGAAGGATCATTGTTGAGATCACATAATAATTGATCGAG | |
| TTAATCTGGAGGATCTGTTTACTTTGGTCACCCATGGGCATTTGCTGTTGAAGTGACCTAGATTTGCCAT | |
| CGAGCCTCCTTGGGAGCTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGGAGTTTGGCGCCAAGTCA | |
| TATGACACATAATTGGTGAAGGGGGTGGCATCCTGCCCTGACCCTCCCCAAATTATTTTTTTAACAACTC | |
| TCAGCAACGGATATCTCGGCTCTTGCATCGATGAAGAACGCAGCGAAATGCGATAAATGGTGTGAATTGC | |
| AGAATCCCGTGAACCATCGAGTCTTTGGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCACGCCT | |
| GCCTGGGCATTGGGAATCATATCTCTCCCCTAACGAGGCTATCCAAACATACTGTTCATCCGGTGCGGAT | |
| GTGAGTTTGGCCCCTTGTTCTTTGGTACCGGGGGTCTAAGAGCTGCATGGGCATTTGATGGTCCTCAAAA | |
| CGGCAAGAGGTGGACGAACTATGCCACAACAAAATTGTTGTCCCAAGGCCCCGGGTTGTCGTATTAGATG | |
| GGCCACCGTAACCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATGACCA | |
| TTTGTTGCGACCCCAGTCAGCTGAGCAACCCGCTGAGTGGAAGGTCATTGCCGATATCACATAATAATTG | |
| ATCGAGTTAATCTGGAGGATCTGTTTACTTGGTCACCCATGAGCATTTGCTGTTGAAGTGACCTAGATTT | |
| GCCATCGAGCCTCCTTGGGAGTTTTCTTGTTGGCGAGATCTAAACCCTTGCCCGGCGGAGTTGTGCGCCA | |
| AGTCATATGACACATAATTGGTGAAGGGGGTGGCATCCTGCCCTGACCCTCCCCAAATTATTTTTTTAAC | |
| AACTCTCAGCAACGGATATCTCGGCTCTTGCATCGATGAAGAACGCAGCGAAATGCGATAAATGGTGTGA | |
| ATTGCAGAATCCCGTGAACCATCGAGTCTTTGAACGCAAGTTGCGCCCGAGGCCATCAGGCCAAGGGCAC | |
| GCCTGCCTGGGCATTGCGAGTCATATCTCTCCCTTAACGAGGCTGTCCATACATACTGTTCATCCGGTGC | |
| GGATGTGAGTTTGGCCCCTTGTTCTTTGGTACGGGGGGTCTAAGAGCTGCATGGGCATTTGATGGTCCTC | |
| AAAACGGCAAGAGGTGGACGAACTATGCTACAACCAAATTGTTGTCCCAAGGCCCCGGGTTGTCGTATTA | |
| GATGGGCCACCGTAACCTGAAGACCCTTTTGAACCCCATTGGAGGCCCATCAACCCATGATCAGTTGATG | |
| ACCATGTGTTGCGACCCCAGTCAGCTGAGCAACGCGCTGAGCGTAACAAGGTTTCCGTAGGTGGACCTCC | |
| GGGAGGATCATTGTTGAGATCACATAATAATTGATCGAGGTAATCTGGAGGATCTGCATATTTTGGTCAC | |
| """ | |
| _dna = "".join(_dna.splitlines()) | |
| _dna = _dna * 25 | |
| _dna_bytes = bytes_from_str(_dna) | |
| _dna_unicode = unicode_from_str(_dna) | |
| def _get_dna(STR): | |
| if STR is UNICODE: | |
| return _dna_unicode | |
| if STR is BYTES: | |
| return _dna_bytes | |
| raise AssertionError | |
| @bench('dna.count("AACT")', "count AACT substrings in DNA example", 10) | |
| def count_aact(STR): | |
| seq = _get_dna(STR) | |
| seq_count = seq.count | |
| needle = STR("AACT") | |
| for x in _RANGE_10: | |
| seq_count(needle) | |
| ##### startswith and endswith | |
| @bench('"Andrew".startswith("A")', 'startswith single character', 1000) | |
| def startswith_single(STR): | |
| s1 = STR("Andrew") | |
| s2 = STR("A") | |
| s1_startswith = s1.startswith | |
| for x in _RANGE_1000: | |
| s1_startswith(s2) | |
| @bench('"Andrew".startswith("Andrew")', 'startswith multiple characters', | |
| 1000) | |
| def startswith_multiple(STR): | |
| s1 = STR("Andrew") | |
| s2 = STR("Andrew") | |
| s1_startswith = s1.startswith | |
| for x in _RANGE_1000: | |
| s1_startswith(s2) | |
| @bench('"Andrew".startswith("Anders")', | |
| 'startswith multiple characters - not!', 1000) | |
| def startswith_multiple_not(STR): | |
| s1 = STR("Andrew") | |
| s2 = STR("Anders") | |
| s1_startswith = s1.startswith | |
| for x in _RANGE_1000: | |
| s1_startswith(s2) | |
| # endswith | |
| @bench('"Andrew".endswith("w")', 'endswith single character', 1000) | |
| def endswith_single(STR): | |
| s1 = STR("Andrew") | |
| s2 = STR("w") | |
| s1_endswith = s1.endswith | |
| for x in _RANGE_1000: | |
| s1_endswith(s2) | |
| @bench('"Andrew".endswith("Andrew")', 'endswith multiple characters', 1000) | |
| def endswith_multiple(STR): | |
| s1 = STR("Andrew") | |
| s2 = STR("Andrew") | |
| s1_endswith = s1.endswith | |
| for x in _RANGE_1000: | |
| s1_endswith(s2) | |
| @bench('"Andrew".endswith("Anders")', | |
| 'endswith multiple characters - not!', 1000) | |
| def endswith_multiple_not(STR): | |
| s1 = STR("Andrew") | |
| s2 = STR("Anders") | |
| s1_endswith = s1.endswith | |
| for x in _RANGE_1000: | |
| s1_endswith(s2) | |
| #### Strip | |
| @bench('"Hello!\\n".strip()', 'strip terminal newline', 1000) | |
| def terminal_newline_strip_right(STR): | |
| s = STR("Hello!\n") | |
| s_strip = s.strip | |
| for x in _RANGE_1000: | |
| s_strip() | |
| @bench('"Hello!\\n".rstrip()', 'strip terminal newline', 1000) | |
| def terminal_newline_rstrip(STR): | |
| s = STR("Hello!\n") | |
| s_rstrip = s.rstrip | |
| for x in _RANGE_1000: | |
| s_rstrip() | |
| @bench('"\\nHello!".strip()', 'strip terminal newline', 1000) | |
| def terminal_newline_strip_left(STR): | |
| s = STR("\nHello!") | |
| s_strip = s.strip | |
| for x in _RANGE_1000: | |
| s_strip() | |
| @bench('"\\nHello!\\n".strip()', 'strip terminal newline', 1000) | |
| def terminal_newline_strip_both(STR): | |
| s = STR("\nHello!\n") | |
| s_strip = s.strip | |
| for x in _RANGE_1000: | |
| s_strip() | |
| @bench('"\\nHello!".rstrip()', 'strip terminal newline', 1000) | |
| def terminal_newline_lstrip(STR): | |
| s = STR("\nHello!") | |
| s_lstrip = s.lstrip | |
| for x in _RANGE_1000: | |
| s_lstrip() | |
| @bench('s="Hello!\\n"; s[:-1] if s[-1]=="\\n" else s', | |
| 'strip terminal newline', 1000) | |
| def terminal_newline_if_else(STR): | |
| s = STR("Hello!\n") | |
| NL = STR("\n") | |
| for x in _RANGE_1000: | |
| s[:-1] if (s[-1] == NL) else s | |
| # Strip multiple spaces or tabs | |
| @bench('"Hello\\t \\t".strip()', 'strip terminal spaces and tabs', 1000) | |
| def terminal_space_strip(STR): | |
| s = STR("Hello\t \t!") | |
| s_strip = s.strip | |
| for x in _RANGE_1000: | |
| s_strip() | |
| @bench('"Hello\\t \\t".rstrip()', 'strip terminal spaces and tabs', 1000) | |
| def terminal_space_rstrip(STR): | |
| s = STR("Hello!\t \t") | |
| s_rstrip = s.rstrip | |
| for x in _RANGE_1000: | |
| s_rstrip() | |
| @bench('"\\t \\tHello".rstrip()', 'strip terminal spaces and tabs', 1000) | |
| def terminal_space_lstrip(STR): | |
| s = STR("\t \tHello!") | |
| s_lstrip = s.lstrip | |
| for x in _RANGE_1000: | |
| s_lstrip() | |
| #### replace | |
| @bench('"This is a test".replace(" ", "\\t")', 'replace single character', | |
| 1000) | |
| def replace_single_character(STR): | |
| s = STR("This is a test!") | |
| from_str = STR(" ") | |
| to_str = STR("\t") | |
| s_replace = s.replace | |
| for x in _RANGE_1000: | |
| s_replace(from_str, to_str) | |
| @uses_re | |
| @bench('re.sub(" ", "\\t", "This is a test"', 'replace single character', | |
| 1000) | |
| def replace_single_character_re(STR): | |
| s = STR("This is a test!") | |
| pat = re.compile(STR(" ")) | |
| to_str = STR("\t") | |
| pat_sub = pat.sub | |
| for x in _RANGE_1000: | |
| pat_sub(to_str, s) | |
| @bench('"...text.with.2000.lines...replace("\\n", " ")', | |
| 'replace single character, big string', 10) | |
| def replace_single_character_big(STR): | |
| s = _get_2000_lines(STR) | |
| from_str = STR("\n") | |
| to_str = STR(" ") | |
| s_replace = s.replace | |
| for x in _RANGE_10: | |
| s_replace(from_str, to_str) | |
| @uses_re | |
| @bench('re.sub("\\n", " ", "...text.with.2000.lines...")', | |
| 'replace single character, big string', 10) | |
| def replace_single_character_big_re(STR): | |
| s = _get_2000_lines(STR) | |
| pat = re.compile(STR("\n")) | |
| to_str = STR(" ") | |
| pat_sub = pat.sub | |
| for x in _RANGE_10: | |
| pat_sub(to_str, s) | |
| @bench('dna.replace("ATC", "ATT")', | |
| 'replace multiple characters, dna', 10) | |
| def replace_multiple_characters_dna(STR): | |
| seq = _get_dna(STR) | |
| from_str = STR("ATC") | |
| to_str = STR("ATT") | |
| seq_replace = seq.replace | |
| for x in _RANGE_10: | |
| seq_replace(from_str, to_str) | |
| # This increases the character count | |
| @bench('"...text.with.2000.newlines...replace("\\n", "\\r\\n")', | |
| 'replace and expand multiple characters, big string', 10) | |
| def replace_multiple_character_big(STR): | |
| s = _get_2000_lines(STR) | |
| from_str = STR("\n") | |
| to_str = STR("\r\n") | |
| s_replace = s.replace | |
| for x in _RANGE_10: | |
| s_replace(from_str, to_str) | |
| # This decreases the character count | |
| @bench('"When shall we three meet again?".replace("ee", "")', | |
| 'replace/remove multiple characters', 1000) | |
| def replace_multiple_character_remove(STR): | |
| s = STR("When shall we three meet again?") | |
| from_str = STR("ee") | |
| to_str = STR("") | |
| s_replace = s.replace | |
| for x in _RANGE_1000: | |
| s_replace(from_str, to_str) | |
| big_s = "A" + ("Z"*128*1024) | |
| big_s_bytes = bytes_from_str(big_s) | |
| big_s_unicode = unicode_from_str(big_s) | |
| def _get_big_s(STR): | |
| if STR is UNICODE: return big_s_unicode | |
| if STR is BYTES: return big_s_bytes | |
| raise AssertionError | |
| # The older replace implementation counted all matches in | |
| # the string even when it only needed to make one replacement. | |
| @bench('("A" + ("Z"*128*1024)).replace("A", "BB", 1)', | |
| 'quick replace single character match', 10) | |
| def quick_replace_single_match(STR): | |
| s = _get_big_s(STR) | |
| from_str = STR("A") | |
| to_str = STR("BB") | |
| s_replace = s.replace | |
| for x in _RANGE_10: | |
| s_replace(from_str, to_str, 1) | |
| @bench('("A" + ("Z"*128*1024)).replace("AZZ", "BBZZ", 1)', | |
| 'quick replace multiple character match', 10) | |
| def quick_replace_multiple_match(STR): | |
| s = _get_big_s(STR) | |
| from_str = STR("AZZ") | |
| to_str = STR("BBZZ") | |
| s_replace = s.replace | |
| for x in _RANGE_10: | |
| s_replace(from_str, to_str, 1) | |
| #### | |
| # CCP does a lot of this, for internationalisation of ingame messages. | |
| _format = "The %(thing)s is %(place)s the %(location)s." | |
| _format_dict = { "thing":"THING", "place":"PLACE", "location":"LOCATION", } | |
| _format_bytes = bytes_from_str(_format) | |
| _format_unicode = unicode_from_str(_format) | |
| _format_dict_bytes = dict((bytes_from_str(k), bytes_from_str(v)) for (k,v) in _format_dict.items()) | |
| _format_dict_unicode = dict((unicode_from_str(k), unicode_from_str(v)) for (k,v) in _format_dict.items()) | |
| def _get_format(STR): | |
| if STR is UNICODE: | |
| return _format_unicode | |
| if STR is BYTES: | |
| if sys.version_info >= (3,): | |
| raise UnsupportedType | |
| return _format_bytes | |
| raise AssertionError | |
| def _get_format_dict(STR): | |
| if STR is UNICODE: | |
| return _format_dict_unicode | |
| if STR is BYTES: | |
| if sys.version_info >= (3,): | |
| raise UnsupportedType | |
| return _format_dict_bytes | |
| raise AssertionError | |
| # Formatting. | |
| @bench('"The %(k1)s is %(k2)s the %(k3)s."%{"k1":"x","k2":"y","k3":"z",}', | |
| 'formatting a string type with a dict', 1000) | |
| def format_with_dict(STR): | |
| s = _get_format(STR) | |
| d = _get_format_dict(STR) | |
| for x in _RANGE_1000: | |
| s % d | |
| #### Upper- and lower- case conversion | |
| @bench('("Where in the world is Carmen San Deigo?"*10).lower()', | |
| "case conversion -- rare", 1000) | |
| def lower_conversion_rare(STR): | |
| s = STR("Where in the world is Carmen San Deigo?"*10) | |
| s_lower = s.lower | |
| for x in _RANGE_1000: | |
| s_lower() | |
| @bench('("WHERE IN THE WORLD IS CARMEN SAN DEIGO?"*10).lower()', | |
| "case conversion -- dense", 1000) | |
| def lower_conversion_dense(STR): | |
| s = STR("WHERE IN THE WORLD IS CARMEN SAN DEIGO?"*10) | |
| s_lower = s.lower | |
| for x in _RANGE_1000: | |
| s_lower() | |
| @bench('("wHERE IN THE WORLD IS cARMEN sAN dEIGO?"*10).upper()', | |
| "case conversion -- rare", 1000) | |
| def upper_conversion_rare(STR): | |
| s = STR("Where in the world is Carmen San Deigo?"*10) | |
| s_upper = s.upper | |
| for x in _RANGE_1000: | |
| s_upper() | |
| @bench('("where in the world is carmen san deigo?"*10).upper()', | |
| "case conversion -- dense", 1000) | |
| def upper_conversion_dense(STR): | |
| s = STR("where in the world is carmen san deigo?"*10) | |
| s_upper = s.upper | |
| for x in _RANGE_1000: | |
| s_upper() | |
| # end of benchmarks | |
| ################# | |
| class BenchTimer(timeit.Timer): | |
| def best(self, repeat=1): | |
| for i in range(1, 10): | |
| number = 10**i | |
| x = self.timeit(number) | |
| if x > 0.02: | |
| break | |
| times = [x] | |
| for i in range(1, repeat): | |
| times.append(self.timeit(number)) | |
| return min(times) / number | |
| def main(): | |
| (options, test_names) = parser.parse_args() | |
| if options.bytes_only and options.unicode_only: | |
| raise SystemExit("Only one of --8-bit and --unicode are allowed") | |
| bench_functions = [] | |
| for (k,v) in globals().items(): | |
| if hasattr(v, "is_bench"): | |
| if test_names: | |
| for name in test_names: | |
| if name in v.group: | |
| break | |
| else: | |
| # Not selected, ignore | |
| continue | |
| if options.skip_re and hasattr(v, "uses_re"): | |
| continue | |
| bench_functions.append( (v.group, k, v) ) | |
| bench_functions.sort() | |
| p("bytes\tunicode") | |
| p("(in ms)\t(in ms)\t%\tcomment") | |
| bytes_total = uni_total = 0.0 | |
| for title, group in itertools.groupby(bench_functions, | |
| operator.itemgetter(0)): | |
| # Flush buffer before each group | |
| sys.stdout.flush() | |
| p("="*10, title) | |
| for (_, k, v) in group: | |
| if hasattr(v, "is_bench"): | |
| bytes_time = 0.0 | |
| bytes_time_s = " - " | |
| if not options.unicode_only: | |
| try: | |
| bytes_time = BenchTimer("__main__.%s(__main__.BYTES)" % (k,), | |
| "import __main__").best(REPEAT) | |
| bytes_time_s = "%.2f" % (1000 * bytes_time) | |
| bytes_total += bytes_time | |
| except UnsupportedType: | |
| bytes_time_s = "N/A" | |
| uni_time = 0.0 | |
| uni_time_s = " - " | |
| if not options.bytes_only: | |
| try: | |
| uni_time = BenchTimer("__main__.%s(__main__.UNICODE)" % (k,), | |
| "import __main__").best(REPEAT) | |
| uni_time_s = "%.2f" % (1000 * uni_time) | |
| uni_total += uni_time | |
| except UnsupportedType: | |
| uni_time_s = "N/A" | |
| try: | |
| average = bytes_time/uni_time | |
| except (TypeError, ZeroDivisionError): | |
| average = 0.0 | |
| p("%s\t%s\t%.1f\t%s (*%d)" % ( | |
| bytes_time_s, uni_time_s, 100.*average, | |
| v.comment, v.repeat_count)) | |
| if bytes_total == uni_total == 0.0: | |
| p("That was zippy!") | |
| else: | |
| try: | |
| ratio = bytes_total/uni_total | |
| except ZeroDivisionError: | |
| ratio = 0.0 | |
| p("%.2f\t%.2f\t%.1f\t%s" % ( | |
| 1000*bytes_total, 1000*uni_total, 100.*ratio, | |
| "TOTAL")) | |
| if __name__ == "__main__": | |
| main() |