注重版权，转载请注明原作者和原文链接
 作者：码农BookSea
 原文链接：https://blog.csdn.net/bookssea/article/details/107309591
 
 
 
先看后赞，养成习惯。
 点赞收藏，人生辉煌。
 
 
 
讲解我们的爬虫之前，先概述关于爬虫的简单概念（毕竟是零基础教程）
 
爬虫
 
网络爬虫（又被称为网页蜘蛛，网络机器人）就是模拟浏览器发送网络请求，接收请求响应，一种按照一定的规则，自动地抓取互联网信息的程序。
 原则上,只要是浏览器(客户端)能做的事情，爬虫都能够做。
 
为什么我们要使用爬虫
 
互联网大数据时代，给予我们的是生活的便利以及海量数据爆炸式的出现在网络中。
 过去，我们通过书籍、报纸、电视、广播或许信息，这些信息数量有限，且是经过一定的筛选，信息相对而言比较有效，但是缺点则是信息面太过于狭窄了。不对称的信息传导，以致于我们视野受限，无法了解到更多的信息和知识。
 互联网大数据时代，我们突然间，信息获取自由了，我们得到了海量的信息，但是大多数都是无效的垃圾信息。
 例如新浪微博，一天产生数亿条的状态更新，而在百度搜索引擎中，随意搜一条——减肥100,000,000条信息。
 在如此海量的信息碎片中，我们如何获取对自己有用的信息呢？
 答案是筛选！
 通过某项技术将相关的内容收集起来，在分析删选才能得到我们真正需要的信息。
 这个信息收集分析整合的工作，可应用的范畴非常的广泛，无论是生活服务、出行旅行、金融投资、各类制造业的产品市场需求等等……都能够借助这个技术获取更精准有效的信息加以利用。
 网络爬虫技术，虽说有个诡异的名字，让能第一反应是那种软软的蠕动的生物，但它却是一个可以在虚拟世界里，无往不前的利器。
 
爬虫准备工作
 
我们平时都说Python爬虫，其实这里可能有个误解，爬虫并不是Python独有的，可以做爬虫的语言有很多例如：PHP,JAVA,C#,C++,Python，选择Python做爬虫是因为Python相对来说比较简单，而且功能比较齐全。
 首先我们需要下载python，我下载的是官方最新的版本 3.8.3
 其次我们需要一个运行Python的环境，我用的是pychram
 
 也可以从官方下载，
 我们还需要一些库来支持爬虫的运行（有些库Python可能自带了）
 
 差不多就是这几个库了，良心的我已经在后面写好注释了
 
 （爬虫运行过程中，不一定就只需要上面几个库，看你爬虫的一个具体写法了，反正需要库的话我们可以直接在setting里面安装）
 
爬虫项目讲解
 
我做的是爬取豆瓣评分电影Top250的爬虫代码
 我们要爬取的就是这个网站：https://movie.douban.com/top250
 
这边我已经爬取完毕，给大家看下效果图，我是将爬取到的内容存到xls中
 
 
我们的爬取的内容是：电影详情链接，图片链接，影片中文名，影片外国名，评分，评价数，概况，相关信息。
 
代码分析
 
先把代码发放上来，然后我根据代码逐步解析
 
# -*- codeing = utf-8 -*-
from bs4 import BeautifulSoup  # 网页解析，获取数据
import re  # 正则表达式，进行文字匹配`
import urllib.request, urllib.error  # 制定URL，获取网页数据
import xlwt  # 进行excel操作
#import sqlite3  # 进行SQLite数据库操作

findLink = re.compile(r'<a href="(.*?)">')  # 创建正则表达式对象，标售规则   影片详情链接的规则
findImgSrc = re.compile(r'<img.*src="(.*?)"', re.S)
findTitle = re.compile(r'<span class="title">(.*)</span>')
findRating = re.compile(r'<span class="rating_num" property="v:average">(.*)</span>')
findJudge = re.compile(r'<span>(\d*)人评价</span>')
findInq = re.compile(r'<span class="inq">(.*)</span>')
findBd = re.compile(r'<p class="">(.*?)</p>', re.S)




def main():
    baseurl = "https://movie.douban.com/top250?start="  #要爬取的网页链接
    # 1.爬取网页
    datalist = getData(baseurl)
    savepath = "豆瓣电影Top250.xls"    #当前目录新建XLS，存储进去
    # dbpath = "movie.db"              #当前目录新建数据库，存储进去
    # 3.保存数据
    saveData(datalist,savepath)      #2种存储方式可以只选择一种
    # saveData2DB(datalist,dbpath)



# 爬取网页
def getData(baseurl):
    datalist = []  #用来存储爬取的网页信息
    for i in range(0, 10):  # 调用获取页面信息的函数，10次
        url = baseurl + str(i * 25)
        html = askURL(url)  # 保存获取到的网页源码
        # 2.逐一解析数据
        soup = BeautifulSoup(html, "html.parser")
        for item in soup.find_all('div', class_="item"):  # 查找符合要求的字符串
            data = []  # 保存一部电影所有信息
            item = str(item)
            link = re.findall(findLink, item)[0]  # 通过正则表达式查找
            data.append(link)
            imgSrc = re.findall(findImgSrc, item)[0]
            data.append(imgSrc)
            titles = re.findall(findTitle, item)
            if (len(titles) == 2):
                ctitle = titles[0]
                data.append(ctitle)
                otitle = titles[1].replace("/", "")  #消除转义字符
                data.append(otitle)
            else:
                data.append(titles[0])
                data.append(' ')
            rating = re.findall(findRating, item)[0]
            data.append(rating)
            judgeNum = re.findall(findJudge, item)[0]
            data.append(judgeNum)
            inq = re.findall(findInq, item)
            if len(inq) != 0:
                inq = inq[0].replace("。", "")
                data.append(inq)
            else:
                data.append(" ")
            bd = re.findall(findBd, item)[0]
            bd = re.sub('<br(\s+)?/>(\s+)?', "", bd)
            bd = re.sub('/', "", bd)
            data.append(bd.strip())
            datalist.append(data)

    return datalist


