Python PriorityQueue.get_nowait方法代码示例

# 需要导入模块: 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")

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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))

# 需要导入模块: 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

# 需要导入模块: 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]

# 需要导入模块: 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))

# 需要导入模块: 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))

# 需要导入模块: 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()

# 需要导入模块: 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

# 需要导入模块: 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('******************************************************')

# 需要导入模块: 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)

# 需要导入模块: 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)