import timeit if __name__ == '__main__': # 使用timeit计时 t = timeit.Timer('??()', setup='from __main__ import ??') print(t.timeit(number=1))
} ''' list(t.tokenize(css)) # c = {} # for x in t.tokenize(css): # n = x[0] # try: # c[n] += 1 # except KeyError: # c[n] = 1 # print c """ t = cssutils.tokenize2.Tokenizer() t = timeit.Timer(do) # outside the try/except try: print(t.timeit(100)) # or t.repeat(...) except Exception: print(t.print_exc()) # print cssutils.script.csscombine(p, # resolveVariables=True) # cssutils.ser.prefs.resolveVariables = True # s = cssutils.parseFile(p) # print s.cssRules # print s.cssText sys.exit(1) if 1:
def test_ppq_cache_enabled_timeit( self, redirects_len: int, timeit_number: int, ppq_cache_max: int, ): """ Test the `RedirectHandler._ppq_cache` is actually useful by timing the difference with and without via `ppq_cache_enabled` flag """ time_start = time.time() RedirectHandler._ppq_cache_max = ppq_cache_max def _gen_redirects(redirects_len_: int) -> Re_Entry_Dict: """generate a `Re_Entry_Dict` of size `redirects_len_`.""" redirects_ = Re_Entry_Dict_new() for i_ in range(0, redirects_len_): from_ = "/%08X" % i_ to_ = "/%08X" % i_ redirects_[Re_EntryKey(from_)] = Re_Entry(from_, to_) return redirects_ # generate the redirects entries redirects = _gen_redirects(redirects_len) # create a small variety of lookups lookups = list() for l_ in ( "/NO-MATCH1", #"/NO-MATCH2;f", #"/NO-MATCH3;f?a=A", #"/NO-MATCH4#foobar", # should match generated entries in `_gen_redirects` "/%08X" % 1, "/%08X?a=A" % 2, "/%08X#c" % 3, "/%08X?a=A&b=B#c" % 4, "/%08X?a=A&b=B#c" % int(redirects_len / 2), "/%08X?a=A&b=B#c" % (redirects_len - 2), "/%08X?a=A&b=B#c" % (redirects_len - 1), ): lookups.append((l_, urllib.parse.urlparse(l_),)) # save `cache_enabled` setting cache_enabled_prev = RedirectHandler.ppq_cache_enabled print("", file=sys.stderr) results = {True: None, False: None} for cache_enabled in (True, False,): # set `cache_enabled` to test setting, clear cache RedirectHandler.ppq_cache_enabled = cache_enabled RedirectHandler.ppq_cache_clear() print("timeit(%4d) lookups len %d, redirects size %-5d, cache enabled %-5s: " % (timeit_number, len(lookups), len(redirects), RedirectHandler.ppq_cache_enabled,), end="", file=sys.stderr) sys.stdout.flush() sys.stderr.flush() # timeit code def stmt_(): for (ppq, ppqpr) in lookups: __, ___ = RedirectHandler._do_VERB_redirect_processing(ppq, ppqpr, redirects) time1 = timeit.Timer(stmt=stmt_, globals=globals()).timeit(number=timeit_number) # print timeit results print("%1.6f" % (time1,), file=sys.stderr) sys.stdout.flush() sys.stderr.flush() # save timeit results for later assert results[cache_enabled] = time1 # restore `cache_enabled` setting, clear cache RedirectHandler.ppq_cache_enabled = cache_enabled_prev RedirectHandler.ppq_cache_clear() time_stop = time.time() print("total time taken for test case %40s%1.6f" % ("", time_stop - time_start,), file=sys.stderr) # the cache disabled should be larger value (longer time; slower) than cache enabled assert results[False] > results[True]
li.extend([i]) def text6(): li = [] for i in range(10000): li = li + [i] def text7(): li = [] for i in range(10000): li.insert(0, i) time1 = timeit.Timer('text1()', 'from __main__ import text1') print('append:%.2f' % time1.timeit(number=1000)) time2 = timeit.Timer('text2()', 'from __main__ import text2') print('+=:%.2f' % time2.timeit(number=1000)) time3 = timeit.Timer('text3()', 'from __main__ import text3') print('[i for i in range]:%.2f' % time3.timeit(number=1000)) time4 = timeit.Timer('text4()', 'from __main__ import text4') print('list(range):%.2f' % time4.timeit(number=1000)) time5 = timeit.Timer('text5()', 'from __main__ import text5') print('extend:%.2f' % time5.timeit(number=1000)) time6 = timeit.Timer('text6()', 'from __main__ import text6')
import timeit def test1(): l1 = [] for i in range(1, 10000): l1.append(i) def test2(): # 从尾部添加 l1 = [] for i in range(1, 10000): l1.insert(i - 1, i) def test3(): # 从头部添加 l1 = [] for i in range(1, 10000): l1.insert(0, i) if __name__ == '__main__': timeit1 = timeit.Timer("test1()", "from __main__ import test1") timeit2 = timeit.Timer("test2()", "from __main__ import test2") timeit3 = timeit.Timer("test3()", "from __main__ import test3") print("append():", timeit1.timeit(1000)) print("insert(i-1):", timeit2.timeit(1000)) print("insert(0):", timeit3.timeit(1000))
from distutils.core import setup, Extension from Cython.Distutils import build_ext import sys import Cython.Compiler.Options #This will generate HTML to show where there are still pythonic bits hiding out Cython.Compiler.Options.annotate = True if len(sys.argv) == 1: sys.argv += ['build_ext','--inplace'] #Note: the name of the module MUST be the same as the name of the pure Python file ext_modules = [Extension("test", ["test.py"]), ] setup( cmdclass = {'build_ext': build_ext}, ext_modules = ext_modules ) import timeit print timeit.Timer('test.f(0.3)','import test').timeit(10000000) print timeit.Timer('test.g(0.3)','import test').timeit(10000000)
def decorator_without_try(func, num): def _wrapper(*args, **kwargs): func(num, *args, **kwargs) return _wrapper def test_add(num): return num test_decorator_with_try = decorator_with_try(test_add, 1) test_decorator_without_try = decorator_without_try(test_add, 1) test_bind = functools.partial(test_add, 1) if __name__ == '__main__': import timeit t0 = timeit.Timer("test_add(1)", "from __main__ import test_add") t1 = timeit.Timer("wrapper(test_add, 1)", "from __main__ import test_add, wrapper") t2 = timeit.Timer("test_decorator_with_try()", "from __main__ import test_decorator_with_try") t3 = timeit.Timer("test_decorator_without_try()", "from __main__ import test_decorator_without_try") t4 = timeit.Timer("test_bind()", "from __main__ import test_bind") t5 = timeit.Timer("functools.partial(test_add, 1)()", "from __main__ import test_add, functools") loop_times = 3000000 print t0.timeit(number=loop_times) print t1.timeit(number=loop_times) print t2.timeit(number=loop_times) print t3.timeit(number=loop_times)
result_arr.extend(new_arr) return result_arr if __name__ == '__main__': print("The merge sort algorithm") arr = [1, 3, 4, 7, 3, 5, 3, 8, 2, 1] new_arr = merge_sort(arr) print("Start:") pprint.pprint(arr) print("Result:") pprint.pprint(new_arr) # test a big random list big_list = [random.randint(0, 100) for _ in range(100)] big_list_sorted_by_merge = merge_sort(big_list) big_list_sorted_by_sorted = sorted(big_list) for x, y in zip(big_list_sorted_by_merge, big_list_sorted_by_sorted): assert x == y # time performance time = timeit.Timer(lambda: merge_sort(arr)).repeat(repeat=10, number=1) print("\nTime performance (10 items): ", sum(time) / len(time)) time = timeit.Timer(lambda: merge_sort(big_list)).repeat(repeat=10, number=1) print("\nTime performance (100 items): ", sum(time) / len(time))
help='optimize by loading c extensions') argparser.add_argument('-d', '--debug', dest='debug', action='store_true', default=False, help='verbose debug info') args = argparser.parse_args() thislocation = os.path.dirname(os.path.realpath(__file__)) svgpath = os.path.join(thislocation, 'test_svgs') def main(): # svgstring = open(os.path.join(svgpath, "full-bed.svg")).read() svgstring = open(os.path.join(svgpath, "rocket_full.svg")).read() # svgstring = open(os.path.join(svgpath, "rosetta.svg")).read() boundarys = read_svg(svgstring, [1220, 610], 0.08) if args.profile: profile.run("main()", 'profile.tmp') p = pstats.Stats('profile.tmp') p.sort_stats('cumulative').print_stats(30) os.remove('profile.tmp') elif args.timeit: t = timeit.Timer("main()", "from __main__ import main") print t.timeit(1) # print t.timeit(3) else: main()
def time_nms_recommend_item_for_item(): t = timeit.Timer("nms_idx.knnQuery(item_vectors[0])[0]") time = t.timeit(100) return time
naive = ''' for i in range(size): for j in range(size): for k in range(size): C[i + j*size] += A[i + k*size] * B[k + j*size] ''' #Von j ist nur jsize abhängig, deswegen sollte diese Schleife ganz außen sein #Von k ist neben ksize noch der Index c abhängig, weswegen die Schleife als zweite kommt #Von i ist nun die eigentliche Operation abhängig, deswegen muss sie als letzte ausgeführt werden optimised = ''' for j in range(size): jsize=j*size for k in range(size): ksize=k*size c=k + jsize for i in range(size): C[i + jsize] += A[i + ksize] * B[c] ''' repeats = 10 size = 100 t1 = timeit.Timer(naive, initialisation, globals=globals()) t2 = timeit.Timer(optimised, initialisation, globals=globals()) time1 = min(t1.repeat(repeats, 1)) print("execution time naive:", (time1 * 1000), "ms") time2 = min(t2.repeat(repeats, 1)) print("execution time optimised:", (time2 * 1000), "ms") print("Faster:", (1 - time2 / time1) * 100, "%") #Die Komplexität ändert sich nicht, da die Hauptarbeit immer noch in den drei Schleifen steckt
def time_Annoy_recommend_item_for_item(): t = timeit.Timer("temp_t.get_nns_by_vector(item_vectors[0], 10)") time = t.timeit(100) return time
def time_recommend_item_for_item(): t = timeit.Timer( "recommend_item_for_item(item_vectors[0].reshape(1, -1), data, 10)") time = t.timeit(100) return time
for i in range(1, len(parts)): jobs.append(r[:, parts[i - 1]:parts[i]]) # parallel jobs pool, out = mp.Pool(processes=numThreads), [] outputs = pool.imap_unordered(barrierTouch, jobs) for out_ in outputs: out.append(out_) # asynchronous respnse pool.close() pool.join() return #----------------- def barrierTouch(r, width=.5): #find the index of the earliest barrier touch t, p = {}, np.log((1 + r).cumprod(axis=0)) for j in range(r.shape[1]): # go through columns for i in range(r.shape[0]): # go through rows if p[i, j] >= width or p[i, j] <= -width: t[j] = i continue return t #--------------------- if __name__ == '__main__': import timeit print( min( timeit.Timer('main1()', setup='from __main__ import main1').repeat(5, 10)))
#Test time and number of collisions for hash import timeit from universalhash import hash_func, probing_hash, linear_probing, quadratic_probing, test_univ_hash, funcs #import universalhash if __name__ == '__main__': coll_err_time = dict() for i, probfnc in enumerate(funcs): collision, errors = test_univ_hash(1000, hash_func=hash_func, probing_hash=probfnc) print(funcs[i]) t = timeit.Timer("test_univ_hash(1000, hash_func = hash_func, \ probing_hash=probfnc_index)", "from universalhash import hash_func, probing_hash, linear_probing, quadratic_probing,\ test_univ_hash, funcs; probfnc_index=funcs[%i]"%(i)) result = t.repeat(1, 2) print("Total time is %s"%max(result)) coll_err_time[probfnc] = [collision, errors, max(result)] for key, item in coll_err_time.items(): print("Function is %s"%key) print("Collisions, errors, max time is %s, %s, %s"%(item[0], item[1], item[2]))
path = Path('/media/rahulrav/Cruzer/benchmark') # Recreate paths if os.path.exists(path.absolute().as_posix()): shutil.rmtree(path) inputs = ['input'] types = ['int'] tub = Tub(path.as_posix(), inputs, types, max_catalog_len=1000) write_count = 1000 for i in range(write_count): record = {'input': i} tub.write_record(record) deletions = np.random.randint(0, write_count, 100) for index in deletions: index = int(index) tub.delete_record(index) for record in tub: print('Record %s' % record) tub.close() if __name__ == "__main__": timer = timeit.Timer(benchmark) time_taken = timer.timeit(number=1) print('Time taken %s seconds' % time_taken) print('\nDone.')
import timeit from Tests_Sorted.Time_test_sorted_integer_5000 import Array_sorted_integer_5000 f1=Array_sorted_integer_5000.sorted_integer_5000_100 f2=f1.copy() f3=f1.copy() f4=f1.copy() f5=f1.copy() f6=f1.copy() f7=f1.copy() f8=f1.copy() f9=f1.copy() f10=f1.copy() #print("Random array\n",f1,"\n") t=timeit.Timer(lambda : Python_Sort.python_sort(f1)) print("Python sort ",t.timeit(number = 1)) #print(f1,"\n") t=timeit.Timer(lambda : Merge_Sort.merge_sort(f2)) print("Merge sort",t.timeit(number = 1)) #print(f2,"\n") t=timeit.Timer(lambda : Comb_Sort.comb(f3)) print("Comb sort ",t.timeit(number = 1)) #print(f3,"\n") t=timeit.Timer(lambda : Heap_Sort.heapSort(f4)) print("Heap sort ",t.timeit(number = 1)) #print(f4,"\n")
#!/usr/bin/python # # Sprawdzam szybkosc kolorowania wierzcholkow sp-grafu. # Wydaje sie, ze grafy dwudzielne trafiaja sie bardzo rzadko. import timeit import random from graphtheory.structures.edges import Edge from graphtheory.structures.graphs import Graph from graphtheory.seriesparallel.spnodes import Node from graphtheory.seriesparallel.spnodecolor import SPNodeColoring from graphtheory.seriesparallel.sptools import make_random_spgraph from graphtheory.seriesparallel.sptools import make_random_ktree V = 10 G = make_random_spgraph(V) #G = make_random_ktree(V, 2) E = G.e() #G.show() algorithm = SPNodeColoring(G) algorithm.run() all_colors = set(algorithm.color[node] for node in G.iternodes()) assert len(all_colors) == 3 print "Testing SPNodeColoring ..." t1 = timeit.Timer(lambda: SPNodeColoring(G).run()) print V, E, t1.timeit(1) # pojedyncze wykonanie # EOF
def timeit(self, line='', cell=None): """Time execution of a Python statement or expression Usage, in line mode: %timeit [-n<N> -r<R> [-t|-c]] statement or in cell mode: %%timeit [-n<N> -r<R> [-t|-c]] setup_code code code... Time execution of a Python statement or expression using the timeit module. This function can be used both as a line and cell magic: - In line mode you can time a single-line statement (though multiple ones can be chained with using semicolons). - In cell mode, the statement in the first line is used as setup code (executed but not timed) and the body of the cell is timed. The cell body has access to any variables created in the setup code. Options: -n<N>: execute the given statement <N> times in a loop. If this value is not given, a fitting value is chosen. -r<R>: repeat the loop iteration <R> times and take the best result. Default: 3 -t: use time.time to measure the time, which is the default on Unix. This function measures wall time. -c: use time.clock to measure the time, which is the default on Windows and measures wall time. On Unix, resource.getrusage is used instead and returns the CPU user time. -p<P>: use a precision of <P> digits to display the timing result. Default: 3 Examples -------- :: In [1]: %timeit pass 10000000 loops, best of 3: 53.3 ns per loop In [2]: u = None In [3]: %timeit u is None 10000000 loops, best of 3: 184 ns per loop In [4]: %timeit -r 4 u == None 1000000 loops, best of 4: 242 ns per loop In [5]: import time In [6]: %timeit -n1 time.sleep(2) 1 loops, best of 3: 2 s per loop The times reported by %timeit will be slightly higher than those reported by the timeit.py script when variables are accessed. This is due to the fact that %timeit executes the statement in the namespace of the shell, compared with timeit.py, which uses a single setup statement to import function or create variables. Generally, the bias does not matter as long as results from timeit.py are not mixed with those from %timeit.""" import timeit opts, stmt = self.parse_options(line,'n:r:tcp:', posix=False, strict=False) if stmt == "" and cell is None: return timefunc = timeit.default_timer number = int(getattr(opts, "n", 0)) repeat = int(getattr(opts, "r", timeit.default_repeat)) precision = int(getattr(opts, "p", 3)) if hasattr(opts, "t"): timefunc = time.time if hasattr(opts, "c"): timefunc = clock timer = timeit.Timer(timer=timefunc) # this code has tight coupling to the inner workings of timeit.Timer, # but is there a better way to achieve that the code stmt has access # to the shell namespace? transform = self.shell.input_splitter.transform_cell if cell is None: # called as line magic ast_setup = ast.parse("pass") ast_stmt = ast.parse(transform(stmt)) else: ast_setup = ast.parse(transform(stmt)) ast_stmt = ast.parse(transform(cell)) ast_setup = self.shell.transform_ast(ast_setup) ast_stmt = self.shell.transform_ast(ast_stmt) # This codestring is taken from timeit.template - we fill it in as an # AST, so that we can apply our AST transformations to the user code # without affecting the timing code. timeit_ast_template = ast.parse('def inner(_it, _timer):\n' ' setup\n' ' _t0 = _timer()\n' ' for _i in _it:\n' ' stmt\n' ' _t1 = _timer()\n' ' return _t1 - _t0\n') class TimeitTemplateFiller(ast.NodeTransformer): "This is quite tightly tied to the template definition above." def visit_FunctionDef(self, node): "Fill in the setup statement" self.generic_visit(node) if node.name == "inner": node.body[:1] = ast_setup.body return node def visit_For(self, node): "Fill in the statement to be timed" if getattr(getattr(node.body[0], 'value', None), 'id', None) == 'stmt': node.body = ast_stmt.body return node timeit_ast = TimeitTemplateFiller().visit(timeit_ast_template) timeit_ast = ast.fix_missing_locations(timeit_ast) # Track compilation time so it can be reported if too long # Minimum time above which compilation time will be reported tc_min = 0.1 t0 = clock() code = compile(timeit_ast, "<magic-timeit>", "exec") tc = clock()-t0 ns = {} exec code in self.shell.user_ns, ns timer.inner = ns["inner"] if number == 0: # determine number so that 0.2 <= total time < 2.0 number = 1 for i in range(1, 10): if timer.timeit(number) >= 0.2: break number *= 10 best = min(timer.repeat(repeat, number)) / number print u"%d loops, best of %d: %s per loop" % (number, repeat, _format_time(best, precision)) if tc > tc_min: print "Compiler time: %.2f s" % tc
img.save('timing-shapes.png') class0 = mapscript.classObj(ilayer) class0.insertStyle(l.getClass(0).getStyle(0)) img = m.prepareImage() ilayer.draw(m, img) img.save('timing-inline.png') # ========================================================================= # Test 1A: Draw all shapes at once using map.draw() print("Test 1A: draw map, all shapes at once") s = """\ img = m.draw() """ t = timeit.Timer(stmt=s, setup='from __main__ import m') print("%.2f usec/pass" % (1000000 * t.timeit(number=100) / 100)) # ========================================================================= # Test 1B: Draw shape by shape from the shapefileObj print("Test 1B: draw shapes one at a time") s = """\ img = m.prepareImage() for i in range(shpfile.numshapes): s = shpfile.getShape(i) s.classindex = 0 s.draw(m, l, img) """ t = timeit.Timer(stmt=s, setup='from __main__ import m, l, shpfile') print("%.2f usec/pass" % (1000000 * t.timeit(number=100) / 100))
return self.arr def bubbleSort_threadChunk(self, i, n): swapped = False for j in range(0, len(n)-i-1, 1): if n[j] > n[j+1]: # Swap items n[j], n[j+1] = n[j+1], n[j] swapped = True return [n, swapped] # Initialize class bubbleSort_ALGORITHM = bubbleSort() pprint.pprint( bubbleSort_ALGORITHM.bubbleSort_withThreading(50), indent=100 ) bubbleSort_withThreading_TIMER = timeit.Timer("bubbleSort_ALGORITHM.bubbleSort_withThreading(5)", "from __main__ import bubbleSort_ALGORITHM") bubbleSort_noThreading_TIMER = timeit.Timer("bubbleSort_ALGORITHM.bubbleSort_noThreading(5)", "from __main__ import bubbleSort_ALGORITHM") for i in range(10): print() repeat = eval(input("REPEAT > ")) pprint.pprint("BUBBLE SORT ALGORITHM WITH THREADING TIMING : {0}".format(bubbleSort_withThreading_TIMER.repeat(repeat=repeat, number=10000)), indent = 100) pprint.pprint("BUBBLE SORT ALGORITHM NO THREADING TIMING : {0}".format(bubbleSort_noThreading_TIMER.timeit(repeat=repeat, number=10000)), indent = 100)
def timer(f, functionParameters): return min( timeit.Timer(lambda: f(X) if functionParameters == 1 else f(X, Xt)).repeat( 3, 100))
def time_it(description, stmt, setup, _globals, repeat, number, reference=None, check_dtype=None): """ Measure execution of a specified statement which is useful for the performance analysis. In this way, the execution time and respective results can be directly compared. Parameters ---------- description : str Descriptive name of configuration to be shown in the log stmt : str Statement to be timed setup : str Additional statement used for setup _globals : Namespace the code will be executed in (as opposed to inside timeit's namespace) repeat : int How many times to repeat the timeit measurement (results will be gathered as a list) number : int How many times to execute the statement to be timed reference : list of (float, any), optional Result with the same data structure as returned by this function, which will be referenced in order to compare execution time and similarity of the result data check_dtype : str, optional Data type of the result to check Returns ------- (float, any) Tuple of execution time in seconds (minimum of all repetitions) and execution result of first repetition (data depends on the specified statement to be timed) """ def _check_dtype(data_dtype): # check date type if data_dtype == check_dtype: _grade = "MATCH" _file = sys.stdout else: _grade = f"MISMATCH ({str(check_dtype)})" _file = sys.stderr print(f"result dtype: {str(data_dtype):>21} ... {_grade}", file=_file) sleep(0.05) # to get correct output order print(description) # execute timed statement result = timeit.Timer(stmt=stmt, setup=setup, globals=_globals).repeat(repeat=repeat, number=number) # generate tuple of (time, evaluation result), whereby the kept time is # the minimum of all repetitions and the data is the result of the first # execution result = (min(list(zip(*result))[0]), result[0][1]) # print conclusion print(f"time: {result[0]:-29.2f}s") sleep(0.05) # to get correct output order if reference: t = result[0] / reference[0] file = sys.stdout if abs(t - 1) < 2e-2: grade = "EVEN" elif t < 1: grade = "BETTER" else: grade = "WORSE" file = sys.stderr print(f"time factor: {t:-22.2f} ... {grade}", file=file) sleep(0.05) # to get correct output order if reference[1].shape != result[1].shape: if reference[1].shape == result[1].T.shape: # flip computation result, if matrices do not match reference = (reference[0], reference[1].T) else: print( f"result shape: {str(result[1].shape):>21s}" f" ... MISMATCH {str(reference[1].shape)}", file=sys.stderr, ) sleep(0.05) # to get correct output order if check_dtype: _check_dtype(result[1].dtype) print() return result r = np.abs(np.sum(np.subtract(result[1], reference[1]))) file = sys.stdout if r == 0: grade = "PERFECT" elif r < 1e-10: grade = "OKAY" else: grade = "MISMATCH" file = sys.stderr print(f"result sum: {r:-22} ... {grade}", file=file) sleep(0.05) # to get correct output order r = np.abs(np.subtract(result[1], reference[1])).max() file = sys.stdout if r == 0: grade = "PERFECT" elif r < 1e-10: grade = "OKAY" else: grade = "MISMATCH" file = sys.stderr print(f"result max: {r:-22} ... {grade}", file=file) sleep(0.05) # to get correct output order if check_dtype: _check_dtype(result[1].dtype) print() return result
opts, args = getopt.getopt(sys.argv[1:], "ahb:", ["all", "help", "backbars=", "start=", "end="]) if len(args) > 0: start = 0 end = 0 for o, a in opts: if o in ("-h", "--help"): print csvtolist.__doc__ sys.exit() elif o in ("-b", "--backbars"): import pprint #pprint.pprint(csvtolist(args[0],int(a))) #print csvtolist(args[0],int(a)) import timeit tt = timeit.Timer("csvtolist('%s',%d)" % (args[0], int(a)), "from __main__ import csvtolist") print "Run csvtolist once take ", tt.timeit(500) / 500 elif o in ("-a", "--all"): print csvtolist(args[0], maxbars=True) elif o in ("--start"): start = a elif o in ("--end"): end = a if start or end: print csvtolist(args[0], start=start, end=end) else: print csvtolist.__doc__ sys.exit()
def test_lists(self): organizations_query = ''' {{ ...OrganizationList_organizations_1tT5Hu ...OrganizationList_organization_types }} fragment OrganizationList_organization_types on Query {{ getChoicesForDropdown(name: "organization_types") {{ name value id }} }} fragment OrganizationList_organizations_1tT5Hu on Query {{ organizations(filter: {filter}, orderBy: {order_by}) {{ edges {{ node {{ handle_id ...OrganizationRow_organization id __typename }} cursor }} pageInfo {{ hasNextPage endCursor }} }} }} fragment OrganizationRow_organization on Organization {{ handle_id name type organization_id affiliation_customer affiliation_end_customer affiliation_host_user affiliation_partner affiliation_provider affiliation_site_owner parent_organization {{ organization_id id }} incoming {{ name relation {{ type start {{ handle_id node_name id }} id }} }} }} ''' # order by id: native django order by_id_query = organizations_query.format(filter={}, order_by='handle_id_DESC') setup_code = self.setup_code.format(query_value=by_id_query) mark1 = timeit.Timer("""result = schema.execute(query, context=context); assert result.data""", \ setup=setup_code).timeit(1) test_result = "Organization list resolution with default order took {} seconds\n".format( mark1) self.write_to_log_file(test_result) # order by id: native django order name_query = organizations_query.format(filter={}, order_by='name_DESC') setup_code = self.setup_code.format(query_value=name_query) mark2 = timeit.Timer("""result = schema.execute(query, context=context); assert result.data""", \ setup=setup_code).timeit(1) test_result = "Organization list resolution with name order took {} seconds\n".format( mark2) self.write_to_log_file(test_result) contacts_query = ''' query SearchContactsAllQuery{{ ...ContactList_contacts_1tT5Hu ...ContactList_organization_types ...ContactList_roles_default }} fragment ContactList_contacts_1tT5Hu on Query {{ contacts(filter: {filter}, orderBy: {order_by}) {{ edges {{ node {{ handle_id ...ContactRow_contact id __typename }} cursor }} pageInfo {{ endCursor hasNextPage hasPreviousPage startCursor }} }} }} fragment ContactList_organization_types on Query {{ getChoicesForDropdown(name: "organization_types") {{ name value id }} }} fragment ContactList_roles_default on Query {{ getRolesFromRoleGroup {{ handle_id name }} }} fragment ContactRow_contact on Contact {{ handle_id first_name last_name contact_type modified roles {{ name end {{ name id }} }} }} ''' # order by id: native django order by_id_query = contacts_query.format(filter={}, order_by='handle_id_DESC') setup_code = self.setup_code.format(query_value=by_id_query) mark1 = timeit.Timer("""result = schema.execute(query, context=context); assert result.data""", \ setup=setup_code).timeit(1) test_result = "Contact list resolution with default order took {} seconds\n".format( mark1) self.write_to_log_file(test_result) # order by id: native django order name_query = contacts_query.format(filter={}, order_by='name_DESC') setup_code = self.setup_code.format(query_value=name_query) mark2 = timeit.Timer("""result = schema.execute(query, context=context); assert result.data""", \ setup=setup_code).timeit(1) test_result = "Contact list resolution with name order took {} seconds\n".format( mark2) self.write_to_log_file(test_result) groups_query = ''' query SearchGroupAllQuery{{ ...GroupList_groups_1tT5Hu }} fragment GroupList_groups_1tT5Hu on Query {{ groups(filter: {filter}, orderBy: {order_by}) {{ edges {{ node {{ handle_id ...GroupRow_group id __typename }} cursor }} pageInfo {{ hasNextPage endCursor }} }} }} fragment GroupRow_group on Group {{ handle_id name description }} ''' # order by id: native django order by_id_query = groups_query.format(filter={}, order_by='handle_id_DESC') setup_code = self.setup_code.format(query_value=by_id_query) mark1 = timeit.Timer("""result = schema.execute(query, context=context); assert result.data""", \ setup=setup_code).timeit(1) test_result = "Group list resolution with default order took {} seconds\n".format( mark1) self.write_to_log_file(test_result) # order by id: native django order name_query = groups_query.format(filter={}, order_by='name_DESC') setup_code = self.setup_code.format(query_value=name_query) mark2 = timeit.Timer("""result = schema.execute(query, context=context); assert result.data""", \ setup=setup_code).timeit(1) test_result = "Group list resolution with name order took {} seconds\n".format( mark2) self.write_to_log_file(test_result)
'Numpy': np.sort} for input_ordering in ['sorted', 'reverse', 'random']: for input_size in range(1, 8): test_data = np.random.random((10 ** input_size,)) if input_ordering == 'sorted': test_data = sorted(test_data) elif input_ordering == 'reverse': test_data = list(reversed(sorted(test_data))) for sorting_name, sorting_function in sorting_functions.items(): quicksort_recursion_error = sorting_name == 'Quicksort' and ((input_ordering == 'sorted' or input_ordering == 'reverse') and input_size > 2) if not quicksort_recursion_error: clock = timeit.Timer(stmt='sort_func(copy(data))', globals={'sort_func': sorting_function, 'data': test_data, 'copy': copy.copy}) n_ar, t_ar = clock.autorange() t = clock.repeat(repeat=7, number=n_ar) print( f"{sorting_name} minimum time on {input_ordering} data of size 10^{input_size}:", min(t)) for run_number in range(7): results = results.append({'Input ordering': input_ordering, 'Input size': 10 ** input_size, 'Run number': run_number + 1, 'Sorting algorithm': sorting_name, 'Time': t[run_number]}, ignore_index=True)
80. import random print(random.randrange(7,15)) 81. import zlib string="hello world!hello world!hello world!hello world!" byt=bytes(string,"utf-8") print(zlib.compress(byt)) print(zlib.decompress(byt)) 82. import timeit t=timeit.Timer("for i in range(100):1+1") print(t.timeit()) 83. import random li=[3,6,7,8] random.shuffle(li) print(li) 84. subject=["I","You"] verb=["Play", "Love"] object=["Hockey", "Football"] for s in subject: for v in verb:
import dis import inspect import timeit programs = dict( loop=""" multiples_of_two = [] for x in range(100): if x % 2 == 0: multiples_of_two.append(x) """, comprehension='multiples_of_two = [x for x in range(100) if x % 2 == 0]', ) for name, text in programs.iteritems(): print name, timeit.Timer(stmt=text).timeit() code = compile(text, '<string>', 'exec') dis.disassemble(code)
import numpy as np from scipy import linalg import timeit m, n = 50, 50 A = np.random.rand(m, n) B = np.random.rand(m, n) def my_func1(): X1 = linalg.solve(A, B) def my_func2(): X2 = np.dot(linalg.inv(A), B) t1 = timeit.Timer(stmt=my_func1).timeit(number=100) t2 = timeit.Timer(stmt=my_func2).timeit(number=100) print(t1, t2)
def timeout_handler(signum, frame): raise Timeout() signal.signal(signal.SIGALRM, timeout_handler) NUMBER = 10 REPEAT_COUNT = 3 TIMEOUT = 10 SIZE_LIST = [10, 1024, 2 * 1024, 100 * 1024, 1024 * 1024] timers = { 'pyhtml2text': timeit.Timer( 'html2text(html)', setup='from pyhtml2text import html2text; from __main__ import html'), 'html2text': timeit.Timer( 'h.handle(html)', setup= 'import html2text as python_html2text; h = python_html2text.HTML2Text(); from __main__ import html' ), 'bs4+html.parser': timeit.Timer( 'BeautifulSoup(html, "html.parser").get_text()', setup='from bs4 import BeautifulSoup; from __main__ import html'), 'bs4+lxml': timeit.Timer( 'BeautifulSoup(html, "lxml").get_text()', setup='from bs4 import BeautifulSoup; from __main__ import html'),