# 得到指定一个URL的网页内容
def askURL(url):
    head = {  # 模拟浏览器头部信息，向豆瓣服务器发送消息
        "User-Agent": "Mozilla / 5.0(Windows NT 10.0; Win64; x64) AppleWebKit / 537.36(KHTML, like Gecko) Chrome / 80.0.3987.122  Safari / 537.36"
    }
    # 用户代理，表示告诉豆瓣服务器，我们是什么类型的机器、浏览器（本质上是告诉浏览器，我们可以接收什么水平的文件内容）

    request = urllib.request.Request(url, headers=head)
    html = ""
    try:
        response = urllib.request.urlopen(request)
        html = response.read().decode("utf-8")
    except urllib.error.URLError as e:
        if hasattr(e, "code"):
            print(e.code)
        if hasattr(e, "reason"):
            print(e.reason)
    return html


# 保存数据到表格
def saveData(datalist,savepath):
    print("save.......")
    book = xlwt.Workbook(encoding="utf-8",style_compression=0) #创建workbook对象
    sheet = book.add_sheet('豆瓣电影Top250', cell_overwrite_ok=True) #创建工作表
    col = ("电影详情链接","图片链接","影片中文名","影片外国名","评分","评价数","概况","相关信息")
    for i in range(0,8):
        sheet.write(0,i,col[i])  #列名
    for i in range(0,250):
        # print("第%d条" %(i+1))       #输出语句，用来测试
        data = datalist[i]
        for j in range(0,8):
            sheet.write(i+1,j,data[j])  #数据
    book.save(savepath) #保存

# def saveData2DB(datalist,dbpath):
#     init_db(dbpath)
#     conn = sqlite3.connect(dbpath)
#     cur = conn.cursor()
#     for data in datalist:
#             for index in range(len(data)):
#                 if index == 4 or index == 5:
#                     continue
#                 data[index] = '"'+data[index]+'"'
#             sql = '''
#                     insert into movie250(
#                     info_link,pic_link,cname,ename,score,rated,instroduction,info)
#                     values (%s)'''%",".join(data)
#             # print(sql)     #输出查询语句，用来测试
#             cur.execute(sql)
#             conn.commit()
#     cur.close
#     conn.close()


# def init_db(dbpath):
#     sql = '''
#         create table movie250(
#         id integer  primary  key autoincrement,
#         info_link text,
#         pic_link text,
#         cname varchar,
#         ename varchar ,
#         score numeric,
#         rated numeric,
#         instroduction text,
#         info text
#         )
#
#
#     '''  #创建数据表
#     conn = sqlite3.connect(dbpath)
#     cursor = conn.cursor()
#     cursor.execute(sql)
#     conn.commit()
#     conn.close()

# 保存数据到数据库







if __name__ == "__main__":  # 当程序执行时
    # 调用函数
     main()
    # init_db("movietest.db")
     print("爬取完毕！")

 
下面我根据代码，从下到下给大家讲解分析一遍
 
 
-- codeing = utf-8 --，开头的这个是设置编码为utf-8 ，写在开头，防止乱码。
 然后下面 import就是导入一些库，做做准备工作，（sqlite3这库我并没有用到所以我注释起来了）。
 下面一些find开头的是正则表达式，是用来我们筛选信息的。
 （正则表达式用到 re 库，也可以不用正则表达式，不是必须的。）
 大体流程分三步走：
 
1. 爬取网页
 2.逐一解析数据
 3. 保存网页
 
先分析流程1，爬取网页，baseurl 就是我们要爬虫的网页网址，往下走，调用了 getData（baseurl) ,
 我们来看 getData方法
 
  for i in range(0, 10):  # 调用获取页面信息的函数，10次
        url = baseurl + str(i * 25)
 
这段大家可能看不懂，其实是这样的：
 因为电影评分Top250，每个页面只显示25个，所以我们需要访问页面10次，25*10=250。
 
baseurl = "https://movie.douban.com/top250?start="
 
我们只要在baseurl后面加上数字就会跳到相应页面，比如i=1时
 
https://movie.douban.com/top250?start=25
 
我放上超链接，大家可以点击看看会跳到哪个页面，毕竟实践出真知。
 
 
然后又调用了askURL来请求网页，这个方法是请求网页的主体方法，
 怕大家翻页麻烦，我再把代码复制一遍，让大家有个直观感受
 
def askURL(url):
    head = {  # 模拟浏览器头部信息，向豆瓣服务器发送消息
        "User-Agent": "Mozilla / 5.0(Windows NT 10.0; Win64; x64) AppleWebKit / 537.36(KHTML, like Gecko) Chrome / 80.0.3987.122  Safari / 537.36"
    }
    # 用户代理，表示告诉豆瓣服务器，我们是什么类型的机器、浏览器（本质上是告诉浏览器，我们可以接收什么水平的文件内容）

    request = urllib.request.Request(url, headers=head)
    html = ""
    try:
        response = urllib.request.urlopen(request)
        html = response.read().decode("utf-8")
    except urllib.error.URLError as e:
        if hasattr(e, "code"):
            print(e.code)
        if hasattr(e, "reason"):
            print(e.reason)
    return html
 
这个askURL就是用来向网页发送请求用的，那么这里就有老铁问了，为什么这里要写个head呢？
 
 
这是因为我们要是不写的话，访问某些网站的时候会被认出来爬虫，显示错误，错误代码
 
418
 
这是一个梗大家可以百度下，
 
 
 
