爬虫百库文库Python代码(python百度文库爬虫)
如何用python写爬虫来获取网页中所有的文章以及关键词
所谓网页抓取，就是把URL地址中指定的网络资源从网络流中读取出来，保存到本地。?
类似于使用程序模拟IE浏览器的功能，把URL作为HTTP请求的内容发送到服务器端， 然后读取服务器端的响应资源。
在Python中，我们使用urllib2这个组件来抓取网页。
urllib2是Python的一个获取URLs(Uniform Resource Locators)的组件。
它以urlopen函数的形式提供了一个非常简单的接口。
最简单的urllib2的应用代码只需要四行。
我们新建一个文件urllib2_test01.py来感受一下urllib2的作用：
import urllib2
response = urllib2.urlopen('')
html = response.read()
print html
按下F5可以看到运行的结果：
我们可以打开百度主页，右击，选择查看源代码（火狐OR谷歌浏览器均可），会发现也是完全一样的内容。
也就是说，上面这四行代码将我们访问百度时浏览器收到的代码们全部打印了出来。
这就是一个最简单的urllib2的例子。
除了"http:"，URL同样可以使用"ftp:"，"file:"等等来替代。
HTTP是基于请求和应答机制的：
客户端提出请求，服务端提供应答。
urllib2用一个Request对象来映射你提出的HTTP请求。
在它最简单的使用形式中你将用你要请求的地址创建一个Request对象，
通过调用urlopen并传入Request对象，将返回一个相关请求response对象，
这个应答对象如同一个文件对象，所以你可以在Response中调用.read()。
我们新建一个文件urllib2_test02.py来感受一下：
import urllib2?
req = urllib2.Request('')?
response = urllib2.urlopen(req)?
the_page = response.read()?
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。
我们新建一个文件urllib2_test03.py来感受一下：
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 = response.read()? #读取反馈的内容
如果没有传送data参数，urllib2使用GET方式的请求。
GET和POST请求的不同之处是POST请求通常有"副作用"，
它们会由于某种途径改变系统状态(例如提交成堆垃圾到你的门口)。
Data同样可以通过在Get请求的URL本身上面编码来传送。
import urllib2?
import urllib
data = {}
data['name'] = 'WHY'?
data['location'] = 'SDU'?
data['language'] = 'Python'
url_values = urllib.urlencode(data)?
print url_values
name=Somebody+Herelanguage=Pythonlocation=Northampton?
url = ''?
full_url = url + '?' + url_values
data = urllib2.open(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 = response.read()
以上就是python利用urllib2通过指定的URL抓取网页内容的全部内容，非常简单吧，希望对大家能有所帮助。
求一个python3爬虫代码，可以从小说网站上直接把小说的文字抄下来，并整合到一个新的文本里
from?bs4?import?BeautifulSoup
from?requests.exceptions?import?RequestException
import?re
import?requests
import?os
def?get_html_text(url):
????try:
????????r?=?requests.get(url)
????????r.raise_for_status()
????????return?r.text
????except?RequestException:
????????return?None
def?get_chapter_names(html):
????soup?=?BeautifulSoup(html,?'lxml')
????charpter?=?soup.select('.bg')
????charpter_names?=?[]
????for?entry?in?charpter[1:]:
????????charpter_name?=?re.findall('h2(.*?)/h2',?str(entry))
????????file_name?=?re.findall('a?href.*?(.*?)/a',?str(entry))
????????if?charpter_name?and?file_name:
????????????for?name?in?file_name:
????????????????name?=?name.split('?')[0]
????????????????charpter_names.append(charpter_name[0]?+?'_'?+?name)
????????else:
????????????pass
????return?set(charpter_names)
def?get_each_url(html):
????soup?=?BeautifulSoup(html,?'lxml')
????urls?=?soup.select('ul?li?a')
????for?url?in?urls:
????????link?=?url.get('href')
????????text?=?url.text.split('?')[0]
????????full_name?=?url.text.replace('?','')
????????yield?{'url':?link,?'text':?text,'full_name':full_name}
????????print(text)
def?get_text(url):
????r?=?requests.get(url)
????r.encoding?=?r.apparent_encoding
????soup?=?BeautifulSoup(r.text,?'lxml')
????items?=?soup.select('div.content-body')
????item?=?re.findall(';(.*?);',?items[0].text,?re.S)
????return?item[0].encode()
def?save_to_file(url,?text,?full_name):
????base_dir?=?'daomu'
????path?=?'{}\\{}\\{}'.format(os.getcwd(),?base_dir,?text)
????if?not?os.path.exists(path):
????????try:
????????????os.makedirs(path)
????????except:
????????????pass
????try:
????????with?open(path?+'\\'+?full_name?+'.txt',?'wb')?as?f:
????????????f.write(get_text(url))
????except:
????????pass
def?main():
????url?=?''
????html?=?get_html_text(url)
????chapters?=?get_chapter_names(html)
????for?chapter?in?chapters:
????????for?each?in?get_each_url(html):
????????????if?each['text']?==?chapter.split('_')[-1]:
????????????????save_to_file(each['url'],chapter,each['full_name'])
if?__name__?==?'__main__':
????main()
python爬虫怎么做？
大到各类搜索引擎，小到日常数据采集，都离不开网络爬虫。爬虫的基本原理很简单，遍历网络中网页，抓取感兴趣的数据内容。这篇文章会从零开始介绍如何编写一个网络爬虫抓取数据，然后会一步步逐渐完善爬虫的抓取功能。
工具安装
我们需要安装python，python的requests和BeautifulSoup库。我们用Requests库用抓取网页的内容，使用BeautifulSoup库来从网页中提取数据。
安装python
运行pipinstallrequests
运行pipinstallBeautifulSoup
抓取网页
完成必要工具安装后，我们正式开始编写我们的爬虫。我们的第一个任务是要抓取所有豆瓣上的图书信息。我们以/subject/26986954/为例，首先看看开如何抓取网页的内容。
使用python的requests提供的get()方法我们可以非常简单的获取的指定网页的内容,代码如下：
提取内容
抓取到网页的内容后，我们要做的就是提取出我们想要的内容。在我们的第一个例子中，我们只需要提取书名。首先我们导入BeautifulSoup库，使用BeautifulSoup我们可以非常简单的提取网页的特定内容。
连续抓取网页
到目前为止，我们已经可以抓取单个网页的内容了，现在让我们看看如何抓取整个网站的内容。我们知道网页之间是通过超链接互相连接在一起的，通过链接我们可以访问整个网络。所以我们可以从每个页面提取出包含指向其它网页的链接，然后重复的对新链接进行抓取。
通过以上几步我们就可以写出一个最原始的爬虫。在理解了爬虫原理的基础上，我们可以进一步对爬虫进行完善。
写过一个系列关于爬虫的文章：/i6567289381185389064/。感兴趣的可以前往查看。
Python基本环境的搭建，爬虫的基本原理以及爬虫的原型
Python爬虫入门(第1部分)
如何使用BeautifulSoup对网页内容进行提取
Python爬虫入门(第2部分)
爬虫运行时数据的存储数据，以SQLite和MySQL作为示例
Python爬虫入门(第3部分)
使用seleniumwebdriver对动态网页进行抓取
Python爬虫入门(第4部分)
讨论了如何处理网站的反爬虫策略
Python爬虫入门(第5部分)
对Python的Scrapy爬虫框架做了介绍，并简单的演示了如何在Scrapy下进行开发
Python爬虫入门(第6部分)
有没有易懂的 Python 多线程爬虫代码
Python 在程序并行化方面多少有些声名狼藉。撇开技术上的问题，例如线程的实现和 GIL1，我觉得错误的教学指导才是主要问题。常见的经典 Python 多线程、多进程教程多显得偏“重”。而且往往隔靴搔痒，没有深入探讨日常工作中最有用的内容。
传统的例子
简单搜索下“Python 多线程教程”，不难发现几乎所有的教程都给出涉及类和队列的例子：
#Example.py
'''
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:
# queue.get() blocks the current thread until
# an item is retrieved.
msg = self._queue.get()
# Checks if the current message is
# the "Poison Pill"
if isinstance(msg, str) and msg == 'quit':
# if so, exists the loop
break
# "Processes" (or in our case, prints) the queue item
print "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 worker
worker = Consumer(queue)
# start calls the internal run() method to
# kick off the thread
worker.start()
# variable to keep track of when we started
start_time = time.time()
# While under 5 seconds..
while time.time() - start_time 5:
# "Produce" a piece of work and stick it in
# the queue for the Consumer to process
queue.put('something at %s' % time.time())
# Sleep a bit just to avoid an absurd number of messages
time.sleep(1)
# This the "poison pill" method of killing a thread.
queue.put('quit')
# wait for the thread to close down
worker.join()
if __name__ == '__main__':
Producer()
哈，看起来有些像 Java 不是吗？
我并不是说使用生产者/消费者模型处理多线程/多进程任务是错误的（事实上，这一模型自有其用武之地）。只是，处理日常脚本任务时我们可以使用更有效率的模型。
问题在于…
首先，你需要一个样板类；
其次，你需要一个队列来传递对象；
而且，你还需要在通道两端都构建相应的方法来协助其工作（如果需想要进行双向通信或是保存结果还需要再引入一个队列）。
worker 越多，问题越多
按照这一思路，你现在需要一个 worker 线程的线程池。下面是一篇 IBM 经典教程中的例子——在进行网页检索时通过多线程进行加速。
#Example2.py
'''
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 = self._queue.get()
if isinstance(content, str) and content == 'quit':
break
response = urllib2.urlopen(content)
print 'Bye byes!'
def Producer():
urls = [
'', ''
'', ''
# etc..
]
queue = Queue.Queue()
worker_threads = build_worker_pool(queue, 4)
start_time = time.time()
# Add the urls to process
for url in urls:
queue.put(url)
# Add the poison pillv
for worker in worker_threads:
queue.put('quit')
for worker in worker_threads:
worker.join()
print 'Done! Time taken: {}'.format(time.time() - start_time)
def build_worker_pool(queue, size):
workers = []
for _ in range(size):
worker = Consumer(queue)
worker.start()
workers.append(worker)
return workers
if __name__ == '__main__':
Producer()
这段代码能正确的运行，但仔细看看我们需要做些什么：构造不同的方法、追踪一系列的线程，还有为了解决恼人的死锁问题，我们需要进行一系列的 join 操作。这还只是开始……
至此我们回顾了经典的多线程教程，多少有些空洞不是吗？样板化而且易出错，这样事倍功半的风格显然不那么适合日常使用，好在我们还有更好的方法。
何不试试 map
map 这一小巧精致的函数是简捷实现 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 Pool
from multiprocessing.dummy import Pool as ThreadPool
实例化 Pool 对象：
pool = ThreadPool()
这条简单的语句替代了 example2.py 中 build_worker_pool 函数 7 行代码的工作。它生成了一系列的 worker 线程并完成初始化工作、将它们储存在变量中以方便访问。
Pool 对象有一些参数，这里我所需要关注的只是它的第一个参数：processes. 这一参数用于设定线程池中的线程数。其默认值为当前机器 CPU 的核数。
一般来说，执行 CPU 密集型任务时，调用越多的核速度就越快。但是当处理网络密集型任务时，事情有有些难以预计了，通过实验来确定线程池的大小才是明智的。
pool = ThreadPool(4) # Sets the pool size to 4
线程数过多时，切换线程所消耗的时间甚至会超过实际工作时间。对于不同的工作，通过尝试来找到线程池大小的最优值是个不错的主意。
创建好 Pool 对象后，并行化的程序便呼之欲出了。我们来看看改写后的 example2.py
import urllib2
from multiprocessing.dummy import Pool as ThreadPool
urls = [
# etc..
]
# Make the Pool of workers
pool = ThreadPool(4)
# Open the urls in their own threads
# and return the results
results = pool.map(urllib2.urlopen, urls)
#close the pool and wait for the work to finish
pool.close()
pool.join()
实际起作用的代码只有 4 行，其中只有一行是关键的。map 函数轻而易举的取代了前文中超过 40 行的例子。为了更有趣一些，我统计了不同方法、不同线程池大小的耗时情况。
# results = []
# for url in urls:
# result = urllib2.urlopen(url)
# results.append(result)
# # ------- VERSUS ------- #
# # ------- 4 Pool ------- #
# pool = ThreadPool(4)
# results = pool.map(urllib2.urlopen, urls)
# # ------- 8 Pool ------- #
# pool = ThreadPool(8)
# results = pool.map(urllib2.urlopen, urls)
# # ------- 13 Pool ------- #
# pool = ThreadPool(13)
# results = pool.map(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 Image
SIZE = (75,75)
SAVE_DIRECTORY = 'thumbs'
def get_image_paths(folder):
return (os.path.join(folder, f)
for f in os.listdir(folder)
if 'jpeg' in f)
def create_thumbnail(filename):
im = Image.open(filename)
im.thumbnail(SIZE, Image.ANTIALIAS)
base, fname = os.path.split(filename)
save_path = os.path.join(base, SAVE_DIRECTORY, fname)
im.save(save_path)
if __name__ == '__main__':
folder = os.path.abspath(
'11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')
os.mkdir(os.path.join(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 Image
SIZE = (75,75)
SAVE_DIRECTORY = 'thumbs'
def get_image_paths(folder):
return (os.path.join(folder, f)
for f in os.listdir(folder)
if 'jpeg' in f)
def create_thumbnail(filename):
im = Image.open(filename)
im.thumbnail(SIZE, Image.ANTIALIAS)
base, fname = os.path.split(filename)
save_path = os.path.join(base, SAVE_DIRECTORY, fname)
im.save(save_path)
if __name__ == '__main__':
folder = os.path.abspath(
'11_18_2013_R000_IQM_Big_Sur_Mon__e10d1958e7b766c3e840')
os.mkdir(os.path.join(folder, SAVE_DIRECTORY))
images = get_image_paths(folder)
pool = Pool()
pool.map(creat_thumbnail, images)
pool.close()
pool.join()
5.6 秒！
虽然只改动了几行代码，我们却明显提高了程序的执行速度。在生产环境中，我们可以为 CPU 密集型任务和 IO 密集型任务分别选择多进程和多线程库来进一步提高执行速度——这也是解决死锁问题的良方。此外，由于 map 函数并不支持手动线程管理，反而使得相关的 debug 工作也变得异常简单。
到这里，我们就实现了（基本）通过一行 Python 实现并行化。
如何用python爬取网站数据？
这里简单介绍一下吧，以抓取网站静态、动态2种数据为例，实验环境win10+python3.6+pycharm5.0，主要内容如下：
抓取网站静态数据（数据在网页源码中）：以糗事百科网站数据为例
1.这里假设我们抓取的数据如下，主要包括用户昵称、内容、好笑数和评论数这4个字段，如下：
对应的网页源码如下，包含我们所需要的数据：
2.对应网页结构，主要代码如下，很简单，主要用到requests+BeautifulSoup，其中requests用于请求页面，BeautifulSoup用于解析页面：
程序运行截图如下，已经成功爬取到数据：
抓取网站动态数据（数据不在网页源码中，json等文件中）：以人人贷网站数据为例
1.这里假设我们爬取的是债券数据，主要包括年利率、借款标题、期限、金额和进度这5个字段信息，截图如下：
打开网页源码中，可以发现数据不在网页源码中，按F12抓包分析时，才发现在一个json文件中，如下：
2.获取到json文件的url后，我们就可以爬取对应数据了，这里使用的包与上面类似，因为是json文件，所以还用了json这个包（解析json），主要内容如下：
程序运行截图如下，已经成功抓取到数据：
至此，这里就介绍完了这2种数据的抓取，包括静态数据和动态数据。总的来说，这2个示例不难，都是入门级别的爬虫，网页结构也比较简单，最重要的还是要会进行抓包分析，对页面进行分析提取，后期熟悉后，可以借助scrapy这个框架进行数据的爬取，可以更方便一些，效率更高，当然，如果爬取的页面比较复杂，像验证码、加密等，这时候就需要认真分析了，网上也有一些教程可供参考，感兴趣的可以搜一下，希望以上分享的内容能对你有所帮助吧。
如果用python爬百度搜索的统计数据
import?requests
from?bs4?import?BeautifulSoup
word='爬虫'
url=';cl=2rtt=1bsst=1tn=newsword=%s'%word
headers={'User-Agent':?'Mozilla/5.0?(Windows?NT?6.1;?Win64;?x64)?AppleWebKit/537.36?(KHTML,?like?Gecko)?Chrome/70.0.3538.77?Safari/537.36'}
req=requests.get(url,headers=headers)
soup=BeautifulSoup(req.content,'lxml')
text=soup.select('div[id="header_top_bar"]?span')
print(text[0].text)