python新手求助 关于爬虫的简单例子

#coding=utf-8from bs4 import BeautifulSoupwith open('', 'r') as file: fcontent = ()sp = BeautifulSoup(fcontent, 'html.parser')t = 'new_text_for_replacement'# replace the paragraph using `replace_with` method(itemprop='someprop').replace_with(t)# open another file for writingwith open('', 'w') as fp: # write the current soup content fp.write(sp.prettify())如果要替换段落的内容而不是段落元素本身，可以设置.string属性。

(itemprop='someprop').string = t赞0收藏0评论0分享用户回答回答于 2018-07-26问题取决于你搜索标准的方式，尝试更改以下代码： print(sp.replace((itemprop="someprop").text,t))对此： print(sp.replace(({"itemprop":"someprop"}).text,t))# coding:utf-8from bs4 import BeautifulSoupimport requestsimport osurl = 'https://'r = (url)demo = r.text # 服务器返回响应soup = BeautifulSoup(demo, "html.parser")"""demo 表示被解析的html格式的内容html.parser表示解析用的解析器""" # 输出响应的html对象ab = list()with open("D:\\temp\\","w+",encoding="utf-8") as xxx: for mi in soup.find_all('a'): ab.append(mi.prettify()) # 使用prettify()格式化显示输出 # xxx.writelines(str(mi))xxx.writelines(ab)xxx.close()。

谷歌人工智能写作项目：小发猫

Python爬虫如何写？

先检查是否有APIAPI是网站官方提供的数据接口，如果通过调用API采集数据，则相当于在网站允许的范围内采集，这样既不会有道德法律风险，也没有网站故意设置的障碍；不过调用API接口的访问则处于网站的控制中，网站可以用来收费，可以用来限制访问上限等typescript巧妙运用。

整体来看，如果数据采集的需求并不是很独特，那么有API则应优先采用调用API的方式。

数据结构分析和数据存储爬虫需求要十分清晰，具体表现为需要哪些字段，这些字段可以是网页上现有的，也可以是根据网页上现有的字段进一步计算的，这些字段如何构建表，多张表如何连接等。

值得一提的是，确定字段环节，不要只看少量的网页，因为单个网页可以缺少别的同类网页的字段，这既有可能是由于网站的问题，也可能是用户行为的差异，只有多观察一些网页才能综合抽象出具有普适性的关键字段——这并不是几分钟看几个网页就可以决定的简单事情，如果遇上了那种臃肿、混乱的网站，可能坑非常多。

对于大规模爬虫，除了本身要采集的数据外，其他重要的中间数据（比如页面Id或者url）也建议存储下来，这样可以不必每次重新爬取id。

数据库并没有固定的选择，本质仍是将Python里的数据写到库里，可以选择关系型数据库MySQL等，也可以选择非关系型数据库MongoDB等；对于普通的结构化数据一般存在关系型数据库即可。

sqlalchemy是一个成熟好用的数据库连接框架，其引擎可与Pandas配套使用，把数据处理和数据存储连接起来，一气呵成。

数据流分析对于要批量爬取的网页，往上一层，看它的入口在哪里；这个是根据采集范围来确定入口，比如若只想爬一个地区的数据，那从该地区的主页切入即可；但若想爬全国数据，则应更往上一层，从全国的入口切入。

一般的网站网页都以树状结构为主，找到切入点作为根节点一层层往里进入即可。

值得注意的一点是，一般网站都不会直接把全量的数据做成列表给你一页页往下翻直到遍历完数据，比如链家上面很清楚地写着有24587套二手房，但是它只给100页，每页30个，如果直接这么切入只能访问3000个，远远低于真实数据量；因此先切片，再整合的数据思维可以获得更大的数据量。

显然100页是系统设定，只要超过300个就只显示100页，因此可以通过其他的筛选条件不断细分，只到筛选结果小于等于300页就表示该条件下没有缺漏；最后把各种条件下的筛选结果集合在一起，就能够尽可能地还原真实数据量。

明确了大规模爬虫的数据流动机制，下一步就是针对单个网页进行解析，然后把这个模式复制到整体。

对于单个网页，采用抓包工具可以查看它的请求方式，是get还是post，有没有提交表单，欲采集的数据是写入源代码里还是通过AJAX调用JSON数据。

同样的道理，不能只看一个页面，要观察多个页面，因为批量爬虫要弄清这些大量页面url以及参数的规律，以便可以自动构造；有的网站的url以及关键参数是加密的，这样就悲剧了，不能靠着明显的逻辑直接构造，这种情况下要批量爬虫，要么找到它加密的js代码，在爬虫代码上加入从明文到密码的加密过程；要么采用下文所述的模拟浏览器的方式。

数据采集之前用R做爬虫，不要笑，R的确可以做爬虫工作；但在爬虫方面，Python显然优势更明显，受众更广，这得益于其成熟的爬虫框架，以及其他的在计算机系统上更好的性能。

scrapy是一个成熟的爬虫框架，直接往里套用就好，比较适合新手学习；requests是一个比原生的urllib包更简洁强大的包，适合作定制化的爬虫功能。

requests主要提供一个基本访问功能，把网页的源代码给download下来。

一般而言，只要加上跟浏览器同样的Requests Headers参数，就可以正常访问，status_code为200，并成功得到网页源代码；但是也有某些反爬虫较为严格的网站，这么直接访问会被禁止；或者说status为200也不会返回正常的网页源码，而是要求写验证码的js脚本等。

下载到了源码之后，如果数据就在源码中，这种情况是最简单的，这就表示已经成功获取到了数据，剩下的无非就是数据提取、清洗、入库。