418 I’m a teapot
 
 
The HTTP 418 I’m a teapot client error response code indicates that
 the server refuses to brew coffee because it is a teapot. This error
 is a reference to Hyper Text Coffee Pot Control Protocol which was an
 April Fools’ joke in 1998.
 
 
我是一个茶壶
 
 
所以我们需要 “装” ，装成我们就是一个浏览器，这样就不会被认出来，
 伪装一个身份。
 
 
来，我们继续往下走，
 
  html = response.read().decode("utf-8")
 
这段就是我们读取网页的内容，设置编码为utf-8，目的就是为了防止乱码。
 访问成功后，来到了第二个流程：
 
2.逐一解析数据
 
解析数据这里我们用到了 BeautifulSoup（靓汤） 这个库，这个库是几乎是做爬虫必备的库，无论你是什么写法。
 
下面就开始查找符合我们要求的数据，用BeautifulSoup的方法以及 re 库的
 正则表达式去匹配，
 
findLink = re.compile(r'<a href="(.*?)">')  # 创建正则表达式对象，标售规则   影片详情链接的规则
findImgSrc = re.compile(r'<img.*src="(.*?)"', re.S)
findTitle = re.compile(r'<span class="title">(.*)</span>')
findRating = re.compile(r'<span class="rating_num" property="v:average">(.*)</span>')
findJudge = re.compile(r'<span>(\d*)人评价</span>')
findInq = re.compile(r'<span class="inq">(.*)</span>')
findBd = re.compile(r'<p class="">(.*?)</p>', re.S)
 
匹配到符合我们要求的数据，然后存进 dataList ， 所以 dataList 里就存放着我们需要的数据了。
 
最后一个流程：
 
3.保存数据
 
    # 3.保存数据
    saveData(datalist,savepath)      #2种存储方式可以只选择一种
    # saveData2DB(datalist,dbpath)
 
保存数据可以选择保存到 xls 表， 需要（xlwt库支持）
 也可以选择保存数据到 sqlite数据库， 需要（sqlite3库支持）
 
这里我选择保存到 xls 表 ，这也是为什么我注释了一大堆代码，注释的部分就是保存到 sqlite 数据库的代码，二者选一就行
 
保存到 xls 的主体方法是 saveData （下面的saveData2DB方法是保存到sqlite数据库）：
 
def saveData(datalist,savepath):
    print("save.......")
    book = xlwt.Workbook(encoding="utf-8",style_compression=0) #创建workbook对象
    sheet = book.add_sheet('豆瓣电影Top250', cell_overwrite_ok=True) #创建工作表
    col = ("电影详情链接","图片链接","影片中文名","影片外国名","评分","评价数","概况","相关信息")
    for i in range(0,8):
        sheet.write(0,i,col[i])  #列名
    for i in range(0,250):
        # print("第%d条" %(i+1))       #输出语句，用来测试
        data = datalist[i]
        for j in range(0,8):
            sheet.write(i+1,j,data[j])  #数据
    book.save(savepath) #保存
 
创建工作表，创列（会在当前目录下创建），
 
   sheet = book.add_sheet('豆瓣电影Top250', cell_overwrite_ok=True) #创建工作表
    col = ("电影详情链接","图片链接","影片中文名","影片外国名","评分","评价数","概况","相关信息")
 
然后把 dataList里的数据一条条存进去就行。
 
最后运作成功后，会在左侧生成这么一个文件
 
 
打开之后看看是不是我们想要的结果
 
 
成了，成了！
 
 
如果我们需要以数据库方式存储，可以先生成 xls 文件，再把 xls 文件导入数据库中，就可以啦
 
 
 
本篇文章讲解到这里啦，我感觉我讲的还算细致吧，爬虫我也是最近才可以学，对这个比较有兴趣，我肯定有讲的不好的地方，欢迎各位大佬来指正我 。
 
 
我也在不断的学习中，学到新东西第一时间会跟大家分享
 大家可以动动小手，点波关注不迷路。
 
如果关于本篇文章有不懂的地方，欢迎大家下面留言，我知道的都会给大家一 一解答。
 
最后给大家放波福利，博主最近在搞阿里云推广，
 
活动折扣价：全网最低价87元/年，261元/3年，比学生9.9每月还便宜(只阿里云新用户可用)
 新用户可以入手试试，有一台属于自己的服务器，前期用来部署和学习都很方便
 
阿里云 【点击购买】
 
 
 
 
 
白嫖不好，创作不易。各位的点赞就是我创作的最大动力，如果我有哪里写的不对，欢迎评论区留言进行指正。
 老铁，如果有收获，请点个免费的赞鼓励一下博主呗
 
 

Python爬虫入门教程导航，已经完结啦，以后的时间不定期补番。
 
 
 
本系列博客争取把爬虫入门阶段的所有内容都包含住，需要你有较好的 Python 基础知识，当然你完全零基础也可以观看本系列博客。
 
Python 爬虫入门教程，加油！
 
基础篇，包含多线程爬虫
 
1. Python爬虫入门教程 1-100 CentOS环境安装
 
2. Python爬虫入门教程 2-100 和谐图网站爬取
 
3. Python爬虫入门教程 3-100 美空网数据爬取
 
4. Python爬虫入门教程 4-100 美空网未登录图片爬取
 
5. Python爬虫入门教程 5-100 27270图片爬取
 
6. Python爬虫入门教程 6-100 蜂鸟网图片爬取之一
 
7. Python爬虫入门教程 7-100 蜂鸟网图片爬取之二
 
8. 

《Python 爬虫 120 例》专栏简介
 
Python 爬虫 100 例教程，编写自 2018-07-30 到 2020-10-28，将近 800 天，至今依旧是 Python 爬虫领域畅销专栏之一。
 
但随着时间的变化，Python 爬虫 100 例中部分抓取目标网站，地址已经失效，是时候进行迭代升级啦。
 
