标签中。
57 |
58 | 
59 |
60 | 1. 我们切换到工作目录下，然后通过命令创建一个叫做baidu的项目。
61 |
62 | ```python
63 | scrapy startproject baidu
64 | ```
65 |
66 | 
67 |
68 | 我们会看到自动创建好的文件夹目录
69 |
70 | 
71 |
72 | - spiders(文件夹):编写爬虫规则，实现数据爬取和数据清洗处理。
73 | - items.py:数据定义和实例化，用于寄存清洗后的数据。
74 | - middlewares.py:是介于Scrapy的request/response处理的钩子框架，用于全局修改Scrapy request和response的一个轻量，底层的系统。
75 | - pipelines.py:执行保存数据的操作，数据对象来源于items.py。
76 | - setting.py:整个框架配置文件。
77 | - scrapy.cfg:项目部署文件。
78 |
79 | Scrapy的常用开发顺序为：
80 |
81 | - setting.py：主要配置爬虫，比如请求头什么的。
82 | - items.py：定义存储数据对象，主要衔接spiders和pipelines.py。
83 | - pipelines.py：数据存储，数据格式为字典，key为items.py定义的变量。
84 | - spiders：编写爬虫规则。
85 |
86 | 2.开始编写爬虫
87 |
88 | - 修改setting.py：初始文件大部分内容都是注释掉的。本项目只需要设置Item Pipeline和请求头即可。修改如下：
89 |
90 | ```python
91 | pass # 上面的内容省略
92 | # Override the default request headers:
93 | DEFAULT_REQUEST_HEADERS = {
94 | 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
95 | 'Accept-Language': 'en',
96 | }
97 | pass # 省略
98 | # Configure item pipelines
99 | # See https://docs.scrapy.org/en/latest/topics/item-pipeline.html
100 | ITEM_PIPELINES = {
101 | 'baidu.pipelines.BaiduPipeline': 300,
102 | }
103 | ```
104 |
105 | > 由于篇幅问题，省略了其他代码
106 |
107 | - 修改items.py文件
108 |
109 | ```python
110 | import scrapy
111 |
112 |
113 | class BaiduItem(scrapy.Item):
114 | # define the fields for your item here like:
115 | # name = scrapy.Field()
116 | TitleName = scrapy.Field()
117 | pass
118 | ```
119 |
120 | - 修改pipelines.py。我们将爬取的内容保存在txt中。
121 |
122 | ```python
123 | class BaiduPipeline(object):
124 | def process_item(self, item, spider):
125 | with open('data.txt', 'a') as f:
126 | for i in item['TitleName']:
127 | value = i.replace("\n","")
128 | f.write(value + "\r\n")
129 | return item
130 | ```
131 |
132 | - 在spiders文件夹下面创建爬虫规则。Spider_spiders.py，代码如下：
133 |
134 | ```python
135 | # 导入items.py的BaiduItem，存放爬取数据
136 | from baidu.items import BaiduItem
137 | # Scrapy自带的数据清洗模块
138 | from scrapy.selector import Selector
139 | # Scrapy搜素引擎
140 | from scrapy.spider import Spider
141 | # 爬虫规则
142 | class Baiduspider(Spider):
143 | # 属性name必须设置,且唯一,用于运行爬虫
144 | name = "Baidu_know"
145 | # 设置允许访问域名
146 | allowed_domins = ['baidu.com']
147 | # 设置URL
148 | start_urls = [https://zhidao.baidu.com/list?cid=110106","https://zhidao.baidu.com/list?cid=110106"]
149 | # 函数parse处理响应内容，函数名不能更改
150 | def parse(self, response):
151 | # 将响应内容生成Selector用于数据清洗
152 | sel = Selector(response)
153 | items = []
154 | item = BaiduItem()
155 | title = sel.xpath('//div[@class="question-title"]/a/text()').extract()
156 | for i in title:
157 | items.append(i)
158 | item['TitleName'] = items
159 | return item
160 | ```
161 |
162 | - 在终端中允许如下代码：
163 |
164 | ```shell
165 | scrapy crawl Baidu_know
166 | ```
167 |
168 | 
169 |
170 | 我们可以看到，两个网站都进行了爬取，只是没有获取到数据。这样我们的第一个Scrapy项目就算允许成功了。关于Scrapy的详细内容大家还是要多多的看文档和书。欢迎大家进群讨论。
171 |
172 |
--------------------------------------------------------------------------------
/md/06-第六周-Lxml库与Xpath语法.md:
--------------------------------------------------------------------------------
1 | # 专栏第六周 Lxml库与Xpath语法
2 |
3 | Lxml库是基于libxml2的XML解析库的Python封装。该模块使用C语言编写，解析速度比BeautifulSoup更快。这个库使用Xpath语法解析定位网页数据。通过本篇文章你将学到以下内容：
4 |
5 | > - Lxml库的使用
6 | > - Xpath相关语法
7 |
8 | ## Lxml库的安装与使用方法
9 |
10 | 1. 安装：
11 |
12 | 和其他第三方库的安装方法一样，在命令行中运行以下代码：
13 |
14 | ```shell
15 | pip install lxml
16 | ```
17 |
18 | 如果在安装过程中提示缺少库，请利用搜索引擎查找解决方法。
19 |
20 | 2. Lxml库的使用
21 |
22 | - 修正HTML代码
23 |
24 | ```python
25 | from lxml import etree
26 |
27 | html_text = '''
28 |
34 | '''
35 | html = etree.HTML(html_text)
36 | print(html) # Lxml库解析数据为Element对象
37 | result = etree.tostring(html)
38 | print(result) # 可以自动修正HTML内容
39 | ```
40 |
41 | 
42 |
43 | 从打印结果我们可以看出，etree库把HTML文档解析为Element对象，并且可以自动修正HTML文档。细心的朋友可能已经发现，我代码中的最后的li标签是不完整的，而从打印结果可以看到，不但li标签补全了，还把html和body标签也自动添加上了。
44 |
45 | - 读取HTML文件
46 |
47 | 我们在本地同级目录下面新建一个html_demo.html文件。内容如下：
48 |
49 | ```html
50 |
51 |
52 |
DemoHTML
53 |
54 |
55 |
56 |
57 | - a
58 | - b
59 | - c
60 | - d
61 |
62 |
63 |
64 |
65 | ```
66 |
67 | 我们可以通过Lxml库读取HTML文件的内容了，代码如下：
68 |
69 | ```python
70 | from lxml import etree
71 |
72 | html= etree.parse("html_demo.html")
73 | result = etree.tostring(html)
74 | print(result)
75 | ```
76 |
77 | 
78 |
79 | - 解析HTML文件
80 |
81 | 我们可以配合requests库获取HTML文件，然后利用Lxml库进行解析。
82 |
83 | 网站为：https://www.qiushibaike.com/text/
84 |
85 | ```python
86 | import requests
87 | from lxml import etree
88 |
89 | header = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)\
90 | AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36'}
91 | res = requests.get('https://www.qiushibaike.com/text/', headers = header)
92 | html = etree.HTML(res.text)
93 | result = etree.tostring(html)
94 | print(result)
95 | ```
96 |
97 | 
98 |
99 | ## Xpath的用法
100 |
101 | 1. 节点选择
102 |
103 | - 节点选择
104 |
105 | | 表达式 | 描述 |
106 | | -------- | -------------------------------------------------------- |
107 | | nodename | 选取此节点的所有子节点 |
108 | | / | 从根节点选取 |
109 | | // | 从匹配选择的当前节点选择文档中的节点，而不考虑他们的位置 |
110 | | . | 选取当前节点 |
111 | | .. | 选取当前节点的父节点 |
112 | | @ | 选取属性 |
113 |
114 | - 谓语
115 |
116 | | 路径表达式 | 结果 |
117 | | ----------------------- | ------------------------------------------------------- |
118 | | /ul/li[1] | 选取ul标签的子元素的第一个li元素 |
119 | | //li[@attribute] | 选取所有拥有名为attribute属性的li元素 |
120 | | //li[@attribute='info'] | 选取所有的li元素，且这些元素拥有值为info的attribute属性 |
121 |
122 | 我们手写这些内容可能会出错，所以通常我们式在谷歌浏览器的开发者模式下，通过Copy Xpath命令来获取。
123 |
124 | 例如我们获取糗事百科的用户名：
125 |
126 | ```python
127 | import requests
128 | from lxml import etree
129 |
130 | header = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)\
131 | AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36'}
132 | res = requests.get('https://www.qiushibaike.com/text/', headers = header)
133 | html = etree.HTML(res.text)
134 | user_id = html.xpath('//*[@id="qiushi_tag_122217427"]/div[1]/a[2]/h2/text()') # text()为获取内容的方法
135 | print(user_id)
136 | ```
137 |
138 | 
139 |
140 | > 这里有一点需要注意:我们注意到id属性中有一串数字，大家在写的时候，要根据自己的情况填写。否则获取不到数据。
141 |
142 | 下面我们看一下如何获取当前页面中所有用户的名字：
143 |
144 | ```python
145 | import requests
146 | from lxml import etree
147 |
148 | header = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)\
149 | AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36'}
150 | res = requests.get('https://www.qiushibaike.com/text/', headers = header)
151 | html = etree.HTML(res.text)
152 |
153 | users = html.xpath('//div[@class="article block untagged mb15 typs_hot"]')
154 | for user_info in users:
155 | user_id = user_info.xpath('div[1]/a[2]/h2/text()')[0]
156 | print(user_id)
157 |
158 | ```
159 |
160 | 
161 |
162 | 但是如果们观看页面的话，会发现第一个的用户名并没有取到，因为第一个的class为“article block untagged mb15 typs_long”
163 |
164 | 所以我们把代码改为以下：
165 |
166 | ```python
167 | import requests
168 | from lxml import etree
169 |
170 | header = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)\
171 | AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36'}
172 | res = requests.get('https://www.qiushibaike.com/text/', headers = header)
173 | html = etree.HTML(res.text)
174 |
175 | users = html.xpath('//div[starts-with(@id,"qiushi_tag")]')
176 | for user_info in users:
177 | user_id = user_info.xpath('div[1]/a[2]/h2/text()')[0]
178 | print(user_id)
179 |
180 | ```
181 |
182 | 
183 |
184 | 这里使用了一个**starts-with()** 它可以只匹配目标元素属性的一部分。
185 |
186 | 好了，这便是本周的内容，大家可以用Xpath把每一个段子的内容获取一下，如果出现问题，可以加入我们的学习群获取帮助。
--------------------------------------------------------------------------------
/md/10-第十周-ORM框架.md:
--------------------------------------------------------------------------------
1 | # 专栏第十周 ORM框架
2 |
3 | 我们的爬虫专栏基本到这里就算是完结了，接下来的几篇文章会介绍一些我们在项目中常用的第三方库或者是框架，有这些框架的支持我们在编写爬虫项目时，会方便很多。今天为大家介绍的这个ORM框架就是用来操作数据库的。
4 |
5 | ## SQLAlchemy框架介绍与安装
6 |
7 | SQLAlchemy是Python编程语言下的一款开源软件，提供SQL工具包以及对象-关系映射工具，使用MIT许可证发行。它的一个目标是提供能兼容众多数据库（如SQLite，MySql，Postgres，Oracle，MS-SQL，SQLServer和Firebird）的企业级持久性模型。
8 |
9 | 1. SQLAlchemy的安装
10 |
11 | 我们通过如下命令安装：
12 |
13 | ```python
14 | pip install SQLAlchemy
15 | ```
16 |
17 | 如果安装比较慢或者失败可以用试试更换一下源，如下：
18 |
19 | ```python
20 | pip install -i https://pypi.tuna.tsinghua.edu.cn/simple SQLAlchemy
21 | ```
22 |
23 | 
24 |
25 | 使用SQLAlchemy连接数据库实质上还是通过数据库接口实现连接，安装SQLAlchemy后还需要安装对应数据库的接口模块，下面以MySql为例安装pymysql：
26 |
27 | ```python
28 | pip install pymysql
29 | ```
30 |
31 | 
32 |
33 | 安装完成后我们在命令行窗口中导入模块来测试是否安装成功：
34 |
35 | 
36 |
37 | 2. SQLAlchemy在Python中操作数据库
38 |
39 | SQLAlchemy连接数据库使用数据库链接池技术，原理是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。使用完毕后，用户也并非将连接关闭，而是将连接放回连接池中，以供下一个请求访问使用。而连接的建立，断开都是由连接池自身来管理。同时，还可以通过设置连接池参数来控制连接池中的初始连接数，连接的上下限数以及每个连接的最大使用次数，最大空闲时间等。也可以通过其自身的管理机制来监视数据库连接的数量以及使用情况等。
40 |
41 | 说完原理后，我没来看看SQLAlchemy连接数据库的代码：
42 |
43 | ```python
44 | from sqlalchemy import create_engine
45 | engine = create_engine("mysql+pymysql://root:pwd@localhost:3306/test?charset=utf8",echo=True)
46 | ```
47 |
48 | - mysql+pymysql://root:pwd@localhost:3306/test： mysql指明数据库系统类型，pymysql是连接数据库接口的模块，root是数据库用户名，pwd是数据库密码，localhost:3306是本地数据库和端口号,test是数据库名。
49 | - echo=True：用于显示SQLAlchemy在操作数据库时所执行的SQL语句情况，相当于一个监视器，可以清楚知道执行情况。
50 |
51 | 其他数据库的连接：
52 |
53 | | 数据库 | 连接字符串 |
54 | | ------------------- | ------------------------------------------- |
55 | | Microsoft SQL Sever | mssql+pymssql://usename:pwd@ip:port/dbname |
56 | | MySql | mysql+pymysql://username:pwd@ip:port/dbname |
57 | | Oracle | cx_Oracle://username:pwd@ip:port/dbname |
58 | | PostgreSQL | postgresql://username:pwd@ip:port/dbname |
59 | | SQLite | sqlite://file_path |
60 |
61 | ## 创建数据库表
62 |
63 | 我们在连接好数据库后，接下来就是创建数据库表了，接下来为大家演示如何用SQLAlchemy创建表：
64 |
65 | ```python
66 | # 连接数据库
67 | from sqlalchemy import create_engine
68 | engine = create_engine("mysql+pymysql://root:root@localhost:3306/test?charset=utf8",echo=True)
69 |
70 | # 创建数据库
71 | from sqlalchemy import Column, Integer, String, DateTime # 常用数据类型
72 | from sqlalchemy.ext.declarative import declarative_base
73 | Base = declarative_base()
74 |
75 | class mytable(Base):
76 | # 表名
77 | __tablename__ = "mytable"
78 | # 字段，属性
79 | id = Column(Integer, primary_key = True)
80 | name = Column(String(10), unique = True)
81 | age = Column(Integer)
82 | brith = Column(DateTime)
83 | class_name = Column(String(50))
84 |
85 | Base.metadata.create_all(engine)
86 | ```
87 |
88 | \__tablename__ = "mytable"可以省略，如果省略那么表名和类名就是一样的。类中的属性就是数据中的字段名以及类型。最后通过Base.metadata.create_all(engine)在数据库中创建对应的数据库表。
89 |
90 | 如果要删除数据表可以通过如下代码：
91 |
92 | ```python
93 | # 先删除类，后删除数据库表
94 | mytable.drop(bind = engine)
95 | Base.metadata.drop_all(engine)
96 | ```
97 |
98 | 无论是创建还是删除都需要先对数据进行连接，即创建engine对象。
99 |
100 | ## 添加数据
101 |
102 | 完成数据表的创建后，接下来我们就可以进行数据的操作。首先创建一个会话对象，用于执行SQL语句，代码如下：
103 |
104 | ```python
105 | from sqlalchemy.orm import sessionmaker
106 | DBSession = sessionmaker(bind = engine)
107 | session = DBSession()
108 | ```
109 |
110 | 我们常用的增，删，改，查在SQLAlchemy中有固定的语法支持。
111 |
112 | ```python
113 | new_data = mytable(name = 'Tango', age = 10, birth='2019-10-05', class_name = '三年一班')
114 | session.add(new_data)
115 | session.commit()
116 | session.close()
117 | ```
118 |
119 | ## 更新数据
120 |
121 | - 使用update方法更新数据
122 |
123 | ```python
124 | session.query(mytable).filter_by(id=1).update({mytable.age:12})
125 | session.commit()
126 | session.close()
127 | ```
128 |
129 | 首先我们查找到id为1的数据，然后对这条数据的age进行修改。
130 |
131 | - 使用赋值方式更新：
132 |
133 | ```python
134 | get_data = session.query(mytable).filter_by(id=1).first()
135 | get_data.class_name = '三年二班'
136 | session.commit()
137 | session.close()
138 | ```
139 |
140 | 这种方式通常用于做单条数据的更新，如果要批量更新那么update的性能会更好一些。
141 |
142 | ## 查询数据
143 |
144 | - 查询所有数据
145 |
146 | ```python
147 | get_data = session.query(mytable).all()
148 | for i in get_data:
149 | print('我的名字' + i.name)
150 | print('我的班接' + i.class_name)
151 | session.close()
152 | ```
153 |
154 | 这种写法相当于sql中的：
155 |
156 | ```sql
157 | select * from mytable;
158 | ```
159 |
160 | all()的返回类型是列表。
161 |
162 | - 查询指定字段
163 |
164 | ```python
165 | get_data = session.query(mytable.name, mytable.class_name).all()
166 | for i in get_data:
167 | print('我的名字' + i.name)
168 | print('我的班接' + i.class_name)
169 | session.close()
170 | ```
171 |
172 | 我们只需要将要查的字段传入query中。
173 |
174 | - 设置筛选条件
175 |
176 | ```python
177 | get_data = session.query(mytable.name, mytable.class_name).filter_by(id=1).all()
178 | for i in get_data:
179 | print('我的名字' + i.name)
180 | print('我的班接' + i.class_name)
181 | session.close()
182 |
183 | ```
184 |
185 | filter_by(id=1)指定的是查询对象id为1的那条数据。
186 |
187 | 如果要获取查询结果中的第一天只需要将all()替换成first()就可以了。
188 |
189 | - and多条件查询
190 |
191 | ```python
192 | get_data = session.query(mytable.name, mytable.class_name).filter(mytable.id>2, mytable.name=='Tango').first()
193 | print('我的名字' + get_data.name)
194 | print('我的班接' + get_data.class_name)
195 | ```
196 |
197 | - or条件查询
198 |
199 | ```python
200 | from sqlalchemy import or_
201 | session.query(mytable).filter(or_(mytable.id>2, mytable.name=='Tango')).all()
202 | ```
203 |
204 | 需要引入or_
205 |
206 | - 多表查询
207 |
208 | ```python
209 | get_data = session.query(mytable).join(mytable2).filter(mytable.id>=2).all()
210 | ```
211 |
212 | join为内连，如果需要使用外连把join换成outerjoin就好。
213 |
214 | 如果执行的sql语句很复杂我们也可以直接调用原生的SQL语句
215 |
216 | ```python
217 | sql = "select * from mytable "
218 | session.excute(sql)
219 | session.commit()
220 | ```
221 |
222 | 好了，这周的内容就是这些了，大家可以将之前的爬虫获取的数据通过这个框架添加到数据库中看看效果如何。
--------------------------------------------------------------------------------
/md/03-第三周-我们的第一个爬虫.md:
--------------------------------------------------------------------------------
1 | # 我们的第一个爬虫
2 |
3 | > 本篇文章涉及到的内容如下：
4 | >
5 | > - Python第三方库的安装方法
6 | > - 学会使用Requests库的使用方法
7 | > - BeautifulSoup库的使用方法
8 | > - Requests库和BeautifulSoup库的组合使用。
9 |
10 | ## Python的第三方库
11 |
12 | Python之所以如此火热和流行，有很大的原因是因为它有很多很强大的第三方库。这样“程序猿”们就不用太了解底层的实现，用最少的代码写出最多的功能。就像我们之前说的购买车票一样，需要：
13 |
14 | - 打印车票的纸和墨
15 | - 一台可以打印的机器
16 | - 查询座位等操作。
17 |
18 | 如果没有使用第三方库的话，恐怕我们买一张车票要一步一步的把上面需要的东西都实现一遍。这样购买一张车票是不是要很久啊。如今有了自动售票机这个“第三方库”，我们只需几十秒就可以拿到车票。这种拿来即用的在Python中就是第三方库。
19 |
20 | 1. 如何安装第三方库呢
21 |
22 | - 纯原生的安装方法
23 |
24 | ```python
25 | pip install 第三方库的名称
26 | ```
27 |
28 | - 在anaconda环境中安装
29 |
30 | ```python
31 | conda install 第三方库的名称
32 | ```
33 |
34 | - 当然还可以通过源码安装
35 |
36 | 我们将源码下载到本地，解压后会看到一个文件夹目录，里面有一个**setp.py**的文件，然后我们在该文件的**同级目录**下，执行如下代码即可：
37 |
38 | ```python
39 | python setp.py install
40 | ```
41 |
42 | > 以上这些方法都是在你的电脑上只有一个python环境的前提下。如果同时存在Python2 和python3的情况下，恐怕要小心一下了。看看你默认的环境是哪个。具体大家遇到问题可以在群里面@我一下。什么？! 还没加群，那快快扫描文章下面的二维码加入进来。会有很多福利的。
43 |
44 | 2. 安装好后如何使用
45 |
46 | 其实使用Python的第三方库很简单，只需要在你的代码开头将它导入进来就可以了。
47 |
48 | ```python
49 | import time # 这个库是Python自带的。可以直接这样引入
50 | from BS4 import BeautifulSoup # 从我们安装的第三方库中引入进来
51 | ```
52 |
53 | ## Requests库
54 |
55 | Requests库的作用就是请求网站获取网页数据的，让我们从简单的实例开始，讲解Requests的使用方法。
56 |
57 | 我们这里的示例网站是，爱站的ICP备案查询[https://icp.aizhan.com](https://icp.aizhan.com/)。我们查询的网站是www.csdn.net
58 |
59 | > 这里的目标url为：https://icp.aizhan.com/www.csdn.net/
60 |
61 | 我们新建一个main.py的文件。将如下代码写在里面。
62 |
63 | > 我建议大家在一个固定的地方建一个文件夹，用来保存我们专栏的所有的代码，等专栏结束后看看你的成就，也许会很吃惊的哦。
64 |
65 | ```python
66 | import requests
67 | # 这里想查的CSDN的备案信息
68 | res = requests.get('https://icp.aizhan.com/www.csdn.net/')
69 | print(res)
70 | print(res.text)
71 | ```
72 |
73 | 然后在控制台（cmd）中输入：
74 |
75 | ```python
76 | python main.py
77 | ```
78 |
79 | 得到如下画面，表示你已经成功的爬取了这个网站的代码信息，恭喜你，你已经成功的入了爬虫的坑。
80 |
81 | 
82 |
83 | 1. 我们看到有一个**
**,代表的意思请求网站成功，若为404，400则表示请求失败，具体的原因有很多。比如：网站地址输错，当然也有可能触发了反爬机制。
84 | 2. 上面的一堆HTML代码就是我们爬取的内容，我们可以通过在浏览器中F12来比较一下我们获取的内容和目标网站的代码是否一致。
85 |
86 | 大部分时候，我们都要在爬虫中添加请求头，让服务器误以为我们是通过浏览器访问的，这样可以减少触发反爬机制的几率。
87 |
88 | 那么如何伪装成浏览器呢？我只需要在get方法里面添加一个headers的参数即可。
89 |
90 | 如何获取header的内容呢？
91 |
92 | 我们在浏览器中按F12打开开发者工具。刷新页面，然后找到**User-Agent**，这就是我们的请求头。
93 |
94 | 
95 |
96 | 然后修改代码：
97 |
98 | ```python
99 | import requests
100 |
101 | headers = {
102 | 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)\
103 | Chrome/76.0.3809.100 Safari/537.36'
104 | }
105 | # 这里想查的CSDN的备案信息
106 | res = requests.get('https://icp.aizhan.com/www.csdn.net/', headers = headers)
107 | print(res)
108 | print(res.text)
109 | ```
110 |
111 | > 这里的headers是一个字典。这里的value会很长，我们可以在合适的地方添加一个\来让它换行。
112 |
113 | Requests库不仅有get方法，还有post方法，通常是用来登录的，我们在后面的实战中会用到，这里暂时就不多说了。
114 |
115 | 我们用这个库来访问网站，有时会出现问题，常见的如下：
116 |
117 | - ConnectionError：通常是网络问题（如DNS查询失败，拒绝连接等）
118 | - HTTPError：原因为请求返回了一个不成功的状态码，比如404等。
119 | - Timeout异常：请求超时
120 | - TooManyRedirects异常，原因为超过了设定的最大重定向次数。
121 |
122 | 我们在实际代码的中通常是需要做异常处理的
123 |
124 | ```python
125 | import requests
126 |
127 | headers = {
128 | 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)\
129 | Chrome/76.0.3809.100 Safari/537.36'
130 | }
131 | # 这里想查的CSDN的备案信息
132 | res = requests.get('https://icp.aizhan.com/www.csdn.net/', headers = headers)
133 | # 异常处理
134 | try:
135 | print(res.text)
136 | except ConnectionError:
137 | print("连接失败")
138 |
139 | ```
140 |
141 | 当出现连接失败的时候，就会在控制台打印一个信息告诉开发者连接失败了。
142 |
143 | ## BeautifulSoup库
144 |
145 | 我们在上面通过requests库获取到了页面代码，但是如何能准确的提取出我们需要的信息呢？
146 |
147 | 我们在之前的代码中引入我们的BeautifulSoup库。
148 |
149 | ```python
150 | import requests
151 | from bs4 import BeautifulSoup
152 |
153 | headers = {
154 | 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)\
155 | Chrome/76.0.3809.100 Safari/537.36'
156 | }
157 | # 这里想查的CSDN的备案信息
158 | res = requests.get('https://icp.aizhan.com/www.csdn.net/', headers = headers)
159 | # 异常处理
160 | try:
161 | # 对返回结果尽心解析
162 | soup = BeautifulSoup(res.text, 'html.parser')
163 | print(soup.prettify())
164 | except ConnectionError:
165 | print("连接失败")
166 | ```
167 |
168 | 同样通过在命令行中运行
169 |
170 | ```python
171 | python main.py
172 | ```
173 |
174 | 会得到页面代码，这时的代码和之前其实是一样的，只不过BS4(*我们后面都将BeautifulSoup库简称为BS4*)对它进行了标准的缩进格式化。
175 |
176 | BS4除了支持Python标准库的HTML解析器外，还支持一些第三方的解析器。如下：
177 |
178 | | 解析器 | 使用方法 | 有点 | 缺点 |
179 | | --------------- | ------------------------------------------------------------ | ------------------------------------------------------- | --------------------------- |
180 | | Python标准库 | BeautifulSoup(res.text, 'html.parser') | 内置库执行速度适中，文档容错能力强 | 旧版本（3.2.2）前的容错性差 |
181 | | lxml HTML解析器 | BeautifulSoup(res.text, 'lxml') | 速度快，文档容错能力强 | 需要安装C语言库 |
182 | | lxml XML解析器 | BeautifulSoup(res.text, 'lxml') 或者BeautifulSoup(res.text, ['lxml', 'xml']) | 速度快，唯一支持XML的解析器 | 同上 |
183 | | html5lib | BeautifulSoup(res.text, 'html5lib') | 最好的容错性，以浏览器的方式解析文档生成HTML5格式的文档 | 速度慢，不依赖外部扩展 |
184 |
185 | > BS4官方推荐使用lxml作为解析器，因为效率高。
186 |
187 | 解析得到的Soup文档可以使用**find(), find_all()以及selector()**方法定位到需要的元素。
188 |
189 | find和find_all的用法类似
190 |
191 | ```python
192 | soup.find_all('div', 'item')
193 | soup.find_all('div', class = 'item')
194 | soup.find_all('div', attrs = {'class':'item'})
195 | ```
196 |
197 | 以上这三行代码的功能是一样的，都是通过class来获取div元素。
198 |
199 | find_all和find的返回类型不一样，前者返回所有符合条件的元素列表，而后知只返回一个元素。
200 |
201 | ```python
202 | soup.selector(#icp-table > table > tbody > tr:nth-child(1) > td:nth-child(2))
203 | ```
204 |
205 | 这个是通过标签的层级关系来获取指定的内容的。可以在谷歌浏览器中在指定元素上面右键，然后有一个copy里面可以选择selector就可以得到括号里面的内容了。
206 |
207 | > tr:nth-child(1) 需要修改的，在Python中需要改成tr:nth-of-type(1)
208 |
209 | 接下来演示一下如何获取到*主办单位名称*和*备案号*
210 |
211 | ```python
212 | import requests
213 | from bs4 import BeautifulSoup
214 |
215 | headers = {
216 | 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)\
217 | Chrome/76.0.3809.100 Safari/537.36'
218 | }
219 | # 这里想查的CSDN的备案信息
220 | res = requests.get('https://icp.aizhan.com/www.csdn.net/', headers = headers)
221 | # 异常处理
222 | try:
223 | # 对返回结果尽心解析
224 | soup = BeautifulSoup(res.text, 'html.parser')
225 | # 通过find_all()获取主办单位名称
226 | div = soup.find('div', attrs = {'id':'icp-table'})
227 | td_list = div.find_all('td')
228 | name_info = td_list[0].text + ":" + td_list[1].text
229 | print(name_info)
230 | # 通过selector获取备案号
231 | icp_no = soup.select('#icp-table > table > tr:nth-of-type(3) > td:nth-of-type(2) > span')[0].get_text()
232 | print(icp_no)
233 | except ConnectionError:
234 | print("连接失败")
235 |
236 | ```
237 |
238 | 运行后得到：
239 |
240 | 
241 |
242 | > 这里有几点需要注意一下
243 | >
244 | > 1. 我们在使用selector的时候，用的方法是**select()**
245 | >
246 | > 2. 我们在复制了selector内容后需要修改，不能直接使用
247 | >
248 | > 我们复制的内容：
249 | >
250 | > #icp-table > table > tbody > tr:nth-child(3) > td:nth-child(2) > span
251 | >
252 | > 实际写入代码的内容：
253 | >
254 | > #icp-table > table > tr:nth-of-type(3) > td:nth-of-type(2) > span
255 | >
256 | > 3. 我们要获取的是文本，所以需要在获取对象后，在调用一些方法类获信息，如：get_text()等
257 |
258 | 好了，今天的内容就是这些。大家下去把其他的信息也取一下，如果有问题欢迎大家在群里积极讨论。
--------------------------------------------------------------------------------
/md/13-第十三周-如何利用爬取的数据.md:
--------------------------------------------------------------------------------
1 | # 专栏第十三周 如何利用爬取的数据
2 |
3 | 我们通过各种方式辛辛苦苦的获取到了数据，那么接下来呢？还需要做些什么。
4 |
5 | - 可以用获取到的图片做机器学习的训练数据
6 | - 可以用获取的商品，招聘等信息做数据分析，看看什么卖的好，什么职位工资高。
7 | - 可以用获取到的数据搭建自己的网站。比如各种搜索网站。
8 |
9 | > 关于机器学习，数据分析大家可以查看一下我们其他的专栏文章。
10 |
11 | 今天，就带着大家一起看看如何用Django快速搭建一个前后台齐全的网站。
12 |
13 | ## 搭建环境
14 |
15 | - 在工作目录下创建一个Pyweb的文件夹，用来保存代码。当然，这个目录的名字你可以任意取，但**不要有中文和特殊符号**。
16 |
17 | - 在Pyweb文件夹下面创建一个env的文件夹，这个文件夹就是虚拟机的名，通过如下命令创建虚拟机。
18 |
19 | ```shell
20 | cd env
21 | python -m venv .
22 | ```
23 |
24 | > 注意venv和 . 之间有一个空格。
25 | >
26 | > 这里演示的是在Windows系统下的创建方式，其他操作系统大家自行搜索一下。ls可以换成dir
27 |
28 | 
29 |
30 | - 激活虚拟环境
31 |
32 | ```shell
33 | Scripts\activate
34 | ```
35 |
36 | 
37 |
38 | 激活成功后，会看到在命令行前面会多出一些内容。
39 |
40 | > 输入deactivate可以退出虚拟环境。
41 |
42 | - 安装Django库
43 |
44 | 在虚拟环境下输入如下命令，安装Django框架
45 |
46 | ```shell
47 | pip install django
48 | ```
49 |
50 | 如果速度慢的话，可以换成国内的源
51 |
52 | ```python
53 | pip install django -i https://pypi.mirrors.ustc.edu.cn/simple/
54 | ```
55 |
56 | 
57 |
58 | 这样环境就创建好了，接下来创建我们的网站。下面的所有操作都是在虚拟机内完成的。
59 |
60 | ## 创建网站
61 |
62 | - 为了方便代码管理，回到Pyweb目录下,通过如下命令来创建一个叫做mysite的DJnago网站。
63 |
64 | ```shell
65 | django-admin startproject mysite
66 | ```
67 |
68 | 
69 |
70 | 可以看到会自动生成一个mysite的目录，里面的目录结构如下：
71 |
72 | 
73 |
74 | - 工程创建好后，再创建一个应用movie：
75 |
76 | ```shell
77 | python manage.py startapp movie
78 | ```
79 |
80 | 创建成功后的目录结构如下：
81 |
82 | 
83 |
84 | - 应用创建好之后我们要将它添加到这个工程之中，修改settings.py文件
85 |
86 | ```python
87 | INSTALLED_APPS = [
88 | 'django.contrib.admin',
89 | 'django.contrib.auth',
90 | 'django.contrib.contenttypes',
91 | 'django.contrib.sessions',
92 | 'django.contrib.messages',
93 | 'django.contrib.staticfiles',
94 | 'movie', # 新加的应用
95 | ]
96 | ```
97 |
98 | - 应用添加好之后，还要为这个应用创建一个数据库表，用来保存爬取或者要展示的内容。修改movie目录下的models.py
99 |
100 | ```python
101 | from django.db import models
102 |
103 | # Create your models here.
104 | class Movie(models.Model):
105 | name = models.CharField(max_length=50, verbose_name='电影名')
106 | url = models.URLField(verbose_name='电影路径', max_length=200)
107 | desc = models.TextField(verbose_name='电影描述')
108 |
109 | def __str__(self):
110 | return self.name
111 |
112 | class Meta:
113 | verbose_name = '电影信息'
114 | verbose_name_plural = '电影信息'
115 | ```
116 |
117 | 为这个应该添加了3个字段，并且定义了它在后台的名称为“电影信息”
118 |
119 | - 将这个应用添加到后台，方便之后的管理。修改admin.py
120 |
121 | ```python
122 | from django.contrib import admin
123 | from .models import Movie
124 |
125 | # Register your models here.
126 | admin.site.register(Movie)
127 | ```
128 |
129 | 完成这些后，还差最后一步，创建数据库和管理员信息。
130 |
131 | - 同步数据
132 |
133 | ```shell
134 | python manage.py makemigrations
135 | ```
136 |
137 | 
138 |
139 | ```shell
140 | python manage.py migrate
141 | ```
142 |
143 | 
144 |
145 | 发现除了我们定义的应用的表，还有很多其他的，这些都是Djnago框架自带的表。暂时不用太在意。
146 |
147 | - 创建管理员账号
148 |
149 | ```shell
150 | python manage.py createsuperuser
151 | ```
152 |
153 | 
154 |
155 | 这里输入完命令后，按照提示一步一步的输入就好。
156 |
157 | - 启动网站
158 |
159 | ```shell
160 | python manage.py runserver
161 | ```
162 |
163 | 
164 |
165 | 启动成功后，在浏览器中输入红框中的网址，将看到如下画面。表示这个网站已经创建成功了。
166 |
167 | 
168 |
169 | 我们进入后台看看，在url后面输入**/admin**看到如下画面：
170 |
171 | 
172 |
173 | 输入我们刚才创建好的管理员用户和密码：
174 |
175 | 
176 |
177 | 可以看到这个应用出现在了后台，可以点击右边的add来添加几条数据。
178 |
179 | 
180 |
181 | 
182 |
183 | 我这里是手动填写的，大家可以通过爬虫获取到数据，自动添加数据。另外这里用的是sqlite数据库。关于这个数据库，大家可以上网查一下用法。不明白的地方欢迎大家进群讨论。
184 |
185 | 现在数据有了，该如何显示呢？
186 |
187 | ## 显示数据
188 |
189 | - 创建用于显示数据的模板
190 |
191 | 创建一个templates的文件夹，用来保存html模板，创建好的目录结构：
192 |
193 | 
194 |
195 | 创建好了文件夹，要将它添加到工程中，并告诉程序这个是保存页面模板的，修改settings.py文件：
196 |
197 | ```python
198 | TEMPLATES = [
199 | {
200 | 'BACKEND': 'django.template.backends.django.DjangoTemplates',
201 | 'DIRS': [os.path.join(BASE_DIR, 'templates')], # 修改的地方
202 | 'APP_DIRS': True,
203 | 'OPTIONS': {
204 | 'context_processors': [
205 | 'django.template.context_processors.debug',
206 | 'django.template.context_processors.request',
207 | 'django.contrib.auth.context_processors.auth',
208 | 'django.contrib.messages.context_processors.messages',
209 | ],
210 | },
211 | },
212 | ]
213 | ```
214 |
215 | - 创建业务逻辑，修改movie文件夹下的views.py文件
216 |
217 | ```python
218 | from django.shortcuts import render
219 | from .models import Movie
220 |
221 | # Create your views here.
222 | def Index(request):
223 | movie_list = Movie.objects.all() # 查询所有数据
224 | return render(request, 'index.html', {'movie_list':movie_list})
225 | ```
226 |
227 | index.html是稍后要创建的html文件，用来显示数据的。
228 |
229 | {'movie_list':movie_list}是告诉页面都显示什么数据，这里将获取到的所有电影信息都显示在页面上。
230 |
231 | - 告诉项目，我们访问什么路径，来显示电影信息，修改和settings.py同级目录下的urls.py文件
232 |
233 | ```python
234 | from django.contrib import admin
235 | from django.urls import path
236 | from movie.views import Index
237 |
238 | urlpatterns = [
239 | path('admin/', admin.site.urls),
240 | path('info/', Index, name='info'),
241 | ]
242 | ```
243 |
244 | - 在templates文件夹下创建html文件
245 |
246 | ```html
247 |
248 |
249 | 电影信息
250 |
251 |
252 |
253 | {% for movie in movie_list %}
254 | -
255 | {{movie.name}}
256 |
257 | {% endfor %}
258 |
259 |
260 |
261 | ```
262 |
263 | 这里的{%%}等内容是Django的模板语言，大家可以看看官方文档，这里就不详细说明了。
264 |
265 | 访问： http://127.0.0.1:8000/info/
266 |
267 | 
268 |
269 | 这样我们的信息就显示在了页面上了。
270 |
271 | 我们这里只是简单的介绍了一下Django框架的入门用法，如果大家要深入学习的话，可以买一些书来看。或者关注公众号，后续可能会有相关的内容哦。如果有什么疑问，欢迎大家来群里讨论。
272 |
273 | ## 最后的话
274 |
275 | 感谢大家对本专栏的支持，这是我第一次写专栏内容，有很多不足的方法希望大家见谅。同时也正是因为大家的支持，才能使我坚持把这个专栏完成。
276 |
277 | 我们的专栏目的是让大家对爬虫有个初步的认识。如果想真正在公司或面试中做到出类拔萃，还需要大家多多练习，同时也希望大家持续关注我们，后续我们还会推出更有意思，更有价值的内容。我们不见不散。
--------------------------------------------------------------------------------