但若网页上有，然而源代码里没有的，就表示数据写在其他地方，一般而言是通过AJAX异步加载JSON数据，从XHR中找即可找到；如果这样还找不到，那就需要去解析js脚本了。

解析工具源码下载后，就是解析数据了，常用的有两种方法，一种是用BeautifulSoup对树状HTML进行解析，另一种是通过正则表达式从文本中抽取数据。

BeautifulSoup比较简单，支持Xpath和CSSSelector两种途径，而且像Chrome这类浏览器一般都已经把各个结点的Xpath或者CSSSelector标记好了，直接复制即可。

以CSSSelector为例，可以选择tag、id、class等多种方式进行定位选择，如果有id建议选id，因为根据HTML语法，一个id只能绑定一个标签。

正则表达式很强大，但构造起来有点复杂，需要专门去学习。因为下载下来的源码格式就是字符串，所以正则表达式可以大显身手，而且处理速度很快。

对于HTML结构固定，即同样的字段处tag、id和class名称都相同，采用BeautifulSoup解析是一种简单高效的方案，但有的网站混乱，同样的数据在不同页面间HTML结构不同，这种情况下BeautifulSoup就不太好使；如果数据本身格式固定，则用正则表达式更方便。

比如以下的例子，这两个都是深圳地区某个地方的经度，但一个页面的class是long，一个页面的class是longitude，根据class来选择就没办法同时满足2个，但只要注意到深圳地区的经度都是介于113到114之间的浮点数，就可以通过正则表达式"11[3-4].\d+"来使两个都满足。

数据整理一般而言，爬下来的原始数据都不是清洁的，所以在入库前要先整理；由于大部分都是字符串，所以主要也就是字符串的处理方式了。

字符串自带的方法可以满足大部分简单的处理需求，比如strip可以去掉首尾不需要的字符或者换行符等，replace可以将指定部分替换成需要的部分，split可以在指定部分分割然后截取一部分。

如果字符串处理的需求太复杂以致常规的字符串处理方法不好解决，那就要请出正则表达式这个大杀器。

Pandas是Python中常用的数据处理模块，虽然作为一个从R转过来的人一直觉得这个模仿R的包实在是太难用了。

Pandas不仅可以进行向量化处理、筛选、分组、计算，还能够整合成DataFrame，将采集的数据整合成一张表，呈现最终的存储效果。

写入数据库如果只是中小规模的爬虫，可以把最后的爬虫结果汇合成一张表，最后导出成一张表格以便后续使用；但对于表数量多、单张表容量大的大规模爬虫，再导出成一堆零散的表就不合适了，肯定还是要放在数据库中，既方便存储，也方便进一步整理。

写入数据库有两种方法，一种是通过Pandas的DataFrame自带的to_sql方法，好处是自动建表，对于对表结构没有严格要求的情况下可以采用这种方式，不过值得一提的是，如果是多行的DataFrame可以直接插入不加索引，但若只有一行就要加索引否则报错，虽然这个认为不太合理；另一种是利用数据库引擎来执行SQL语句，这种情况下要先自己建表，虽然多了一步，但是表结构完全是自己控制之下。

Pandas与SQL都可以用来建表、整理数据，结合起来使用效率更高。

如何用Python做爬虫

1）首先你要明白爬虫怎样工作。想象你是一只蜘蛛，现在你被放到了互联“网”上。那么，你需要把所有的网页都看一遍。怎么办呢？

没问题呀，你就随便从某个地方开始，比如说人民日报的首页，这个叫initial pages，用$表示吧。在人民日报的首页，你看到那个页面引向的各种链接。于是你很开心地从爬到了“国内新闻”那个页面。

太好了，这样你就已经爬完了俩页面（首页和国内新闻）！暂且不用管爬下来的页面怎么处理的，你就想象你把这个页面完完整整抄成了个html放到了你身上。

突然你发现， 在国内新闻这个页面上，有一个链接链回“首页”。作为一只聪明的蜘蛛，你肯定知道你不用爬回去的吧，因为你已经看过了啊。所以，你需要用你的脑子，存下你已经看过的页面地址。

这样，每次看到一个可能需要爬的新链接，你就先查查你脑子里是不是已经去过这个页面地址。如果去过，那就别去了。

好的，理论上如果所有的页面可以从initial page达到的话，那么可以证明你一定可以爬完所有的网页。那么在python里怎么实现呢？

很简单import Queueinitial_page = "初始化页"url_queue = Queue.Queue()seen = set()seen.insert(initial_page)(initial_page)while(True): #一直进行直到海枯石烂 if ()>0: current_url = () #拿出队例中第一个的url store(current_url) #把这个url代表的网页存储好 for next_url in extract_urls(current_url): #提取把这个url里链向的url if next_url not in seen: (next_url) (next_url) else: break写得已经很伪代码了。

所有的爬虫的backbone都在这里，下面分析一下为什么爬虫事实上是个非常复杂的东西——搜索引擎公司通常有一整个团队来维护和开发。

2）效率如果你直接加工一下上面的代码直接运行的话，你需要一整年才能爬下整个豆瓣的内容。更别说Google这样的搜索引擎需要爬下全网的内容了。问题出在哪呢？

需要爬的网页实在太多太多了，而上面的代码太慢太慢了。设想全网有N个网站，那么分析一下判重的复杂度就是N*log(N)，因为所有网页要遍历一次，而每次判重用set的话需要log(N)的复杂度。

OK，OK，我知道python的set实现是hash——不过这样还是太慢了，至少内存使用效率不高。通常的判重做法是怎样呢？

Bloom Filter. 简单讲它仍然是一种hash的方法，但是它的特点是，它可以使用固定的内存（不随url的数量而增长）以O(1)的效率判定url是否已经在set中。

