python爬虫万能代码下载,python爬虫万能代码bs4

python 爬虫求教

python爬虫，requests非常好用，建议使用。

匹配结果使用re正则，列：# -*- coding:utf-8 -*-import restr1 = """寻梦环游记...9.0"""title = re.search(r'(.*?)', str1)if title: print(title.group(1))rating = re.search(r'(.*?)', str1)if rating: print(rating.group(1))。

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

Python爬虫如何写？

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

整体来看，如果数据采集的需求并不是很独特，那么有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 多线程爬虫代码

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爬虫图片在目录中存在图片1 跳过该图片1，继续写入图片2的代码

给你一个代码借鉴下：#!/usr/bin/python3# -*- coding: utf-8 -*-import requestsimport reimport osHeader = {"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.104 Safari/537.36"}def picture_get(picture_url): try: root = "E:/pic/" path = root + url.split('/')[-1] if not .exists(root): # 目录不存在创建目录 os.mkdir(root) if not .exists(path): # 文件不存在则下载 r = (picture_url, headers=Header) f = open(path, "wb") f.write(r.content) f.close() print("文件下载成功") else: print("文件已经存在") except: print("获取失败")。

如何用python 爬虫抓取金融数据

获取数据是数据分析中必不可少的一部分，而网络爬虫是是获取数据的一个重要渠道之一。鉴于此，我拾起了Python这把利器，开启了网络爬虫之路。

本篇使用的版本为python3.5，意在抓取证券之星上当天所有A股数据。程序主要分为三个部分：网页源码的获取、所需内容的提取、所得结果的整理。

一、网页源码的获取很多人喜欢用python爬虫的原因之一就是它容易上手。只需以下几行代码既可抓取大部分网页的源码。

import urllib.requesturl='' #目标网址headers={"User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64)"} #伪装浏览器请求报头request=urllib.request.Request(url=url,headers=headers) #请求服务器response=urllib.request.urlopen(request) #服务器应答().decode('gbk') #以一定的编码方式查看源码print(content) #打印页面源码虽说抓一页的源码容易，不过在一个网站内大量抓取网页源码却经常遭到服务器拦截，顿时感觉世界充满了恶意。

于是我开始研习突破反爬虫限制的功法。1.伪装流浪器报头很多服务器通过浏览器发给它的报头来确认是否是人类用户，所以我们可以通过模仿浏览器的行为构造请求报头给服务器发送请求。

服务器会识别其中的一些参数来识别你是否是人类用户，很多网站都会识别User-Agent这个参数，所以请求头最好带上。

有一些警觉性比较高的网站可能还会通过其他参数识别，比如通过Accept-Language来辨别你是否是人类用户，一些有防盗链功能的网站还得带上referer这个参数等等。

2.随机生成UA证券之星只需带User-Agent这个参数就可以抓取页面信息了，不过连续抓取几页就被服务器阻止了。

于是我决定每次抓取数据时模拟不同的浏览器发送请求，而服务器通过User-Agent来识别不同浏览器，所以每次爬取页面可以通过随机生成不同的UA构造报头去请求服务器，3.减慢爬取速度虽然模拟了不同浏览器爬取数据，但发现有的时间段可以爬取上百页的数据，有时候却只能爬取十来页，看来服务器还会根据你的访问的频率来识别你是人类用户还是网络爬虫。

所以我每抓取一页都让它随机休息几秒，加入此句代码后，每个时间段都能爬取大量股票数据了。4.使用代理IP天有不测风云，程序在公司时顺利测试成功，回寝室后发现又只能抓取几页就被服务器阻止了。

惊慌失措的我赶紧询问度娘，获知服务器可以识别你的IP，并记录此IP访问的次数，可以使用高匿的代理IP，并在抓取的过程中不断的更换，让服务器无法找出谁是真凶。此功还未修成，欲知后事如何，请听下回分解。

5.其他突破反爬虫限制的方法很多服务器在接受浏览器请求时会发送一个cookie文件给浏览器，然后通过cookie来跟踪你的访问过程，为了不让服务器识别出你是爬虫，建议最好带上cookie一起去爬取数据；如果遇上要模拟登陆的网站，为了不让自己的账号被拉黑，可以申请大量的账号，然后再爬入，此处涉及模拟登陆、验证码识别等知识，暂时不再深究...总之，对于网站主人来说，有些爬虫确实是令人讨厌的，所以会想出很多方法限制爬虫的进入，所以我们在强行进入之后也得注意些礼仪，别把人家的网站给拖垮了。

二、所需内容的提取获取网页源码后，我们就可以从中提取我们所需要的数据了。从源码中获取所需信息的方法有很多，使用正则表达式就是比较经典的方法之一。我们先来看所采集网页源码的部分内容。

为了减少干扰，我先用正则表达式从整个页面源码中匹配出以上的主体部分，然后从主体部分中匹配出每只股票的信息。代码如下。pattern=re.compile('(.*?)。

如何用Python爬虫抓取网页内容?

爬虫流程其实把网络爬虫抽象开来看，它无外乎包含如下几个步骤模拟请求网页。模拟浏览器，打开目标网站。获取数据。打开网站之后，就可以自动化的获取我们所需要的网站数据。保存数据。

拿到数据之后，需要持久化到本地文件或者数据库等存储设备中。那么我们该如何使用 Python 来编写自己的爬虫程序呢，在这里我要重点介绍一个 Python 库：Requests。

Requests 使用Requests 库是 Python 中发起 HTTP 请求的库，使用非常方便简单。

模拟发送 HTTP 请求发送 GET 请求当我们用浏览器打开豆瓣首页时，其实发送的最原始的请求就是 GET 请求import requests res = ('') print(res) print(type(res)) >>>。

有没有易懂的 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 不是吗？

'''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 操作。

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

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

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

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

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

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

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

Pool 对象有一些参数，这里我所需要关注的只是它的第一个参数：processes. 这一参数用于设定线程池中的线程数。其默认值为当前机器 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 行的例子。为了更有趣一些，我统计了不同方法、不同线程池大小的耗时情况。

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