2021 年 5 月 21 日，升级版 Python 爬虫 120 例上线啦。
 
更新内容如下：
 
更新频率更快，上次 800 天完成 100 例，这次 300 天完成 120 例；
更新所有目标网站；
更新最新框架；
 
Python 爬虫的整体技术思想是不会发生变化的，所以你依旧可以购买原专栏进行学习。
 
购买与预览地址为 https://dream.blog.csdn.net/category_9280209.html。
 
专栏更新频率为每周 2~3 篇内容，内容从浅入深，专栏由大龄程序员 擦哥 撰写。
 
一切的起点，10 行代码集美女
 
前奏篇
 
正式编写爬虫学习前，以下内容先搞定：
 
 能安装 Python 环境，例如安装 3.5 版本，可以切换为其他版本；
 能熟练开发工具，例如 VSCode，PyCharm；
 能熟练 Python 第三方库；
 能运行 Python 脚本文件，能输出 hello world。
 
有以上技能，就可以放心大胆的购买本专栏进行学习。
 
截止 2021 年 5 月 20 日 Python 最新版本，官网版本为 3.9.5 版本，你可以直接使用该版本，也可以使用任意 3.0 以上版本。
 
目标数据源分析
 
本次待抓取的目标地址为：
 http://www.netbian.com/mei/index.htm
 
 
抓取目标：
 抓取该网站的图片，目标 2000 张。
 
用到的 Python 框架为：
 requests 库、re 模块
 
其它技术栈补充：
 正则表达式
 
目标网站地址规则：
 
http://www.netbian.com/mei/index.htm
http://www.netbian.com/mei/index_2.htm
http://www.netbian.com/mei/index_3.htm
 
结论，列表页规则为 http://www.netbian.com/mei/index_{页码}.htm。
 
数据范围
 
累计 164 页；
每页 20 条数据。
 
图片所在标签与页面地址
 图片所在标签位置代码如下：
 
<li><a href="/desk/23397.htm" title="陆萱萱 白色衬衫  裙子 职业装 美女模特壁纸 更新时间：2021-04-11" target="_blank"><img src="http://img.netbian.com/file/2021/0411/small30caf1465200926b08db3893c6f35f6c1618152842.jpg" alt="陆萱萱 白色衬衫  裙子 职业装 美女模特壁纸"><b>陆萱萱 白色衬衫  裙子 职业装 美女模特壁纸</b></a></li>
 
页面地址为 /desk/23397.htm。
 
整理需求如下
 
生成所有列表页 URL 地址；
遍历列表页 URL 地址，并获取图片详情页地址；
进入详情页获取大图；
保存图片；
得到 2000 张图片之后，开始欣赏。
 
代码实现时间
 
提前安装完毕 requests 模块，使用 pip install requests 即可，如果访问失败，切换国内 pip 源。
 
留个课后小作业，如何设置全局的 pip 源。
 
代码结构如下：
 
import requests

# 抓取函数
def main():
    pass

# 解析函数
def format():
    pass

# 存储函数
def save_image():
    pass

if __name__ == '__main__':
    main()
 
先实现 10 行代码抓美女图，举个例子，在正式开始前，需要略微了解一些前端知识与正则表达式知识。
 
例如通过开发者工具查看网页，得到图片素材都在 <div class="list"> 和 <div class="page"> 这两个标签中，首先要做的就是拆解字符串，取出目标数据部分。
 

 通过 requests 对网页源码进行获取，代码如下。
 
# 抓取函数
def main():
    url = "http://www.netbian.com/mei/index.htm"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36"
    }
    res = requests.get(url=url, headers=headers, timeout=5)
    res.encoding = "GBK"
    print(res.text)
 
使用 requests 模块的 get 方法即可获取网页数据，其中的参数分别是请求地址，请求头，等待时间。
 
请求头字段中的 User-Agent，可以先使用我提供给你的内容，也可以通过开发者工具，进行获取。
 
在数据返回 Response 对象之后，通过 res.encoding="GBK" 设置了数据编码，该值可以从网页源码中获取到。
 
 
请求到数据源码，即开始解析数据，如果使用正则表达式，建议先对目标数据进行一些简单的裁剪工作。
 
裁剪字符串是 Python 中比较常规的操作了，直接编写代码即可实现。
 
用到的还是上文已经提及的两个字符串。
 
# 解析函数
def format(text):
    # 处理字符串
    div_html = '<div class="list">'
    page_html = '<div class="page">'
    start = text.find(div_html) + len(div_html)
    end = text.find(page_html)
    origin_text = text[start:end]
 
最终得到的 origin_text 就是我们的目标文本。
 
通过 re 模块解析目标文本
 
上文返回的目标文本如下所示，本小节的目标就是获取到图片详情页地址。
 

 使用的技术是 re 模块，当然需要配合正则表达式进行使用，对于正则表达式，可以跟随橡皮擦一点点的接触。
 

# 解析函数
def format(text):
    # 处理字符串
    div_html = '<div class="list">'
    page_html = '<div class="page">'
    start = text.find(div_html) + len(div_html)
    end = text.find(page_html)
    origin_text = text[start:end]

    pattern = re.compile('href="(.*?)"')
    hrefs = pattern.findall(origin_text)
    print(hrefs)
 
其中 re.compile 方法中传递的就是正则表达式，它是一种检索字符串特定内容的语法结构。
 
例如
 
. ：表示除换行符（\n、\r）之外的任何单个字符；
*：表示匹配前面的子表达式零次或多次；
?：当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的，非贪婪就是减少匹配；
()：分组提取用。
 
有这些知识之后，在回到代码中去看实现。
 

 假设存在一个字符串：href="/desk/23478.htm"，使用 href="(.*?)" 可以将其中的 /desk/23478.htm 匹配出来，括号的作用也是为了后续方便提取。
 
最后输出内容如下图所示。
 
 
清洗爬取结果
 