可惜天下没有白吃的午餐，它的唯一问题在于，如果这个url不在set中，BF可以100%确定这个url没有看过。

但是如果这个url在set中，它会告诉你：这个url应该已经出现过，不过我有2%的不确定性。注意这里的不确定性在你分配的内存足够大的时候，可以变得很小很少。

一个简单的教程:Bloom Filters by Example注意到这个特点，url如果被看过，那么可能以小概率重复看一看（没关系，多看看不会累死）。

但是如果没被看过，一定会被看一下（这个很重要，不然我们就要漏掉一些网页了！）。 [IMPORTANT: 此段有问题，请暂时略过]好，现在已经接近处理判重最快的方法了。另外一个瓶颈——你只有一台机器。

不管你的带宽有多大，只要你的机器下载网页的速度是瓶颈的话，那么你只有加快这个速度。用一台机子不够的话——用很多台吧！

当然，我们假设每台机子都已经进了最大的效率——使用多线程（python的话，多进程吧）。3）集群化抓取爬取豆瓣的时候，我总共用了100多台机器昼夜不停地运行了一个月。

想象如果只用一台机子你就得运行100个月了…那么，假设你现在有100台机器可以用，怎么用python实现一个分布式的爬取算法呢？

我们把这100台中的99台运算能力较小的机器叫作slave，另外一台较大的机器叫作master，那么回顾上面代码中的url_queue，如果我们能把这个queue放到这台master机器上，所有的slave都可以通过网络跟master联通，每当一个slave完成下载一个网页，就向master请求一个新的网页来抓取。

而每次slave新抓到一个网页，就把这个网页上所有的链接送到master的queue里去。

同样，bloom filter也放到master上，但是现在master只发送确定没有被访问过的url给slave。

Bloom Filter放到master的内存里，而被访问过的url放到运行在master上的Redis里，这样保证所有操作都是O(1)。

（至少平摊是O(1)，Redis的访问效率见:LINSERT – Redis)考虑如何用python实现：在各台slave上装好scrapy，那么各台机子就变成了一台有抓取能力的slave，在master上装好Redis和rq用作分布式队列。

代码于是写成current_url = request_from_master()to_send = []for next_url in extract_urls(current_url): to_send.append(next_url)store(current_url);send_to_master(to_send)distributed_queue = DistributedQueue()bf = BloomFilter()initial_pages = ""while(True): if request == 'GET': if ()>0: send(()) else: break elif request == 'POST': ()好的，其实你能想到，有人已经给你写好了你需要的：darkrho/scrapy-redis · GitHub4）展望及后处理虽然上面用很多“简单”，但是真正要实现一个商业规模可用的爬虫并不是一件容易的事。

上面的代码用来爬一个整体的网站几乎没有太大的问题。

但是如果附加上你需要这些后续处理，比如有效地存储（数据库应该怎样安排）有效地判重（这里指网页判重，咱可不想把人民日报和抄袭它的大民日报都爬一遍）有效地信息抽取（比如怎么样抽取出网页上所有的地址抽取出来，“朝阳区奋进路中华道”），搜索引擎通常不需要存储所有的信息，比如图片我存来干嘛…及时更新（预测这个网页多久会更新一次）如你所想，这里每一个点都可以供很多研究者十数年的研究。

虽然如此，“路漫漫其修远兮,吾将上下而求索”。所以，不要问怎么入门，直接上路就好了：）

python网页爬虫如何获取Network中的response?

你好,获取某个url请求的响应,现在python比较受欢迎的库就是requests了,我就拿requests这个库给你举个简单的例子吧:requests库最简单的功能应该就是获取某个url请求了,说白了就是使到某个页面的源码, 我在本地搭了个web服务器,在根目录下有一个文件,我们在浏览器中访问这个页面会显示 "Hello Friend":文件内容:访问该文件浏览器的输出:————-接下来我们就使用python的requests库来获取的内容:从上到下四个红框的意思:导入requests库;使用requests库的get()方法访问url: ,并将服务器响应回来的内容封装好赋给变量response;使用response对象的text属性来获取刚刚访问url的响应内容;因为输出的内容没有格式化,所以这里又使用print()函数打印一下,这样看起来更清晰一点最后我们可以再导入像re这样的正则库去中拿到我们想得到的内容**.一点点建议:requests库很常用,但建议先稍系统的学一下该库常用的方法和属性,有一个大概的了解,再去找简单的例子练练手,一点点找感觉.这样会好一点.像requests官方文档应该有中文的,把tutorial看完了简单的一些操作就不在话下了.如果你没有学习相应要用的库,然后就按自己的想法去操作,步步都是坎,这样不仅耗时长,而且长时间没有进展会很打击积极性的.希望对你有帮助,欢迎追问。

python可以爬取什么数据

一、爬取我们所需要的一线链接 这里的一线链接也就是我们所说的大类链接：from bs4 import BeautifulSoupimport requestsstart_url = ''host_url = ''def get_channel_urls(url):wb_data = (url)soup = BeautifulSoup(, 'lxml')links = soup.select('.fenlei > dt > a') #print(links)for link in links:page_url = host_url + ('href')print(page_url)#get_channel_urls(start_url)channel_urls = '''jiaju/rirongbaihuo/shouji/bangong/nongyongpin/jiadian/ershoubijibendiannao/ruanjiantushu/yingyouyunfu/diannao/xianzhilipin/fushixiaobaxuemao/meironghuazhuang/shuma/laonianyongpin/xuniwupin/'''呵呵1112131415161718192021222324252627282930313233343536那么拿我爬取的58同城为例就是爬取了二手市场所有品类的链接，也就是我说的大类链接； 找到这些链接的共同特征，用函数将其输出，并作为多行文本储存起来。

