def fastmap(self, func, iterable):
main_timer = timeit.Timer()
iterable = list(iterable) # TODO
if not iterable:
self.log.warning("Returning empty set due to empty iterable")
return []
self.log.info(f"Mapping {func.__name__} to {len(iterable)} items")
# if isinstance(iterable, types.GeneratorType): # TODO
# first_batch = list(itertools.islice(iterable, num_threads))
first_batch = iterable[:self.num_threads]
iterable = iterable[self.num_threads:]
avg_size_element = len(json.dumps(first_batch)) / self.num_threads
mapped_results = []
with Pool(self.num_threads) as local_pool:
timed_func_results = local_pool.map(lambda e: _timed_func(func, e), first_batch)
avg_local_dur = sum(r[0] for r in timed_func_results) / self.num_threads
mapped_results += [r[1] for r in timed_func_results]
sources = _get_full_sources(func)
module_name = func.__module__.__name__
func_name = func.__name__
func_hash = _gen_hash(sources, module_name, func_name)
if func_hash in _transfer_durs:
avg_transfer_dur = _transfer_durs[func_hash]
else:
start_time = time.time()
post_payload = json.dumps({"source": sources,
"module_name": module_name,
"func_name": func_name})
resp = post_json(Defaults.CLOUD_URL + "/api/v1/init_map", post_payload)
elapsed_time = time.time() - start_time
transfer_time = elapsed_time - resp['elapsed_time']
avg_transfer_dur = 0 # TODO
if True: # avg_local_dur < _config.avg_transfer_dur():
self.log.info(f"Local-execution-time < item-transfer-time ({avg_local_dur}s < {avg_transfer_dur}s). Executing entire map locally"),
with Pool(self.num_threads) as local_pool:
mapped_results += local_pool.map(func, iterable)
self.log.info(f"Processed {len(iterable)} items in {main_timer.timeit()}s")
return mapped_results
self.log.info(f"item-transfer-time < local-execution-time ({avg_local_dur}s < {avg_transfer_dur}s). Executing on cloud and locally"),
def iSort(self, r1):
'''
Function for insertion sort
- always maintains a sorted sublist in
the lower positions of the list.
- Each new item is then “inserted” back
into the previous sublist such that the
sorted sublist is one item larger.
'''
print("iSort")
for index in range(1, len(r1)):
currentvalue = r1[index]
position = index
while position > 0 and r1[position - 1] > currentvalue:
r1[position] = r1[position - 1]
position = position - 1
r1[position] = currentvalue
print(r1)
t3 = timeit.Timer('a.iSort()', 'from __main__ import a').timeit(1)
a3time.append(t3) #time for 1 time and add them to a timeset
def bubbleSort(self, r1):
'''
Function for bubble sort
- makes multiple passes through a list.
- compares adjacent items and exchanges those that are out of order.
'''
#If there are n items in the list,
#then there are n−1 pairs of items that need to be compared on the first pass.
print("bSort")
for passnum in range(len(r1) - 1, 0, -1):
for i in range(passnum): #Between the items for comparison:
if r1[i] > r1[
i +
1]: #If the former term is greater than the letter one:
temp = r1[i]
r1[i] = r1[i + 1]
r1[i + 1] = temp #They will be swapped.
print(r1)
t1 = timeit.Timer('a.bSort()', 'from __main__ import a').timeit(1)
a1time.append(t1) #time for 1 time and add them to a timeset
def sSort(self, r1):
'''
Function for selection sort
- improves on the bubble sort by making
only one exchange for every pass through the list.
- looks for the largest value as it makes a pass and,
after completing the pass,
places it in the proper location.
'''
print("sSort")
for fillslot in range(len(r1) - 1, 0, -1):
positionOfMax = 0
for location in range(1, fillslot + 1):
if r1[location] > r1[positionOfMax]:
positionOfMax = location
temp = r1[fillslot]
r1[fillslot] = r1[positionOfMax]
r1[positionOfMax] = temp
print(r1)
t2 = timeit.Timer('a.sSort()', 'from __main__ import a').timeit(1)
a2time.append(t2) #time for 1 time and add them to a timeset
#/usr/bin/env python
# -*- coding: utf-8 -*-
"""
"""
"""
pre:
1.
post:
1.
"""
class Solution(object):
pass
if __name__ == "__main__":
from timeit import timeit
n = 0
ret = Solution()
print(ret)
import timeit
timer = timeit.Timer("Solution().functionCall(%s)" % n, "from __main__ import Solution")
print("timeConsume: %s" % timer.timeit(10))
sum_buffer = sum_buffer - old_tick + new_tick
ma.append(sum_buffer/window_length)
return ma
if __name__ == "__main__" :
data_length = 100000 # 总数据量
# 生成测试数据
data = []
for i in range(data_length):
data.append(random.randint(1, 100))
window_length = 500 # 移动均值的窗口
test_times = 10 # 测试次数
t_basic = timeit.Timer(functools.partial(window_mean_basic, data, window_length))
t_numpy_wrong = timeit.Timer(functools.partial(window_mean_numpy_wrong, data, window_length))
t_numpy_right = timeit.Timer(functools.partial(window_mean_numpy_right, data, window_length))
t_numba = timeit.Timer(functools.partial(window_mean_numba, data, window_length))
t_cache_algorithm = timeit.Timer(functools.partial(window_mean_cache, data, window_length))
print("basic :\t" + str(t_basic.timeit(test_times)))
print("numpy wrong :\t" + str(t_numpy_wrong.timeit(test_times)))
print("numpy right :\t" + str(t_numpy_right.timeit(test_times)))
print("numba :\t" + str(t_numba.timeit(test_times)))
print("cache algorithm :\t" + str(t_cache_algorithm.timeit(test_times)))
start = time.time()
cores = multiprocessing.cpu_count()
pool = multiprocessing.Pool(processes=cores)
result = []
return False
p_0 = 0
p_1 = 1
p_s = 0
while p_s!=len_s:
if p[p_0]==s[p_s]:
p_0+=1
p_s+=1
elif p[p_0]==".":
pass
p_s+=1
def cheat(self, s, p):
import re
return bool(re.match("^"+p+"$", s))
if __name__ == "__main__":
from timeit import timeit
s = "aaa"
p = "ab*a"
#from ipdb import set_trace; set_trace()
ret = Solution().isMatch(s, p)
print(ret)
import timeit
timer = timeit.Timer("Solution().isMatch('%s', '%s')" % (s, p), "from __main__ import Solution")
print("timeConsume: %s" % timer.timeit(10))
def _timed_func(func, *args):
t = timeit.Timer()
ret = func(*args)
return (t.timeit(), ret)
length = len(nums)
if length < 4:
return max(nums)
self.search(nums[:-1], tmp=0)
self.search(nums[1:], tmp=0)
self.search(nums[2:], tmp=0)
return self.ret
def search(self, nums, tmp):
if nums:
tmp += nums[0]
self.search(nums[2:], tmp)
self.search(nums[3:], tmp)
else:
if tmp > self.ret:
self.ret = tmp
if __name__ == "__main__":
from timeit import timeit
nums = [
226, 174, 214, 16, 218, 48, 153, 131, 128, 17, 157, 142, 88, 43, 37,
157, 43, 221
] #,191,68,206,23,225,82,54,118,111,46,80,49,245,63,25,194,72,80,143,55,209,18,55,122,65,66,177,101,63,201,172,130,103,225,142,46,86,185,62,138,212,192,125,77,223,188,99,228,90,25,193,211,84,239,119,234,85,83,123,120,131,203,219,10,82,35,120,180,249,106,37,169,225,54,103,55,166,124]
ret = Solution().rob(nums)
print(ret)
import timeit
timer = timeit.Timer("Solution().rob(%s)" % nums,
"from __main__ import Solution")
print("timeConsume: %s" % timer.timeit(10))
r2.append(int(random.random() * 20000))
r3 = []
for i in range(0, 30000):
r3.append(int(random.random() * 30000))
r4 = []
for i in range(0, 40000):
r4.append(int(random.random() * 40000))
r5 = []
for i in range(0, 50000):
r5.append(int(random.random() * 50000))
a = sortingAlgorithms()
a.bubbleSort(r1)
a.sSort(r1)
a.iSort(r1)
timeit.Timer(a.bSort).timeit()
timeit.Timer(a.sSort).timeit()
timeit.Timer(a.iSort).timeit()
a.output()
#Make a title for the graph
plt.title("Sorting Algorithms")
#Plot the time(x-value(s),y-value(s),the style(red dots) of graph)
plt.plot(r1, [a1time, a2time, a3time], 'ro:')
#Change the size of the axis label:
ax = plt.gca()
for label in ax.xaxis.get_ticklabels():
label.set_fontsize(20)
for label in ax.yaxis.get_ticklabels():
label.set_fontsize(20)
myfont = matplotlib.font_manager.FontProperties(
fname='C:/Windows/Fonts/simsun.ttc', size=24)