其中存在部分链接地址不正确，需要从列表中进行去除，本步骤使用列表生成器即可完成任务。
 
    pattern = re.compile('href="(.*?)"')
    hrefs = pattern.findall(origin_text)
    hrefs = [i for i in hrefs if i.find("desk")>0]
    print(hrefs)
 
抓取内页数据
 
获取到列表页地址之后，就可以对图片内页数据进行获取了，这里用到的技术与前文逻辑一致。
 
# 解析函数
def format(text, headers):
    # 处理字符串
    div_html = '<div class="list">'
    page_html = '<div class="page">'
    start = text.find(div_html) + len(div_html)
    end = text.find(page_html)
    origin_text = text[start:end]

    pattern = re.compile('href="(.*?)"')
    hrefs = pattern.findall(origin_text)
    hrefs = [i for i in hrefs if i.find("desk") > 0]
    for href in hrefs:
        url = f"http://www.netbian.com{href}"
        res = requests.get(url=url, headers=headers, timeout=5)
        res.encoding = "GBK"
        format_detail(res.text)
        break
 
在第一次循环中增加了 break，跳出循环，format_detail 函数用于格式化内页数据，依旧采用格式化字符串的形式进行。
 
由于每页只有一张图片是目标数据，故使用的是 re.search 进行检索，同时调用该对象的 group 方法对数据进行提取。
 
 
 
发现重复代码了，稍后进行优化。
 
 
def format_detail(text):
    # 处理字符串
    div_html = '<div class="pic">'
    page_html = '<div class="pic-down">'
    start = text.find(div_html) + len(div_html)
    end = text.find(page_html)
    origin_text = text[start:end]
    pattern = re.compile('src="(.*?)"')
    image_src = pattern.search(origin_text).group(1)
    # 保存图片
    save_image(image_src)
 
保存图片部分，需要提前导入 time 模块，对图片进行重命名。
 
使用 requests.get 方法直接请求图片地址，调用响应对象的 content 属性，获取二进制流，然后使用 f.write 存储成图片。
 
# 存储函数
def save_image(image_src):
    res = requests.get(url=image_src, timeout=5)
    content = res.content
    with open(f"{str(time.time())}.jpg", "wb") as f:
        f.write(content)
 
得到的第一张图片，贴到博客中记录。
 
 
优化代码
 
将代码重复逻辑进行提取，封装成公用函数，最终整理之后的代码如下：
 
import requests
import re
import time


# 请求函数
def request_get(url, ret_type="text", timeout=5, encoding="GBK"):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36"
    }
    res = requests.get(url=url, headers=headers, timeout=timeout)
    res.encoding = encoding
    if ret_type == "text":
        return res.text
    elif ret_type == "image":
        return res.content


# 抓取函数
def main():
    url = "http://www.netbian.com/mei/index.htm"
    text = request_get(url)
    format(text)


# 解析函数
def format(text):
    origin_text = split_str(text, '<div class="list">', '<div class="page">')
    pattern = re.compile('href="(.*?)"')
    hrefs = pattern.findall(origin_text)
    hrefs = [i for i in hrefs if i.find("desk") > 0]
    for href in hrefs:
        url = f"http://www.netbian.com{href}"
        print(f"正在下载：{url}")
        text = request_get(url)
        format_detail(text)


def split_str(text, s_html, e_html):
    start = text.find(s_html) + len(e_html)
    end = text.find(e_html)
    origin_text = text[start:end]

    return origin_text


def format_detail(text):
    origin_text = split_str(text, '<div class="pic">', '<div class="pic-down">')
    pattern = re.compile('src="(.*?)"')
    image_src = pattern.search(origin_text).group(1)
    # 保存图片
    save_image(image_src)


# 存储函数
def save_image(image_src):
    content = request_get(image_src, "image")
    with open(f"{str(time.time())}.jpg", "wb") as f:
        f.write(content)
        print("图片保存成功")


if __name__ == '__main__':
    main()
 
运行代码，得到下图所示运行效果。
 
 
目标 2000 张
 
20 张图片的爬取已经得到，下面目标 2000 张，初学阶段按照这种简单的方式抓取即可。
 
这一步需要改造的就是 main 函数：
 
# 抓取函数
def main():
    urls = [f"http://www.netbian.com/mei/index_{i}.htm" for i in range(2, 201)]
    url = "http://www.netbian.com/mei/index.htm"
    urls.insert(0, url)
    for url in urls:
        print("抓取列表页地址为：", url)
        text = request_get(url)
        format(text)
 
 
完整代码下载地址：https://codechina.csdn.net/hihell/python120
 2000 图片下载地址：
 
Python爬虫120例之1776图图
Python爬虫120例之350图图
 
抽奖环节
 
只要评论数过50
 随机抽取一名幸运读者
 奖励39.9元爬虫100例专栏 1 折购买券一份，只需3.99元
 
 
 
今天是持续写作的第 155 / 200 天。
 求点赞、求评论、求收藏。
 

 
Python是什么
 
Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。
 
创始人Guido van Rossum是BBC出品英剧Monty Python’s Flying Circus（中文：蒙提·派森的飞行马戏团）的狂热粉丝，因而将自己创造的这门编程语言命名为Python。
 
人生苦短，我用python，翻译自"Life is short, you need Python"
 
Python英式发音：/ˈpaɪθən/ ，中文类似‘拍森’。而美式发音：/ˈpaɪθɑːn/，中文类似‘拍赏’。我看麻省理工授课教授读的是‘拍赏’，我觉得国内大多是读‘拍森’吧。
 
2017年python排第一也无可争议，比较AI第一语言，在当下人工智能大数据大火的情况下，python无愧第一语言的称号，至于C、C++、java都是万年的老大哥了，在代码量比较方面，小编相信java肯定是完爆其它语言的。
 