二、获取我们所需要的详情页面的链接和详情信息1、说说我们的数据库：先看代码：#引入库文件from bs4 import BeautifulSoupimport requestsimport pymongo #python操作MongoDB的库import reimport time#链接和建立数据库client = pymongo.MongoClient('localhost', 27017)ceshi = client['ceshi'] #建ceshi数据库ganji_url_list = ceshi['ganji_url_list'] #建立表文件ganji_url_info = ceshi['ganji_url_info']呵呵11122、判断页面结构是否和我们想要的页面结构相匹配，比如有时候会有404页面；3、从页面中提取我们想要的链接，也就是每个详情页面的链接；这里我们要说的是一个方法就是:item_link = ('href').split('?')[0]12这里的这个link什么类型的，这个get方法又是什么鬼？

后来我发现了这个类型是 .zz-til > a')link_2 = soup.select('.js-item > a')link = link + link_2 #print(len(link))for linkc in link:linkc = ('href')ganji_url_list.insert_one({'url': linkc})print(linkc) else: pass呵呵111213141516171819204、爬取详情页中我们所需要的信息我来贴一段代码：#爬取赶集网详情页链接：def get_url_info_ganji(url):time.sleep(1)wb_data = (url)soup = BeautifulSoup(, 'lxml') try:title = soup.select('head > title')[0].texttimec = soup.select('.pr-5')[0].text.strip()type = soup.select('.det-infor > li > span > a')[0].textprice = soup.select('.det-infor > li > i')[0].textplace = soup.select('.det-infor > li > a')[1:]placeb = [] for placec in place:placeb.append()tag = soup.select('.second-dt-bewrite > ul > li')[0].texttag = ''.join(tag.split()) #print(time.split())data = { 'url' : url, 'title' : title, 'time' : timec.split(), 'type' : type, 'price' : price, 'place' : placeb, 'new' : tag}ganji_url_info.insert_one(data) #向数据库中插入一条数据；print(data) except IndexError: pass呵呵1112131415161718192021222324252627282930四、我们的主函数怎么写？

看代码：#先从别的文件中引入函数和数据：from multiprocessing import Poolfrom page_parsing import get_type_links,get_url_info_ganji,ganji_url_listfrom channel_extract import channel_urls#爬取所有链接的函数：def get_all_links_from(channel):for i in range(1,100):get_type_links(channel,i)#后执行这个函数用来爬取所有详情页的文件：if __name__ == '__main__':# pool = Pool()# # pool = Pool()# (get_url_info_ganji, [url['url'] for url in ()])# pool.close()# ()#先执行下面的这个函数，用来爬取所有的链接：if __name__ == '__main__':pool = Pool()pool = Pool()(get_all_links_from,channel_urls.split())pool.close()()呵呵11121314151617181920212223242526五、计数程序 用来显示爬取数据的数目；import timefrom page_parsing import ganji_url_list,ganji_url_infowhile True: # print(().count())# time.sleep(5)print(().count())time.sleep(5)。

有没有易懂的 Python 多线程爬虫代码

Python 在程序并行化方面多少有些声名狼藉。撇开技术上的问题，例如线程的实现和 GIL1，我觉得错误的教学指导才是主要问题。常见的经典 Python 多线程、多进程教程多显得偏“重”。

而且往往隔靴搔痒，没有深入探讨日常工作中最有用的内容。

传统的例子简单搜索下“Python 多线程教程”，不难发现几乎所有的教程都给出涉及类和队列的例子：'''Standard Producer/Consumer Threading Pattern'''import time import threading import Queue class Consumer(threading.Thread):def __init__(self, queue):threading.Thread.__init__(self)self._queue = queue def run(self):while True:# () blocks the current thread until# an item is retrieved.msg = ()# Checks if the current message is# the "Poison Pill"if isinstance(msg, str) and msg == 'quit':# if so, exists the loopbreak# "Processes" (or in our case, prints) the queue itemprint "I'm a thread, and I received %s!!" % msg# Always be friendly!print 'Bye byes!'def Producer():# Queue is used to share items between# the threads.queue = Queue.Queue()# Create an instance of the workerworker = Consumer(queue)# start calls the internal run() method to# kick off the threadworker.start() # variable to keep track of when we startedstart_time = ()# While under 5 seconds..while () – start_time < 5:# "Produce" a piece of work and stick it in# the queue for the Consumer to process('something at %s' % ())# Sleep a bit just to avoid an absurd number of messagestime.sleep(1)# This the "poison pill" method of killing a thread.('quit')# wait for the thread to close down()if __name__ == '__main__':Producer()哈，看起来有些像 Java 不是吗？

我并不是说使用生产者/消费者模型处理多线程/多进程任务是错误的（事实上，这一模型自有其用武之地）。只是，处理日常脚本任务时我们可以使用更有效率的模型。

问题在于…首先，你需要一个样板类；其次，你需要一个队列来传递对象；而且，你还需要在通道两端都构建相应的方法来协助其工作（如果需想要进行双向通信或是保存结果还需要再引入一个队列）。

worker 越多，问题越多按照这一思路，你现在需要一个 worker 线程的线程池。下面是一篇 IBM 经典教程中的例子——在进行网页检索时通过多线程进行加速。

