class Printer():
def __init__(self):
self.printQueue = Queue()
self.currentTask = None
def isBusy(self):
return self.currentTask == None
def addTask(self, task):
self.printQueue.enqueue(task)
def removeTask(self):
self.currentTask = None
def getNextTask(self):
if self.printQueue.isEmpty():
self.currentTask = None
else:
self.currentTask = self.printQueue.dequeue()
def printTask(self):
if self.currentTask != None:
self.currentTask.removePage()
if self.currentTask.isDone():
self.currentTask = None
if self.currentTask == None and not self.printQueue.isEmpty():
self.currentTask = self.printQueue.dequeue()
waitTimes.append(time - self.currentTask.startTime)
def pig_latin_converter(word):
if type(word) != str:
raise TypeError('Argument should be a string')
my_simulation = Queue()
to_lower = word.lower()
modified = list(to_lower)
pos = 0
found = True
if modified[0] in ['a', 'e', 'i', 'o', 'u']:
return word + 'way'
else:
while pos <= len(word) and found:
if modified[pos] in ['a', 'e', 'i', 'o', 'u']:
found = False
else:
my_simulation.enqueue(modified[pos])
pos += 1
rounds = my_simulation.size()
simulator_stack = Stack()
for i in modified:
simulator_stack.push(i)
diff = len(word) - rounds
fixed = []
for j in range(diff):
fixed.append(simulator_stack.pop())
fixed.reverse()
final_word = ''
to_fix_with = []
while not my_simulation.isEmpty():
to_fix_with.append(my_simulation.dequeue())
final_word = ''.join(fixed) + ''.join(to_fix_with) + 'ay'
return final_word
def simulation(numSeconds, pagesPerMinute):
# create a new printer object
labprinter = Printer(pagesPerMinute)
# create a queue object
printQueue = Queue()
# create a list type of object, for storing all waiting times for each task
waitingtimes = []
# unit is based on second, and numSeconds is the total time
# for simulation, create a loop for simulation
for currentSecond in range(numSeconds):
# newprinttaask decides whether we want to create a new task
# see detail in newPrintTask function defined later
if newPrintTask():
task = Task(currentSecond)
# if there is a new task, put that new task to
# the end of the queue
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
# when printer is not busy or queue is empty
# start to process next task from the top of the task queue
nexttask = printQueue.dequeue()
# meanwhile add the waiting time to the end of the time lise
waitingtimes.append(nexttask.waitTime(currentSecond))
# then start the next task pop out from the queue
labprinter.startNext(nexttask)
# keep counting the time till the end of the task
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, printQueue.size()))
def simulation(numSeconds, pagesPerMinute):
"""
Simulate the printing tasks managed by the shared printer in a computer
science lab.
:param numSeconds: the total time for the printer to run
:param pagesPerMinute: the printing speed of the printer
"""
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, printQueue.size()))
def radixSorter(lon):
mainBin = Queue()
digList = []
for i in range(10):
digList.append(Queue())
res = []
#pass all the lon items into the mainBin:
for n in lon:
mainBin.enqueue(n)
for i in [1, 0]:
while not mainBin.isEmpty():
n = mainBin.dequeue()
digList[int(str(n)[i])].enqueue(n)
for queue in digList:
while not queue.isEmpty():
mainBin.enqueue(queue.dequeue())
#return the queue as a list of numbers
while not mainBin.isEmpty():
res.append(mainBin.dequeue())
return res
def simulation(numSeconds, pagesPerMinute):
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.setStart(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, printQueue.size()))
def simulation(numSeconds, ppm):
labprinter = Printer(ppm)
printq = Queue()
waitingtime = []
for i in range(numSeconds):
if newtask():
task = Task(i)
printq.enqueue(task)
if (not labprinter.busy()) and (not printq.isEmpty()):
nextprint = printq.dequeue()
waitingtime.append(nextprint.waittime(i))
labprinter.startnew(nextprint)
labprinter.tick()
averagewaittime = sum(waitingtime) / len(waitingtime)
print('Average wait time %6.2f secs and %3d tasks remaining.' %
(averagewaittime, printq.size()))
def simulation(numSeconds, pagesPerMinute):
labprinter = Printer(pagesPerMinute) #初始化打印机
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nextTask = printQueue.dequeue()
waitingtimes.append(nextTask.waitTime(currentSecond))
labprinter.startNext(nextTask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("平均等待时间为：%6.2f" % averageWait)
def simulation(numberSeconds, ppm):
printer = Printer(ppm=ppm)
tasks = Queue()
waitingList = []
for currentTime in range(numberSeconds):
if printer.isBusy():
printer.tick()
else:
if not tasks.isEmpty():
newTask = tasks.dequeue()
printer.startNext(newTask)
waitingList.append(newTask.waitTime(currentTime))
if random.randint(1, 180) == 180:
task = Task(currentTime)
tasks.enqueue(task)
print(sum(waitingList) * 1.0 / len(waitingList))
def simulation(num_seconds, ppm):
lab_printer = Printer(ppm)
print_queue = Queue()
waiting_times = []
for current_second in range(num_seconds):
if new_print_task():
task = Task(current_second)
print_queue.enqueue(task)
if (not lab_printer.busy()) and (not print_queue.isEmpty()):
next_task = print_queue.dequeue()
waiting_times.append(next_task.wait_time(current_second))
lab_printer.start_next(next_task)
lab_printer.tick()
average_wait = sum(waiting_times) / len(waiting_times)
print('Average wait %6.2f secs %3d tasks remaining.' %
(average_wait, print_queue.size()))
def simulation(number_second, pages_per_minute):
lab_printer = Printer(pages_per_minute)
print_queue = Queue()
wait_times = []
for current_second in range(number_second):
if new_print_task():
task = Task(current_second)
print_queue.enqueue(task)
if (not lab_printer.busy()) and (not print_queue.isEmpty()):
next_task = print_queue.dequeue()
wait_times.append(next_task.wait_time(current_second))
lab_printer.start_next(next_task)
lab_printer.tick()
average_wait = sum(wait_times) / len(wait_times)
print("Average Wait %6.2f secs %3d task remaining." % (average_wait, print_queue.size()))
def simulation(timeSpanSeconds, pagerate, studentnum, pages_per_task):
labprinter = Printer(pagerate)
waitQueue = Queue()
waitTimes = []
for nth_second in range(timeSpanSeconds):
if nextTask(studentnum):
task = Task(nth_second, pages_per_task)
waitQueue.enqueue(task)
if (not labprinter.busy()) and (not waitQueue.isEmpty()):
newtask = waitQueue.dequeue()
waitTimes.append(newtask.waitTime(nth_second))
labprinter.setNextTask(newtask)
labprinter.tick()
average_wait_time = sum(waitTimes) / len(waitTimes)
print("Average wait time = {:.4f}, tasks remaining = {:d}".format(
average_wait_time, waitQueue.size()))
return average_wait_time
def main(numSeconds,pagesPerMinute):
labPrinter = Printer(pagesPerMinute)
printQueue = Queue()
watingtimes = []
for currentSeconds in range(numSeconds):
if newPrintTask():
task = Task(currentSeconds)
printQueue.enqueue(task)
if(not labPrinter.is_busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
watingtimes.append(nexttask.waitTime(currentSeconds))
labPrinter.startNew(nexttask)
labPrinter.tick()
averageWait = sum(watingtimes)/len(watingtimes)
print('平均等待%6.2f秒 还剩%3d任务'%(averageWait,printQueue.size()))
def simulation(numSeconds, pagesPerMinute, stud):
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask(stud):
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes)/len(waitingtimes)
print('Average Wait %2.2f secs %2d tasks remaining.' % (averageWait, printQueue.size()))
def simulation(speed, totaltime):
l = Line(speed)
cartQueue = Queue()
waitTimes = []
for i in range(totaltime):
if newCart():
c = Cart(i)
cartQueue.enqueue(c)
if (not l.busy()) and (not cartQueue.isEmpty()):
cart = cartQueue.dequeue()
waitTimes.append(cart.waitTime(i))
l.startNext(cart)
l.tick()
avgWait = sum(waitTimes) / len(waitTimes)
print(
"Average wait time for each cart is %6.2f secs, %3d tasks remaining" %
(avgWait, cartQueue.size()))
def printer_simulator(num_sec, pages_per_min):
printer = Printer(pages_per_min)
wait_time_list = []
print_queue = Queue()
for sec in range(num_sec):
if new_task():
task = Task(sec)
print_queue.enqueue(task)
if (not printer.is_busy()) and (not print_queue.isEmpty()):
next_task = print_queue.dequeue()
wait_time_list.append(sec - next_task.get_timestamp())
printer.next_task(next_task)
printer.tick()
average_wait_time = sum(wait_time_list) / len(wait_time_list)
print('average: {aver}; waiting task: {tasks}'.format(
aver=average_wait_time, tasks=print_queue.size()))
def simulateOneServer(file):
"""function to handle requests using one server"""
global averageWait
content = urllib.request.urlopen(file).read().decode(
"ascii", "ignore") # fetch contents
data = StringIO(content)
# read csv file
csv_reader = csv.reader(data, delimiter=',')
dataList = [] # store data from csv
for line in csv_reader:
# Use list to store data
dataList.append(line)
requestQueue = Queue() # queue tor requests
waitingtimes = [
] # list to store's that are waiting before a request is processed
server = Server() # instantiate server class
# listlength=len(dataList)-1
for i in dataList:
# iterated the requests
request = Request(i) # pass data to request class
requestQueue.enqueue(request) # enqueue the request object
if (not requestQueue.isEmpty()) and (not server.busy(
)): # if server is not busy and queue is not empty
nexttask = requestQueue.dequeue() # dequeue first item in queue
waitingtimes.append(nexttask.waitTime(int(
i[0]))) # append to waiting time to list
server.startNext(
nexttask) # if server is free move to the next task
server.tick() # server timer
averageWait = sum(waitingtimes) / len(
waitingtimes) # calculate average wait time
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait,
requestQueue.size())) # similar to pritning example in notes
print("Average latency is {} seconds".format(averageWait))
return averageWait # return latency
def simulation(num_seconds, page_rate):
labPrinter = Printer(page_rate)
printerQueue = Queue()
waitingTime = []
pages_number = 20
students_number = 10
for second in range(num_seconds):
if newPrintTask(students_number):
task = Task(second, pages_number)
printerQueue.enqueue(task)
if (not labPrinter.busy()) and (not printerQueue.isEmpty()):
nextTask = printerQueue.dequeue()
waitingTime.append(nextTask.waitingTime(second))
labPrinter.startNext(nextTask)
labPrinter.tick()
averageWait = sum(waitingTime) / len(waitingTime)
print("Average Wait %6.2f secs %3d tasks remaining." % (averageWait, printerQueue.size()))
def simulation(numSeconds,pagesPerMinute):
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingTime = []
# For every timestamp in numSeconds, we need to judge if there is a new task needs to be print.
# If true, we append it into queue.
for currentSecond in range(numSeconds):
if newTask():
task = Tasks(currentSecond)
printQueue.enqueue(task)
# We need to judge whether printer is busy or there is no task remaining.
if (not labprinter.is_busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue() ########### First in First out
waitingTime.append(nexttask.waitTime(currentSecond))
labprinter.next_task(nexttask)
labprinter.processing()
averagewait = sum(waitingTime) / len(waitingTime)
print("Average waiting time is %6.2f, %3d task(s) remaining."%(averagewait,printQueue.size()))
def simulation(numSec, pagePerMin):
labprinter = Printer(pagePerMin)
printQueue = Queue()
waitingTime = []
for currentSecond in range(numSec):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingTime.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingTime) / len(waitingTime)
print("Average Wait %f secs %d tasks remaining." %
(averageWait, printQueue.size()))
def simulation(numSeconds, carsPerMinute):
w = Washer(carsPerMinute)
washQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newCar():
task = Task(currentSecond)
washQueue.enqueue(task)
if (not w.busy()) and (not washQueue.isEmpty()):
nexttask = washQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
w.startNext(nexttask)
w.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, washQueue.size()))
def simulation(num_seconds, pages_per_minute):
labprinter = Printer(pages_per_minute)
print_queue = Queue()
waiting_times = []
for current_second in range(num_seconds):
# check if new task is generated
if new_print_task():
task = Task(current_second)
print_queue.enqueue(task)
# feed queue to printer
if (not labprinter.busy()) and (not print_queue.isEmpty()):
nexttask = print_queue.deque()
waiting_times.append(nexttask.waitTime(current_second))
labprinter.startNext(nexttask)
labprinter.tick()
average_wait = sum(waiting_times) / len(waiting_times)
print("The average wait time is %f" % average_wait)
def simulation(numSeconds, pagesPerMinute):
# set total time for the simulation (1 hour = 3600s)
# and pages per minute for the printer
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask(): # boolean helper function, decides if a task has been created
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
average_wait = sum(waitingtimes)//len(waitingtimes)
print("Average Wait {:6.2f} secs and {:3d} tasks remaining".format(average_wait, printQueue.size()))
def simulateManyServers(file, noOfServers):
global averageWait
content = urllib.request.urlopen(file).read().decode(
"ascii", "ignore") # fetch contents
data = StringIO(content)
# read csv file
csv_reader = csv.reader(data, delimiter=',')
dataList = [] # store data from csv
for line in csv_reader:
# Use list to store data
dataList.append(line)
requestQueue = Queue() # queue for requests
waitingtimes = [] # array to store waiting time
servers = [Server() for a in range(noOfServers)
] # create the number of server objects passed as parameter
# eg if 2 then two servers will be instantiated
for i in dataList:
# iterate the data list
request = Request(i) # create a request object
requestQueue.enqueue(request) # add object to queue
for server in servers: # iterate the servers
if (not server.busy()) and (not requestQueue.isEmpty()):
nexttask = requestQueue.dequeue()
waitingtimes.append(nexttask.waitTime(int(
i[0]))) # append waiting time to list
server.startNext(nexttask) # start new task
server.tick() # server ticker
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, requestQueue.size()))
print("Average latency is {} seconds".format(averageWait))
return averageWait # return average latency
def simulation(numSeconds, pagesPerMinute):
labprinter = Printer(pagesPerMinute)
printQueue = Queue() #打印任务队列
waitingtimes = [] #等待时间列表
for currentSecond in range(numSeconds):
if newPrintTask(): #如果==180
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (
not printQueue.isEmpty()): #打印机不忙且队列不为空
nexttask = printQueue.dequeue() #下一个任务从队列中移除
waitingtimes.append(
nexttask.waitTime(currentSecond)) #nexttask完成需要的时间
labprinter.startNext(nexttask) #打印机开始工作
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes) #求平均时间
print("Average Wait %6.2f secs %3d tasks remaining." %
(averageWait, printQueue.size()))
from pythonds.basic.queue import Queue
class Queue:
def __init__(self):
self.item = []
def isEmpty(self):
if self.item == []:
return True
else:
return False
def enqueue(self, item):
self.item.append(item)
def dequeue(self):
return self.item.pop(0)
def size(self):
return len(self.item)
x = Queue()
print x.isEmpty()
x.enqueue(5)
print x.item
x.dequeue()
print x.item
print x.size()
try:
elem=driver.find_elements_by_class_name('snippet__link')
except:
print "\n_______NO Followers of %s__________\n"%user_name
elem=[]
for i in elem:
url_q.enqueue(str(i.get_attribute('href')))
print "\n*******Network Fetched... Beginning the next crawl************\n"
driver.quit()
try:
crawl()
except Exception,e:
print str(e)
f=open('url_queue.txt','w')
print >>f,url
while not url_q.isEmpty():
print >>f,url_q.dequeue()
f.close()
driver.quit()
'''Clicking the LOAD MORE button
c=1
d=0
a=0
elem=driver.find_element_by_xpath('//*[@id="foodjourney"]/div[2]')
while c==1:
try:
s=wait.until(EC.element_to_be_clickable((By.XPATH,'//*[@id="foodjourney"]/div[2]')))
elem=driver.find_element_by_xpath('//*[@id="foodjourney"]/div[2]')
if str(elem.text)=="":
break
from pythonds.basic.queue import Queue
q = Queue()
print(q.isEmpty())
q.enqueue('dog')
print(q)
return currenttime - self.timestamp
def newPrintTask():
num = random.randrange(1, 61)
if num == 60:
return True
else:
return False
for i in range(10):
pagesPerMinute = 50
printer = Printer(pagesPerMinute)
printQueue = Queue()
# 计算平均等待时间，所以需将所有的等待时间进行存储
waitingtimes = []
# 模拟的是一小时当中的 60m=3600s
for currentSecond in range(3600):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not printer.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
printer.startNext(nexttask)
printer.tick()
# 平均等待时间
averageWatingTime = sum(waitingtimes) / len(waitingtimes)
print('平均等待时间：%6.2f s，剩下%3d任务' % (averageWatingTime, printQueue.size()))
def enqueue(item):
self.items.insert(0, item)
def dequeue():
return self.items.pop()
def size():
return len(self.items)
q = Queue()
q.enqueue(4)
q.enqueue('dog')
q.enqueue(True)
print(q.size())
q.isEmpty()
q.enqueue(8.4)
q.dequeue()
q.dequeue()
q.size()
from pythonds.basic.queue import Queue
player = ['Aaron', 'Drew', 'Russel', 'Ben', 'Patrick', 'Eli']
def hotPotato(namelist, num):
simqueue = Queue()
for name in namelist:
simqueue.enqueue(name) #move the names from the list to the queue
except:
print "\n_______NO Followers of %s__________\n" % user_name
elem = []
for i in elem:
url_q.enqueue(str(i.get_attribute('href')))
print "\n*******Network Fetched... Beginning the next crawl************\n"
driver.quit()
try:
crawl()
except Exception, e:
print str(e)
f = open('url_queue.txt', 'w')
print >> f, url
while not url_q.isEmpty():
print >> f, url_q.dequeue()
f.close()
driver.quit()
'''Clicking the LOAD MORE button
c=1
d=0
a=0
elem=driver.find_element_by_xpath('//*[@id="foodjourney"]/div[2]')
while c==1:
try:
s=wait.until(EC.element_to_be_clickable((By.XPATH,'//*[@id="foodjourney"]/div[2]')))
elem=driver.find_element_by_xpath('//*[@id="foodjourney"]/div[2]')
if str(elem.text)=="":
break
elem.click()
class DouBanSpider(object):
def __init__(self):
# 创建一个队列用来保存进程获取到的数据
self.q = Queue()
self.headers = {
'Cookie':
'll="118282"; bid=ctyiEarSLfw; ps=y; __yadk_uid=0Sr85yZ9d4bEeLKhv4w3695OFOPoedzC; dbcl2="155150959:OEu4dds1G1o"; as="https://sec.douban.com/b?r=https%3A%2F%2Fbook.douban.com%2F"; ck=fTrQ; _pk_id.100001.4cf6=c86baf05e448fb8d.1506160776.3.1507290432.1507283501.; _pk_ses.100001.4cf6=*; __utma=30149280.1633528206.1506160772.1507283346.1507290433.3; __utmb=30149280.0.10.1507290433; __utmc=30149280; __utmz=30149280.1506160772.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); __utma=223695111.1475767059.1506160772.1507283346.1507290433.3; __utmb=223695111.0.10.1507290433; __utmc=223695111; __utmz=223695111.1506160772.1.1.utmcsr=(direct)|utmccn=(direct)|utmcmd=(none); push_noty_num=0; push_doumail_num=0',
'Host':
'movie.douban.com',
'Referer':
'https://movie.douban.com/top250?start=225&filter=',
'User-Agent':
'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.104 Safari/537.36',
}
def run(self, url):
self.parse_page(url)
def send_request(self, url):
'''
用来发送请求的方法
:return: 返回网页源码
'''
# 请求出错时，重复请求３次,
i = 0
while i <= 3:
try:
print(u"[INFO]请求url:" + url)
html = requests.get(url=url, headers=self.headers).content
except Exception as e:
print(u'[INFO] %s%s' % (e, url))
i += 1
else:
return html
def parse_page(self, url):
'''
解析网站源码，并采用ｘｐａｔｈ提取 电影名称和平分放到队列中
:return:
'''
response = self.send_request(url)
html = etree.HTML(response)
# 获取到一页的电影数据
node_list = html.xpath("//div[@class='info']")
for move in node_list:
# 电影名称
title = move.xpath('.//a/span/text()')[0]
# 评分
score = move.xpath(
'.//div[@class="bd"]//span[@class="rating_num"]/text()')[0]
# 将每一部电影的名称跟评分加入到队列
self.q.enqueue(score + "\t" + title)
def main(self):
base_url = 'https://movie.douban.com/top250?start='
# 构造所有ｕｒｌ
url_list = [base_url + str(num) for num in range(0, 225 + 1, 25)]
# 创建协程并执行
job_list = [gevent.spawn(self.run, url) for url in url_list]
# 让线程等待所有任务完成，再继续执行。
gevent.joinall(job_list)
while not self.q.isEmpty():
print(self.q.dequeue())