不过从这一年的编程语言流行趋势看，java依然是传播最多的，比较无论app、web、云计算都离不开，而其相对python而言，学习路径更困难一点，想要转行编程，而且追赶潮流，python已然是最佳语言。
 
许多大型网站就是用Python开发的，国内：豆瓣、搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝、热酷、土豆、新浪、果壳…； 国外：谷歌、NASA、YouTube、Facebook、工业光魔、红帽…
 
Python将被纳入高考内容
 
浙江省信息技术课程改革方案已经出台，Python确定进入浙江省信息技术高考，从2018年起浙江省信息技术教材编程语言将会从vb更换为Python。其实不止浙江，教育大省北京和山东也确定要把Python编程基础纳入信息技术课程和高考的内容体系，Python语言课程化也将成为孩子学习的一种趋势。尤其山东省最新出版的小学信息技术六年级教材也加入了Python内容，小学生都开始接触Python语言了！！
 
再不学习，又要被小学生完爆了。。。
 
 
 
 
Python入门教程
 
Python教程 - 廖雪峰的官方网站
Python官网
Python 100例 | 菜鸟教程
Python中文社区
微信公众号：裸睡的猪
微信跳一跳的python外挂项目：https://github.com/wangshub/wechat_jump_game
微信机器人、爬取京东充气娃娃、豆瓣影评、新浪话题、模拟登录淘宝，爬取淘宝案例，都在vx公众号「裸睡的猪」
 
500G 百度云Python入门资料免费送，公众号回复：python入门
 
Python能做什么
 
网络爬虫
Web应用开发
系统网络运维
科学与数字计算
图形界面开发
网络编程
自然语言处理（NLP）
人工智能
区块链
多不胜举。。。
Python入门爬虫
 
这是我的第一个python项目，在这里与大家分享出来~
 
需求 
  
我们目前正在开发一款产品其功能大致是：用户收到短信如：购买了电影票或者火车票机票之类的事件。然后app读取短信，解析短信，获取时间地点，然后后台自动建立一个备忘录，在事件开始前1小时提醒用户。
设计 
  
开始我们将解析的功能放在了服务端，但是后来考虑到用户隐私问题。后来将解析功能放到了app端，服务端只负责收集数据，然后将新数据发送给app端。
关于服务端主要是分离出两个功能，一、响应app端请求返回数据。二、爬取数据，存入数据库。
响应请求返回数据使用java来做，而爬取数据存入数据库使用python来做，这样分别使用不同语言来做是因为这两种语言各有优势，java效率比python高些，适合做web端，而爬取数据并不是太追求性能且python语言和大量的库适合做爬虫。
代码 
  
本项目使用python3的版本
 
获取源码：扫描下方关注微信公众号「裸睡的猪」回复：爬虫入门 获取
  
 
 
 
 
了解这个项目你只需要有简单的python基础，能了解python语法就可以。其实我自己也是python没学完，然后就开始写，遇到问题就百度，边做边学这样才不至于很枯燥，因为python可以做一些很有意思的事情，比如模拟连续登录挣积分，比如我最近在写一个预定模范出行车子的python脚本。推荐看廖雪峰的python入门教程
首先带大家看看我的目录结构，开始我打算是定义一个非常好非常全的规范，后来才发现由于自己不熟悉框架，而是刚入门级别，所以就放弃了。从简而入：
下面咱们按照上图中的顺序，从上往下一个一个文件的讲解init.py包的标识文件，python包就是文件夹，当改文件夹下有一个init.py文件后它就成为一个package，我在这个包中引入一些py供其他py调用。
init.py
 
# -*- coding: UTF-8 -*-  

# import need manager module  
import MongoUtil  
import FileUtil  
import conf_dev  
import conf_test  
import scratch_airport_name  
import scratch_flight_number  
import scratch_movie_name  
import scratch_train_number  
import scratch_train_station  
import MainUtil
 
下面两个是配置文件，第一个是开发环境的（windows），第二个是测试环境的（linux），然后再根据不同系统启用不同的配置文件
 
conf_dev.py
 
# -*- coding: UTF-8 -*-  
# the configuration file of develop environment  

# path configure  
data_root_path = 'E:/APK98_GNBJ_SMARTSERVER/Proj-gionee-data/smart/data'  

# mongodb configure  
user = "cmc"  
pwd = "123456"  
server = "localhost"  
port = "27017"  
db_name = "smartdb"
 
conf_test.py
 
# -*- coding: UTF-8 -*-  
# the configuration file of test environment  

#path configure  
data_root_path = '/data/app/smart/data'  

#mongodb configure  
user = "smart"  
pwd = "123456"  
server = "10.8.0.30"  
port = "27017"  
db_name = "smartdb"
 
下面文件是一个util文件，主要是读取原文件的内容，还有将新内容写入原文件。
 
FileUtil.py
 
# -*- coding: UTF-8 -*-  
import conf_dev  
import conf_test  
import platform  


# configure Multi-confronment  
# 判断当前系统，并引入相对的配置文件
platform_os = platform.system()  
config = conf_dev  
if (platform_os == 'Linux'):  
    config = conf_test  
# path  
data_root_path = config.data_root_path  


# load old data  
def read(resources_file_path, encode='utf-8'):  
    file_path = data_root_path + resources_file_path  
    outputs = []  
    for line in open(file_path, encoding=encode):  
        if not line.startswith("//"):  
            outputs.append(line.strip('\n').split(',')[-1])  
    return outputs  


# append new data to file from scratch  
def append(resources_file_path, data, encode='utf-8'):  
    file_path = data_root_path + resources_file_path  
    with open(file_path, 'a', encoding=encode) as f:  
        f.write(data)  
    f.close
 
下面这个main方法控制着执行流程，其他的执行方法调用这个main方法
 
MainUtil.py
 
# -*- coding: UTF-8 -*-  