'''A more realistic thread pool example '''import time import threading import Queue import urllib2 class Consumer(threading.Thread):def __init__(self, queue):threading.Thread.__init__(self)self._queue = queue def run(self):while True:content = ()if isinstance(content, str) and content == 'quit':breakresponse = urllib2.urlopen(content)print 'Bye byes!'def Producer():urls = ['', '''', ''# etc..]queue = Queue.Queue()worker_threads = build_worker_pool(queue, 4)start_time = ()# Add the urls to processfor url in urls:(url)# Add the poison pillvfor worker in worker_threads:('quit')for worker in worker_threads:()print 'Done! Time taken: {}'.format(() – start_time)def build_worker_pool(queue, size):workers = []for _ in range(size):worker = Consumer(queue)worker.start()workers.append(worker)return workersif __name__ == '__main__':Producer()这段代码能正确的运行，但仔细看看我们需要做些什么：构造不同的方法、追踪一系列的线程，还有为了解决恼人的死锁问题，我们需要进行一系列的 join 操作。

这还只是开始……至此我们回顾了经典的多线程教程，多少有些空洞不是吗？样板化而且易出错，这样事倍功半的风格显然不那么适合日常使用，好在我们还有更好的方法。

何不试试 mapmap 这一小巧精致的函数是简捷实现 Python 程序并行化的关键。map 源于 Lisp 这类函数式编程语言。它可以通过一个序列实现两个函数之间的映射。

urls = ['', '']results = map(urllib2.urlopen, urls)上面的这两行代码将 urls 这一序列中的每个元素作为参数传递到 urlopen 方法中，并将所有结果保存到 results 这一列表中。

其结果大致相当于：results = []for url in urls:results.append(urllib2.urlopen(url))map 函数一手包办了序列操作、参数传递和结果保存等一系列的操作。

为什么这很重要呢？这是因为借助正确的库，map 可以轻松实现并行化操作。

在 Python 中有个两个库包含了 map 函数： multiprocessing 和它鲜为人知的子库 multiprocessing.dummy.这里多扯两句： multiprocessing.dummy？

mltiprocessing 库的线程版克隆？这是虾米？即便在 multiprocessing 库的官方文档里关于这一子库也只有一句相关描述。

而这句描述译成人话基本就是说:"嘛，有这么个东西，你知道就成."相信我，这个库被严重低估了！

dummy 是 multiprocessing 模块的完整克隆，唯一的不同在于 multiprocessing 作用于进程，而 dummy 模块作用于线程（因此也包括了 Python 所有常见的多线程限制）。

所以替换使用这两个库异常容易。你可以针对 IO 密集型任务和 CPU 密集型任务来选择不同的库。

2动手尝试使用下面的两行代码来引用包含并行化 map 函数的库：from multiprocessing import Poolfrom multiprocessing.dummy import Pool as ThreadPool实例化 Pool 对象：pool = ThreadPool()这条简单的语句替代了 中 build_worker_pool 函数 7 行代码的工作。

它生成了一系列的 worker 线程并完成初始化工作、将它们储存在变量中以方便访问。

Pool 对象有一些参数，这里我所需要关注的只是它的第一个参数：processes. 这一参数用于设定线程池中的线程数。其默认值为当前机器 CPU 的核数。

一般来说，执行 CPU 密集型任务时，调用越多的核速度就越快。但是当处理网络密集型任务时，事情有有些难以预计了，通过实验来确定线程池的大小才是明智的。

pool = ThreadPool(4) # Sets the pool size to 4线程数过多时，切换线程所消耗的时间甚至会超过实际工作时间。

对于不同的工作，通过尝试来找到线程池大小的最优值是个不错的主意。创建好 Pool 对象后，并行化的程序便呼之欲出了。

我们来看看改写后的 import urllib2 from multiprocessing.dummy import Pool as ThreadPool urls = [# etc..]# Make the Pool of workerspool = ThreadPool(4) # Open the urls in their own threads# and return the resultsresults = (urllib2.urlopen, urls)#close the pool and wait for the work to finish pool.close() () 实际起作用的代码只有 4 行，其中只有一行是关键的。

map 函数轻而易举的取代了前文中超过 40 行的例子。为了更有趣一些，我统计了不同方法、不同线程池大小的耗时情况。

# results = [] # for url in urls:# result = urllib2.urlopen(url)# results.append(result)# # ——- VERSUS ——- # # # ——- 4 Pool ——- # # pool = ThreadPool(4) # results = (urllib2.urlopen, urls)# # ——- 8 Pool ——- # # pool = ThreadPool(8) # results = (urllib2.urlopen, urls)# # ——- 13 Pool ——- # # pool = ThreadPool(13) # results = (urllib2.urlopen, urls)结果：# Single thread: 14.4 Seconds # 4 Pool: 3.1 Seconds# 8 Pool: 1.4 Seconds# 13 Pool: 1.3 Seconds很棒的结果不是吗？

这一结果也说明了为什么要通过实验来确定线程池的大小。在我的机器上当线程池大小大于 9 带来的收益就十分有限了。

另一个真实的例子生成上千张图片的缩略图这是一个 CPU 密集型的任务，并且十分适合进行并行化。

基础单进程版本import os import PIL from multiprocessing import Pool from PIL import ImageSIZE = (75,75)SAVE_DIRECTORY = 'thumbs'def get_image_paths(folder):return ((folder, f)for f in os.listdir(folder)if 'jpeg' in f)def create_thumbnail(filename):im = (filename)im.thumbnail(SIZE, Image.ANTIALIAS)base, fname = .split(filename)save_path = (base, SAVE_DIRECTORY, fname)(save_path)if __name__ == '__main__':folder = .abspath('11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')os.mkdir((folder, SAVE_DIRECTORY))images = get_image_paths(folder)for image in images:create_thumbnail(Image)上边这段代码的主要工作就是将遍历传入的文件夹中的图片文件，一一生成缩略图，并将这些缩略图保存到特定文件夹中。

这我的机器上，用这一程序处理 6000 张图片需要花费 27.9 秒。

如果我们使用 map 函数来代替 for 循环：import os import PIL from multiprocessing import Pool from PIL import ImageSIZE = (75,75)SAVE_DIRECTORY = 'thumbs'def get_image_paths(folder):return ((folder, f)for f in os.listdir(folder)if 'jpeg' in f)def create_thumbnail(filename):im = (filename)im.thumbnail(SIZE, Image.ANTIALIAS)base, fname = .split(filename)save_path = (base, SAVE_DIRECTORY, fname)(save_path)if __name__ == '__main__':folder = .abspath('11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')os.mkdir((folder, SAVE_DIRECTORY))images = get_image_paths(folder)pool = Pool()(creat_thumbnail, images)pool.close()()5.6 秒！

虽然只改动了几行代码，我们却明显提高了程序的执行速度。在生产环境中，我们可以为 CPU 密集型任务和 IO 密集型任务分别选择多进程和多线程库来进一步提高执行速度——这也是解决死锁问题的良方。

此外，由于 map 函数并不支持手动线程管理，反而使得相关的 debug 工作也变得异常简单。到这里，我们就实现了（基本）通过一行 Python 实现并行化。

怎样用Python设计一个爬虫模拟登陆知乎

给你一个例子，可以看看：import requestsimport timeimport jsonimport osimport reimport sysimport subprocessfrom bs4 import BeautifulSoup as BSclass ZhiHuClient(object):"""连接知乎的工具类，维护一个Session2015.11.11用法：client = ZhiHuClient()# 第一次使用时需要调用此方法登录一次，生成cookie文件# 以后可以跳过这一步client.login("username", "password") # 用这个session进行其他网络操作，详见requests库session = client.getSession()"""# 网址参数是账号类型TYPE_PHONE_NUM = "phone_num"TYPE_EMAIL = "email"loginURL = r"{0}"homeURL = r""captchaURL = r""headers = {"User-Agent": "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.86 Safari/537.36","Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8","Accept-Encoding": "gzip, deflate","Host": "","Upgrade-Insecure-Requests": "1",}captchaFile = ([0], "")cookieFile = ([0], "cookie")def __init__(self):os.chdir([0]) # 设置脚本所在目录为当前工作目录self.__session = requests.Session()self.__session.headers = self.headers # 用self调用类变量是防止将来类改名# 若已经有 cookie 则直接登录self.__cookie = self.__loadCookie()if self.__cookie:print("检测到cookie文件，直接使用cookie登录")self.__session.cookies.update(self.__cookie)soup = BS((r"/").text, "html.parser")print("已登陆账号： %s" % ("span", class_="name").getText())else:print("没有找到cookie文件，请调用login方法登录一次！

")# 登录def login(self, username, password):"""验证码错误返回：{'errcode': 1991829, 'r': 1, 'data': {'captcha': '请提交正确的验证码 :('}, 'msg': '请提交正确的验证码 :('}登录成功返回：{'r': 0, 'msg': '登陆成功'}"""self.__username = usernameself.__password = passwordself.__loginURL = self.loginURL.format(self.__getUsernameType())# 随便开个网页，获取登陆所需的_xsrfhtml = (self.homeURL).textsoup = BS(html, "html.parser") _xsrf = ("input", {"name": "_xsrf"})["value"]# 下载验证码图片while True:captcha = (self.captchaURL).contentwith open(self.captchaFile, "wb") as output:output.write(captcha)# 人眼识别print("=" * 50)print("已打开验证码图片，请识别！

")(self.captchaFile, shell=True)captcha = input("请输入验证码：")os.remove(self.captchaFile)# 发送POST请求data = {"_xsrf": _xsrf,"password": self.__password,"remember_me": "true",self.__getUsernameType(): self.__username,"captcha": captcha}res = (self.__loginURL, data=data)print("=" * 50)# print() # 输出脚本信息，调试用if ()["r"] == 0:print("登录成功")self.__saveCookie()breakelse:print("登录失败")print("错误信息 —>", ()["msg"])def __getUsernameType(self):"""判断用户名类型经测试，网页的判断规则是纯数字为phone_num，其他为email"""if self.__username.isdigit():return self.TYPE_PHONE_NUMreturn self.TYPE_EMAILdef __saveCookie(self):"""cookies 序列化到文件即把dict对象转化成字符串保存"""with open(self.cookieFile, "w") as output:cookies = self.__session.cookies.get_dict()(cookies, output)print("=" * 50)print("已在同目录下生成cookie文件：", self.cookieFile)def __loadCookie(self):"""读取cookie文件，返回反序列化后的dict对象，没有则返回None"""if .exists(self.cookieFile):print("=" * 50)with open(self.cookieFile, "r") as f:cookie = (f)return cookiereturn Nonedef open(self, url, delay=0, timeout=10):"""打开网页，返回Response对象"""if delay:time.sleep(delay)return (url, timeout=timeout)def getSession(self):return self.__sessionif __name__ == '__main__':client = ZhiHuClient()# 第一次使用时需要调用此方法登录一次，生成cookie文件# 以后可以跳过这一步# client.login("username", "password") # 用这个session进行其他网络操作，详见requests库session = client.getSession()。

如何用python写爬虫来获取网页中所有的文章以及关键词

所谓网页抓取，就是把URL地址中指定的网络资源从网络流中读取出来，保存到本地。 类似于使用程序模拟IE浏览器的功能，把URL作为HTTP请求的内容发送到服务器端， 然后读取服务器端的响应资源。

在Python中，我们使用urllib2这个组件来抓取网页。urllib2是Python的一个获取URLs(Uniform Resource Locators)的组件。

它以urlopen函数的形式提供了一个非常简单的接口。最简单的urllib2的应用代码只需要四行。

我们新建一个文件来感受一下urllib2的作用：import urllib2response = urllib2.urlopen('')html = ()print html按下F5可以看到运行的结果：我们可以打开百度主页，右击，选择查看源代码（火狐OR谷歌浏览器均可），会发现也是完全一样的内容。

也就是说，上面这四行代码将我们访问百度时浏览器收到的代码们全部打印了出来。这就是一个最简单的urllib2的例子。除了"http:"，URL同样可以使用"ftp:"，"file:"等等来替代。

HTTP是基于请求和应答机制的：客户端提出请求，服务端提供应答。urllib2用一个Request对象来映射你提出的HTTP请求。

在它最简单的使用形式中你将用你要请求的地址创建一个Request对象，通过调用urlopen并传入Request对象，将返回一个相关请求response对象，这个应答对象如同一个文件对象，所以你可以在Response中调用.read()。

我们新建一个文件来感受一下：import urllib2  req = urllib2.Request('')  response = urllib2.urlopen(req)  the_page = ()  print the_page可以看到输出的内容和test01是一样的。

urllib2使用相同的接口处理所有的URL头。例如你可以像下面那样创建一个ftp请求。req = urllib2.Request('')在HTTP请求时，允许你做额外的两件事。

1.发送data表单数据这个内容相信做过Web端的都不会陌生，有时候你希望发送一些数据到URL(通常URL与CGI[通用网关接口]脚本，或其他WEB应用程序挂接)。

在HTTP中,这个经常使用熟知的POST请求发送。这个通常在你提交一个HTML表单时由你的浏览器来做。并不是所有的POSTs都来源于表单，你能够使用POST提交任意的数据到你自己的程序。

一般的HTML表单，data需要编码成标准形式。然后做为data参数传到Request对象。编码工作使用urllib的函数而非urllib2。

我们新建一个文件来感受一下：import urllib  import urllib2  url = ''  values = {'name' : 'WHY',            'location' : 'SDU',            'language' : 'Python' }  data = urllib.urlencode(values) # 编码工作req = urllib2.Request(url, data)  # 发送请求同时传data表单response = urllib2.urlopen(req)  #接受反馈的信息the_page = ()  #读取反馈的内容如果没有传送data参数，urllib2使用GET方式的请求。

GET和POST请求的不同之处是POST请求通常有"副作用"，它们会由于某种途径改变系统状态(例如提交成堆垃圾到你的门口)。Data同样可以通过在Get请求的URL本身上面编码来传送。

import urllib2  import urllibdata = {}data['name'] = 'WHY'  data['location'] = 'SDU'  data['language'] = 'Python'url_values = urllib.urlencode(data)  print url_valuesname=Somebody+Here&language=Python&location=Northampton  url = ''  full_url = url + '?' + url_valuesdata = (full_url)这样就实现了Data数据的Get传送。

2.设置Headers到http请求有一些站点不喜欢被程序（非人为访问）访问，或者发送不同版本的内容到不同的浏览器。

默认的urllib2把自己作为“Python-urllib/x.y”(x和y是Python主版本和次版本号,例如Python-urllib/2.7)，这个身份可能会让站点迷惑，或者干脆不工作。

浏览器确认自己身份是通过User-Agent头，当你创建了一个请求对象，你可以给他一个包含头数据的字典。下面的例子发送跟上面一样的内容，但把自身模拟成Internet Explorer。

（多谢大家的提醒，现在这个Demo已经不可用了，不过原理还是那样的）。

import urllib  import urllib2  url = ''user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'  values = {'name' : 'WHY',            'location' : 'SDU',            'language' : 'Python' }  headers = { 'User-Agent' : user_agent }  data = urllib.urlencode(values)  req = urllib2.Request(url, data, headers)  response = urllib2.urlopen(req)  the_page = ()以上就是python利用urllib2通过指定的URL抓取网页内容的全部内容，非常简单吧，希望对大家能有所帮助。

有没有易懂的 Python 多线程爬虫代码

Python 在程序并行化方面多少有些声名狼藉。撇开技术上的问题，例如线程的实现和 GIL1，我觉得错误的教学指导才是主要问题。常见的经典 Python 多线程、多进程教程多显得偏“重”。

而且往往隔靴搔痒，没有深入探讨日常工作中最有用的内容。

传统的例子简单搜索下“Python 多线程教程”，不难发现几乎所有的教程都给出涉及类和队列的例子：'''Standard Producer/Consumer Threading Pattern'''import time import threading import Queue class Consumer(threading.Thread):def __init__(self, queue):threading.Thread.__init__(self)self._queue = queue def run(self):while True:# () blocks the current thread until# an item is retrieved.msg = ()# Checks if the current message is# the "Poison Pill"if isinstance(msg, str) and msg == 'quit': # if so, exists the loopbreak# "Processes" (or in our case, prints) the queue itemprint "I'm a thread, and I received %s!!" % msg # Always be friendly!print 'Bye byes!'def Producer():# Queue is used to share items between# the threads.queue = Queue.Queue() # Create an instance of the workerworker = Consumer(queue) # start calls the internal run() method to# kick off the threadworker.start() # variable to keep track of when we startedstart_time = ()# While under 5 seconds..while () – start_time < 5:# "Produce" a piece of work and stick it in# the queue for the Consumer to process('something at %s' % ()) # Sleep a bit just to avoid an absurd number of messagestime.sleep(1) # This the "poison pill" method of killing a thread.('quit') # wait for the thread to close down()if __name__ == '__main__':Producer()哈，看起来有些像 Java 不是吗？

我并不是说使用生产者/消费者模型处理多线程/多进程任务是错误的（事实上，这一模型自有其用武之地）。只是，处理日常脚本任务时我们可以使用更有效率的模型。

问题在于…首先，你需要一个样板类；其次，你需要一个队列来传递对象；而且，你还需要在通道两端都构建相应的方法来协助其工作（如果需想要进行双向通信或是保存结果还需要再引入一个队列）。

worker 越多，问题越多按照这一思路，你现在需要一个 worker 线程的线程池。下面是一篇 IBM 经典教程中的例子——在进行网页检索时通过多线程进行加速。

'''A more realistic thread pool example '''import time import threading import Queue import urllib2 class Consumer(threading.Thread):def __init__(self, queue):threading.Thread.__init__(self)self._queue = queue def run(self):while True:content = ()if isinstance(content, str) and content == 'quit': breakresponse = urllib2.urlopen(content) print 'Bye byes!'def Producer():urls = [ 'http', 'httcom''', ''# etc..]queue = Queue.Queue()worker_threads = build_worker_pool(queue, 4)start_time = () # Add the urls to processfor url in urls:(url)# Add the poison pillvfor worker in worker_threads:('quit') for worker in worker_threads:() print 'Done! Time taken: {}'.format(() – start_time)def build_worker_pool(queue, size):workers = [] for _ in range(size):worker = Consumer(queue)worker.start()workers.append(worker) return workersif __name__ == '__main__':Producer()这段代码能正确的运行，但仔细看看我们需要做些什么：构造不同的方法、追踪一系列的线程，还有为了解决恼人的死锁问题，我们需要进行一系列的 join 操作。

这还只是开始……至此我们回顾了经典的多线程教程，多少有些空洞不是吗？样板化而且易出错，这样事倍功半的风格显然不那么适合日常使用，好在我们还有更好的方法。

何不试试 mapmap 这一小巧精致的函数是简捷实现 Python 程序并行化的关键。map 源于 Lisp 这类函数式编程语言。它可以通过一个序列实现两个函数之间的映射。

urls = ['', '']results = map(urllib2.urlopen, urls)上面的这两行代码将 urls 这一序列中的每个元素作为参数传递到 urlopen 方法中，并将所有结果保存到 results 这一列表中。

其结果大致相当于：results = []for url in urls:results.append(urllib2.urlopen(url))map 函数一手包办了序列操作、参数传递和结果保存等一系列的操作。

为什么这很重要呢？这是因为借助正确的库，map 可以轻松实现并行化操作。

在 Python 中有个两个库包含了 map 函数： multiprocessing 和它鲜为人知的子库 multiprocessing.dummy.这里多扯两句： multiprocessing.dummy？

mltiprocessing 库的线程版克隆？这是虾米？即便在 multiprocessing 库的官方文档里关于这一子库也只有一句相关描述。

而这句描述译成人话基本就是说:"嘛，有这么个东西，你知道就成."相信我，这个库被严重低估了！

dummy 是 multiprocessing 模块的完整克隆，唯一的不同在于 multiprocessing 作用于进程，而 dummy 模块作用于线程（因此也包括了 Python 所有常见的多线程限制）。

所以替换使用这两个库异常容易。你可以针对 IO 密集型任务和 CPU 密集型任务来选择不同的库。

2动手尝试使用下面的两行代码来引用包含并行化 map 函数的库：from multiprocessing import Poolfrom multiprocessing.dummy import Pool as ThreadPool实例化 Pool 对象：pool = ThreadPool()这条简单的语句替代了 中 build_worker_pool 函数 7 行代码的工作。

它生成了一系列的 worker 线程并完成初始化工作、将它们储存在变量中以方便访问。

Pool 对象有一些参数，这里我所需要关注的只是它的第一个参数：processes. 这一参数用于设定线程池中的线程数。其默认值为当前机器 CPU 的核数。

一般来说，执行 CPU 密集型任务时，调用越多的核速度就越快。但是当处理网络密集型任务时，事情有有些难以预计了，通过实验来确定线程池的大小才是明智的。

pool = ThreadPool(4) # Sets the pool size to 4线程数过多时，切换线程所消耗的时间甚至会超过实际工作时间。

对于不同的工作，通过尝试来找到线程池大小的最优值是个不错的主意。创建好 Pool 对象后，并行化的程序便呼之欲出了。

我们来看看改写后的 import urllib2 from multiprocessing.dummy import Pool as ThreadPool urls = [ 'httorg','','',# etc..]# Make the Pool of workerspool = ThreadPool(4) # Open the urls in their own threads# and return the resultsresults = (urllib2.urlopen, urls)#close the pool and wait for the work to finish pool.close() () 实际起作用的代码只有 4 行，其中只有一行是关键的。

map 函数轻而易举的取代了前文中超过 40 行的例子。为了更有趣一些，我统计了不同方法、不同线程池大小的耗时情况。

# results = [] # for url in urls:# result = urllib2.urlopen(url)# results.append(result)# # ——- VERSUS ——- # # # ——- 4 Pool ——- # # pool = ThreadPool(4) # results = (urllib2.urlopen, urls)# # ——- 8 Pool ——- # # pool = ThreadPool(8) # results = (urllib2.urlopen, urls)# # ——- 13 Pool ——- # # pool = ThreadPool(13) # results = (urllib2.urlopen, urls)结果：# Single thread: 14.4 Seconds # 4 Pool: 3.1 Seconds# 8 Pool: 1.4 Seconds# 13 Pool: 1.3 Seconds很棒的结果不是吗？

这一结果也说明了为什么要通过实验来确定线程池的大小。在我的机器上当线程池大小大于 9 带来的收益就十分有限了。

相关链接：
1、vue全套教程从入门到精通,vue全套教程百度云
2、有限元和神经网络结合,人脑神经网络和宇宙
3、vue拖拽组件生成页面代码,vue可视化拖拽组件模板
4、vue axios封装以及数据交互,vue封装axios全局使用
5、typescript 中文文档,typescript完全解读