本文整理汇总了Python中queue.PriorityQueue.get_nowait方法的典型用法代码示例。如果您正苦于以下问题:Python PriorityQueue.get_nowait方法的具体用法?Python PriorityQueue.get_nowait怎么用?Python PriorityQueue.get_nowait使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类queue.PriorityQueue
的用法示例。
在下文中一共展示了PriorityQueue.get_nowait方法的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: findWayByAStar
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
def findWayByAStar(start, isFinish, getDistance, getIncidenceList, getHeuristicCostEstimate):
"""
start - start vertex, isFinish - function which returns True only on finish
getIncidenceList(vertex) - returns incidence list of vertex,
getDistance(first_vertex, second_vertex) - returns distance from first_vertex to second_vertex,
getHeuristicCostEstimate(vertex).
findWayByAStar returns path(list) from start to finish
"""
processed_vertices = set()
waiting_vertices = set((start, ))
node_queue = PriorityQueue()
node_storage = dict()
node_storage[start] = _AStarNode(start)
node_storage[start].hce = getHeuristicCostEstimate(start)
node_storage[start].updateSum()
node_queue.put_nowait(tuple(((node_storage[start].sum, 0), node_storage[start].vertex)))
while len(waiting_vertices) != 0:
processing_vertex = node_queue.get_nowait()[1] # item = ((priority number, priority_index), data).
while processing_vertex in processed_vertices:
processing_vertex = node_queue.get_nowait()[1]
if isFinish(processing_vertex):
return _createPath(processing_vertex, node_storage)
_processVertex(processing_vertex, getDistance, getIncidenceList, getHeuristicCostEstimate,
processed_vertices, waiting_vertices, node_storage, node_queue)
raise Exception("Path doesn't exist")
示例2: getREF
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
def getREF(self):
#used to make sure that each each vector in priority queue is a unique instance
#Using a tuple to make priorities in the queue b/c there are too
#many ways to naturally sort vectors and subclassing seemed like overkill
#First tiebreaker is the pivot location
#Next tiebreaker is "qId" which is basically the order it entered the queue
def nextQId():
nextQId.id = nextQId.id+1
return nextQId.id
nextQId.id = 0
#These methods have to do with the PriorityQueue
#The first converts the vector to a tuple so that the priority queue can sort by the pivot
#The second converts from this tuple back to vector form
def qForm(vec):
if vec.firstNonZeroLoc() is not None:
return (vec.firstNonZeroLoc(),nextQId(),vec)
else:
return vec.getDimension()+1,nextQId(),vec
def vecForm(tup):
return tup[2]
q = PriorityQueue()
for row in self.rows:
q.put_nowait(qForm(row))
finishedVecs = []
while not q.empty():
topVec = vecForm(q.get_nowait())
if q.empty(): #top Vec was the last one
finishedVecs.append(topVec)
break
#can't use zero vector to subtract stuff out
#Additionally, this means all remaining vectors are zero vectors
elif topVec.firstNonZeroLoc() is None:
finishedVecs.append(topVec)
else:
nextVec = vecForm(q.get_nowait())
#While there are vectors w/ same pivot, subtract them
while nextVec is not None and nextVec.firstNonZeroLoc() == topVec.firstNonZeroLoc():
subNextVec = nextVec - topVec*(nextVec.firstNonZeroVal()//topVec.firstNonZeroVal())
q.put_nowait(qForm(subNextVec))
nextVec = vecForm(q.get_nowait()) #Have to put in queue to make sure we don't skip any w/ same pivot
if nextVec is not None: #got out of loop b/c pivot position didn't math. There is probably a cleaner way to do this
q.put_nowait(qForm(nextVec))
finishedVecs.append(topVec)#topVec is now the only one w/ that pivot
return Matrix(finishedVecs)
示例3: MultiThreadedWeatherDatabase
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
class MultiThreadedWeatherDatabase(Thread):
def __init__(self, file):
super(MultiThreadedWeatherDatabase, self).__init__()
self.file = file
self.queue = PriorityQueue()
self.event = Event()
self.create_tables = False
if not os.path.isfile(file):
self.create_tables = True
self.start() # Threading module start
def run(self):
super(MultiThreadedWeatherDatabase, self).run()
db = sqlite3.connect(self.file)
cursor = db.cursor()
if self.create_tables:
self.create_all_tables()
while True:
if self.queue.empty():
sleep(0.1) # So the thread doesnt use all of the processor
continue
job, sql, arg, result = self.queue.get_nowait()
if sql == '__close__':
break
if arg is None:
arg = ''
cursor.execute(sql, arg)
db.commit()
if result:
for rec in cursor:
result.put(rec)
result.put('__last__')
db.close()
self.event.set()
def execute(self, sql, args=None, res=None, priority=2):
self.queue.put_nowait((priority, sql, args, res))
def select(self, sql, args=None, priority=2):
res = Queue()
self.execute(sql, args, res, priority)
while True:
rec = res.get()
if rec == '__last__':
break
yield rec
def close(self):
self.execute('__close__')
def create_all_tables(self):
command1 = '''CREATE TABLE location (location_id INTEGER PRIMARY KEY , town TEXT, country TEXT, lat REAL, lon REAL, dateadded INTEGER, timezone INTEGER)'''
self.execute(command1)
command2 = '''CREATE TABLE "forecast" (forecast_id INTEGER PRIMARY KEY, location_id INTEGER, time INTEGER, temp REAL, pressure INTEGER, humidity INTEGER, clouds INTEGER, windspeed REAL, winddirection INTEGER, symbol INTEGER, FOREIGN KEY (location_id) REFERENCES location (location_id) DEFERRABLE INITIALLY DEFERRED)'''
self.execute(command2)
def remove_old_forecasts(self):
command = '''DELETE FROM forecast WHERE forecast.time < STRFTIME('%s', 'now')'''
self.execute(command)
示例4: MemStorage
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
class MemStorage(object):
def __init__(self):
self.urls = PriorityQueue()
def read_next(self):
return self.urls.get_nowait()
def write(self, timestamp, url):
self.urls.put((timestamp, url))
示例5: Dijkstra
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
def Dijkstra(self, source):
best = {x: inf for x in self.vertices}
best[source] = 0
S = PriorityQueue()
S.put((0, source))
while not S.empty():
(_, x) = S.get_nowait()
for (y, weight) in self.outboundEdges(x):
alternativeCost = best[x] + weight
if alternativeCost < best[y]:
#print("best[%i] = best[%i] + weight(%i, %i) = %i + %i = %i" % (y, x, x, y, best[x], weight, alternativeCost))
best[y] = alternativeCost
S.put((best[y], y))
return best
示例6: dijkstra
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
def dijkstra(g, s):
"""
Computes shortest past from source vertex to every other vertex
graph must be a weighted undirected graph
"""
# dist = [float('inf') for _ in range(graph.size)]
# dist[s] = 0
from queue import PriorityQueue
# This is to keep easy track of v -> distance
visited = [[[False, float('inf')], x] for x in range(g.size)]
visited[s][0][1] = 0
# The idea behind using a PQueue is that it can be faster if implemented
# with a heap. The items are ((visited, distance), v). This way the
# unvisited will always come up first, ordered by distance. The lowest key
# will therefore be exactly what we want
# This makes every lookup O(|V|), keeping it balanced
# If the heap were built efficiently that'd just be O(|V|), but the way I
# built it it's just O(|V|log|V|) since I do consecutive inserts
q = PriorityQueue()
for item in visited:
q.put_nowait(item)
closest = lambda: q.get_nowait()
# Result is O(|E| + |V|log|V|) since we're handling every edge once and
# the heapify occurs only |V| times, i.e. until the we handled all vertices
for _ in range(g.size - 1):
u = closest()
u[0][0] = True
if u[0][1] == float('inf'):
continue
print(g.getNeighbors(u[1]))
for neighbor in g.getNeighbors(u[1]):
v = visited[neighbor]
distance = u[0][1] + g.m[u[1]][v[1]]
if not v[0][0] and distance < v[0][1]:
v[0][1] = distance
return [entry[0][1] for entry in visited]
示例7: shortest_distance
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
def shortest_distance(graph, origin, target):
"""takes a graph, an origin node and a target node and returns the length
of the shortest path, or None if the path does not exist."""
q = PriorityQueue()
q.put((0, origin))
visited = set()
while True:
if q.empty():
return "IMPOSSIBLE"
node_cost, node = q.get_nowait()
if node == target:
return node_cost
if not node in visited:
visited.add(node)
for neigh, neigh_cost in graph[node]:
if not neigh in visited:
q.put((node_cost + neigh_cost, neigh))
示例8: solve
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
def solve():
b = dict()
x = dict()
q = PriorityQueue()
for i in range(1, 10):
q.put((Node(int(i * str(d)), i)))
b[i] = b.get(i, []) + []
while not q.empty():
c = q.get_nowait()
if c.b > 9 or (c.b >= b.get(c.a, MAXINT)):
continue
if c.a == n:
return c.b
b[c.a] = c.b
for i in range(1, 10):
y = int(i*str(d))
q.put_nowait(Node(c.a + y, c.b+i))
q.put_nowait(Node(c.a - y, c.b+i))
q.put_nowait(Node(c.a * y, c.b+i))
q.put_nowait(Node(c.a // y, c.b+i))
示例9: range
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
str="abcdefghijk"
import random
#Queue
q=Queue(10)
for i in range(10):
q.put(random.choice(str))
print("size=",q.qsize())
while not q.empty():
print(q.get())
q.task_done()
#Lifo Queue
print("-"*10,"lifo_queue","-"*10)
lifoq=LifoQueue(10)
for i in range(10):
lifoq.put_nowait(random.choice(str))
while not lifoq.empty():
print(lifoq.get_nowait())
lifoq.task_done()
#Priority Queue
print("-"*10,"priority queue","-"*10)
pq=PriorityQueue(10)
for i in range(10):
pq.put_nowait(random.choice(str))
while not pq.empty():
print(pq.get_nowait())
pq.task_done()
示例10: __init__
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
#.........这里部分代码省略.........
# # t.start()
# threads.append(t)
# self.traversed_focus = 0
leaves = self.tree.paths_to_leaves()
# logger.debug('leaves from tree: {}'.format(len(leaves)))
# leaves.sort(key=lambda lp: len(lp) + sum(int(lpn.split('_')[0]) for lpn in lp), reverse=True)
# # logger.debug('{} leaves are now sorted by formula'.format(len(leaves)))
# logger.debug('{}'.format(json.dumps(leaves[:3], indent=4, default=str)))
# leaves.sort(key=len)
# logger.debug('{} leaves are now sorted by length'.format(len(leaves)))
# logger.debug('{}'.format(json.dumps(leaves[:3], indent=4, default=str)))
# leaves.sort(key=lambda lp: int(lp[-1][:3]), reverse=True)
# logger.debug('{} leaves are now sorted by rank'.format(len(leaves)))
# logger.error(json.dumps(leaves, indent=4, default=str))
# input('>>')
for leaf_path in leaves:
node = self.tree[leaf_path[-1]]
item = (
1 - node.data['cum_stats'],
leaf_path,
)
self.queue.put(item)
# for t in threads:
# t.start()
#
# for t in threads:
# t.join()
# if t.error:
# raise Exception().with_traceback(t.error[2])
while self.is_time_left() and not self.queue.empty():
priority, self.leaf_path = self.queue.get_nowait()
self.run_item(self.leaf_path)
if self.queue.empty():
logger.info(f'Everything was processed in queue!')
total_traversions_end = sum(a[2] for a in self.current_actions)
if total_traversions_end <= total_traversions_start:
logger.warning(f'No new traversion added to {total_traversions_start}')
def run_item(self, path):
# logger.debug('running this path: {}'.format(path))
e = deepcopy(self.engine)
e.mc = True
"""To calculate the investment for the loss EV, the total amounts used till end is required. Cannot
use final player balance on engine as that might have winnings allocated to it by the engine. Instead
the difference from all the new matched bets from the current matched bets will be used.
Need to add current contrib
"""
e.matched_start = e.data[self.hero]['matched'] + e.data[self.hero]['contrib']
# logger.info('hero starting with matched = {} from {} + {}'.format(
# e.matched_start, e.data[self.hero]['matched'], e.data[self.hero]['contrib']))
# self.tree.show()
self.fast_forward(e, path)
# logger.info('{}'.format('-' * 200))
# input('check item')
def show_best_action(self):
"""Calculates best action on root"""
# logger.error("\n\n")
sum_traversed = 0
delta = 0
示例11: print
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
print(MAP_NFILES_DIR[max_nfiles])
nfiles = 0
for k in MAP_NFILES_DIR:
nfiles += k * len(MAP_NFILES_DIR[k])
print('we found',nfiles,'files in total')
print('average number of files per leaf:',nfiles * 1. / n_leaves)
# tmp files
ntmpfiles = len( get_all_files(maindir,ext='.h5_tmp') )
print('we found',ntmpfiles,'temp files')
if ntmpfiles > 0: print('WATCHOUT FOR TMP FILES!!!!')
# find modif date for all files, and pop out the most recent ones
get_all_files_modif_date(maindir)
print('******************************************************')
if not trim and not trimdryrun:
print('most recent files are:')
for k in range(5):
t,f = MODIFQUEUE.get_nowait()
print(f,'(',time.ctime(-t),')')
elif trim or trimdryrun:
ntoomany = nfiles - 1000000
print('we have',ntoomany,'too many files.')
for k in range(ntoomany):
t,f = MODIFQUEUE.get_nowait()
print(f,'(',time.ctime(-t),')')
if trim:
os.remove(f)
# done
print('******************************************************')
示例12: print
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
priorityQueue.put_nowait((pro, times))
break
problems.append(l)
problem_set.add(l)
else:
for pro in problems:
priorityQueue.put_nowait((pro, 1))
print('wow')
time = 0
penalty = 0
solved = 0
"""
for problem in sorted(problems):
time += problem
if time > t:
break
penalty += time
solved += 1
"""
timeLeft = t
while priorityQueue.qsize() > 0:
element, times = priorityQueue.get_nowait()
times = min(times, timeLeft // element)
timeLeft -= element * times
solved += 1
penalty += (t - timeLeft)
if timeLeft < element:
break
print(solved, penalty % 1000000007)
示例13: __init__
# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get_nowait [as 别名]
class Core:
def __init__(self):
self.event_queue = PriorityQueue()
self.clock = 0
self.retired_events = 0
self.group = None
self._quit = False
self._controller = None
def __str__(self):
return "|Core(time={0})|={1}".format(self.clock, len(self.event_queue))
def set_controller(self, controller):
self._controller = controller
def _process_next_event(self, upto_clock):
"""
Broken out inner core of event processing loop.
:param upto_clock: Only process events scheduled up to this time. -1
for executing till stable state.
:return: Processed event or None if nothing was pending or clock
limit reached
"""
if self.event_queue.empty() or \
self.event_queue.queue[0].when > upto_clock:
# If queue is empty circuit is steady state so simulation is
# infinitely fast. Also we need this clock behavior to make delta
# timing in the controller work. It totally makes sense though ;)
self.clock = upto_clock
return None
event = self.event_queue.get_nowait()
assert event.when >= self.clock, "Encountered event from the past"
self.clock = event.when
self.group = event.group
last_in_group = \
self.event_queue.empty() or \
self.event_queue.queue[0].group != self.group or \
self.event_queue.queue[0].when != self.clock
followup_events = event.process(last_in_group)
self.retired_events += 1
self.schedule_many(followup_events)
return event
def quit(self):
"""
Causes the core to terminate execution as soon as possible.
"""
self._quit = True
def run(self):
assert self._controller, "Need to set a controller"
self._quit = False
while not self._quit:
(target_clock, target_time) = self._controller.process(self.clock)
while target_time - time.clock() > 0:
if not self._process_next_event(target_clock):
break
def schedule_many(self, events):
for event in events:
self.schedule(event)
def schedule(self, event):
"""
Schedules an event for processing.
Must NOT be called outside of this processes thread.
:param event:
:return:
"""
assert isinstance(event, Event), \
"Can only schedule things derived from Event"
assert event.when >= self.clock, \
"Cannot schedule events in the past"
self.event_queue.put(event)