import sys  
from datetime import datetime  
import MongoUtil  
import FileUtil  

# @param resources_file_path 资源文件的path  
# @param base_url 爬取的连接  
# @param scratch_func 爬取的方法  
def main(resources_file_path, base_url, scratch_func):  
    old_data = FileUtil.read(resources_file_path)   #读取原资源  
    new_data = scratch_func(base_url, old_data)     #爬取新资源  
    if new_data:        #如果新数据不为空  
        date_new_data = "//" + datetime.now().strftime('%Y-%m-%d') + "\n" + "\n".join(new_data) + "\n"      #在新数据前面加上当前日期  
        FileUtil.append(resources_file_path, date_new_data)     #将新数据追加到文件中  
        MongoUtil.insert(resources_file_path, date_new_data)    #将新数据插入到mongodb数据库中  
    else:   #如果新数据为空，则打印日志  
        print(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), '----', getattr(scratch_func, '__name__'), ": nothing to update ")
 
将更新的内容插入mongodb中
 
MongoUtil.py
 
# -*- coding: UTF-8 -*-  

import platform  
from pymongo import MongoClient  
from datetime import datetime, timedelta, timezone  
import conf_dev  
import conf_test  

# configure Multi-confronment  
platform_os = platform.system()  
config = conf_dev  
if (platform_os == 'Linux'):  
    config = conf_test  
# mongodb  
uri = 'mongodb://' + config.user + ':' + config.pwd + '@' + config.server + ':' + config.port + '/' + config.db_name  


# 将数据写入mongodb  
# @author chenmc  
# @param uri connect to mongodb  
# @path save mongodb field  
# @data save mongodb field  
# @operation save mongodb field default value 'append'  
# @date 2017/12/07 16:30  
# 先在mongodb中插入一条自增数据 db.sequence.insert({ "_id" : "version","seq" : 1})  

def insert(path, data, operation='append'):  
    client = MongoClient(uri)  
    resources = client.smartdb.resources  
    sequence = client.smartdb.sequence  
    seq = sequence.find_one({"_id": "version"})["seq"]      #获取自增id  
    sequence.update_one({"_id": "version"}, {"$inc": {"seq": 1}})       #自增id+1  
    post_data = {"_class": "com.gionee.smart.domain.entity.Resources", "version": seq, "path": path,  
                 "content": data, "status": "enable", "operation": operation,  
                 "createtime": datetime.now(timezone(timedelta(hours=8)))}  
    resources.insert(post_data)     #插入数据
 
项目引入的第三方库，可使用pip install -r requirements.txt下载第三方库
 
requirements.txt
 
# need to install module# need to install module  
bs4  
pymongo  
requests  
json
 
下面真正的执行方法来了，这五个py分别表示爬取五种信息：机场名、航班号、电影名、列车号、列车站。他们的结构都差不多，如下:
 
第一部分：定义查找的url；
第二部分：获取并与旧数据比较，返回新数据；
第三部分：main方法，执行写入新数据到文件和mongodb中；
 
scratch_airport_name.py：爬取全国机场
 
# -*- coding: UTF-8 -*-  
import requests  
import bs4  
import json  
import MainUtil  

resources_file_path = '/resources/airplane/airportNameList.ini'  
scratch_url_old = 'https://data.variflight.com/profiles/profilesapi/search'  
scratch_url = 'https://data.variflight.com/analytics/codeapi/initialList'  
get_city_url = 'https://data.variflight.com/profiles/Airports/%s'  


#传入查找网页的url和旧数据，然后本方法会比对原数据中是否有新的条目，如果有则不加入，如果没有则重新加入，最后返回新数据
def scratch_airport_name(scratch_url, old_airports):  
    new_airports = []  
    data = requests.get(scratch_url).text  
    all_airport_json = json.loads(data)['data']  
    for airport_by_word in all_airport_json.values():  
        for airport in airport_by_word:  
            if airport['fn'] not in old_airports:  
                get_city_uri = get_city_url % airport['id']  
                data2 = requests.get(get_city_uri).text  
                soup = bs4.BeautifulSoup(data2, "html.parser")  
                city = soup.find('span', text="城市").next_sibling.text  
                new_airports.append(city + ',' + airport['fn'])  
    return new_airports  

 #main方法，执行这个py，默认调用main方法，相当于java的main
if __name__ == '__main__':  
    MainUtil.main(resources_file_path, scratch_url, scratch_airport_name)
 
scratch_flight_number.py：爬取全国航班号
 
#!/usr/bin/python  
# -*- coding: UTF-8 -*-  

import requests  
import bs4  
import MainUtil  

resources_file_path = '/resources/airplane/flightNameList.ini'  
scratch_url = 'http://www.variflight.com/sitemap.html?AE71649A58c77='  


def scratch_flight_number(scratch_url, old_flights):  
    new_flights = []  
    data = requests.get(scratch_url).text  
    soup = bs4.BeautifulSoup(data, "html.parser")  
    a_flights = soup.find('div', class_='list').find_all('a', recursive=False)  
    for flight in a_flights:  
        if flight.text not in old_flights and flight.text != '国内航段列表':  
            new_flights.append(flight.text)  
    return new_flights  


if __name__ == '__main__':  
    MainUtil.main(resources_file_path, scratch_url, scratch_flight_number)
 
scratch_movie_name.py：爬取最近上映的电影
 
#!/usr/bin/python  
# -*- coding: UTF-8 -*-  
import re  
import requests  
import bs4  
import json  
import MainUtil  

# 相对路径，也是需要将此路径存入数据库  
resources_file_path = '/resources/movie/cinemaNameList.ini'  
scratch_url = 'http://theater.mtime.com/China_Beijing/'  


# scratch data with define url  
def scratch_latest_movies(scratch_url, old_movies):  
    data = requests.get(scratch_url).text  
    soup = bs4.BeautifulSoup(data, "html.parser")  
    new_movies = []  
    new_movies_json = json.loads(  
        soup.find('script', text=re.compile("var hotplaySvList")).text.split("=")[1].replace(";", ""))  
    coming_movies_data = soup.find_all('li', class_='i_wantmovie')  
    # 上映的电影  
    for movie in new_movies_json:  
        move_name = movie['Title']  
        if move_name not in old_movies:  
            new_movies.append(movie['Title'])  
    # 即将上映的电影  
    for coming_movie in coming_movies_data:  
        coming_movie_name = coming_movie.h3.a.text  
        if coming_movie_name not in old_movies and coming_movie_name not in new_movies:  
            new_movies.append(coming_movie_name)  
    return new_movies  


if __name__ == '__main__':  
    MainUtil.main(resources_file_path, scratch_url, scratch_latest_movies)
 
scratch_train_number.py：爬取全国列车号
 
#!/usr/bin/python  
# -*- coding: UTF-8 -*-  
import requests  
import bs4  
import json  
import MainUtil  

resources_file_path = '/resources/train/trainNameList.ini'  
scratch_url = 'http://www.59178.com/checi/'  


def scratch_train_number(scratch_url, old_trains):  
    new_trains = []  
    resp = requests.get(scratch_url)  
    data = resp.text.encode(resp.encoding).decode('gb2312')  
    soup = bs4.BeautifulSoup(data, "html.parser")  
    a_trains = soup.find('table').find_all('a')  
    for train in a_trains:  
        if train.text not in old_trains and train.text:  
            new_trains.append(train.text)  
    return new_trains  


if __name__ == '__main__':  
    MainUtil.main(resources_file_path, scratch_url, scratch_train_number)
 
scratch_train_station.py：爬取全国列车站
 
#!/usr/bin/python  
# -*- coding: UTF-8 -*-  
import requests  
import bs4  
import random  
import MainUtil  

resources_file_path = '/resources/train/trainStationNameList.ini'  
scratch_url = 'http://www.smskb.com/train/'  


def scratch_train_station(scratch_url, old_stations):  
    new_stations = []  
    provinces_eng = (  
        "Anhui", "Beijing", "Chongqing", "Fujian", "Gansu", "Guangdong", "Guangxi", "Guizhou", "Hainan", "Hebei",  
        "Heilongjiang", "Henan", "Hubei", "Hunan", "Jiangsu", "Jiangxi", "Jilin", "Liaoning", "Ningxia", "Qinghai",  
        "Shandong", "Shanghai", "Shanxi", "Shanxisheng", "Sichuan", "Tianjin", "Neimenggu", "Xianggang", "Xinjiang",  
        "Xizang",  
        "Yunnan", "Zhejiang")  
    provinces_chi = (  
        "安徽", "北京", "重庆", "福建", "甘肃", "广东", "广西", "贵州", "海南", "河北",  
        "黑龙江", "河南", "湖北", "湖南", "江苏", "江西", "吉林", "辽宁", "宁夏", "青海",  
        "山东", "上海", "陕西", "山西", "四川", "天津", "内蒙古", "香港", "新疆", "西藏",  
        "云南", "浙江")  
    for i in range(0, provinces_eng.__len__(), 1):  
        cur_url = scratch_url + provinces_eng[i] + ".htm"  
        resp = requests.get(cur_url)  
        data = resp.text.encode(resp.encoding).decode('gbk')  
        soup = bs4.BeautifulSoup(data, "html.parser")  
        a_stations = soup.find('left').find('table').find_all('a')  
        for station in a_stations:  
            if station.text not in old_stations:  
                new_stations.append(provinces_chi[i] + ',' + station.text)  
    return new_stations  


if __name__ == '__main__':  
    MainUtil.main(resources_file_path, scratch_url, scratch_train_station)
 
将项目放到测试服务器(centos7系统)中运行起来，我写了一个crontab，定时调用他们，下面贴出crontab。
 
/etc/crontab
 
SHELL=/bin/bash  
PATH=/sbin:/bin:/usr/sbin:/usr/bin  
MAILTO=root  

# For details see man 4 crontabs  

# Example of job definition:  
# .---------------- minute (0 - 59)  
# |  .------------- hour (0 - 23)  
# |  |  .---------- day of month (1 - 31)  
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...  
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat  
# |  |  |  |  |  
# *  *  *  *  * user-name  command to be executed  
  0  0  *  *  * root python3 /data/app/smart/py/scratch_movie_name.py    >> /data/logs/smartpy/out.log 2>&1  
  0  1  *  *  1 root python3 /data/app/smart/py/scratch_train_station.py >> /data/logs/smartpy/out.log 2>&1  
  0  2  *  *  2 root python3 /data/app/smart/py/scratch_train_number.py  >> /data/logs/smartpy/out.log 2>&1  
  0  3  *  *  4 root python3 /data/app/smart/py/scratch_flight_number.py >> /data/logs/smartpy/out.log 2>&1  
  0  4  *  *  5 root python3 /data/app/smart/py/scratch_airport_name.py  >> /data/logs/smartpy/out.log 2>&1
 
后续
 
目前项目已经正常运行了三个多月啦。。。
 
 
有问题反馈
 
在阅读与学习中有任何问题，欢迎反馈给我，可以用以下联系方式跟我交流
 
微信公众号：裸睡的猪
在下面留言
直接给我私信
关于此公众号
 
后期或提供各种软件的免费激活码
推送python，java等编程技术文章和面试技巧
当然你们可以将你们感兴趣的东西直接送给我
谢谢你们真诚的关注，此公众号以后获得的收益将全部通过抽奖的形式送给大家
以后如果博主要创业的话，也会在此公众号中挑选小伙伴哦~
希望大家分享出去，让更多想学习python的朋友看到~
​