diff --git a/Day36-40/37.SQL和MySQL详解.md b/Day36-40/37.SQL详解.md
similarity index 99%
rename from Day36-40/37.SQL和MySQL详解.md
rename to Day36-40/37.SQL详解.md
index 575b580..39766a7 100644
--- a/Day36-40/37.SQL和MySQL详解.md
+++ b/Day36-40/37.SQL详解.md
@@ -934,7 +934,7 @@ alter table tb_student drop index idx_student_name;
 drop index idx_student_name on tb_student;
 ```
 
-在创建索引时，我们还可以使用复合索引、函数索引（MySQL 5.7 开始支持），用好复合索引可以减少不必要的排序和回表操作，这样就会让查询的性能成倍的提升，有兴趣的读者可以自行研究。
+在创建索引时，我们还可以使用复合索引、函数索引（MySQL 5.7 开始支持），用好复合索引实现**索引覆盖**可以减少不必要的排序和回表操作，这样就会让查询的性能成倍的提升，有兴趣的读者可以自行研究。
 
 我们简单的为大家总结一下索引的设计原则：
 
diff --git a/Day36-40/38.深入MySQL.md b/Day36-40/38.深入MySQL.md
new file mode 100644
index 0000000..da2ef49
--- /dev/null
+++ b/Day36-40/38.深入MySQL.md
@@ -0,0 +1,661 @@
+## 深入MySQL
+
+### 索引
+
+索引是关系型数据库中用来提升查询性能最为重要的手段。关系型数据库中的索引就像一本书的目录，我们可以想象一下，如果要从一本书中找出某个知识点，但是这本书没有目录，这将是意见多么可怕的事情！我们估计得一篇一篇的翻下去，才能确定这个知识点到底在什么位置。创建索引虽然会带来存储空间上的开销，就像一本书的目录会占用一部分篇幅一样，但是在牺牲空间后换来的查询时间的减少也是非常显著的。
+
+MySQL 数据库中所有数据类型的列都可以被索引。对于MySQL 8.0 版本的 InnoDB 存储引擎来说，它支持三种类型的索引，分别是 B+ 树索引、全文索引和 R 树索引。这里，我们只介绍使用得最为广泛的 B+ 树索引。使用 B+ 树的原因非常简单，因为它是目前在基于磁盘进行海量数据存储和排序上最有效率的数据结构。B+ 树是一棵[平衡树](https://zh.wikipedia.org/zh-cn/%E5%B9%B3%E8%A1%A1%E6%A0%91)，树的高度通常为3或4，但是却可以保存从百万级到十亿级的数据，而从这些数据里面查询一条数据，只需要3次或4次 I/O 操作。
+
+B+ 树由根节点、中间节点和叶子节点构成，其中叶子节点用来保存排序后的数据。由于记录在索引上是排序过的，因此在一个叶子节点内查找数据时可以使用二分查找，这种查找方式效率非常的高。当数据很少的时候，B+ 树只有一个根节点，数据也就保存在根节点上。随着记录越来越多，B+ 树会发生分裂，根节点不再保存数据，而是提供了访问下一层节点的指针，帮助快速确定数据在哪个叶子节点上。
+
+在创建二维表时，我们通常都会为表指定主键列，主键列上默认会创建索引，而对于 MySQL InnoDB 存储引擎来说，因为它使用的是索引组织表这种数据存储结构，所以主键上的索引就是整张表的数据，而这种索引我们也将其称之为**聚集索引**（clustered index）。很显然，一张表只能有一个聚集索引，否则表的数据岂不是要保存多次。我们自己创建的索引都是二级索引（secondary index），更常见的叫法是**非聚集索引**（non-clustered index）。通过我们自定义的非聚集索引只能定位记录的主键，在获取数据时可能需要再通过主键上的聚集索引进行查询，这种现象称为“回表”，因此通过非聚集索引检索数据通常比使用聚集索引检索数据要慢。
+
+接下来我们通过一个简单的例子来说明索引的意义，比如我们要根据学生的姓名来查找学生，这个场景在实际开发中应该经常遇到，就跟通过商品名称查找商品是一个道理。我们可以使用 MySQL 的`explain`关键字来查看 SQL 的执行计划（数据库执行 SQL 语句的具体步骤）。
+
+```SQL
+explain select * from tb_student where stuname='林震南'\G
+```
+
+```
+*************************** 1. row ***************************
+           id: 1
+  select_type: SIMPLE
+        table: tb_student
+   partitions: NULL
+         type: ALL
+possible_keys: NULL
+          key: NULL
+      key_len: NULL
+          ref: NULL
+         rows: 11
+     filtered: 10.00
+        Extra: Using where
+1 row in set, 1 warning (0.00 sec)
+```
+
+在上面的 SQL 执行计划中，有几项值得我们关注：
+
+1. `select_type`：查询的类型。
+    - `SIMPLE`：简单 SELECT，不需要使用 UNION 操作或子查询。
+    - `PRIMARY`：如果查询包含子查询，最外层的 SELECT 被标记为 PRIMARY。
+    - `UNION`：UNION 操作中第二个或后面的 SELECT 语句。
+    - `SUBQUERY`：子查询中的第一个 SELECT。
+    - `DERIVED`：派生表的 SELECT 子查询。
+2. `table`：查询对应的表。
+3. `type`：MySQL 在表中找到满足条件的行的方式，也称为访问类型，包括：`ALL`（全表扫描）、`index`（索引全扫描，只遍历索引树）、`range`（索引范围扫描）、`ref`（非唯一索引扫描）、`eq_ref`（唯一索引扫描）、`const` / `system`（常量级查询）、`NULL`（不需要访问表或索引）。在所有的访问类型中，很显然 ALL 是性能最差的，它代表的全表扫描是指要扫描表中的每一行才能找到匹配的行。
+4. `possible_keys`：MySQL 可以选择的索引，但是**有可能不会使用**。
+5. `key`：MySQL 真正使用的索引，如果为`NULL`就表示没有使用索引。
+6. `key_len`：使用的索引的长度，在不影响查询的情况下肯定是长度越短越好。
+7. `rows`：执行查询需要扫描的行数，这是一个**预估值**。
+8. `extra`：关于查询额外的信息。
+    - `Using filesort`：MySQL 无法利用索引完成排序操作。
+    - `Using index`：只使用索引的信息而不需要进一步查表来获取更多的信息。
+    - `Using temporary`：MySQL 需要使用临时表来存储结果集，常用于分组和排序。
+    - `Impossible where`：`where`子句会导致没有符合条件的行。
+    - `Distinct`：MySQL 发现第一个匹配行后，停止为当前的行组合搜索更多的行。
+    - `Using where`：查询的列未被索引覆盖，筛选条件并不是索引的前导列。
+
+从上面的执行计划可以看出，当我们通过学生名字查询学生时实际上是进行了全表扫描，不言而喻这个查询性能肯定是非常糟糕的，尤其是在表中的行很多的时候。如果我们需要经常通过学生姓名来查询学生，那么就应该在学生姓名对应的列上创建索引，通过索引来加速查询。
+
+```SQL
+create index idx_student_name on tb_student(stuname);
+```
+
+再次查看刚才的 SQL 对应的执行计划。
+
+```SQL
+explain select * from tb_student where stuname='林震南'\G
+```
+
+```
+*************************** 1. row ***************************
+           id: 1
+  select_type: SIMPLE
+        table: tb_student
+   partitions: NULL
+         type: ref
+possible_keys: idx_student_name
+          key: idx_student_name
+      key_len: 62
+          ref: const
+         rows: 1
+     filtered: 100.00
+        Extra: NULL
+1 row in set, 1 warning (0.00 sec)
+```
+
+可以注意到，在对学生姓名创建索引后，刚才的查询已经不是全表扫描而是基于索引的查询，而且扫描的行只有唯一的一行，这显然大大的提升了查询的性能。MySQL 中还允许创建前缀索引，即对索引字段的前N个字符创建索引，这样的话可以减少索引占用的空间（但节省了空间很有可能会浪费时间，**时间和空间是不可调和的矛盾**），如下所示。
+
+```SQL
+create index idx_student_name_1 on tb_student(stuname(1));
+```
+
+上面的索引相当于是根据学生姓名的第一个字来创建的索引，我们再看看 SQL 执行计划。
+
+```SQL
+explain select * from tb_student where stuname='林震南'\G
+```
+
+```
+*************************** 1. row ***************************
+           id: 1
+  select_type: SIMPLE
+        table: tb_student
+   partitions: NULL
+         type: ref
+possible_keys: idx_student_name
+          key: idx_student_name
+      key_len: 5
+          ref: const
+         rows: 2
+     filtered: 100.00
+        Extra: Using where
+1 row in set, 1 warning (0.00 sec)
+```
+
+不知道大家是否注意到，这一次扫描的行变成了2行，因为学生表中有两个姓“林”的学生，我们只用姓名的第一个字作为索引的话，在查询时通过索引就会找到这两行。
+
+如果要删除索引，可以使用下面的SQL。
+
+```SQL
+alter table tb_student drop index idx_student_name;
+```
+
+或者
+
+```SQL
+drop index idx_student_name on tb_student;
+```
+
+在创建索引时，我们还可以使用复合索引、函数索引（MySQL 5.7 开始支持），用好复合索引实现**索引覆盖**可以减少不必要的排序和回表操作，这样就会让查询的性能成倍的提升，有兴趣的读者可以自行研究。
+
+我们简单的为大家总结一下索引的设计原则：
+
+1. **最适合**索引的列是出现在**WHERE子句**和连接子句中的列。
+2. 索引列的基数越大（取值多、重复值少），索引的效果就越好。
+3. 使用**前缀索引**可以减少索引占用的空间，内存中可以缓存更多的索引。
+4. **索引不是越多越好**，虽然索引加速了读操作（查询），但是写操作（增、删、改）都会变得更慢，因为数据的变化会导致索引的更新，就如同书籍章节的增删需要更新目录一样。
+5. 使用 InnoDB 存储引擎时，表的普通索引都会保存主键的值，所以**主键要尽可能选择较短的数据类型**，这样可以有效的减少索引占用的空间，提升索引的缓存效果。
+
+最后，还有一点需要说明，InnoDB 使用的 B-tree 索引，数值类型的列除了等值判断时索引会生效之外，使用`>`、`<`、`>=`、`<=`、`BETWEEN...AND... `、`<>`时，索引仍然生效；对于字符串类型的列，如果使用不以通配符开头的模糊查询，索引也是起作用的，但是其他的情况会导致索引失效，这就意味着很有可能会做全表查询。
+
+### 视图
+
+视图是关系型数据库中将一组查询指令构成的结果集组合成可查询的数据表的对象。简单的说，视图就是虚拟的表，但与数据表不同的是，数据表是一种实体结构，而视图是一种虚拟结构，你也可以将视图理解为保存在数据库中被赋予名字的 SQL 语句。
+
+使用视图可以获得以下好处：
+
+1. 可以将实体数据表隐藏起来，让外部程序无法得知实际的数据结构，让访问者可以使用表的组成部分而不是整个表，降低数据库被攻击的风险。
+2. 在大多数的情况下视图是只读的（更新视图的操作通常都有诸多的限制），外部程序无法直接透过视图修改数据。
+3. 重用 SQL 语句，将高度复杂的查询包装在视图表中，直接访问该视图即可取出需要的数据；也可以将视图视为数据表进行连接查询。
+4. 视图可以返回与实体数据表不同格式的数据，在创建视图的时候可以对数据进行格式化处理。
+
+创建视图。
+
+```SQL
+-- 创建视图
+create view `vw_avg_score` 
+as 
+    select `stu_id`, round(avg(`score`), 1) as `avg_score` 
+    from `tb_record` group by `stu_id`;
+
+-- 基于已有的视图创建视图
+create view `vw_student_score` 
+as 
+    select `stu_name`, `avg_score` 
+    from `tb_student` natural join `vw_avg_score`;
+```
+
+> **提示**：因为视图不包含数据，所以每次使用视图时，都必须执行查询以获得数据，如果你使用了连接查询、嵌套查询创建了较为复杂的视图，你可能会发现查询性能下降得很厉害。因此，在使用复杂的视图前，应该进行测试以确保其性能能够满足应用的需求。
+
+使用视图。
+
+```SQL
+select * from `vw_student_score` order by `avg_score` desc;
+```
+
+```
++--------------+----------+
+| stuname      | avgscore |
++--------------+----------+
+| 杨过         |     95.6 |
+| 任我行       |     53.5 |
+| 王语嫣       |     84.3 |
+| 纪嫣然       |     73.8 |
+| 岳不群       |     78.0 |
+| 东方不败     |     88.0 |
+| 项少龙       |     92.0 |
++--------------+----------+
+```
+
+既然视图是一张虚拟的表，那么视图的中的数据可以更新吗？视图的可更新性要视具体情况而定，以下类型的视图是不能更新的：
+
+1. 使用了聚合函数（`SUM`、`MIN`、`MAX`、`AVG`、`COUNT`等）、`DISTINCT`、`GROUP BY`、`HAVING`、`UNION`或者`UNION ALL`的视图。
+2. `SELECT`中包含了子查询的视图。
+3. `FROM`子句中包含了一个不能更新的视图的视图。
+4. `WHERE`子句的子查询引用了`FROM`子句中的表的视图。
+
+删除视图。
+
+```SQL
+drop view vw_student_score;
+```
+
+> **说明**：如果希望更新视图，可以先用上面的命令删除视图，也可以通过`create or replace view`来更新视图。
+
+视图的规则和限制。
+
+1. 视图可以嵌套，可以利用从其他视图中检索的数据来构造一个新的视图。视图也可以和表一起使用。
+2. 创建视图时可以使用`order by`子句，但如果从视图中检索数据时也使用了`order by`，那么该视图中原先的`order by`会被覆盖。
+3. 视图无法使用索引，也不会激发触发器（实际开发中因为性能等各方面的考虑，通常不建议使用触发器，所以我们也不对这个概念进行介绍）的执行。
+
+### 函数
+
+MySQL 中的函数跟 Python 中的函数太多的差异，因为函数都是用来封装功能上相对独立且会被重复使用的代码的。如果非要找出一些差别来，那么 MySQL 中的函数是可以执行 SQL 语句的。下面的例子，我们通过自定义函数实现了截断超长字符串的功能。
+
+```SQL
+delimiter $$
+
+create function truncate_string(
+    content varchar(10000),
+    max_length int unsigned
+) returns varchar(10000) no sql
+begin
+    declare result varchar(10000) default content;
+    if char_length(content) > max_length then
+        set result = left(content, max_length);
+        set result = concat(result, '……');
+    end if;
+    return result;
+end $$
+
+delimiter ;
+```
+
+> **说明1**：函数声明后面的`no sql`是声明函数体并没有使用 SQL 语句；如果函数体中需要通过 SQL 读取数据，需要声明为`reads sql data`。
+>
+> **说明2**：定义函数前后的`delimiter`命令是为了修改定界符，因为函数体中的语句都是用`;`表示结束，如果不重新定义定界符，那么遇到的`;`的时候代码就会被截断执行，显然这不是我们想要的效果。
+
+在查询中调用自定义函数。
+
+```SQL
+select truncate_string('和我在成都的街头走一走，直到所有的灯都熄灭了也不停留', 10) as short_string;
+```
+
+```
++--------------------------------------+
+| short_string                         |
++--------------------------------------+
+| 和我在成都的街头走一……                 |
++--------------------------------------+
+```
+
+### 过程
+
+过程（又称存储过程）是事先编译好存储在数据库中的一组 SQL 的集合，调用过程可以简化应用程序开发人员的工作，减少与数据库服务器之间的通信，对于提升数据操作的性能也是有帮助的。其实迄今为止，我们使用的 SQL 语句都是针对一个或多个表的单条语句，但在实际开发中经常会遇到某个操作需要多条 SQL 语句才能完成的情况。例如，电商网站在受理用户订单时，需要做以下一系列的处理。 
+
+1. 通过查询来核对库存中是否有对应的物品以及库存是否充足。
+2. 如果库存有物品，需要锁定库存以确保这些物品不再卖给别人， 并且要减少可用的物品数量以反映正确的库存量。
+3. 如果库存不足，可能需要进一步与供应商进行交互或者至少产生一条系统提示消息。 
+4. 不管受理订单是否成功，都需要产生流水记录，而且需要给对应的用户产生一条通知信息。 
+
+我们可以通过过程将复杂的操作封装起来，这样不仅有助于保证数据的一致性，而且将来如果业务发生了变动，只需要调整和修改过程即可。对于调用过程的用户来说，过程并没有暴露数据表的细节，而且执行过程比一条条的执行一组 SQL 要快得多。
+
+下面的过程实现了查询某门课程的最高分、最低分和平均分。
+
+```SQL
+drop procedure if exists sp_score_stat;
+
+delimiter $$
+
+create procedure sp_score_stat(
+	courseId int, 
+	out maxScore decimal(4,1), 
+	out minScore decimal(4,1),
+	out avgScore decimal(4,1)
+)
+begin
+	select max(score) into maxScore from tb_record where cou_id=courseId;
+	select min(score) into minScore from tb_record where cou_id=courseId;
+	select avg(score) into avgScore from tb_record where cou_id=courseId;
+end $$
+
+delimiter ;
+```
+
+> **说明**：在定义过程时，因为可能需要书写多条 SQL，而分隔这些 SQL 需要使用分号作为分隔符，如果这个时候，仍然用分号表示整段代码结束，那么定义过程的 SQL 就会出现错误，所以上面我们用`delimiter $$`将整段代码结束的标记定义为`$$`，那么代码中的分号将不再表示整段代码的结束，整段代码只会在遇到`end $$`时才会执行。在定义完过程后，通过`delimiter ;`将结束符重新改回成分号（恢复现场）。
+
+上面定义的过程有四个参数，其中第一个参数是输入参数，代表课程的编号，后面的参数都是输出参数，因为过程不能定义返回值，只能通过输出参数将执行结果带出，定义输出参数的关键字是`out`，默认情况下参数都是输入参数。
+
+调用过程。
+
+```SQL
+call sp_score_stat(1111, @a, @b, @c);
+```
+
+获取输出参数的值。
+
+```SQL
+select @a as 最高分, @b as 最低分, @c as 平均分;
+```
+
+删除过程。
+
+```SQL
+drop procedure sp_score_stat;
+```
+
+在过程中，我们可以定义变量、条件，可以使用分支和循环语句，可以通过游标操作查询结果，还可以使用事件调度器，这些内容我们暂时不在此处进行介绍。虽然我们说了很多过程的好处，但是在实际开发中，如果频繁的使用过程并将大量复杂的运算放到过程中，会给据库服务器造成巨大的压力，而数据库往往都是性能瓶颈所在，使用过程无疑是雪上加霜的操作。所以，对于互联网产品开发，我们一般建议让数据库只做好存储，复杂的运算和处理交给应用服务器上的程序去完成，如果应用服务器变得不堪重负了，我们可以比较容易的部署多台应用服务器来分摊这些压力。
+
+如果大家对上面讲到的视图、函数、过程包括我们没有讲到的触发器这些知识有兴趣，建议大家阅读 MySQL 的入门读物[《MySQL必知必会》](https://item.jd.com/12818982.html)进行一般性了解即可，因为这些知识点在大家将来的工作中未必用得上，学了也可能仅仅是为了应付面试而已。
+
+### MySQL 新特性
+
+#### JSON类型
+
+很多开发者在使用关系型数据库做数据持久化的时候，常常感到结构化的存储缺乏灵活性，因为必须事先设计好所有的列以及对应的数据类型。在业务发展和变化的过程中，如果需要修改表结构，这绝对是比较麻烦和难受的事情。从 MySQL 5.7 版本开始，MySQL引入了对 JSON 数据类型的支持（MySQL 8.0 解决了 JSON 的日志性能瓶颈问题），用好 JSON 类型，其实就是打破了关系型数据库和非关系型数据库之间的界限，为数据持久化操作带来了更多的便捷。
+
+JSON 类型主要分为 JSON 对象和 JSON数组两种，如下所示。
+
+1. JSON 对象
+
+```JSON
+{"name": "骆昊", "tel": "13122335566", "QQ": "957658"}
+```
+
+2. JSON 数组
+
+```JSON
+[1, 2, 3]
+```
+
+```JSON
+[{"name": "骆昊", "tel": "13122335566"}, {"name": "王大锤", "QQ": "123456"}]
+```
+
+哪些地方需要用到JSON类型呢？举一个简单的例子，现在很多产品的用户登录都支持多种方式，例如手机号、微信、QQ、新浪微博等，但是一般情况下我们又不会要求用户提供所有的这些信息，那么用传统的设计方式，就需要设计多个列来对应多种登录方式，可能还需要允许这些列存在空值，这显然不是很好的选择；另一方面，如果产品又增加了一种登录方式，那么就必然要修改之前的表结构，这就更让人痛苦了。但是，有了 JSON 类型，刚才的问题就迎刃而解了，我们可以做出如下所示的设计。
+
+```SQL
+create table `tb_test`
+(
+`user_id` bigint unsigned,
+`login_info` json,
+primary key (`user_id`)
+) engine=innodb;
+
+insert into `tb_test` values 
+    (1, '{"tel": "13122335566", "QQ": "654321", "wechat": "jackfrued"}'),
+    (2, '{"tel": "13599876543", "weibo": "wangdachui123"}');
+```
+
+如果要查询用户的手机和微信号，可以用如下所示的 SQL 语句。
+
+```SQL
+select 
+    `user_id`,
+    json_unquote(json_extract(`login_info`, '$.tel')) as 手机号,
+    json_unquote(json_extract(`login_info`, '$.wechat')) as 微信 
+from `tb_test`;
+```
+
+```
++---------+-------------+-----------+
+| user_id | 手机号      | 微信       |
++---------+-------------+-----------+
+|       1 | 13122335566 | jackfrued |
+|       2 | 13599876543 | NULL      |
++---------+-------------+-----------+
+```
+
+因为支持 JSON 类型，MySQL 也提供了配套的处理 JSON 数据的函数，就像上面用到的`json_extract`和`json_unquote`。当然，上面的 SQL 还有更为便捷的写法，如下所示。
+
+```SQL
+select 
+	`user_id`,
+    `login_info` ->> '$.tel' as 手机号,
+    `login_info` ->> '$.wechat' as 微信
+from `tb_test`;
+```
+
+再举个例子，如果我们的产品要实现用户画像功能（给用户打标签），然后基于用户画像给用户推荐平台的服务或消费品之类的东西，我们也可以使用 JSON 类型来保存用户画像数据，示意代码如下所示。
+
+创建画像标签表。
+
+```SQL
+create table `tb_tags`
+(
+`tag_id` int unsigned not null comment '标签ID',
+`tag_name` varchar(20) not null comment '标签名',
+primary key (`tag_id`)
+) engine=innodb;
+
+insert into `tb_tags` (`tag_id`, `tag_name`) 
+values
+    (1, '70后'),
+    (2, '80后'),
+    (3, '90后'),
+    (4, '00后'),
+    (5, '爱运动'),
+    (6, '高学历'),
+    (7, '小资'),
+    (8, '有房'),
+    (9, '有车'),
+    (10, '爱看电影'),
+    (11, '爱网购'),
+    (12, '常点外卖');
+```
+
+为用户打标签。
+
+```SQL
+create table `tb_users_tags`
+(
+`user_id` bigint unsigned not null comment '用户ID',
+`user_tags` json not null comment '用户标签'
+) engine=innodb;
+
+insert into `tb_users_tags` values 
+    (1, '[2, 6, 8, 10]'),
+    (2, '[3, 10, 12]'),
+    (3, '[3, 8, 9, 11]');
+```
+
+接下来，我们通过一组查询来了解 JSON 类型的巧妙之处。
+
+1. 查询爱看电影（有`10`这个标签）的用户ID。
+
+    ```SQL
+    select * from `tb_users` where 10 member of (user_tags->'$');
+    ```
+
+2. 查询爱看电影（有`10`这个标签）的80后（有`2`这个标签）用户ID。
+
+    ```
+    select * from `tb_users` where json_contains(user_tags->'$', '[2, 10]');
+
+3. 查询爱看电影或80后或90后的用户ID。
+
+    ```SQL
+    select `user_id` from `tb_users_tags` where json_overlaps(user_tags->'$', '[2, 3, 10]');
+    ```
+
+> **说明**：上面的查询用到了`member of`谓词和两个 JSON 函数，`json_contains`可以检查 JSON 数组是否包含了指定的元素，而`json_overlaps`可以检查 JSON 数组是否与指定的数组有重叠部分。
+
+#### 窗口函数
+
+MySQL 从8.0开始支持窗口函数，大多数商业数据库和一些开源数据库早已提供了对窗口函数的支持，有的也将其称之为 OLAP（联机分析和处理）函数，听名字就知道跟统计和分析相关。为了帮助大家理解窗口函数，我们先说说窗口的概念。
+
+窗口可以理解为记录的集合，窗口函数也就是在满足某种条件的记录集合上执行的特殊函数，对于每条记录都要在此窗口内执行函数。窗口函数和我们上面讲到的聚合函数比较容易混淆，二者的区别主要在于聚合函数是将多条记录聚合为一条记录，窗口函数是每条记录都会执行，执行后记录条数不会变。窗口函数不仅仅是几个函数，它是一套完整的语法，函数只是该语法的一部分，基本语法如下所示：
+
+```SQL
+<窗口函数> over (partition by <用于分组的列名> order by <用户排序的列名>)
+```
+
+上面语法中，窗口函数的位置可以放以下两种函数：
+
+1. 专用窗口函数，包括：`lead`、`lag`、`first_value`、`last_value`、`rank`、`dense_rank`和`row_number`等。
+2. 聚合函数，包括：`sum`、`avg`、`max`、`min`和`count`等。
+
+下面为大家举几个使用窗口函数的简单例子，我们先用如下所示的 SQL 建库建表。
+
+```SQL
+-- 创建名为hrs的数据库并指定默认的字符集
+create database `hrs` default charset utf8mb4;
+
+-- 切换到hrs数据库
+use `hrs`;
+
+-- 创建部门表
+create table `tb_dept`
+(
+`dno` int not null comment '编号',
+`dname` varchar(10) not null comment '名称',
+`dloc` varchar(20) not null comment '所在地',
+primary key (`dno`)
+);
+
+-- 插入4个部门
+insert into `tb_dept` values 
+    (10, '会计部', '北京'),
+    (20, '研发部', '成都'),
+    (30, '销售部', '重庆'),
+    (40, '运维部', '深圳');
+
+-- 创建员工表
+create table `tb_emp`
+(
+`eno` int not null comment '员工编号',
+`ename` varchar(20) not null comment '员工姓名',
+`job` varchar(20) not null comment '员工职位',
+`mgr` int comment '主管编号',
+`sal` int not null comment '员工月薪',
+`comm` int comment '每月补贴',
+`dno` int not null comment '所在部门编号',
+primary key (`eno`),
+constraint `fk_emp_mgr` foreign key (`mgr`) references tb_emp (`eno`),
+constraint `fk_emp_dno` foreign key (`dno`) references tb_dept (`dno`)
+);
+
+-- 插入14个员工
+insert into `tb_emp` values 
+    (7800, '张三丰', '总裁', null, 9000, 1200, 20),
+    (2056, '乔峰', '分析师', 7800, 5000, 1500, 20),
+    (3088, '李莫愁', '设计师', 2056, 3500, 800, 20),
+    (3211, '张无忌', '程序员', 2056, 3200, null, 20),
+    (3233, '丘处机', '程序员', 2056, 3400, null, 20),
+    (3251, '张翠山', '程序员', 2056, 4000, null, 20),
+    (5566, '宋远桥', '会计师', 7800, 4000, 1000, 10),
+    (5234, '郭靖', '出纳', 5566, 2000, null, 10),
+    (3344, '黄蓉', '销售主管', 7800, 3000, 800, 30),
+    (1359, '胡一刀', '销售员', 3344, 1800, 200, 30),
+    (4466, '苗人凤', '销售员', 3344, 2500, null, 30),
+    (3244, '欧阳锋', '程序员', 3088, 3200, null, 20),
+    (3577, '杨过', '会计', 5566, 2200, null, 10),
+    (3588, '朱九真', '会计', 5566, 2500, null, 10);
+```
+
+例子1：查询按月薪从高到低排在第4到第6名的员工的姓名和月薪。
+
+```SQL
+select * from (
+	select 
+		`ename`, `sal`,
+		row_number() over (order by `sal` desc) as `rank`
+	from `tb_emp`
+) `temp` where `rank` between 4 and 6;
+```
+
+> **说明**：上面使用的函数`row_number()`可以为每条记录生成一个行号，在实际工作中可以根据需要将其替换为`rank()`或`dense_rank()`函数，三者的区别可以参考官方文档或阅读[《通俗易懂的学会：SQL窗口函数》](https://zhuanlan.zhihu.com/p/92654574)进行了解。在MySQL 8以前的版本，我们可以通过下面的方式来完成类似的操作。
+>
+> ```SQL
+> select `rank`, `ename`, `sal` from (
+>     select @a:=@a+1 as `rank`, `ename`, `sal` 
+>     from `tb_emp`, (select @a:=0) as t1 order by `sal` desc
+> ) t2 where `rank` between 4 and 6;
+> ```
+
+例子2：查询每个部门月薪最高的两名的员工的姓名和部门名称。
+
+```SQL
+select `ename`, `sal`, `dname` 
+from (
+    select 
+        `ename`, `sal`, `dno`,
+        rank() over (partition by `dno` order by `sal` desc) as `rank`
+    from `tb_emp`
+) as `temp` natural join `tb_dept` where `rank`<=2;
+```
+
+> 说明：在MySQL 8以前的版本，我们可以通过下面的方式来完成类似的操作。
+>
+> ```SQL
+> select `ename`, `sal`, `dname` from `tb_emp` as `t1` 
+natural join `tb_dept` 
+where (
+    select count(*) from `tb_emp` as `t2` 
+    where `t1`.`dno`=`t2`.`dno` and `t2`.`sal`>`t1`.`sal` 
+)<2 order by `dno` asc, `sal` desc;
+> ```
+
+###  其他内容
+
+#### 范式理论
+
+范式理论是设计关系型数据库中二维表的指导思想。
+
+1. 第一范式：数据表的每个列的值域都是由原子值组成的，不能够再分割。
+2. 第二范式：数据表里的所有数据都要和该数据表的键（主键与候选键）有完全依赖关系。
+3. 第三范式：所有非键属性都只和候选键有相关性，也就是说非键属性之间应该是独立无关的。
+
+> **说明**：实际工作中，出于效率的考虑，我们在设计表时很有可能做出反范式设计，即故意降低方式级别，增加冗余数据来获得更好的操作性能。
+
+#### 数据完整性
+
+1. 实体完整性 - 每个实体都是独一无二的
+
+   - 主键（`primary key`） / 唯一约束（`unique`）
+2. 引用完整性（参照完整性）- 关系中不允许引用不存在的实体
+
+   - 外键（`foreign key`）
+3. 域（domain）完整性 - 数据是有效的
+   - 数据类型及长度
+
+   - 非空约束（`not null`）
+
+   - 默认值约束（`default`）
+
+   - 检查约束（`check`）
+
+     > **说明**：在 MySQL 8.x 以前，检查约束并不起作用。
+
+#### 数据一致性
+
+1. 事务：一系列对数据库进行读/写的操作，这些操作要么全都成功，要么全都失败。
+
+2. 事务的 ACID 特性
+   - 原子性：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么都不执行
+   - 一致性：事务应确保数据库的状态从一个一致状态转变为另一个一致状态
+   - 隔离性：多个事务并发执行时，一个事务的执行不应影响其他事务的执行
+   - 持久性：已被提交的事务对数据库的修改应该永久保存在数据库中
+
+3. MySQL 中的事务操作
+
+   - 开启事务环境
+
+     ```SQL
+     start transaction
+     ```
+
+   - 提交事务
+
+     ```SQL
+     commit
+     ```
+
+   - 回滚事务
+
+     ```SQL
+     rollback
+     ```
+
+4. 查看事务隔离级别
+
+    ```SQL
+    show variables like 'transaction_isolation';
+    ```
+
+    ```
+    +-----------------------+-----------------+
+    | Variable_name         | Value           |
+    +-----------------------+-----------------+
+    | transaction_isolation | REPEATABLE-READ |
+    +-----------------------+-----------------+
+    ```
+
+    可以看出，MySQL 默认的事务隔离级别是`REPEATABLE-READ`。
+
+5. 修改（当前会话）事务隔离级别
+
+    ```SQL
+    set session transaction isolation level read committed;
+    ```
+
+    重新查看事务隔离级别，结果如下所示。
+
+    ```
+    +-----------------------+----------------+
+    | Variable_name         | Value          |
+    +-----------------------+----------------+
+    | transaction_isolation | READ-COMMITTED |
+    +-----------------------+----------------+
+    ```
+
+关系型数据库的事务是一个很大的话题，因为当存在多个并发事务访问数据时，就有可能出现三类读数据的问题（脏读、不可重复读、幻读）和两类更新数据的问题（第一类丢失更新、第二类丢失更新）。想了解这五类问题的，可以阅读我发布在 CSDN 网站上的[《Java面试题全集（上）》](https://blog.csdn.net/jackfrued/article/details/44921941)一文的第80题。为了避免这些问题，关系型数据库底层是有对应的锁机制的，按锁定对象不同可以分为表级锁和行级锁，按并发事务锁定关系可以分为共享锁和独占锁。然而直接使用锁是非常麻烦的，为此数据库为用户提供了自动锁机制，只要用户指定适当的事务隔离级别，数据库就会通过分析 SQL 语句，然后为事务访问的资源加上合适的锁。此外，数据库还会维护这些锁通过各种手段提高系统的性能，这些对用户来说都是透明的。想了解 MySQL 事务和锁的细节知识，推荐大家阅读进阶读物[《高性能MySQL》](https://item.jd.com/11220393.html)，这也是数据库方面的经典书籍。
+
+ANSI/ISO SQL 92标准定义了4个等级的事务隔离级别，如下表所示。需要说明的是，事务隔离级别和数据访问的并发性是对立的，事务隔离级别越高并发性就越差。所以要根据具体的应用来确定到底使用哪种事务隔离级别，这个地方没有万能的原则。
+
+<img src="https://gitee.com/jackfrued/mypic/raw/master/20211121225327.png" style="zoom:50%;">
+
+### 总结
+
+关于 SQL 和 MySQL 的知识肯定远远不止上面列出的这些，比如 SQL 本身的优化、MySQL 性能调优、MySQL 运维相关工具、MySQL 数据的备份和恢复、监控 MySQL 服务、部署高可用架构等，这一系列的问题在这里都没有办法逐一展开来讨论，那就留到有需要的时候再进行讲解吧，各位读者也可以自行探索。
diff --git a/Day36-40/39.数据库相关知识.md b/Day36-40/39.数据库相关知识.md
new file mode 100644
index 0000000..60bd9f4
--- /dev/null
+++ b/Day36-40/39.数据库相关知识.md
@@ -0,0 +1,102 @@
+## 数据库相关知识
+
+### 范式理论
+
+范式理论是设计关系型数据库中二维表的指导思想。
+
+1. 第一范式：数据表的每个列的值域都是由原子值组成的，不能够再分割。
+2. 第二范式：数据表里的所有数据都要和该数据表的键（主键与候选键）有完全依赖关系。
+3. 第三范式：所有非键属性都只和候选键有相关性，也就是说非键属性之间应该是独立无关的。
+
+> **说明**：实际工作中，出于效率的考虑，我们在设计表时很有可能做出反范式设计，即故意降低方式级别，增加冗余数据来获得更好的操作性能。
+
+### 数据完整性
+
+1. 实体完整性 - 每个实体都是独一无二的
+
+   - 主键（`primary key`） / 唯一约束（`unique`）
+2. 引用完整性（参照完整性）- 关系中不允许引用不存在的实体
+
+   - 外键（`foreign key`）
+3. 域（domain）完整性 - 数据是有效的
+   - 数据类型及长度
+
+   - 非空约束（`not null`）
+
+   - 默认值约束（`default`）
+
+   - 检查约束（`check`）
+
+     > **说明**：在 MySQL 8.x 以前，检查约束并不起作用。
+
+### 数据一致性
+
+1. 事务：一系列对数据库进行读/写的操作，这些操作要么全都成功，要么全都失败。
+
+2. 事务的 ACID 特性
+   - 原子性：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么都不执行
+   - 一致性：事务应确保数据库的状态从一个一致状态转变为另一个一致状态
+   - 隔离性：多个事务并发执行时，一个事务的执行不应影响其他事务的执行
+   - 持久性：已被提交的事务对数据库的修改应该永久保存在数据库中
+
+3. MySQL 中的事务操作
+
+   - 开启事务环境
+
+     ```SQL
+     start transaction
+     ```
+
+   - 提交事务
+
+     ```SQL
+     commit
+     ```
+
+   - 回滚事务
+
+     ```SQL
+     rollback
+     ```
+
+4. 查看事务隔离级别
+
+    ```SQL
+    show variables like 'transaction_isolation';
+    ```
+
+    ```
+    +-----------------------+-----------------+
+    | Variable_name         | Value           |
+    +-----------------------+-----------------+
+    | transaction_isolation | REPEATABLE-READ |
+    +-----------------------+-----------------+
+    ```
+
+    可以看出，MySQL 默认的事务隔离级别是`REPEATABLE-READ`。
+
+5. 修改（当前会话）事务隔离级别
+
+    ```SQL
+    set session transaction isolation level read committed;
+    ```
+
+    重新查看事务隔离级别，结果如下所示。
+
+    ```
+    +-----------------------+----------------+
+    | Variable_name         | Value          |
+    +-----------------------+----------------+
+    | transaction_isolation | READ-COMMITTED |
+    +-----------------------+----------------+
+    ```
+
+关系型数据库的事务是一个很大的话题，因为当存在多个并发事务访问数据时，就有可能出现三类读数据的问题（脏读、不可重复读、幻读）和两类更新数据的问题（第一类丢失更新、第二类丢失更新）。想了解这五类问题的，可以阅读我发布在 CSDN 网站上的[《Java面试题全集（上）》](https://blog.csdn.net/jackfrued/article/details/44921941)一文的第80题。为了避免这些问题，关系型数据库底层是有对应的锁机制的，按锁定对象不同可以分为表级锁和行级锁，按并发事务锁定关系可以分为共享锁和独占锁。然而直接使用锁是非常麻烦的，为此数据库为用户提供了自动锁机制，只要用户指定适当的事务隔离级别，数据库就会通过分析 SQL 语句，然后为事务访问的资源加上合适的锁。此外，数据库还会维护这些锁通过各种手段提高系统的性能，这些对用户来说都是透明的。想了解 MySQL 事务和锁的细节知识，推荐大家阅读进阶读物[《高性能MySQL》](https://item.jd.com/11220393.html)，这也是数据库方面的经典书籍。
+
+ANSI/ISO SQL 92标准定义了4个等级的事务隔离级别，如下表所示。需要说明的是，事务隔离级别和数据访问的并发性是对立的，事务隔离级别越高并发性就越差。所以要根据具体的应用来确定到底使用哪种事务隔离级别，这个地方没有万能的原则。
+
+<img src="https://gitee.com/jackfrued/mypic/raw/master/20211121225327.png" style="zoom:50%;">
+
+### 总结
+
+关于 SQL 和 MySQL 的知识肯定远远不止上面列出的这些，比如 SQL 本身的优化、MySQL 性能调优、MySQL 运维相关工具、MySQL 数据的备份和恢复、监控 MySQL 服务、部署高可用架构等，这一系列的问题在这里都没有办法逐一展开来讨论，那就留到有需要的时候再进行讲解吧，各位读者也可以自行探索。
diff --git a/Day36-40/38.Python程序接入MySQL数据库.md b/Day36-40/40.Python程序接入MySQL数据库.md
similarity index 100%
rename from Day36-40/38.Python程序接入MySQL数据库.md
rename to Day36-40/40.Python程序接入MySQL数据库.md
diff --git a/Day36-40/39-40.NoSQL数据库入门.md b/Day36-40/NoSQL数据库入门.md
similarity index 100%
rename from Day36-40/39-40.NoSQL数据库入门.md
rename to Day36-40/NoSQL数据库入门.md
diff --git a/Day41-55/43.静态资源和Ajax请求.md b/Day41-55/43.静态资源和Ajax请求.md
index c6332a4..b74bca7 100644
--- a/Day41-55/43.静态资源和Ajax请求.md
+++ b/Day41-55/43.静态资源和Ajax请求.md
@@ -65,8 +65,8 @@ from vote import views
 urlpatterns = [
     path('', views.show_subjects),
     path('teachers/', views.show_teachers),
-    path('praise/', views.prise_or_criticize),
-    path('criticize/', views.prise_or_criticize),
+    path('praise/', views.praise_or_criticize),
+    path('criticize/', views.praise_or_criticize),
     path('admin/', admin.site.urls),
 ]
 ```
diff --git a/Day61-65/61.网络数据采集概述.md b/Day61-65/61.网络数据采集概述.md
new file mode 100644
index 0000000..cd4b240
--- /dev/null
+++ b/Day61-65/61.网络数据采集概述.md
@@ -0,0 +1,200 @@
+## 第31课：网络数据采集概述
+
+爬虫（crawler）也经常被称为网络蜘蛛（spider），是按照一定的规则自动浏览网站并获取所需信息的机器人程序（自动化脚本代码），被广泛的应用于互联网搜索引擎和数据采集。使用过互联网和浏览器的人都知道，网页中除了供用户阅读的文字信息之外，还包含一些超链接，网络爬虫正是通过网页中的超链接信息，不断获得网络上其它页面的地址，然后持续的进行数据采集。正因如此，网络数据采集的过程就像一个爬虫或者蜘蛛在网络上漫游，所以才被形象的称为爬虫或者网络蜘蛛。
+
+### 爬虫的应用领域
+
+在理想的状态下，所有 ICP（Internet Content Provider）都应该为自己的网站提供 API 接口来共享它们允许其他程序获取的数据，在这种情况下就根本不需要爬虫程序。国内比较有名的电商平台（如淘宝、京东等）、社交平台（如微博、微信等）等都提供了自己的 API 接口，但是这类 API 接口通常会对可以抓取的数据以及抓取数据的频率进行限制。对于大多数的公司而言，及时的获取行业数据和竞对数据是企业生存的重要环节之一，然而对大部分企业来说，数据都是其与生俱来的短板。在这种情况下，合理的利用爬虫来获取数据并从中提取出有商业价值的信息对这些企业来说就显得至关重要的。
+
+爬虫的应用领域其实非常广泛，下面我们列举了其中的一部分，有兴趣的读者可以自行探索相关内容。
+
+1. 搜索引擎
+2. 新闻聚合
+3. 社交应用
+4. 舆情监控
+5. 行业数据
+
+### 爬虫合法性探讨
+
+经常听人说起“爬虫写得好，牢饭吃到饱”，那么编程爬虫程序是否违法呢？关于这个问题，我们可以从以下几个角度进行解读。
+
+1. 网络爬虫这个领域目前还属于拓荒阶段，虽然互联网世界已经通过自己的游戏规则建立起了一定的道德规范，即 Robots 协议（全称是“网络爬虫排除标准”），但法律部分还在建立和完善中，也就是说，现在这个领域暂时还是灰色地带。
+2. “法不禁止即为许可”，如果爬虫就像浏览器一样获取的是前端显示的数据（网页上的公开信息）而不是网站后台的私密敏感信息，就不太担心法律法规的约束，因为目前大数据产业链的发展速度远远超过了法律的完善程度。
+3. 在爬取网站的时候，需要限制自己的爬虫遵守 Robots 协议，同时控制网络爬虫程序的抓取数据的速度；在使用数据的时候，必须要尊重网站的知识产权（从Web 2.0时代开始，虽然Web上的数据很多都是由用户提供的，但是网站平台是投入了运营成本的，当用户在注册和发布内容时，平台通常就已经获得了对数据的所有权、使用权和分发权）。如果违反了这些规定，在打官司的时候败诉几率相当高。
+4. 适当的隐匿自己的身份在编写爬虫程序时必要的，而且最好不要被对方举证你的爬虫有破坏别人动产（例如服务器）的行为。
+5. 不要在公网（如代码托管平台）上去开源或者展示你的爬虫代码，这些行为通常会给自己带来不必要的麻烦。
+
+#### Robots协议
+
+大多数网站都会定义`robots.txt`文件，这是一个君子协议，并不是所有爬虫都必须遵守的游戏规则。下面以淘宝的[`robots.txt`](http://www.taobao.com/robots.txt)文件为例，看看淘宝网对爬虫有哪些限制。
+
+```
+User-agent: Baiduspider
+Disallow: /
+
+User-agent: baiduspider
+Disallow: /
+```
+
+通过上面的文件可以看出，淘宝禁止百度爬虫爬取它任何资源，因此当你在百度搜索“淘宝”的时候，搜索结果下方会出现：“由于该网站的`robots.txt`文件存在限制指令（限制搜索引擎抓取），系统无法提供该页面的内容描述”。百度作为一个搜索引擎，至少在表面上遵守了淘宝网的`robots.txt`协议，所以用户不能从百度上搜索到淘宝内部的产品信息。
+
+图1. 百度搜索淘宝的结果
+
+![](https://gitee.com/jackfrued/mypic/raw/master/20210824004320.png)
+
+下面是豆瓣网的[`robots.txt`](https://www.douban.com/robots.txt)文件，大家可以自行解读，看看它做出了什么样的限制。
+
+```
+User-agent: *
+Disallow: /subject_search
+Disallow: /amazon_search
+Disallow: /search
+Disallow: /group/search
+Disallow: /event/search
+Disallow: /celebrities/search
+Disallow: /location/drama/search
+Disallow: /forum/
+Disallow: /new_subject
+Disallow: /service/iframe
+Disallow: /j/
+Disallow: /link2/
+Disallow: /recommend/
+Disallow: /doubanapp/card
+Disallow: /update/topic/
+Disallow: /share/
+Allow: /ads.txt
+Sitemap: https://www.douban.com/sitemap_index.xml
+Sitemap: https://www.douban.com/sitemap_updated_index.xml
+# Crawl-delay: 5
+
+User-agent: Wandoujia Spider
+Disallow: /
+
+User-agent: Mediapartners-Google
+Disallow: /subject_search
+Disallow: /amazon_search
+Disallow: /search
+Disallow: /group/search
+Disallow: /event/search
+Disallow: /celebrities/search
+Disallow: /location/drama/search
+Disallow: /j/
+```
+
+### 超文本传输协议（HTTP）
+
+在开始讲解爬虫之前，我们稍微对超文本传输协议（HTTP）做一些回顾，因为我们在网页上看到的内容通常是浏览器执行 HTML （超文本标记语言）得到的结果，而 HTTP 就是传输 HTML 数据的协议。HTTP 和其他很多应用级协议一样是构建在 TCP（传输控制协议）之上的，它利用了 TCP 提供的可靠的传输服务实现了 Web 应用中的数据交换。按照维基百科上的介绍，设计 HTTP 最初的目的是为了提供一种发布和接收 [HTML](https://zh.wikipedia.org/wiki/HTML) 页面的方法，也就是说，这个协议是浏览器和 Web 服务器之间传输的数据的载体。关于 HTTP 的详细信息以及目前的发展状况，大家可以阅读[《HTTP 协议入门》](http://www.ruanyifeng.com/blog/2016/08/http.html)、[《互联网协议入门》](http://www.ruanyifeng.com/blog/2012/05/internet_protocol_suite_part_i.html)、[《图解 HTTPS 协议》](http://www.ruanyifeng.com/blog/2014/09/illustration-ssl.html)等文章进行了解。
+
+下图是我在四川省网络通信技术重点实验室工作期间用开源协议分析工具 Ethereal（WireShark 的前身）截取的访问百度首页时的 HTTP 请求和响应的报文（协议数据），由于 Ethereal 截取的是经过网络适配器的数据，因此可以清晰的看到从物理链路层到应用层的协议数据。
+
+图2. HTTP请求
+
+![http-request](https://gitee.com/jackfrued/mypic/raw/master/20210824003915.png)
+
+HTTP 请求通常是由请求行、请求头、空行、消息体四个部分构成，如果没有数据发给服务器，消息体就不是必须的部分。请求行中包含了请求方法（GET、POST 等，如下表所示）、资源路径和协议版本；请求头由若干键值对构成，包含了浏览器、编码方式、首选语言、缓存策略等信息；请求头的后面是空行和消息体。
+
+<img src="https://gitee.com/jackfrued/mypic/raw/master/20210825002720.PNG" width="65%">
+
+图3. HTTP响应
+
+![http-response](https://gitee.com/jackfrued/mypic/raw/master/20210824234158.png)
+
+HTTP 响应通常是由响应行、响应头、空行、消息体四个部分构成，其中消息体是服务响应的数据，可能是 HTML 页面，也有可能是JSON或二进制数据等。响应行中包含了协议版本和响应状态码，响应状态码有很多种，常见的如下表所示。
+
+<img src="https://gitee.com/jackfrued/mypic/raw/master/20210825002802.PNG" width="65%">
+
+#### 相关工具
+
+下面我们先介绍一些开发爬虫程序的辅助工具，这些工具相信能帮助你事半功倍。
+
+1. Chrome Developer Tools：谷歌浏览器内置的开发者工具。该工具最常用的几个功能模块是：
+
+   - 元素（ELements）：用于查看或修改 HTML 元素的属性、CSS 属性、监听事件等。CSS 可以即时修改，即时显示，大大方便了开发者调试页面。
+   - 控制台（Console）：用于执行一次性代码，查看 JavaScript 对象，查看调试日志信息或异常信息。控制台其实就是一个执行 JavaScript 代码的交互式环境。
+   - 源代码（Sources）：用于查看页面的 HTML 文件源代码、JavaScript 源代码、CSS 源代码，此外最重要的是可以调试 JavaScript 源代码，可以给代码添加断点和单步执行。
+   - 网络（Network）：用于 HTTP 请求、HTTP 响应以及与网络连接相关的信息。
+   - 应用（Application）：用于查看浏览器本地存储、后台任务等内容，本地存储主要包括Cookie、Local Storage、Session Storage等。
+
+   ![chrome-developer-tools](https://gitee.com/jackfrued/mypic/raw/master/20210824004034.png)
+
+2. Postman：功能强大的网页调试与 RESTful 请求工具。Postman可以帮助我们模拟请求，非常方便的定制我们的请求以及查看服务器的响应。
+
+   ![postman](https://gitee.com/jackfrued/mypic/raw/master/20210824004048.png)
+
+3. HTTPie：命令行HTTP客户端。
+
+   安装。
+
+   ```Bash
+   pip install httpie
+   ```
+
+   使用。
+
+   ```Bash
+   http --header http --header https://movie.douban.com/
+   
+   HTTP/1.1 200 OK
+   Connection: keep-alive
+   Content-Encoding: gzip
+   Content-Type: text/html; charset=utf-8
+   Date: Tue, 24 Aug 2021 16:48:00 GMT
+   Keep-Alive: timeout=30
+   Server: dae
+   Set-Cookie: bid=58h4BdKC9lM; Expires=Wed, 24-Aug-22 16:48:00 GMT; Domain=.douban.com; Path=/
+   Strict-Transport-Security: max-age=15552000
+   Transfer-Encoding: chunked
+   X-Content-Type-Options: nosniff
+   X-DOUBAN-NEWBID: 58h4BdKC9lM
+   ```
+
+4. `builtwith`库：识别网站所用技术的工具。
+
+   安装。
+
+   ```Bash
+   pip install builtwith
+   ```
+
+   使用。
+
+   ```Python
+   import ssl
+   
+   import builtwith
+   
+   ssl._create_default_https_context = ssl._create_unverified_context
+   print(builtwith.parse('http://www.bootcss.com/'))
+   ```
+
+5. `python-whois`库：查询网站所有者的工具。
+
+   安装。
+
+   ```Bash
+   pip3 install python-whois
+   ```
+
+   使用。
+
+   ```Python
+   import whois
+   
+   print(whois.whois('https://www.bootcss.com'))
+   ```
+
+### 爬虫的基本工作流程
+
+一个基本的爬虫通常分为数据采集（网页下载）、数据处理（网页解析）和数据存储（将有用的信息持久化）三个部分的内容，当然更为高级的爬虫在数据采集和处理时会使用并发编程或分布式技术，这就需要有调度器（安排线程或进程执行对应的任务）、后台管理程序（监控爬虫的工作状态以及检查数据抓取的结果）等的参与。
+
+![crawler-workflow](https://gitee.com/jackfrued/mypic/raw/master/20210824004107.png)
+
+一般来说，爬虫的工作流程包括以下几个步骤：
+
+1. 设定抓取目标（种子页面/起始页面）并获取网页。
+2. 当服务器无法访问时，按照指定的重试次数尝试重新下载页面。
+3. 在需要的时候设置用户代理或隐藏真实IP，否则可能无法访问页面。
+4. 对获取的页面进行必要的解码操作然后抓取出需要的信息。
+5. 在获取的页面中通过某种方式（如正则表达式）抽取出页面中的链接信息。
+6. 对链接进行进一步的处理（获取页面并重复上面的动作）。
+7. 将有用的信息进行持久化以备后续的处理。
diff --git a/Day61-65/61.网络爬虫和相关工具.md b/Day61-65/61.网络爬虫和相关工具.md
deleted file mode 100644
index 157fc8f..0000000
--- a/Day61-65/61.网络爬虫和相关工具.md
+++ /dev/null
@@ -1,319 +0,0 @@
-## 网络爬虫和相关工具
-
-### 网络爬虫的概念
-
-网络爬虫（web crawler），以前经常称之为网络蜘蛛（spider），是按照一定的规则自动浏览万维网并获取信息的机器人程序（或脚本），曾经被广泛的应用于互联网搜索引擎。使用过互联网和浏览器的人都知道，网页中除了供用户阅读的文字信息之外，还包含一些超链接。网络爬虫系统正是通过网页中的超链接信息不断获得网络上的其它页面。正因如此，网络数据采集的过程就像一个爬虫或者蜘蛛在网络上漫游，所以才被形象的称为网络爬虫或者网络蜘蛛。
-
-#### 爬虫的应用领域
-
-在理想的状态下，所有ICP（Internet Content Provider）都应该为自己的网站提供API接口来共享它们允许其他程序获取的数据，在这种情况下爬虫就不是必需品，国内比较有名的电商平台（如淘宝、京东等）、社交平台（如腾讯微博等）等网站都提供了自己的Open API，但是这类Open API通常会对可以抓取的数据以及抓取数据的频率进行限制。对于大多数的公司而言，及时的获取行业相关数据是企业生存的重要环节之一，然而大部分企业在行业数据方面的匮乏是其与生俱来的短板，合理的利用爬虫来获取数据并从中提取出有商业价值的信息是至关重要的。当然爬虫还有很多重要的应用领域，下面列举了其中的一部分：
-
-1. 搜索引擎
-2. 新闻聚合
-3. 社交应用
-4. 舆情监控
-5. 行业数据
-
-### 合法性和背景调研
-
-#### 爬虫合法性探讨
-
-1. 网络爬虫领域目前还属于拓荒阶段，虽然互联网世界已经通过自己的游戏规则建立起一定的道德规范(Robots协议，全称是“网络爬虫排除标准”)，但法律部分还在建立和完善中，也就是说，现在这个领域暂时还是灰色地带。
-2. “法不禁止即为许可”，如果爬虫就像浏览器一样获取的是前端显示的数据（网页上的公开信息）而不是网站后台的私密敏感信息，就不太担心法律法规的约束，因为目前大数据产业链的发展速度远远超过了法律的完善程度。
-3. 在爬取网站的时候，需要限制自己的爬虫遵守Robots协议，同时控制网络爬虫程序的抓取数据的速度；在使用数据的时候，必须要尊重网站的知识产权（从Web 2.0时代开始，虽然Web上的数据很多都是由用户提供的，但是网站平台是投入了运营成本的，当用户在注册和发布内容时，平台通常就已经获得了对数据的所有权、使用权和分发权）。如果违反了这些规定，在打官司的时候败诉几率相当高。
-
-#### Robots.txt文件
-
-大多数网站都会定义robots.txt文件，下面以淘宝的[robots.txt](http://www.taobao.com/robots.txt)文件为例，看看该网站对爬虫有哪些限制。
-
-```
-User-agent:  Baiduspider
-Allow:  /article
-Allow:  /oshtml
-Disallow:  /product/
-Disallow:  /
-
-User-Agent:  Googlebot
-Allow:  /article
-Allow:  /oshtml
-Allow:  /product
-Allow:  /spu
-Allow:  /dianpu
-Allow:  /oversea
-Allow:  /list
-Disallow:  /
-
-User-agent:  Bingbot
-Allow:  /article
-Allow:  /oshtml
-Allow:  /product
-Allow:  /spu
-Allow:  /dianpu
-Allow:  /oversea
-Allow:  /list
-Disallow:  /
-
-User-Agent:  360Spider
-Allow:  /article
-Allow:  /oshtml
-Disallow:  /
-
-User-Agent:  Yisouspider
-Allow:  /article
-Allow:  /oshtml
-Disallow:  /
-
-User-Agent:  Sogouspider
-Allow:  /article
-Allow:  /oshtml
-Allow:  /product
-Disallow:  /
-
-User-Agent:  Yahoo!  Slurp
-Allow:  /product
-Allow:  /spu
-Allow:  /dianpu
-Allow:  /oversea
-Allow:  /list
-Disallow:  /
-
-User-Agent:  *
-Disallow:  /
-```
-
-注意上面robots.txt第一段的最后一行，通过设置“Disallow: /”禁止百度爬虫访问除了“Allow”规定页面外的其他所有页面。因此当你在百度搜索“淘宝”的时候，搜索结果下方会出现：“由于该网站的robots.txt文件存在限制指令（限制搜索引擎抓取），系统无法提供该页面的内容描述”。百度作为一个搜索引擎，至少在表面上遵守了淘宝网的robots.txt协议，所以用户不能从百度上搜索到淘宝内部的产品信息。
-
-![](./res/baidu-search-taobao.png) 
-
-### 相关工具介绍
-
-#### HTTP协议
-
-在开始讲解爬虫之前，我们稍微对HTTP（超文本传输协议）做一些回顾，因为我们在网页上看到的内容通常是浏览器执行HTML语言得到的结果，而HTTP就是传输HTML数据的协议。HTTP和其他很多应用级协议一样是构建在TCP（传输控制协议）之上的，它利用了TCP提供的可靠的传输服务实现了Web应用中的数据交换。按照维基百科上的介绍，设计HTTP最初的目的是为了提供一种发布和接收[HTML](https://zh.wikipedia.org/wiki/HTML)页面的方法，也就是说这个协议是浏览器和Web服务器之间传输的数据的载体。关于这个协议的详细信息以及目前的发展状况，大家可以阅读阮一峰老师的[《HTTP 协议入门》](http://www.ruanyifeng.com/blog/2016/08/http.html)、[《互联网协议入门》](http://www.ruanyifeng.com/blog/2012/05/internet_protocol_suite_part_i.html)系列以及[《图解HTTPS协议》](http://www.ruanyifeng.com/blog/2014/09/illustration-ssl.html)进行了解，下图是我在四川省网络通信技术重点实验室工作期间用开源协议分析工具Ethereal（抓包工具WireShark的前身）截取的访问百度首页时的HTTP请求和响应的报文（协议数据），由于Ethereal截取的是经过网络适配器的数据，因此可以清晰的看到从物理链路层到应用层的协议数据。
-
-HTTP请求（请求行+请求头+空行+[消息体]）：
-
-![](./res/http-request.png)
-
-HTTP响应（响应行+响应头+空行+消息体）：
-
-![](./res/http-response.png)
-
-> 说明：但愿这两张如同泛黄照片般的截图帮助你大概的了解到HTTP是一个怎样的协议。 
-
-#### 相关工具
-
-1. Chrome Developer Tools：谷歌浏览器内置的开发者工具。
-
-   ![](./res/chrome-developer-tools.png)
-
-2. Postman：功能强大的网页调试与RESTful请求工具。
-
-   ![](./res/postman.png)
-
-3. HTTPie：命令行HTTP客户端。
-
-   ```Bash
-   pip3 install httpie
-   ```
-
-   ```Bash
-   http --header http://www.scu.edu.cn
-   HTTP/1.1 200 OK
-   Accept-Ranges: bytes
-   Cache-Control: private, max-age=600
-   Connection: Keep-Alive
-   Content-Encoding: gzip
-   Content-Language: zh-CN
-   Content-Length: 14403
-   Content-Type: text/html
-   Date: Sun, 27 May 2018 15:38:25 GMT
-   ETag: "e6ec-56d3032d70a32-gzip"
-   Expires: Sun, 27 May 2018 15:48:25 GMT
-   Keep-Alive: timeout=5, max=100
-   Last-Modified: Sun, 27 May 2018 13:44:22 GMT
-   Server: VWebServer
-   Vary: User-Agent,Accept-Encoding
-   X-Frame-Options: SAMEORIGIN
-   ```
-
-4. `builtwith`库：识别网站所用技术的工具。
-
-   ```Bash
-   pip3 install builtwith
-   ```
-
-   ```Python
-   >>> import builtwith
-   >>> builtwith.parse('http://www.bootcss.com/')
-   {'web-servers': ['Nginx'], 'font-scripts': ['Font Awesome'], 'javascript-frameworks': ['Lo-dash', 'Underscore.js', 'Vue.js', 'Zepto', 'jQuery'], 'web-frameworks': ['Twitter Bootstrap']}
-   >>>
-   >>> import ssl
-   >>> ssl._create_default_https_context = ssl._create_unverified_context
-   >>> builtwith.parse('https://www.jianshu.com/')
-   {'web-servers': ['Tengine'], 'web-frameworks': ['Twitter Bootstrap', 'Ruby on Rails'], 'programming-languages': ['Ruby']}
-   ```
-
-5. `python-whois`库：查询网站所有者的工具。
-
-   ```Bash
-   pip3 install python-whois
-   ```
-
-   ```Python
-   >>> import whois
-   >>> whois.whois('baidu.com')
-   {'domain_name': ['BAIDU.COM', 'baidu.com'], 'registrar': 'MarkMonitor, Inc.', 'whois_server': 'whois.markmonitor.com', 'referral_url': None, 'updated_date': [datetime.datetime(2017, 7, 28, 2, 36, 28), datetime.datetime(2017, 7, 27, 19, 36, 28)], 'creation_date': [datetime.datetime(1999, 10, 11, 11, 5, 17), datetime.datetime(1999, 10, 11, 4, 5, 17)], 'expiration_date': [datetime.datetime(2026, 10, 11, 11, 5, 17), datetime.datetime(2026, 10, 11, 0, 0)], 'name_servers': ['DNS.BAIDU.COM', 'NS2.BAIDU.COM', 'NS3.BAIDU.COM', 'NS4.BAIDU.COM', 'NS7.BAIDU.COM', 'dns.baidu.com', 'ns4.baidu.com', 'ns3.baidu.com', 'ns7.baidu.com', 'ns2.baidu.com'], 'status': ['clientDeleteProhibited https://icann.org/epp#clientDeleteProhibited', 'clientTransferProhibited https://icann.org/epp#clientTransferProhibited', 'clientUpdateProhibited https://icann.org/epp#clientUpdateProhibited', 'serverDeleteProhibited https://icann.org/epp#serverDeleteProhibited', 'serverTransferProhibited https://icann.org/epp#serverTransferProhibited', 'serverUpdateProhibited https://icann.org/epp#serverUpdateProhibited', 'clientUpdateProhibited (https://www.icann.org/epp#clientUpdateProhibited)', 'clientTransferProhibited (https://www.icann.org/epp#clientTransferProhibited)', 'clientDeleteProhibited (https://www.icann.org/epp#clientDeleteProhibited)', 'serverUpdateProhibited (https://www.icann.org/epp#serverUpdateProhibited)', 'serverTransferProhibited (https://www.icann.org/epp#serverTransferProhibited)', 'serverDeleteProhibited (https://www.icann.org/epp#serverDeleteProhibited)'], 'emails': ['abusecomplaints@markmonitor.com', 'whoisrelay@markmonitor.com'], 'dnssec': 'unsigned', 'name': None, 'org': 'Beijing Baidu Netcom Science Technology Co., Ltd.', 'address': None, 'city': None, 'state': 'Beijing', 'zipcode': None, 'country': 'CN'}
-   ```
-
-6. `robotparser`模块：解析`robots.txt`的工具。
-
-   ```Python
-   >>> from urllib import robotparser
-   >>> parser = robotparser.RobotFileParser()
-   >>> parser.set_url('https://www.taobao.com/robots.txt')
-   >>> parser.read()
-   >>> parser.can_fetch('Baiduspider', 'http://www.taobao.com/article')
-   True
-   >>> parser.can_fetch('Baiduspider', 'http://www.taobao.com/product')
-   False
-   ```
-
-### 一个简单的爬虫
-
-一个基本的爬虫通常分为数据采集（网页下载）、数据处理（网页解析）和数据存储（将有用的信息持久化）三个部分的内容，当然更为高级的爬虫在数据采集和处理时会使用并发编程或分布式技术，这就需要有调度器（安排线程或进程执行对应的任务）、后台管理程序（监控爬虫的工作状态以及检查数据抓取的结果）等的参与。
-
-![](./res/crawler-workflow.png)
-
-一般来说，爬虫的工作流程包括以下几个步骤：
-
-1. 设定抓取目标（种子页面/起始页面）并获取网页。
-2. 当服务器无法访问时，按照指定的重试次数尝试重新下载页面。
-3. 在需要的时候设置用户代理或隐藏真实IP，否则可能无法访问页面。
-4. 对获取的页面进行必要的解码操作然后抓取出需要的信息。
-5. 在获取的页面中通过某种方式（如正则表达式）抽取出页面中的链接信息。
-6. 对链接进行进一步的处理（获取页面并重复上面的动作）。
-7. 将有用的信息进行持久化以备后续的处理。
-
-下面的例子给出了一个从“搜狐体育”上获取NBA新闻标题和链接的爬虫。
-
-```Python
-import re
-from collections import deque
-from urllib.parse import urljoin
-
-import requests
-
-LI_A_PATTERN = re.compile(r'<li class="item">.*?</li>')
-A_TEXT_PATTERN = re.compile(r'<a\s+[^>]*?>(.*?)</a>')
-A_HREF_PATTERN = re.compile(r'<a\s+[^>]*?href="(.*?)"\s*[^>]*?>')
-
-
-def decode_page(page_bytes, charsets):
-    """通过指定的字符集对页面进行解码"""
-    for charset in charsets:
-        try:
-            return page_bytes.decode(charset)
-        except UnicodeDecodeError:
-            pass
-
-
-def get_matched_parts(content_string, pattern):
-    """从字符串中提取所有跟正则表达式匹配的内容"""
-    return pattern.findall(content_string, re.I) \
-        if content_string else []
-
-
-def get_matched_part(content_string, pattern, group_no=1):
-    """从字符串中提取跟正则表达式匹配的内容"""
-    match = pattern.search(content_string)
-    if match:
-        return match.group(group_no)
-
-
-def get_page_html(seed_url, *, charsets=('utf-8', )):
-    """获取页面的HTML代码"""
-    resp = requests.get(seed_url)
-    if resp.status_code == 200:
-        return decode_page(resp.content, charsets)
-
-
-def repair_incorrect_href(current_url, href):
-    """修正获取的href属性"""
-    if href.startswith('//'):
-        href = urljoin('http://', href)
-    elif href.startswith('/'):
-        href = urljoin(current_url, href)
-    return href if href.startswith('http') else ''
-
-
-def start_crawl(seed_url, pattern, *, max_depth=-1):
-    """开始爬取数据"""
-    new_urls, visited_urls = deque(), set()
-    new_urls.append((seed_url, 0))
-    while new_urls:
-        current_url, depth = new_urls.popleft()
-        if depth != max_depth:
-            page_html = get_page_html(current_url, charsets=('utf-8', 'gbk'))
-            contents = get_matched_parts(page_html, pattern)
-            for content in contents:
-                text = get_matched_part(content, A_TEXT_PATTERN)
-                href = get_matched_part(content, A_HREF_PATTERN)
-                if href:
-                    href = repair_incorrect_href(href)
-                print(text, href)
-                if href and href not in visited_urls:
-                    new_urls.append((href, depth + 1))
-
-
-def main():
-    """主函数"""
-    start_crawl(
-        seed_url='http://sports.sohu.com/nba_a.shtml',
-        pattern=LI_A_PATTERN,
-        max_depth=2
-    )
-
-
-if __name__ == '__main__':
-    main()
-```
-
-### 爬虫注意事项
-
-通过上面的例子，我们对爬虫已经有了一个感性的认识，在编写爬虫时有以下一些注意事项：
-
-1. 上面的代码使用了`requests`三方库来获取网络资源，这是一个非常优质的三方库，关于它的用法可以参考它的[官方文档](https://requests.readthedocs.io/zh_CN/latest/)。
-
-2. 上面的代码中使用了双端队列（`deque`）来保存待爬取的URL。双端队列相当于是使用链式存储结构的`list`，在双端队列的头尾添加和删除元素性能都比较好，刚好可以用来构造一个FIFO（先进先出）的队列结构。
-
-3. 处理相对路径。有的时候我们从页面中获取的链接不是一个完整的绝对链接而是一个相对链接，这种情况下需要将其与URL前缀进行拼接（`urllib.parse`中的`urljoin()`函数可以完成此项操作）。
-
-4. 设置代理服务。有些网站会限制访问的区域（例如美国的Netflix屏蔽了很多国家的访问），有些爬虫需要隐藏自己的身份，在这种情况下可以设置使用代理服务器，代理服务器有免费的服务器和付费的商业服务器，但后者稳定性和可用性都更好，强烈建议在商业项目中使用付费的商业代理服务器。如果使用`requests`三方库，可以在请求方法中添加`proxies`参数来指定代理服务器；如果使用标准库，可以通过修改`urllib.request`中的`ProxyHandler`来为请求设置代理服务器。
-
-5. 限制下载速度。如果我们的爬虫获取网页的速度过快，可能就会面临被封禁或者产生“损害动产”的风险（这个可能会导致吃官司且败诉），可以在两次获取页面数据之间添加延时从而对爬虫进行限速。
-
-6. 避免爬虫陷阱。有些网站会动态生成页面内容，这会导致产生无限多的页面（例如在线万年历通常会有无穷无尽的链接）。可以通过记录到达当前页面经过了多少个链接（链接深度）来解决该问题，当达到事先设定的最大深度时，爬虫就不再像队列中添加该网页中的链接了。
-
-7. 避开蜜罐链接。网站上的有些链接是浏览器中不可见的，这种链接通常是故意诱使爬虫去访问的蜜罐，一旦访问了这些链接，服务器就会判定请求是来自于爬虫的，这样可能会导致被服务器封禁IP地址。如何避开这些蜜罐链接我们在后面为大家进行讲解。
-
-8. SSL相关问题。如果使用标准库的`urlopen`打开一个HTTPS链接时会验证一次SSL证书，如果不做出处理会产生错误提示“SSL: CERTIFICATE_VERIFY_FAILED”，可以通过以下两种方式加以解决：
-
-   - 使用未经验证的上下文
-
-     ```Python
-     import ssl
-     
-     request = urllib.request.Request(url='...', headers={...}) 
-     context = ssl._create_unverified_context()
-     web_page = urllib.request.urlopen(request, context=context)
-     ```
-
-   - 设置全局性取消证书验证
-
-     ```Python
-     import ssl
-     
-     ssl._create_default_https_context = ssl._create_unverified_context
-     ```
-
diff --git a/Day61-65/62-1.用Python获取网络资源.md b/Day61-65/62-1.用Python获取网络资源.md
new file mode 100644
index 0000000..ab7ede2
--- /dev/null
+++ b/Day61-65/62-1.用Python获取网络资源.md
@@ -0,0 +1,133 @@
+## 第32课：用Python获取网络数据
+
+网络数据采集是 Python 语言非常擅长的领域，上节课我们讲到，实现网络数据采集的程序通常称之为网络爬虫或蜘蛛程序。即便是在大数据时代，数据对于中小企业来说仍然是硬伤和短板，有些数据需要通过开放或付费的数据接口来获得，其他的行业数据和竞对数据则必须要通过网络数据采集的方式来获得。不管使用哪种方式获取网络数据资源，Python 语言都是非常好的选择，因为 Python 的标准库和三方库都对网络数据采集提供了良好的支持。
+
+### requests库
+
+要使用 Python 获取网络数据，我们推荐大家使用名为`requests` 的三方库，这个库我们在之前的课程中其实已经使用过了。按照官方网站的解释，`requests`是基于 Python 标准库进行了封装，简化了通过 HTTP 或 HTTPS 访问网络资源的操作。上课我们提到过，HTTP 是一个请求响应式的协议，当我们在浏览器中输入正确的 [URL](https://developer.mozilla.org/zh-CN/docs/Learn/Common_questions/What_is_a_URL)（通常也称为网址）并按下 Enter 键时，我们就向网络上的 [Web 服务器](https://developer.mozilla.org/zh-CN/docs/Learn/Common_questions/What_is_a_web_server)发送了一个 HTTP 请求，服务器在收到请求后会给我们一个 HTTP 响应。在 Chrome 浏览器中的菜单中打开“开发者工具”切换到“Network”选项卡就能够查看 HTTP 请求和响应到底是什么样子的，如下图所示。
+
+![](https://gitee.com/jackfrued/mypic/raw/master/20210822093434.png)
+
+通过`requests`库，我们可以让 Python 程序向浏览器一样向 Web 服务器发起请求，并接收服务器返回的响应，从响应中我们就可以提取出想要的数据。浏览器呈现给我们的网页是用 [HTML](https://developer.mozilla.org/zh-CN/docs/Web/HTML) 编写的，浏览器相当于是 HTML 的解释器环境，我们看到的网页中的内容都包含在 HTML 的标签中。在获取到 HTML 代码后，就可以从标签的属性或标签体中提取内容。下面例子演示了如何获取网页 HTML 代码，我们通过`requests`库的`get`函数，获取了搜狐首页的代码。
+
+```Python
+import requests
+
+resp = requests.get('https://www.sohu.com/')
+if resp.status_code == 200:
+    print(resp.text)
+```
+
+> **说明**：上面代码中的变量`resp`是一个`Response`对象（`requests`库封装的类型），通过该对象的`status_code`属性可以获取响应状态码，而该对象的`text`属性可以帮我们获取到页面的 HTML 代码。
+
+由于`Response`对象的`text`是一个字符串，所以我们可以利用之前讲过的正则表达式的知识，从页面的 HTML 代码中提取新闻的标题和链接，代码如下所示。
+
+```Python
+import re
+
+import requests
+
+pattern = re.compile(r'<a.*?href="(.*?)".*?title="(.*?)".*?>')
+resp = requests.get('https://www.sohu.com/')
+if resp.status_code == 200:
+    all_matches = pattern.findall(resp.text)
+    for href, title in all_matches:
+        print(href)
+        print(title)
+```
+
+除了文本内容，我们也可以使用`requests`库通过 URL 获取二进制资源。下面的例子演示了如何获取百度 Logo 并保存到名为`baidu.png`的本地文件中。可以在百度的首页上右键点击百度Logo，并通过“复制图片地址”菜单项获取图片的 URL。
+
+```Python
+import requests
+
+resp = requests.get('https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png')
+with open('baidu.png', 'wb') as file:
+    file.write(resp.content)
+```
+
+> **说明**：`Response`对象的`content`属性可以获得服务器响应的二进制数据。
+
+`requests`库非常好用而且功能上也比较强大和完整，具体的内容我们在使用的过程中为大家一点点剖析。想解锁关于`requests`库更多的知识，可以阅读它的[官方文档](https://docs.python-requests.org/zh_CN/latest/)。
+
+### 编写爬虫代码
+
+接下来，我们以“豆瓣电影”为例，为大家讲解如何编写爬虫代码。按照上面提供的方法，我们先使用`requests`获取到网页的HTML代码，然后将整个代码看成一个长字符串，这样我们就可以使用正则表达式的捕获组从字符串提取我们需要的内容。下面的代码演示了如何从[豆瓣电影](https://movie.douban.com/)获取排前250名的电影的名称。[豆瓣电影Top250](https://movie.douban.com/top250)的页面结构和对应代码如下图所示，可以看出，每页共展示了25部电影，如果要获取到 Top250 数据，我们共需要访问10个页面，对应的地址是<https://movie.douban.com/top250?start=xxx>，这里的`xxx`如果为`0`就是第一页，如果`xxx`的值是`100`，那么我们可以访问到第五页。为了代码简单易读，我们只获取电影的标题和评分。
+
+![](https://gitee.com/jackfrued/mypic/raw/master/20210822093447.png)
+
+```Python
+import random
+import re
+import time
+
+import requests
+
+for page in range(1, 11):
+    resp = requests.get(
+        url=f'https://movie.douban.com/top250?start={(page - 1) * 25}',
+        # 如果不设置HTTP请求头中的User-Agent，豆瓣会检测出不是浏览器而阻止我们的请求。
+        # 通过get函数的headers参数设置User-Agent的值，具体的值可以在浏览器的开发者工具查看到。
+        # 用爬虫访问大部分网站时，将爬虫伪装成来自浏览器的请求都是非常重要的一步。
+        headers={'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'}
+    )
+    # 通过正则表达式获取class属性为title且标签体不以&开头的span标签并用捕获组提取标签内容
+    pattern1 = re.compile(r'<span class="title">([^&]*?)</span>')
+    titles = pattern1.findall(resp.text)
+    # 通过正则表达式获取class属性为rating_num的span标签并用捕获组提取标签内容
+    pattern2 = re.compile(r'<span class="rating_num".*?>(.*?)</span>')
+    ranks = pattern2.findall(resp.text)
+    # 使用zip压缩两个列表，循环遍历所有的电影标题和评分
+    for title, rank in zip(titles, ranks):
+        print(title, rank)
+    # 随机休眠1-5秒，避免爬取页面过于频繁
+    time.sleep(random.random() * 4 + 1)
+```
+
+> **说明**：通过分析豆瓣网的robots协议，我们发现豆瓣网并不拒绝百度爬虫获取它的数据，因此我们也可以将爬虫伪装成百度的爬虫，将`get`函数的`headers`参数修改为：`headers={'User-Agent': 'BaiduSpider'}`。
+
+### 使用 IP 代理
+
+让爬虫程序隐匿自己的身份对编写爬虫程序来说是比较重要的，很多网站对爬虫都比较反感的，因为爬虫会耗费掉它们很多的网络带宽并制造很多无效的流量。要隐匿身份通常需要使用**商业 IP 代理**（如蘑菇代理、芝麻代理、快代理等），让被爬取的网站无法获取爬虫程序来源的真实 IP 地址，也就无法简单的通过 IP 地址对爬虫程序进行封禁。
+
+下面以[蘑菇代理](http://www.moguproxy.com/)为例，为大家讲解商业 IP 代理的使用方法。首先需要在该网站注册一个账号，注册账号后就可以[购买](http://www.moguproxy.com/buy)相应的套餐来获得商业 IP 代理。作为商业用途，建议大家购买不限量套餐，这样可以根据实际需要获取足够多的代理 IP 地址；作为学习用途，可以购买包时套餐或根据自己的需求来决定。蘑菇代理提供了两种接入代理的方式，分别是 API 私密代理和 HTTP 隧道代理，前者是通过请求蘑菇代理的 API 接口获取代理服务器地址，后者是直接使用统一的入口（蘑菇代理提供的域名）进行接入。
+
+<img src="https://gitee.com/jackfrued/mypic/raw/master/20210829080647.png" width="75%">
+
+下面，我们以HTTP隧道代理为例，为大家讲解接入 IP 代理的方式，大家也可以直接参考蘑菇代理官网提供的代码来为爬虫设置代理。
+
+```Python
+import requests
+
+APP_KEY = 'Wnp******************************XFx'
+PROXY_HOST = 'secondtransfer.moguproxy.com:9001'
+
+for page in range(1, 11):
+    resp = requests.get(
+        url=f'https://movie.douban.com/top250?start={(page - 1) * 25}',
+        # 需要在HTTP请求头设置代理的身份认证方式
+        headers={
+            'Proxy-Authorization': f'Basic {APP_KEY}',
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
+            'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.6,en;q=0.4'
+        },
+        # 设置代理服务器
+        proxies={
+            'http': f'http://{PROXY_HOST}',
+            'https': f'https://{PROXY_HOST}'
+        },
+        verify=False
+    )
+    pattern1 = re.compile(r'<span class="title">([^&]*?)</span>')
+    titles = pattern1.findall(resp.text)
+    pattern2 = re.compile(r'<span class="rating_num".*?>(.*?)</span>')
+    ranks = pattern2.findall(resp.text)
+    for title, rank in zip(titles, ranks):
+        print(title, rank)
+```
+
+> **说明**：上面的代码需要修改`APP_KEY`为自己创建的订单对应的`Appkey`值，这个值可以在用户中心用户订单中查看到。蘑菇代理提供了免费的 API 代理和 HTTP 隧道代理试用，但是试用的代理接通率不能保证，建议大家还是直接购买一个在自己支付能力范围内的代理服务来体验。
+
+###  简单的总结
+
+Python 语言能做的事情真的很多，就网络数据采集这一项而言，Python 几乎是一枝独秀的，大量的企业和个人都在使用 Python 从网络上获取自己需要的数据，这可能也是你将来日常工作的一部分。另外，用编写正则表达式的方式从网页中提取内容虽然可行，但是写出一个能够满足需求的正则表达式本身也不是件容易的事情，这一点对于新手来说尤为明显。在下一节课中，我们将会为大家介绍另外两种从页面中提取数据的方法，虽然从性能上来讲，它们可能不如正则表达式，但是却降低了编码的复杂性，相信大家会喜欢上它们的。
diff --git a/Day61-65/62-2.用Python解析HTML页面.md b/Day61-65/62-2.用Python解析HTML页面.md
new file mode 100644
index 0000000..b357bcb
--- /dev/null
+++ b/Day61-65/62-2.用Python解析HTML页面.md
@@ -0,0 +1,149 @@
+## 第33课：用Python解析HTML页面
+
+在前面的课程中，我们讲到了使用`request`三方库获取网络资源，还介绍了一些前端的基础知识。接下来，我们继续探索如何解析 HTML 代码，从页面中提取出有用的信息。之前，我们尝试过用正则表达式的捕获组操作提取页面内容，但是写出一个正确的正则表达式也是一件让人头疼的事情。为了解决这个问题，我们得先深入的了解一下 HTML 页面的结构，并在此基础上研究另外的解析页面的方法。
+
+### HTML 页面的结构
+
+我们在浏览器中打开任意一个网站，然后通过鼠标右键菜单，选择“显示网页源代码”菜单项，就可以看到网页对应的 HTML 代码。
+
+![image-20210822094218269](https://gitee.com/jackfrued/mypic/raw/master/20210822094218.png)
+
+代码的第`1`行是文档类型声明，第`2`行的`<html>`标签是整个页面根标签的开始标签，最后一行是根标签的结束标签`</html>`。`<html>`标签下面有两个子标签`<head>`和`<body>`，放在`<body>`标签下的内容会显示在浏览器窗口中，这部分内容是网页的主体；放在`<head>`标签下的内容不会显示在浏览器窗口中，但是却包含了页面重要的元信息，通常称之为网页的头部。HTML 页面大致的代码结构如下所示。
+
+```HTML
+<!doctype html>
+<html>
+    <head>
+        <!-- 页面的元信息，如字符编码、标题、关键字、媒体查询等 -->
+    </head>
+    <body>
+        <!-- 页面的主体，显示在浏览器窗口中的内容 -->
+    </body>
+</html>
+```
+
+标签、层叠样式表（CSS）、JavaScript 是构成 HTML 页面的三要素，其中标签用来承载页面要显示的内容，CSS 负责对页面的渲染，而 JavaScript 用来控制页面的交互式行为。要实现 HTML 页面的解析，可以使用 XPath 的语法，它原本是 XML 的一种查询语法，可以根据 HTML 标签的层次结构提取标签中的内容或标签属性；此外，也可以使用 CSS 选择器来定位页面元素，就跟用 CSS 渲染页面元素是同样的道理。
+
+### XPath 解析
+
+XPath 是在 XML（eXtensible Markup Language）文档中查找信息的一种语法，XML 跟 HTML 类似也是一种用标签承载数据的标签语言，不同之处在于 XML 的标签是可扩展的，可以自定义的，而且 XML 对语法有更严格的要求。XPath 使用路径表达式来选取 XML 文档中的节点或者节点集，这里所说的节点包括元素、属性、文本、命名空间、处理指令、注释、根节点等。下面我们通过一个例子来说明如何使用 XPath 对页面进行解析。
+
+```XML
+<?xml version="1.0" encoding="UTF-8"?>
+<bookstore>
+    <book>
+      <title lang="eng">Harry Potter</title>
+      <price>29.99</price>
+    </book>
+    <book>
+      <title lang="zh">Learning XML</title>
+      <price>39.95</price>
+    </book>
+</bookstore>
+```
+
+对于上面的 XML 文件，我们可以用如下所示的 XPath 语法获取文档中的节点。
+
+| 路径表达式      | 结果                                                         |
+| --------------- | ------------------------------------------------------------ |
+| `/bookstore`    | 选取根元素 bookstore。**注意**：假如路径起始于正斜杠( / )，则此路径始终代表到某元素的绝对路径！ |
+| `//book`        | 选取所有 book 子元素，而不管它们在文档中的位置。             |
+| `//@lang`       | 选取名为 lang 的所有属性。                                  |
+| `/bookstore/book[1]`               | 选取属于 bookstore 子元素的第一个 book 元素。                |
+| `/bookstore/book[last()]`          | 选取属于 bookstore 子元素的最后一个 book 元素。              |
+| `/bookstore/book[last()-1]`        | 选取属于 bookstore 子元素的倒数第二个 book 元素。            |
+| `/bookstore/book[position()<3]`    | 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。    |
+| `//title[@lang]`                   | 选取所有拥有名为 lang 的属性的 title 元素。                  |
+| `//title[@lang='eng']`             | 选取所有 title 元素，且这些元素拥有值为 eng 的 lang 属性。   |
+| `/bookstore/book[price>35.00]`     | 选取 bookstore 元素的所有 book 元素，且其中的 price 元素的值须大于 35.00。 |
+| `/bookstore/book[price>35.00]/title` | 选取 bookstore 元素中的 book 元素的所有 title 元素，且其中的 price 元素的值须大于 35.00。 |
+
+XPath还支持通配符用法，如下所示。
+
+| 路径表达式     | 结果                              |
+| -------------- | --------------------------------- |
+| `/bookstore/*` | 选取 bookstore 元素的所有子元素。 |
+| `//*`          | 选取文档中的所有元素。            |
+| `//title[@*]`  | 选取所有带有属性的 title 元素。   |
+
+如果要选取多个节点，可以使用如下所示的方法。
+
+| 路径表达式                         | 结果                                                         |
+| ---------------------------------- | ------------------------------------------------------------ |
+| `//book/title \| //book/price`     | 选取 book 元素的所有 title 和 price 元素。                   |
+| `//title \| //price`               | 选取文档中的所有 title 和 price 元素。                       |
+| `/bookstore/book/title \| //price` | 选取属于 bookstore 元素的 book 元素的所有 title 元素，以及文档中所有的 price 元素。 |
+
+> **说明**：上面的例子来自于“菜鸟教程”网站上的 [XPath 教程](<https://www.runoob.com/xpath/xpath-tutorial.html>)，有兴趣的读者可以自行阅读原文。
+
+当然，如果不理解或不熟悉 XPath 语法，可以在浏览器的开发者工具中按照如下所示的方法查看元素的 XPath 语法，下图是在 Chrome 浏览器的开发者工具中查看豆瓣网电影详情信息中影片标题的 XPath 语法。
+
+![](https://gitee.com/jackfrued/mypic/raw/master/20210822093707.png)
+
+实现 XPath 解析需要三方库`lxml` 的支持，可以使用下面的命令安装`lxml`。
+
+```Bash
+pip install lxml
+```
+
+下面我们用 XPath 解析方式改写之前获取豆瓣电影 Top250的代码，如下所示。
+
+```Python
+from lxml import etree
+import requests
+
+for page in range(1, 11):
+    resp = requests.get(
+        url=f'https://movie.douban.com/top250?start={(page - 1) * 25}',
+        headers={'User-Agent': 'BaiduSpider'}
+    )
+    tree = etree.HTML(resp.text)
+    # 通过XPath语法从页面中提取电影标题
+    title_spans = tree.xpath('//*[@id="content"]/div/div[1]/ol/li/div/div[2]/div[1]/a/span[1]')
+    # 通过XPath语法从页面中提取电影评分
+    rank_spans = tree.xpath('//*[@id="content"]/div/div[1]/ol/li[1]/div/div[2]/div[2]/div/span[2]')
+    for title_span, rank_span in zip(title_spans, rank_spans):
+        print(title_span.text, rank_span.text)
+```
+
+### CSS 选择器解析
+
+对于熟悉 CSS 选择器和 JavaScript 的开发者来说，通过 CSS 选择器获取页面元素可能是更为简单的选择，因为浏览器中运行的 JavaScript 本身就可以`document`对象的`querySelector()`和`querySelectorAll()`方法基于 CSS 选择器获取页面元素。在 Python 中，我们可以利用三方库`beautifulsoup4`或`pyquery`来做同样的事情。Beautiful Soup 可以用来解析 HTML 和 XML 文档，修复含有未闭合标签等错误的文档，通过为待解析的页面在内存中创建一棵树结构，实现对从页面中提取数据操作的封装。可以用下面的命令来安装 Beautiful Soup。
+
+```Python
+pip install beautifulsoup4
+```
+
+下面是使用`bs4`改写的获取豆瓣电影Top250电影名称的代码。
+
+```Python
+import bs4
+import requests
+
+for page in range(1, 11):
+    resp = requests.get(
+        url=f'https://movie.douban.com/top250?start={(page - 1) * 25}',
+        headers={'User-Agent': 'BaiduSpider'}
+    )
+    # 创建BeautifulSoup对象
+    soup = bs4.BeautifulSoup(resp.text, 'lxml')
+    # 通过CSS选择器从页面中提取包含电影标题的span标签
+    title_spans = soup.select('div.info > div.hd > a > span:nth-child(1)')
+    # 通过CSS选择器从页面中提取包含电影评分的span标签
+    rank_spans = soup.select('div.info > div.bd > div > span.rating_num')
+    for title_span, rank_span in zip(title_spans, rank_spans):
+        print(title_span.text, rank_span.text)
+```
+
+关于 BeautifulSoup 更多的知识，可以参考它的[官方文档](https://www.crummy.com/software/BeautifulSoup/bs4/doc.zh/)。
+
+###  简单的总结
+
+下面我们对三种解析方式做一个简单比较。
+
+| 解析方式       | 对应的模块       | 速度   | 使用难度 |
+| -------------- | ---------------- | ------ | -------- |
+| 正则表达式解析 | `re`             | 快     | 困难     |
+| XPath 解析     | `lxml`           | 快     | 一般     |
+| CSS 选择器解析 | `bs4`或`pyquery` | 不确定 | 简单     |
+
diff --git a/Day61-65/62.数据采集和解析.md b/Day61-65/62.数据采集和解析.md
deleted file mode 100644
index 672cd0d..0000000
--- a/Day61-65/62.数据采集和解析.md
+++ /dev/null
@@ -1,382 +0,0 @@
-## 数据采集和解析
-
-通过上一个章节的讲解，我们已经了解到了开发一个爬虫需要做的工作以及一些常见的问题，下面我们给出一个爬虫开发相关技术的清单以及这些技术涉及到的标准库和第三方库，稍后我们会一一介绍这些内容。
-
-1. 下载数据 - **urllib** / **requests** / **aiohttp** / **httpx**。
-2. 解析数据 - **re** / **lxml** / **beautifulsoup4** / **pyquery**。
-3. 缓存和持久化 - **mysqlclient** / **sqlalchemy** / **peewee** / **redis** / **pymongo**。
-4. 生成数字签名 - **hashlib**。
-5. 序列化和压缩 - **pickle** / **json** / **zlib**。
-6. 调度器 - **multiprocessing** / **threading** / **concurrent.futures**。
-
-### HTML页面
-
-```HTML
-<!DOCTYPE html>
-<html>
-	<head>
-		<title>Home</title>
-		<style type="text/css">
-			/* 此处省略层叠样式表代码 */
-		</style>
-	</head>
-	<body>
-		<div class="wrapper">
-			<header>
-				<h1>Yoko's Kitchen</h1>
-				<nav>
-					<ul>
-						<li><a href="" class="current">Home</a></li>
-						<li><a href="">Classes</a></li>
-						<li><a href="">Catering</a></li>
-						<li><a href="">About</a></li>
-						<li><a href="">Contact</a></li>
-					</ul>
-				</nav>
-			</header>
-			<section class="courses">
-				<article>
-					<figure>
-						<img src="images/bok-choi.jpg" alt="Bok Choi" />
-						<figcaption>Bok Choi</figcaption>
-					</figure>
-					<hgroup>
-						<h2>Japanese Vegetarian</h2>
-						<h3>Five week course in London</h3>
-					</hgroup>
-					<p>A five week introduction to traditional Japanese vegetarian meals, teaching you a selection of rice and noodle dishes.</p>
-				</article>    
-				<article>
-					<figure>
-						<img src="images/teriyaki.jpg" alt="Teriyaki sauce" />
-						<figcaption>Teriyaki Sauce</figcaption>
-					</figure>
-					<hgroup>
-						<h2>Sauces Masterclass</h2>
-						<h3>One day workshop</h3>
-					</hgroup>
-					<p>An intensive one-day course looking at how to create the most delicious sauces for use in a range of Japanese cookery.</p>
-				</article>    
-			</section>
-			<aside>
-				<section class="popular-recipes">
-					<h2>Popular Recipes</h2>
-					<a href="">Yakitori (grilled chicken)</a>
-					<a href="">Tsukune (minced chicken patties)</a>
-					<a href="">Okonomiyaki (savory pancakes)</a>
-					<a href="">Mizutaki (chicken stew)</a>
-				</section>
-				<section class="contact-details">
-					<h2>Contact</h2>
-					<p>Yoko's Kitchen<br>
-						27 Redchurch Street<br>
-						Shoreditch<br>
-						London E2 7DP</p>
-				</section>
-			</aside>
-			<footer>
-				&copy; 2011 Yoko's Kitchen
-			</footer>
-		</div>
-        <script>
-        	/* 此处省略JavaScript代码 */
-        </script>
-	</body>
-</html>
-```
-
-如上所示的HTML页面通常由三部分构成，分别是用来承载内容的Tag（标签）、负责渲染页面的CSS（层叠样式表）以及控制交互式行为的JavaScript。通常，我们可以在浏览器的右键菜单中通过“查看网页源代码”的方式获取网页的代码并了解页面的结构；当然，我们也可以通过浏览器提供的开发人员工具来了解更多的信息。
-
-#### 使用requests获取页面
-
-在上一节课的代码中我们使用了三方库`requests`来获取页面，下面我们对`requests`库的用法做进一步说明。
-
-1. GET请求和POST请求。
-
-   ```Python
-   import requests
-   
-   resp = requests.get('http://www.baidu.com/index.html')
-   print(resp.status_code)
-   print(resp.headers)
-   print(resp.cookies)
-   print(resp.content.decode('utf-8'))
-   
-   resp = requests.post('http://httpbin.org/post', data={'name': 'Hao', 'age': 40})
-   print(resp.text)
-   data = resp.json()
-   print(type(data))
-   ```
-
-2. URL参数和请求头。
-
-   ```Python
-   resp = requests.get(
-       url='https://movie.douban.com/top250',
-       headers={
-           'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) '
-                         'AppleWebKit/537.36 (KHTML, like Gecko) '
-                         'Chrome/83.0.4103.97 Safari/537.36',
-           'Accept': 'text/html,application/xhtml+xml,application/xml;'
-                     'q=0.9,image/webp,image/apng,*/*;'
-                     'q=0.8,application/signed-exchange;v=b3;q=0.9',
-           'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
-       }
-   )
-   print(resp.status_code)
-   ```
-
-3. 复杂的POST请求（文件上传）。
-
-   ```Python
-   resp = requests.post(
-   	url='http://httpbin.org/post',
-       files={'file': open('data.xlsx', 'rb')}
-   )
-   print(resp.text)
-   ```
-
-4. 操作Cookie。
-
-   ```Python
-   cookies = {'key1': 'value1', 'key2': 'value2'}
-   resp = requests.get('http://httpbin.org/cookies', cookies=cookies)
-   print(resp.text)
-   
-   jar = requests.cookies.RequestsCookieJar()
-   jar.set('tasty_cookie', 'yum', domain='httpbin.org', path='/cookies')
-   jar.set('gross_cookie', 'blech', domain='httpbin.org', path='/elsewhere')
-   resp = requests.get('http://httpbin.org/cookies', cookies=jar)
-   print(resp.text)
-   ```
-
-5. 设置代理服务器。
-
-   ```Python
-   requests.get('https://www.taobao.com', proxies={
-       'http': 'http://10.10.1.10:3128',
-       'https': 'http://10.10.1.10:1080',
-   })
-   ```
-   
-   > **说明**：关于`requests`库的相关知识，还是强烈建议大家自行阅读它的[官方文档](https://requests.readthedocs.io/zh_CN/latest/)。
-   
-6. 设置请求超时。
-
-   ```Python
-   requests.get('https://github.com', timeout=10)
-   ```
-
-### 页面解析
-
-#### 几种解析方式的比较
-
-| 解析方式       | 对应的模块    | 速度   | 使用难度 | 备注                                        |
-| -------------- | ------------- | ------ | -------- | ------------------------------------------- |
-| 正则表达式解析 | re            | 快     | 困难     | 常用正则表达式<br/>在线正则表达式测试       |
-| XPath解析      | lxml          | 快     | 一般     | 需要安装C语言依赖库<br/>唯一支持XML的解析器 |
-| CSS选择器解析  | bs4 / pyquery | 不确定 | 简单     |                                             |
-
-> **说明**：`BeautifulSoup`可选的解析器包括：Python标准库中的`html.parser`、`lxml`的HTML解析器、`lxml`的XML解析器和`html5lib`。
-
-#### 使用正则表达式解析页面
-
-如果你对正则表达式没有任何的概念，那么推荐先阅读[《正则表达式30分钟入门教程》](https://deerchao.cn/tutorials/regex/regex.htm)，然后再阅读我们之前讲解在Python中如何使用正则表达式一文。
-
-下面的例子演示了如何用正则表达式解析“豆瓣电影Top250”中的中文电影名称。
-
-```Python
-import random
-import re
-import time
-
-import requests
-
-PATTERN = re.compile(r'<a[^>]*?>\s*<span class="title">(.*?)</span>')
-
-for page in range(10):
-    resp = requests.get(
-        url=f'https://movie.douban.com/top250?start={page * 25}',
-        headers={
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) '
-                          'AppleWebKit/537.36 (KHTML, like Gecko) '
-                          'Chrome/83.0.4103.97 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;'
-                      'q=0.9,image/webp,image/apng,*/*;'
-                      'q=0.8,application/signed-exchange;v=b3;q=0.9',
-            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
-        },
-    )
-    items = PATTERN.findall(resp.text)
-    for item in items:
-        print(item)
-    time.sleep(random.randint(1, 5))
-```
-
-#### XPath解析和lxml
-
-XPath是在XML文档中查找信息的一种语法，它使用路径表达式来选取XML文档中的节点或者节点集。这里所说的XPath节点包括元素、属性、文本、命名空间、处理指令、注释、根节点等。
-
-```XML
-<?xml version="1.0" encoding="UTF-8"?>
-<bookstore>
-    <book>
-      <title lang="eng">Harry Potter</title>
-      <price>29.99</price>
-    </book>
-    <book>
-      <title lang="zh">三国演义</title>
-      <price>39.95</price>
-    </book>
-</bookstore>
-```
-对于上面的XML文件，我们可以用如下所示的XPath语法获取文档中的节点。
-
-| 路径表达式      | 结果                                                         |
-| --------------- | ------------------------------------------------------------ |
-| bookstore       | 选取 bookstore 元素的所有子节点。                            |
-| /bookstore      | 选取根元素 bookstore。注释：假如路径起始于正斜杠( / )，则此路径始终代表到某元素的绝对路径！ |
-| bookstore/book  | 选取属于 bookstore 的子元素的所有 book 元素。                |
-| //book          | 选取所有 book 子元素，而不管它们在文档中的位置。             |
-| bookstore//book | 选择属于 bookstore 元素的后代的所有 book 元素，而不管它们位于 bookstore 之下的什么位置。 |
-| //@lang         | 选取名为 lang 的所有属性。                                   |
-
-在使用XPath语法时，还可以使用XPath中的谓词。
-
-| 路径表达式                         | 结果                                                         |
-| ---------------------------------- | ------------------------------------------------------------ |
-| /bookstore/book[1]                 | 选取属于 bookstore 子元素的第一个 book 元素。                |
-| /bookstore/book[last()]            | 选取属于 bookstore 子元素的最后一个 book 元素。              |
-| /bookstore/book[last()-1]          | 选取属于 bookstore 子元素的倒数第二个 book 元素。            |
-| /bookstore/book[position()<3]      | 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。    |
-| //title[@lang]                     | 选取所有拥有名为 lang 的属性的 title 元素。                  |
-| //title[@lang='eng']               | 选取所有 title 元素，且这些元素拥有值为 eng 的 lang 属性。   |
-| /bookstore/book[price>35.00]       | 选取 bookstore 元素的所有 book 元素，且其中的 price 元素的值须大于 35.00。 |
-| /bookstore/book[price>35.00]/title | 选取 bookstore 元素中的 book 元素的所有 title 元素，且其中的 price 元素的值须大于 35.00。 |
-
-XPath还支持通配符用法，如下所示。
-
-| 路径表达式   | 结果                              |
-| ------------ | --------------------------------- |
-| /bookstore/* | 选取 bookstore 元素的所有子元素。 |
-| //*          | 选取文档中的所有元素。            |
-| //title[@*]  | 选取所有带有属性的 title 元素。   |
-
-如果要选取多个节点，可以使用如下所示的方法。
-
-| 路径表达式                       | 结果                                                         |
-| -------------------------------- | ------------------------------------------------------------ |
-| //book/title \| //book/price     | 选取 book 元素的所有 title 和 price 元素。                   |
-| //title \| //price               | 选取文档中的所有 title 和 price 元素。                       |
-| /bookstore/book/title \| //price | 选取属于 bookstore 元素的 book 元素的所有 title 元素，以及文档中所有的 price 元素。 |
-
-> **说明**：上面的例子来自于菜鸟教程网站上[XPath教程](<https://www.runoob.com/xpath/xpath-tutorial.html>)，有兴趣的读者可以自行阅读原文。
-
-当然，如果不理解或者不太熟悉XPath语法，可以在Chrome浏览器中按照如下所示的方法查看元素的XPath语法。
-
-![](./res/douban-xpath.png)
-
-下面的例子演示了如何用XPath解析“豆瓣电影Top250”中的中文电影名称。
-
-```Python
-from lxml import etree
-
-import requests
-
-for page in range(10):
-    resp = requests.get(
-        url=f'https://movie.douban.com/top250?start={page * 25}',
-        headers={
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) '
-                          'AppleWebKit/537.36 (KHTML, like Gecko) '
-                          'Chrome/83.0.4103.97 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;'
-                      'q=0.9,image/webp,image/apng,*/*;'
-                      'q=0.8,application/signed-exchange;v=b3;q=0.9',
-            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
-        }
-    )
-    html = etree.HTML(resp.text)
-    spans = html.xpath('/html/body/div[3]/div[1]/div/div[1]/ol/li/div/div[2]/div[1]/a/span[1]')
-    for span in spans:
-        print(span.text)
-```
-
-### BeautifulSoup的使用
-
-BeautifulSoup是一个可以从HTML或XML文件中提取数据的Python库。它能够通过你喜欢的转换器实现惯用的文档导航、查找、修改文档的方式。
-
-1. 遍历文档树
-   - 获取标签
-   - 获取标签属性
-   - 获取标签内容
-   - 获取子（孙）节点
-   - 获取父节点/祖先节点
-   - 获取兄弟节点
-2. 搜索树节点
-   - find / find_all
-   - select_one / select
-
-> **说明**：更多内容可以参考BeautifulSoup的[官方文档](https://beautifulsoup.readthedocs.io/zh_CN/v4.4.0/)。
-
-下面的例子演示了如何用CSS选择器解析“豆瓣电影Top250”中的中文电影名称。
-
-```Python
-import random
-import time
-
-import bs4
-import requests
-
-for page in range(10):
-    resp = requests.get(
-        url=f'https://movie.douban.com/top250?start={page * 25}',
-        headers={
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) '
-                          'AppleWebKit/537.36 (KHTML, like Gecko) '
-                          'Chrome/83.0.4103.97 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;'
-                      'q=0.9,image/webp,image/apng,*/*;'
-                      'q=0.8,application/signed-exchange;v=b3;q=0.9',
-            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
-        },
-    )
-    soup = bs4.BeautifulSoup(resp.text, 'lxml')
-    elements = soup.select('.info>div>a')
-    for element in elements:
-        span = element.select_one('.title')
-        print(span.text)
-    time.sleep(random.random() * 5)
-
-```
-
-### 例子 - 获取知乎发现上的问题链接
-
-```Python
-import re
-from urllib.parse import urljoin
-
-import bs4
-import requests
-
-
-def main():
-    headers = {'user-agent': 'Baiduspider'}
-    base_url = 'https://www.zhihu.com/'
-    resp = requests.get(urljoin(base_url, 'explore'), headers=headers)
-    soup = bs4.BeautifulSoup(resp.text, 'lxml')
-    href_regex = re.compile(r'^/question')
-    links_set = set()
-    for a_tag in soup.find_all('a', {'href': href_regex}):
-        if 'href' in a_tag.attrs:
-            href = a_tag.attrs['href']
-            full_url = urljoin(base_url, href)
-            links_set.add(full_url)
-    print('Total %d question pages found.' % len(links_set))
-    print(links_set)
-
-
-if __name__ == '__main__':
-    main()
-```
-
diff --git a/Day61-65/63-1.Python中的并发编程-1.md b/Day61-65/63-1.Python中的并发编程-1.md
new file mode 100644
index 0000000..1183e14
--- /dev/null
+++ b/Day61-65/63-1.Python中的并发编程-1.md
@@ -0,0 +1,382 @@
+## 第34课：Python中的并发编程-1
+
+现如今，我们使用的计算机早已是多 CPU 或多核的计算机，而我们使用的操作系统基本都支持“多任务”，这使得我们可以同时运行多个程序，也可以将一个程序分解为若干个相对独立的子任务，让多个子任务“并行”或“并发”的执行，从而缩短程序的执行时间，同时也让用户获得更好的体验。因此当下，不管用什么编程语言进行开发，实现“并行”或“并发”编程已经成为了程序员的标配技能。为了讲述如何在 Python 程序中实现“并行”或“并发”，我们需要先了解两个重要的概念：进程和线程。
+
+### 线程和进程
+
+我们通过操作系统运行一个程序会创建出一个或多个进程，进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动。简单的说，进程是操作系统分配存储空间的基本单位，每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据；操作系统管理所有进程的执行，为它们合理的分配资源。一个进程可以通过 fork 或 spawn 的方式创建新的进程来执行其他的任务，不过新的进程也有自己独立的内存空间，因此两个进程如果要共享数据，必须通过进程间通信机制来实现，具体的方式包括管道、信号、套接字等。
+
+一个进程还可以拥有多个执行线索，简单的说就是拥有多个可以获得 CPU 调度的执行单元，这就是所谓的线程。由于线程在同一个进程下，它们可以共享相同的上下文，因此相对于进程而言，线程间的信息共享和通信更加容易。当然在单核 CPU 系统中，多个线程不可能同时执行，因为在某个时刻只有一个线程能够获得 CPU，多个线程通过共享 CPU 执行时间的方式来达到并发的效果。
+
+在程序中使用多线程技术通常都会带来不言而喻的好处，最主要的体现在提升程序的性能和改善用户体验，今天我们使用的软件几乎都用到了多线程技术，这一点可以利用系统自带的进程监控工具（如 macOS 中的“活动监视器”、Windows 中的“任务管理器”）来证实，如下图所示。
+
+<img src="https://gitee.com/jackfrued/mypic/raw/master/20210822094243.png" width="80%">
+
+这里，我们还需要跟大家再次强调两个概念：**并发**（concurrency）和**并行**（parallel）。**并发**通常是指同一时刻只能有一条指令执行，但是多个线程对应的指令被快速轮换地执行。比如一个处理器，它先执行线程 A 的指令一段时间，再执行线程 B 的指令一段时间，再切回到线程 A 执行一段时间。由于处理器执行指令的速度和切换的速度极快，人们完全感知不到计算机在这个过程中有多个线程切换上下文执行的操作，这就使得宏观上看起来多个线程在同时运行，但微观上其实只有一个线程在执行。**并行**是指同一时刻，有多条指令在多个处理器上同时执行，并行必须要依赖于多个处理器，不论是从宏观上还是微观上，多个线程可以在同一时刻一起执行的。很多时候，我们并不用严格区分并发和并行两个词，所以我们有时候也把 Python 中的多线程、多进程以及异步 I/O 都视为实现并发编程的手段，但实际上前面两者也可以实现并行编程，当然这里还有一个全局解释器锁（GIL）的问题，我们稍后讨论。
+
+### 多线程编程
+
+Python 标准库中`threading`模块的`Thread`类可以帮助我们非常轻松的实现多线程编程。我们用一个联网下载文件的例子来对比使用多线程和不使用多线程到底有什么区别，代码如下所示。
+
+不使用多线程的下载。
+
+```Python
+import random
+import time
+
+
+def download(*, filename):
+    start = time.time()
+    print(f'开始下载 {filename}.')
+    time.sleep(random.randint(3, 6))
+    print(f'{filename} 下载完成.')
+    end = time.time()
+    print(f'下载耗时: {end - start:.3f}秒.')
+
+
+def main():
+    start = time.time()
+    download(filename='Python从入门到住院.pdf')
+    download(filename='MySQL从删库到跑路.avi')
+    download(filename='Linux从精通到放弃.mp4')
+    end = time.time()
+    print(f'总耗时: {end - start:.3f}秒.')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+> **说明**：上面的代码并没有真正实现联网下载的功能，而是通过`time.sleep()`休眠一段时间来模拟下载文件需要一些时间上的开销，跟实际下载的状况比较类似。
+
+运行上面的代码，可以得到如下所示的运行结果。可以看出，当我们的程序只有一个工作线程时，每个下载任务都需要等待上一个下载任务执行结束才能开始，所以程序执行的总耗时是三个下载任务各自执行时间的总和。
+
+```
+开始下载Python从入门到住院.pdf.
+Python从入门到住院.pdf下载完成.
+下载耗时: 3.005秒.
+开始下载MySQL从删库到跑路.avi.
+MySQL从删库到跑路.avi下载完成.
+下载耗时: 5.006秒.
+开始下载Linux从精通到放弃.mp4.
+Linux从精通到放弃.mp3下载完成.
+下载耗时: 6.007秒.
+总耗时: 14.018秒.
+```
+
+事实上，上面的三个下载任务之间并没有逻辑上的因果关系，三者是可以“并发”的，下一个下载任务没有必要等待上一个下载任务结束，为此，我们可以使用多线程编程来改写上面的代码。
+
+```Python
+import random
+import time
+from threading import Thread
+
+
+def download(*, filename):
+    start = time.time()
+    print(f'开始下载 {filename}.')
+    time.sleep(random.randint(3, 6))
+    print(f'{filename} 下载完成.')
+    end = time.time()
+    print(f'下载耗时: {end - start:.3f}秒.')
+
+
+def main():
+    threads = [
+        Thread(target=download, kwargs={'filename': 'Python从入门到住院.pdf'}),
+        Thread(target=download, kwargs={'filename': 'MySQL从删库到跑路.avi'}),
+        Thread(target=download, kwargs={'filename': 'Linux从精通到放弃.mp4'})
+    ]
+    start = time.time()
+    # 启动三个线程
+    for thread in threads:
+        thread.start()
+    # 等待线程结束
+    for thread in threads:
+        thread.join()
+    end = time.time()
+    print(f'总耗时: {end - start:.3f}秒.')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+某次的运行结果如下所示。
+
+```
+开始下载 Python从入门到住院.pdf.
+开始下载 MySQL从删库到跑路.avi.
+开始下载 Linux从精通到放弃.mp4.
+MySQL从删库到跑路.avi 下载完成.
+下载耗时: 3.005秒.
+Python从入门到住院.pdf 下载完成.
+下载耗时: 5.006秒.
+Linux从精通到放弃.mp4 下载完成.
+下载耗时: 6.003秒.
+总耗时: 6.004秒.
+```
+
+通过上面的运行结果可以发现，整个程序的执行时间几乎等于耗时最长的一个下载任务的执行时间，这也就意味着，三个下载任务是并发执行的，不存在一个等待另一个的情况，这样做很显然提高了程序的执行效率。简单的说，如果程序中有非常耗时的执行单元，而这些耗时的执行单元之间又没有逻辑上的因果关系，即 B 单元的执行不依赖于 A 单元的执行结果，那么 A 和 B 两个单元就可以放到两个不同的线程中，让他们并发的执行。这样做的好处除了减少程序执行的等待时间，还可以带来更好的用户体验，因为一个单元的阻塞不会造成程序的“假死”，因为程序中还有其他的单元是可以运转的。
+
+#### 使用 Thread 类创建线程对象
+
+通过上面的代码可以看出，直接使用`Thread`类的构造器就可以创建线程对象，而线程对象的`start()`方法可以启动一个线程。线程启动后会执行`target`参数指定的函数，当然前提是获得 CPU 的调度；如果`target`指定的线程要执行的目标函数有参数，需要通过`args`参数为其进行指定，对于关键字参数，可以通过`kwargs`参数进行传入。`Thread`类的构造器还有很多其他的参数，我们遇到的时候再为大家进行讲解，目前需要大家掌握的，就是`target`、`args`和`kwargs`。
+
+#### 继承 Thread 类自定义线程
+
+除了上面的代码展示的创建线程的方式外，还可以通过继承`Thread`类并重写`run()`方法的方式来自定义线程，具体的代码如下所示。
+
+```Python
+import random
+import time
+from threading import Thread
+
+
+class DownloadThread(Thread):
+
+    def __init__(self, filename):
+        self.filename = filename
+        super().__init__()
+
+    def run(self):
+        start = time.time()
+        print(f'开始下载 {self.filename}.')
+        time.sleep(random.randint(3, 6))
+        print(f'{self.filename} 下载完成.')
+        end = time.time()
+        print(f'下载耗时: {end - start:.3f}秒.')
+
+
+def main():
+    threads = [
+        DownloadThread('Python从入门到住院.pdf'),
+        DownloadThread('MySQL从删库到跑路.avi'),
+        DownloadThread('Linux从精通到放弃.mp4')
+    ]
+    start = time.time()
+    # 启动三个线程
+    for thread in threads:
+        thread.start()
+    # 等待线程结束
+    for thread in threads:
+        thread.join()
+    end = time.time()
+    print(f'总耗时: {end - start:.3f}秒.')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+#### 使用线程池
+
+我们还可以通过线程池的方式将任务放到多个线程中去执行，通过线程池来使用线程应该是多线程编程最理想的选择。事实上，线程的创建和释放都会带来较大的开销，频繁的创建和释放线程通常都不是很好的选择。利用线程池，可以提前准备好若干个线程，在使用的过程中不需要再通过自定义的代码创建和释放线程，而是直接复用线程池中的线程。Python 内置的`concurrent.futures`模块提供了对线程池的支持，代码如下所示。
+
+```Python
+import random
+import time
+from concurrent.futures import ThreadPoolExecutor
+from threading import Thread
+
+
+def download(*, filename):
+    start = time.time()
+    print(f'开始下载 {filename}.')
+    time.sleep(random.randint(3, 6))
+    print(f'{filename} 下载完成.')
+    end = time.time()
+    print(f'下载耗时: {end - start:.3f}秒.')
+
+
+def main():
+    with ThreadPoolExecutor(max_workers=4) as pool:
+        filenames = ['Python从入门到住院.pdf', 'MySQL从删库到跑路.avi', 'Linux从精通到放弃.mp4']
+        start = time.time()
+        for filename in filenames:
+            pool.submit(download, filename=filename)
+    end = time.time()
+    print(f'总耗时: {end - start:.3f}秒.')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+### 守护线程
+
+所谓“守护线程”就是在主线程结束的时候，不值得再保留的执行线程。这里的不值得保留指的是守护线程会在其他非守护线程全部运行结束之后被销毁，它守护的是当前进程内所有的非守护线程。简单的说，守护线程会跟随主线程一起挂掉，而主线程的生命周期就是一个进程的生命周期。如果不理解，我们可以看一段简单的代码。
+
+```Python
+import time
+from threading import Thread
+
+
+def display(content):
+    while True:
+        print(content, end='', flush=True)
+        time.sleep(0.1)
+
+
+def main():
+    Thread(target=display, args=('Ping', )).start()
+    Thread(target=display, args=('Pong', )).start()
+
+
+if __name__ == '__main__':
+    main()
+```
+
+> **说明**：上面的代码中，我们将`print`函数的参数`flush`设置为`True`，这是因为`flush`参数的值如果为`False`，而`print`又没有做换行处理，就会导致每次`print`输出的内容被放到操作系统的输出缓冲区，直到缓冲区被输出的内容塞满，才会清空缓冲区产生一次输出。上述现象是操作系统为了减少 I/O 中断，提升 CPU 利用率做出的设定，为了让代码产生直观交互，我们才将`flush`参数设置为`True`，强制每次输出都清空输出缓冲区。
+
+上面的代码运行起来之后是不会停止的，因为两个子线程中都有死循环，除非你手动中断代码的执行。但是，如果在创建线程对象时，将名为`daemon`的参数设置为`True`，这两个线程就会变成守护线程，那么在其他线程结束时，即便有死循环，两个守护线程也会挂掉，不会再继续执行下去，代码如下所示。
+
+ ```Python
+ import time
+ from threading import Thread
+ 
+ 
+ def display(content):
+     while True:
+         print(content, end='', flush=True)
+         time.sleep(0.1)
+ 
+ 
+ def main():
+     Thread(target=display, args=('Ping', ), daemon=True).start()
+     Thread(target=display, args=('Pong', ), daemon=True).start()
+     time.sleep(5)
+ 
+ 
+ if __name__ == '__main__':
+     main()
+ ```
+
+上面的代码，我们在主线程中添加了一行`time.sleep(5)`让主线程休眠5秒，在这个过程中，输出`Ping`和`Pong`的守护线程会持续运转，直到主线程在5秒后结束，这两个守护线程也被销毁，不再继续运行。
+
+> **思考**：如果将上面代码第12行的`daemon=True`去掉，代码会怎样执行？有兴趣的读者可以尝试一下，并看看实际执行的结果跟你想象的是否一致。
+
+### 资源竞争
+
+在编写多线程代码时，不可避免的会遇到多个线程竞争同一个资源（对象）的情况。在这种情况下，如果没有合理的机制来保护被竞争的资源，那么就有可能出现非预期的状况。下面的代码创建了`100`个线程向同一个银行账户（初始余额为`0`元）转账，每个线程转账金额为`1`元。在正常的情况下，我们的银行账户最终的余额应该是`100`元，但是运行下面的代码我们并不能得到`100`元这个结果。
+
+```Python
+import time
+
+from concurrent.futures import ThreadPoolExecutor
+
+
+class Account(object):
+    """银行账户"""
+
+    def __init__(self):
+        self.balance = 0.0
+
+    def deposit(self, money):
+        """存钱"""
+        new_balance = self.balance + money
+        time.sleep(0.01)
+        self.balance = new_balance
+
+
+def main():
+    """主函数"""
+    account = Account()
+    with ThreadPoolExecutor(max_workers=16) as pool:
+        for _ in range(100):
+            pool.submit(account.deposit, 1)
+    print(account.balance)
+
+
+if __name__ == '__main__':
+    main()
+```
+
+上面代码中的`Account`类代表了银行账户，它的`deposit`方法代表存款行为，参数`money`代表存入的金额，该方法通过`time.sleep`函数模拟受理存款需要一段时间。我们通过线程池的方式启动了`100`个线程向一个账户转账，但是上面的代码并不能运行出`100`这个我们期望的结果，这就是在多个线程竞争一个资源的时候，可能会遇到的数据不一致的问题。注意上面代码的第`14`行，当多个线程都执行到这行代码时，它们会在相同的余额上执行加上存入金额的操作，这就会造成“丢失更新”现象，即之前修改数据的成果被后续的修改给覆盖掉了，所以才得不到正确的结果。
+
+要解决上面的问题，可以使用锁机制，通过锁对操作数据的关键代码加以保护。Python 标准库的`threading`模块提供了`Lock`和`RLock`类来支持锁机制，这里我们不去深究二者的区别，建议大家直接使用`RLock`。接下来，我们给银行账户添加一个锁对象，通过锁对象来解决刚才存款时发生“丢失更新”的问题，代码如下所示。
+
+```Python
+import time
+
+from concurrent.futures import ThreadPoolExecutor
+from threading import RLock
+
+
+class Account(object):
+    """银行账户"""
+
+    def __init__(self):
+        self.balance = 0.0
+        self.lock = RLock()
+
+    def deposit(self, money):
+        # 获得锁
+        self.lock.acquire()
+        try:
+            new_balance = self.balance + money
+            time.sleep(0.01)
+            self.balance = new_balance
+        finally:
+            # 释放锁
+            self.lock.release()
+
+
+def main():
+    """主函数"""
+    account = Account()
+    with ThreadPoolExecutor(max_workers=16) as pool:
+        for _ in range(100):
+            pool.submit(account.deposit, 1)
+    print(account.balance)
+
+
+if __name__ == '__main__':
+    main()
+```
+
+上面代码中，获得锁和释放锁的操作也可以通过上下文语法来实现，使用上下文语法会让代码更加简单优雅，这也是我们推荐大家使用的方式。
+
+```Python
+import time
+
+from concurrent.futures import ThreadPoolExecutor
+from threading import RLock
+
+
+class Account(object):
+    """银行账户"""
+
+    def __init__(self):
+        self.balance = 0.0
+        self.lock = RLock()
+
+    def deposit(self, money):
+        # 通过上下文语法获得锁和释放锁
+        with self.lock:
+            new_balance = self.balance + money
+            time.sleep(0.01)
+            self.balance = new_balance
+
+
+def main():
+    """主函数"""
+    account = Account()
+    with ThreadPoolExecutor(max_workers=16) as pool:
+        for _ in range(100):
+            pool.submit(account.deposit, 1)
+    print(account.balance)
+
+
+if __name__ == '__main__':
+    main()
+```
+
+> **思考**：将上面的代码修改为5个线程向银行账户存钱，5个线程从银行账户取钱，取钱的线程在银行账户余额不足时，需要停下来等待存钱的线程将钱存入后再尝试取钱。这里需要用到线程调度的知识，大家可以自行研究下`threading`模块中的`Condition`类，看看是否能够完成这个任务。
+
+### GIL问题
+
+如果使用官方的 Python 解释器（通常称之为 CPython）运行 Python 程序，我们并不能通过使用多线程的方式将 CPU 的利用率提升到逼近400%（对于4核 CPU）或逼近800%（对于8核 CPU）这样的水平，因为 CPython 在执行代码时，会受到 GIL（全局解释器锁）的限制。具体的说，CPython 在执行任何代码时，都需要对应的线程先获得 GIL，然后每执行100条（字节码）指令，CPython 就会让获得 GIL 的线程主动释放 GIL，这样别的线程才有机会执行。因为 GIL 的存在，无论你的 CPU 有多少个核，我们编写的 Python 代码也没有机会真正并行的执行。
+
+GIL 是官方 Python 解释器在设计上的历史遗留问题，要解决这个问题，让多线程能够发挥 CPU 的多核优势，需要重新实现一个不带 GIL 的 Python 解释器。这个问题按照官方的说法，在 Python 发布4.0版本时会得到解决，就让我们拭目以待吧。当下，对于 CPython 而言，如果希望充分发挥 CPU 的多核优势，可以考虑使用多进程，因为每个进程都对应一个 Python 解释器，因此每个进程都有自己独立的 GIL，这样就可以突破 GIL 的限制。在下一个章节中，我们会为大家介绍关于多进程的相关知识，并对多线程和多进程的代码及其执行效果进行比较。
+
diff --git a/Day61-65/63-2.Python中的并发编程-2.md b/Day61-65/63-2.Python中的并发编程-2.md
new file mode 100644
index 0000000..439a9bc
--- /dev/null
+++ b/Day61-65/63-2.Python中的并发编程-2.md
@@ -0,0 +1,254 @@
+## 第35课：Python中的并发编程-2
+
+在上一课中我们说过，由于 GIL 的存在，CPython 中的多线程并不能发挥 CPU 的多核优势，如果希望突破 GIL 的限制，可以考虑使用多进程。对于多进程的程序，每个进程都有一个属于自己的 GIL，所以多进程不会受到 GIL 的影响。那么，我们应该如何在 Python 程序中创建和使用多进程呢？
+
+###创建进程
+
+在 Python 中可以基于`Process`类来创建进程，虽然进程和线程有着本质的差别，但是`Process`类和`Thread`类的用法却非常类似。在使用`Process`类的构造器创建对象时，也是通过`target`参数传入一个函数来指定进程要执行的代码，而`args`和`kwargs`参数可以指定该函数使用的参数值。
+
+```Python
+from multiprocessing import Process, current_process
+from time import sleep
+
+
+def sub_task(content, nums):
+    # 通过current_process函数获取当前进程对象
+    # 通过进程对象的pid和name属性获取进程的ID号和名字
+    print(f'PID: {current_process().pid}')
+    print(f'Name: {current_process().name}')
+    # 通过下面的输出不难发现，每个进程都有自己的nums列表，进程之间本就不共享内存
+    # 在创建子进程时复制了父进程的数据结构，三个进程从列表中pop(0)得到的值都是20
+    counter, total = 0, nums.pop(0)
+    print(f'Loop count: {total}')
+    sleep(0.5)
+    while counter < total:
+        counter += 1
+        print(f'{counter}: {content}')
+        sleep(0.01)
+
+
+def main():
+    nums = [20, 30, 40]
+    # 创建并启动进程来执行指定的函数
+    Process(target=sub_task, args=('Ping', nums)).start()
+    Process(target=sub_task, args=('Pong', nums)).start()
+    # 在主进程中执行sub_task函数
+    sub_task('Good', nums)
+
+
+if __name__ == '__main__':
+    main()
+```
+
+> **说明**：上面的代码通过`current_process`函数获取当前进程对象，再通过进程对象的`pid`属性获取进程ID。在 Python 中，使用`os`模块的`getpid`函数也可以达到同样的效果。
+
+如果愿意，也可以使用`os`模块的`fork`函数来创建进程，调用该函数时，操作系统自动把当前进程（父进程）复制一份（子进程），父进程的`fork`函数会返回子进程的ID，而子进程中的`fork`函数会返回`0`，也就是说这个函数调用一次会在父进程和子进程中得到两个不同的返回值。需要注意的是，Windows 系统并不支持`fork`函数，如果你使用的是 Linux 或 macOS 系统，可以试试下面的代码。
+
+```Python
+import os
+
+print(f'PID: {os.getpid()}')
+pid = os.fork()
+if pid == 0:
+    print(f'子进程 - PID: {os.getpid()}')
+    print('Todo: 在子进程中执行的代码')
+else:
+    print(f'父进程 - PID: {os.getpid()}')
+    print('Todo: 在父进程中执行的代码')
+```
+
+简而言之，我们还是推荐大家通过直接使用`Process`类、继承`Process`类和使用进程池（`ProcessPoolExecutor`）这三种方式来创建和使用多进程，这三种方式不同于上面的`fork`函数，能够保证代码的兼容性和可移植性。具体的做法跟之前讲过的创建和使用多线程的方式比较接近，此处不再进行赘述。
+
+### 多进程和多线程的比较
+
+对于爬虫这类 I/O 密集型任务来说，使用多进程并没有什么优势；但是对于计算密集型任务来说，多进程相比多线程，在效率上会有显著的提升，我们可以通过下面的代码来加以证明。下面的代码会通过多线程和多进程两种方式来判断一组大整数是不是质数，很显然这是一个计算密集型任务，我们将任务分别放到多个线程和多个进程中来加速代码的执行，让我们看看多线程和多进程的代码具体表现有何不同。
+
+我们先实现一个多线程的版本，代码如下所示。
+
+```Python
+import concurrent.futures
+
+PRIMES = [
+    1116281,
+    1297337,
+    104395303,
+    472882027,
+    533000389,
+    817504243,
+    982451653,
+    112272535095293,
+    112582705942171,
+    112272535095293,
+    115280095190773,
+    115797848077099,
+    1099726899285419
+] * 5
+
+
+def is_prime(n):
+    """判断素数"""
+    for i in range(2, int(n ** 0.5) + 1):
+        if n % i == 0:
+            return False
+    return n != 1
+
+
+def main():
+    """主函数"""
+    with concurrent.futures.ThreadPoolExecutor(max_workers=16) as executor:
+        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
+            print('%d is prime: %s' % (number, prime))
+
+
+if __name__ == '__main__':
+    main()
+```
+
+假设上面的代码保存在名为`example.py`的文件中，在 Linux 或 macOS 系统上，可以使用`time python example.py`命令执行程序并获得操作系统关于执行时间的统计，在我的 macOS 上，某次的运行结果的最后一行输出如下所示。
+
+```
+python example09.py  38.69s user 1.01s system 101% cpu 39.213 total
+```
+
+从运行结果可以看出，多线程的代码只能让 CPU 利用率达到100%，这其实已经证明了多线程的代码无法利用 CPU 多核特性来加速代码的执行，我们再看看多进程的版本，我们将上面代码中的线程池（`ThreadPoolExecutor`）更换为进程池（`ProcessPoolExecutor`）。
+
+多进程的版本。
+
+```Python
+import concurrent.futures
+
+PRIMES = [
+    1116281,
+    1297337,
+    104395303,
+    472882027,
+    533000389,
+    817504243,
+    982451653,
+    112272535095293,
+    112582705942171,
+    112272535095293,
+    115280095190773,
+    115797848077099,
+    1099726899285419
+] * 5
+
+
+def is_prime(n):
+    """判断素数"""
+    for i in range(2, int(n ** 0.5) + 1):
+        if n % i == 0:
+            return False
+    return n != 1
+
+
+def main():
+    """主函数"""
+    with concurrent.futures.ProcessPoolExecutor(max_workers=16) as executor:
+        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
+            print('%d is prime: %s' % (number, prime))
+
+
+if __name__ == '__main__':
+    main()
+```
+
+> **提示**：运行上面的代码时，可以通过操作系统的任务管理器（资源监视器）来查看是否启动了多个 Python  解释器进程。
+
+我们仍然通过`time python example.py`的方式来执行上述代码，运行结果的最后一行如下所示。
+
+```
+python example09.py 106.63s user 0.57s system 389% cpu 27.497 total
+```
+
+可以看出，多进程的版本在我使用的这台电脑上，让 CPU 的利用率达到了将近400%，而运行代码时用户态耗费的 CPU 的时间（106.63秒）几乎是代码运行总时间（27.497秒）的4倍，从这两点都可以看出，我的电脑使用了一款4核的 CPU。当然，要知道自己的电脑有几个 CPU 或几个核，可以直接使用下面的代码。
+
+```Python
+import os
+
+print(os.cpu_count())
+```
+
+综上所述，多进程可以突破 GIL 的限制，充分利用 CPU 多核特性，对于计算密集型任务，这一点是相当重要的。常见的计算密集型任务包括科学计算、图像处理、音视频编解码等，如果这些计算密集型任务本身是可以并行的，那么使用多进程应该是更好的选择。
+
+### 进程间通信
+
+在讲解进程间通信之前，先给大家一个任务：启动两个进程，一个输出“Ping”，一个输出“Pong”，两个进程输出的“Ping”和“Pong”加起来一共有50个时，就结束程序。听起来是不是非常简单，但是实际编写代码时，由于多个进程之间不能够像多个线程之间直接通过共享内存的方式交换数据，所以下面的代码是达不到我们想要的结果的。
+
+```Python
+from multiprocessing import Process
+from time import sleep
+
+counter = 0
+
+
+def sub_task(string):
+    global counter
+    while counter < 50:
+        print(string, end='', flush=True)
+        counter += 1
+        sleep(0.01)
+
+        
+def main():
+    Process(target=sub_task, args=('Ping', )).start()
+    Process(target=sub_task, args=('Pong', )).start()
+
+
+if __name__ == '__main__':
+    main()
+```
+
+上面的代码看起来没毛病，但是最后的结果是“Ping”和“Pong”各输出了50个。再次提醒大家，当我们在程序中创建进程的时候，子进程会复制父进程及其所有的数据结构，每个子进程有自己独立的内存空间，这也就意味着两个子进程中各有一个`counter`变量，它们都会从`0`加到`50`，所以结果就可想而知了。要解决这个问题比较简单的办法是使用`multiprocessing`模块中的`Queue`类，它是可以被多个进程共享的队列，底层是通过操作系统底层的管道和信号量（semaphore）机制来实现的，代码如下所示。
+
+```Python
+import time
+from multiprocessing import Process, Queue
+
+
+def sub_task(content, queue):
+    counter = queue.get()
+    while counter < 50:
+        print(content, end='', flush=True)
+        counter += 1
+        queue.put(counter)
+        time.sleep(0.01)
+        counter = queue.get()
+
+
+def main():
+    queue = Queue()
+    queue.put(0)
+    p1 = Process(target=sub_task, args=('Ping', queue))
+    p1.start()
+    p2 = Process(target=sub_task, args=('Pong', queue))
+    p2.start()
+    while p1.is_alive() and p2.is_alive():
+        pass
+    queue.put(50)
+
+
+if __name__ == '__main__':
+    main()
+```
+
+> **提示**：`multiprocessing.Queue`对象的`get`方法默认在队列为空时是会阻塞的，直到获取到数据才会返回。如果不希望该方法阻塞以及需要指定阻塞的超时时间，可以通过指定`block`和`timeout`参数进行设定。
+
+上面的代码通过`Queue`类的`get`和`put`方法让三个进程（`p1`、`p2`和主进程）实现了数据的共享，这就是所谓的进程间的通信，通过这种方式，当`Queue`中取出的值已经大于等于`50`时，`p1`和`p2`就会跳出`while`循环，从而终止进程的执行。代码第22行的循环是为了等待`p1`和`p2`两个进程中的一个结束，这时候主进程还需要向`Queue`中放置一个大于等于`50`的值，这样另一个尚未结束的进程也会因为读到这个大于等于`50`的值而终止。
+
+进程间通信的方式还有很多，比如使用套接字也可以实现两个进程的通信，甚至于这两个进程并不在同一台主机上，有兴趣的读者可以自行了解。
+
+###  简单的总结
+
+在 Python 中，我们还可以通过`subprocess`模块的`call`函数执行其他的命令来创建子进程，相当于就是在我们的程序中调用其他程序，这里我们暂不探讨这些知识，有兴趣的读者可以自行研究。
+
+对于Python开发者来说，以下情况需要考虑使用多线程：
+
+1. 程序需要维护许多共享的状态（尤其是可变状态），Python 中的列表、字典、集合都是线程安全的（多个线程同时操作同一个列表、字典或集合，不会引发错误和数据问题），所以使用线程而不是进程维护共享状态的代价相对较小。
+2. 程序会花费大量时间在 I/O 操作上，没有太多并行计算的需求且不需占用太多的内存。
+
+那么在遇到下列情况时，应该考虑使用多进程：
+
+1. 程序执行计算密集型任务（如：音视频编解码、数据压缩、科学计算等）。
+2. 程序的输入可以并行的分成块，并且可以将运算结果合并。
+3. 程序在内存使用方面没有任何限制且不强依赖于 I/O 操作（如读写文件、套接字等）。
diff --git a/Day61-65/63-3.Python中的并发编程-3.md b/Day61-65/63-3.Python中的并发编程-3.md
new file mode 100644
index 0000000..f7fcfe2
--- /dev/null
+++ b/Day61-65/63-3.Python中的并发编程-3.md
@@ -0,0 +1,215 @@
+## 第36课：Python中的并发编程-3
+
+爬虫是典型的 I/O 密集型任务，I/O 密集型任务的特点就是程序会经常性的因为 I/O 操作而进入阻塞状态，比如我们之前使用`requests`获取页面代码或二进制内容，发出一个请求之后，程序必须要等待网站返回响应之后才能继续运行，如果目标网站不是很给力或者网络状况不是很理想，那么等待响应的时间可能会很久，而在这个过程中整个程序是一直阻塞在那里，没有做任何的事情。通过前面的课程，我们已经知道了可以通过多线程的方式为爬虫提速，使用多线程的本质就是，当一个线程阻塞的时候，程序还有其他的线程可以继续运转，因此整个程序就不会在阻塞和等待中浪费了大量的时间。
+
+事实上，还有一种非常适合 I/O 密集型任务的并发编程方式，我们称之为异步编程，你也可以将它称为异步 I/O。这种方式并不需要启动多个线程或多个进程来实现并发，它是通过多个子程序相互协作的方式来提升 CPU 的利用率，解决了 I/O 密集型任务 CPU  利用率很低的问题，我一般将这种方式称为“协作式并发”。这里，我不打算探讨操作系统的各种 I/O 模式，因为这对很多读者来说都太过抽象；但是我们得先抛出两组概念给大家，一组叫做“阻塞”和“非阻塞”，一组叫做“同步”和“异步”。
+
+### 基本概念
+
+#### 阻塞
+
+阻塞状态指程序未得到所需计算资源时被挂起的状态。程序在等待某个操作完成期间，自身无法继续处理其他的事情，则称该程序在该操作上是阻塞的。阻塞随时都可能发生，最典型的就是 I/O 中断（包括网络 I/O 、磁盘 I/O 、用户输入等）、休眠操作、等待某个线程执行结束，甚至包括在 CPU 切换上下文时，程序都无法真正的执行，这就是所谓的阻塞。
+
+#### 非阻塞
+
+程序在等待某操作过程中，自身不被阻塞，可以继续处理其他的事情，则称该程序在该操作上是非阻塞的。非阻塞并不是在任何程序级别、任何情况下都可以存在的。仅当程序封装的级别可以囊括独立的子程序单元时，它才可能存在非阻塞状态。显然，某个操作的阻塞可能会导程序耗时以及效率低下，所以我们会希望把它变成非阻塞的。
+
+#### 同步
+
+不同程序单元为了完成某个任务，在执行过程中需靠某种通信方式以协调一致，我们称这些程序单元是同步执行的。例如前面讲过的给银行账户存钱的操作，我们在代码中使用了“锁”作为通信信号，让多个存钱操作强制排队顺序执行，这就是所谓的同步。
+
+#### 异步
+
+不同程序单元在执行过程中无需通信协调，也能够完成一个任务，这种方式我们就称之为异步。例如，使用爬虫下载页面时，调度程序调用下载程序后，即可调度其他任务，而无需与该下载任务保持通信以协调行为。不同网页的下载、保存等操作都是不相关的，也无需相互通知协调。很显然，异步操作的完成时刻和先后顺序并不能确定。
+
+很多人都不太能准确的把握这几个概念，这里我们简单的总结一下，同步与异步的关注点是**消息通信机制**，最终表现出来的是“有序”和“无序”的区别；阻塞和非阻塞的关注点是**程序在等待消息时状态**，最终表现出来的是程序在等待时能不能做点别的。如果想深入理解这些内容，推荐大家阅读经典著作[《UNIX网络编程》](https://item.jd.com/11880047.html)，这本书非常的赞。
+
+### 生成器和协程
+
+前面我们说过，异步编程是一种“协作式并发”，即通过多个子程序相互协作的方式提升 CPU 的利用率，从而减少程序在阻塞和等待中浪费的时间，最终达到并发的效果。我们可以将多个相互协作的子程序称为“协程”，它是实现异步编程的关键。在介绍协程之前，我们先通过下面的代码，看看什么是生成器。
+
+```Python
+def fib(max_count):
+    a, b = 0, 1
+    for _ in range(max_count):
+        a, b = b, a + b
+        yield a
+```
+
+上面我们编写了一个生成斐波那契数列的生成器，调用上面的`fib`函数并不是执行该函数获得返回值，因为`fib`函数中有一个特殊的关键字`yield`。这个关键字使得`fib`函数跟普通的函数有些区别，调用该函数会得到一个生成器对象，我们可以通过下面的代码来验证这一点。
+
+```Python
+gen_obj = fib(20)
+print(gen_obj)
+```
+
+输出：
+
+```
+<generator object fib at 0x106daee40>
+```
+
+我们可以使用内置函数`next`从生成器对象中获取斐波那契数列的值，也可以通过`for-in`循环对生成器能够提供的值进行遍历，代码如下所示。
+
+```Python
+for value in gen_obj:
+    print(value)
+```
+
+生成器经过预激活，就是一个协程，它可以跟其他子程序协作。
+
+```Python
+def calc_average():
+    total, counter = 0, 0
+    avg_value = None
+    while True:
+        curr_value = yield avg_value
+        total += curr_value
+        counter += 1
+        avg_value = total / counter
+
+
+def main():
+    obj = calc_average()
+    # 生成器预激活
+    obj.send(None)
+    for _ in range(5):
+        print(obj.send(float(input())))
+
+
+if __name__ == '__main__':
+    main()
+```
+
+上面的`main`函数首先通过生成器对象的`send`方法发送一个`None`值来将其激活为协程，也可以通过`next(obj)`达到同样的效果。接下来，协程对象会接收`main`函数发送的数据并产出（`yield`）数据的平均值。通过上面的例子，不知道大家是否看出两段子程序是怎么“协作”的。
+
+### 异步函数
+
+Python 3.5版本中，引入了两个非常有意思的元素，一个叫`async`，一个叫`await`，它们在Python 3.7版本中成为了正式的关键字。通过这两个关键字，可以简化协程代码的编写，可以用更为简单的方式让多个子程序很好的协作起来。我们通过一个例子来加以说明，请大家先看看下面的代码。
+
+```Python
+import time
+
+
+def display(num):
+    time.sleep(1)
+    print(num)
+
+
+def main():
+    start = time.time()
+    for i in range(1, 10):
+        display(i)
+    end = time.time()
+    print(f'{end - start:.3f}秒')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+上面的代码每次执行都会依次输出`1`到`9`的数字，每个间隔`1`秒钟，整个代码需要执行大概需要`9`秒多的时间，这一点我相信大家都能看懂。不知道大家是否意识到，这段代码就是以同步和阻塞的方式执行的，同步可以从代码的输出看出来，而阻塞是指在调用`display`函数发生休眠时，整个代码的其他部分都不能继续执行，必须等待休眠结束。
+
+接下来，我们尝试用异步的方式改写上面的代码，让`display`函数以异步的方式运转。
+
+```Python
+import asyncio
+import time
+
+
+async def display(num):
+    await asyncio.sleep(1)
+    print(num)
+
+
+def main():
+    start = time.time()
+    objs = [display(i) for i in range(1, 10)]
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(asyncio.wait(objs))
+    loop.close()
+    end = time.time()
+    print(f'{end - start:.3f}秒')
+
+
+if __name__ == '__main__':
+    main()
+```
+
+Python 中的`asyncio`模块提供了对异步 I/O 的支持。上面的代码中，我们首先在`display`函数前面加上了`async`关键字使其变成一个异步函数，调用异步函数不会执行函数体而是获得一个协程对象。我们将`display`函数中的`time.sleep(1)`修改为`await asyncio.sleep(1)`，二者的区别在于，后者不会让整个代码陷入阻塞，因为`await`操作会让其他协作的子程序有获得 CPU 资源而得以运转的机会。为了让这些子程序可以协作起来，我们需要将他们放到一个事件循环（实现消息分派传递的系统）上，因为**当协程遭遇 I/O 操作阻塞时，就会到事件循环中监听 I/O 操作是否完成，并注册自身的上下文以及自身的唤醒函数（以便恢复执行），之后该协程就变为阻塞状态**。上面的第12行代码创建了`9`个协程对象并放到一个列表中，第13行代码通过`asyncio`模块的`get_event_loop`函数获得了系统的事件循环，第14行通过`asyncio`模块的`run_until_complete`函数将协程对象挂载到事件循环上。执行上面的代码会发现，`9`个分别会阻塞`1`秒钟的协程总共只阻塞了约`1`秒种的时间，因为**阻塞的协程对象会放弃对 CPU 的占有而不是让 CPU 处于闲置状态，这种方式大大的提升了 CPU 的利用率**。而且我们还会注意到，数字并不是按照从`1`到`9`的顺序打印输出的，这正是我们想要的结果，说明它们是**异步执行**的。对于爬虫这样的 I/O 密集型任务来说，这种协作式并发在很多场景下是比使用多线程更好的选择，因为这种做法减少了管理和维护多个线程以及多个线程切换所带来的开销。
+
+### aiohttp库
+
+我们之前使用的`requests`三方库并不支持异步 I/O，如果希望使用异步 I/O 的方式来加速爬虫代码的执行，我们可以安装和使用名为`aiohttp`的三方库。
+
+安装`aiohttp`。
+
+```Bash
+pip install aiohttp
+```
+
+下面的代码使用`aiohttp`抓取了`10`个网站的首页并解析出它们的标题。
+
+```Python
+import asyncio
+import re
+
+import aiohttp
+from aiohttp import ClientSession
+
+TITLE_PATTERN = re.compile(r'<title.*?>(.*?)</title>', re.DOTALL)
+
+
+async def fetch_page_title(url):
+    async with aiohttp.ClientSession(headers={
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36',
+    }) as session:  # type: ClientSession
+        async with session.get(url, ssl=False) as resp:
+            if resp.status == 200:
+                html_code = await resp.text()
+                matcher = TITLE_PATTERN.search(html_code)
+                title = matcher.group(1).strip()
+                print(title)
+
+
+def main():
+    urls = [
+        'https://www.python.org/',
+        'https://www.jd.com/',
+        'https://www.baidu.com/',
+        'https://www.taobao.com/',
+        'https://git-scm.com/',
+        'https://www.sohu.com/',
+        'https://gitee.com/',
+        'https://www.amazon.com/',
+        'https://www.usa.gov/',
+        'https://www.nasa.gov/'
+    ]
+    objs = [fetch_page_title(url) for url in urls]
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(asyncio.wait(objs))
+    loop.close()
+
+
+if __name__ == '__main__':
+    main()
+```
+
+输出：
+
+```
+京东(JD.COM)-正品低价、品质保障、配送及时、轻松购物！
+搜狐
+淘宝网 - 淘！我喜欢
+百度一下，你就知道
+Gitee - 基于 Git 的代码托管和研发协作平台
+Git
+NASA
+Official Guide to Government Information and Services   &#124; USAGov
+Amazon.com. Spend less. Smile more.
+Welcome to Python.org
+```
+
+从上面的输出可以看出，网站首页标题的输出顺序跟它们的 URL 在列表中的顺序没有关系。代码的第11行到第13行创建了`ClientSession`对象，通过它的`get`方法可以向指定的 URL 发起请求，如第14行所示，跟`requests`中的`Session`对象并没有本质区别，唯一的区别是这里使用了异步上下文。代码第16行的`await`会让因为 I/O 操作阻塞的子程序放弃对 CPU 的占用，这使得其他的子程序可以运转起来去抓取页面。代码的第17行和第18行使用了正则表达式捕获组操作解析网页标题。`fetch_page_title`是一个被`async`关键字修饰的异步函数，调用该函数会获得协程对象，如代码第35行所示。后面的代码跟之前的例子没有什么区别，相信大家能够理解。
+
+大家可以尝试将`aiohttp`换回到`requests`，看看不使用异步 I/O 也不使用多线程，到底和上面的代码有什么区别，相信通过这样的对比，大家能够更深刻的理解我们之前强调的几个概念：同步和异步，阻塞和非阻塞。
diff --git a/Day61-65/63-4.并发编程在爬虫中的应用.md b/Day61-65/63-4.并发编程在爬虫中的应用.md
new file mode 100644
index 0000000..6662c24
--- /dev/null
+++ b/Day61-65/63-4.并发编程在爬虫中的应用.md
@@ -0,0 +1,185 @@
+## 第37课：并发编程在爬虫中的应用
+
+之前的课程，我们已经为大家介绍了 Python 中的多线程、多进程和异步编程，通过这三种手段，我们可以实现并发或并行编程，这一方面可以加速代码的执行，另一方面也可以带来更好的用户体验。爬虫程序是典型的 I/O 密集型任务，对于 I/O 密集型任务来说，多线程和异步 I/O 都是很好的选择，因为当程序的某个部分因 I/O 操作阻塞时，程序的其他部分仍然可以运转，这样我们不用在等待和阻塞中浪费大量的时间。下面我们以爬取“[360图片](https://image.so.com/)”网站的图片并保存到本地为例，为大家分别展示使用单线程、多线程和异步 I/O 编程的爬虫程序有什么区别，同时也对它们的执行效率进行简单的对比。
+
+“360图片”网站的页面使用了 [Ajax](https://developer.mozilla.org/zh-CN/docs/Web/Guide/AJAX) 技术，这是很多网站都会使用的一种异步加载数据和局部刷新页面的技术。简单的说，页面上的图片都是通过 JavaScript 代码异步获取 JSON 数据并动态渲染生成的，而且整个页面还使用了瀑布式加载（一边向下滚动，一边加载更多的图片）。我们在浏览器的“开发者工具”中可以找到提供动态内容的数据接口，如下图所示，我们需要的图片信息就在服务器返回的 JSON 数据中。
+
+<img src="https://gitee.com/jackfrued/mypic/raw/master/20211205221352.png" style="zoom:50%;">
+
+例如，要获取“美女”频道的图片，我们可以请求如下所示的URL，其中参数`ch`表示请求的频道，`=`后面的参数值`beauty`就代表了“美女”频道，参数`sn`相当于是页码，`0`表示第一页（共`30`张图片），`30`表示第二页，`60`表示第三页，以此类推。
+
+```
+https://image.so.com/zjl?ch=beauty&sn=0
+```
+
+### 单线程版本
+
+通过上面的 URL 下载“美女”频道共`90`张图片。
+
+```Python
+"""
+example04.py - 单线程版本爬虫
+"""
+import os
+
+import requests
+
+
+def download_picture(url):
+    filename = url[url.rfind('/') + 1:]
+    resp = requests.get(url)
+    if resp.status_code == 200:
+        with open(f'images/beauty/{filename}', 'wb') as file:
+            file.write(resp.content)
+
+
+def main():
+    if not os.path.exists('images/beauty'):
+        os.makedirs('images/beauty')
+    for page in range(3):
+        resp = requests.get(f'https://image.so.com/zjl?ch=beauty&sn={page * 30}')
+        if resp.status_code == 200:
+            pic_dict_list = resp.json()['list']
+            for pic_dict in pic_dict_list:
+                download_picture(pic_dict['qhimg_url'])
+
+if __name__ == '__main__':
+    main()
+```
+
+在 macOS 或 Linux 系统上，我们可以使用`time`命令来了解上面代码的执行时间以及 CPU 的利用率，如下所示。
+
+```Bash
+time python3 example04.py 
+```
+
+下面是单线程爬虫代码在我的电脑上执行的结果。
+
+```
+python3 example04.py  2.36s user 0.39s system 12% cpu 21.578 total
+```
+
+这里我们只需要关注代码的总耗时为`21.578`秒，CPU 利用率为`12%`。
+
+### 多线程版本
+
+我们使用之前讲到过的线程池技术，将上面的代码修改为多线程版本。
+
+```Python
+"""
+example05.py - 多线程版本爬虫
+"""
+import os
+from concurrent.futures import ThreadPoolExecutor
+
+import requests
+
+
+def download_picture(url):
+    filename = url[url.rfind('/') + 1:]
+    resp = requests.get(url)
+    if resp.status_code == 200:
+        with open(f'images/beauty/{filename}', 'wb') as file:
+            file.write(resp.content)
+
+
+def main():
+    if not os.path.exists('images/beauty'):
+        os.makedirs('images/beauty')
+    with ThreadPoolExecutor(max_workers=16) as pool:
+        for page in range(3):
+            resp = requests.get(f'https://image.so.com/zjl?ch=beauty&sn={page * 30}')
+            if resp.status_code == 200:
+                pic_dict_list = resp.json()['list']
+                for pic_dict in pic_dict_list:
+                    pool.submit(download_picture, pic_dict['qhimg_url'])
+
+
+if __name__ == '__main__':
+    main()
+```
+
+执行如下所示的命令。
+
+```Bash
+time python3 example05.py
+```
+
+代码的执行结果如下所示：
+
+```
+python3 example05.py  2.65s user 0.40s system 95% cpu 3.193 total
+```
+
+### 异步I/O版本
+
+我们使用`aiohttp`将上面的代码修改为异步 I/O 的版本。为了以异步 I/O 的方式实现网络资源的获取和写文件操作，我们首先得安装三方库`aiohttp`和`aiofile`，命令如下所示。
+
+```Bash
+pip install aiohttp aiofile
+```
+
+`aiohttp` 的用法在之前的课程中已经做过简要介绍，`aiofile`模块中的`async_open`函数跟 Python 内置函数`open`的用法大致相同，只不过它支持异步操作。下面是异步 I/O 版本的爬虫代码。
+
+```Python
+"""
+example06.py - 异步I/O版本爬虫
+"""
+import asyncio
+import json
+import os
+
+import aiofile
+import aiohttp
+
+
+async def download_picture(session, url):
+    filename = url[url.rfind('/') + 1:]
+    async with session.get(url, ssl=False) as resp:
+        if resp.status == 200:
+            data = await resp.read()
+            async with aiofile.async_open(f'images/beauty/{filename}', 'wb') as file:
+                await file.write(data)
+
+
+async def fetch_json():
+    async with aiohttp.ClientSession() as session:
+        for page in range(3):
+            async with session.get(
+                url=f'https://image.so.com/zjl?ch=beauty&sn={page * 30}',
+                ssl=False
+            ) as resp:
+                if resp.status == 200:
+                    json_str = await resp.text()
+                    result = json.loads(json_str)
+                    for pic_dict in result['list']:
+                        await download_picture(session, pic_dict['qhimg_url'])
+
+
+def main():
+    if not os.path.exists('images/beauty'):
+        os.makedirs('images/beauty')
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(fetch_json())
+    loop.close()
+
+
+if __name__ == '__main__':
+    main()
+```
+
+执行如下所示的命令。
+
+```Bash
+time python3 example06.py
+```
+
+代码的执行结果如下所示：
+
+```
+python3 example06.py  0.82s user 0.21s system 27% cpu 3.782 total
+```
+
+### 总结
+
+通过上面三段代码执行结果的比较，我们可以得出一个结论，使用多线程和异步 I/O 都可以改善爬虫程序的性能，因为我们不用将时间浪费在因 I/O 操作造成的等待和阻塞上，而`time`命令的执行结果也告诉我们，单线程的代码 CPU 利用率仅仅只有`12%`，而多线程版本的 CPU 利用率则高达`95%`；单线程版本的爬虫执行时间约`21`秒，而多线程和异步 I/O 的版本仅执行了`3`秒钟。另外，在运行时间差别不大的情况下，多线程的代码比异步 I/O 的代码耗费了更多的 CPU 资源，这是因为多线程的调度和切换也需要花费 CPU 时间。至此，三种方式在 I/O 密集型任务上的优劣已经一目了然，当然这只是在我的电脑上跑出来的结果。如果网络状况不是很理想或者目标网站响应很慢，那么使用多线程和异步 I/O 的优势将更为明显，有兴趣的读者可以自行试验。
diff --git a/Day61-65/63.存储数据.md b/Day61-65/63.存储数据.md
deleted file mode 100644
index 9857293..0000000
--- a/Day61-65/63.存储数据.md
+++ /dev/null
@@ -1,118 +0,0 @@
-## 存储数据
-
-### 存储海量数据
-
-数据持久化的首选方案应该是关系型数据库，关系型数据库的产品很多，包括：Oracle、MySQL、SQLServer、PostgreSQL等。如果要存储海量的低价值数据，文档数据库也是不错的选择，MongoDB是文档数据库中的佼佼者，有兴趣的读者可以自行研究。
-
-下面的代码演示了如何使用MySQL来保存从知乎发现上爬取到的链接和页面。
-
-```SQL
-create database zhihu default charset utf8;
-create user 'hellokitty'@'%' identified by 'Hellokitty.618';
-grant all privileges on zhihu.* to 'hellokitty'@'%';
-flush privileges;
-
-use zhihu;
-create table `tb_explore`
-(
-	`id` integer auto_increment,
-    `url` varchar(1024) not null,
-    `page` longblob not null,
-    `digest` char(48) unique not null,
-    `idate` datetime default now(),
-    primary key (`id`)
-);
-```
-
-```Python
-import hashlib
-import pickle
-import re
-import zlib
-from urllib.parse import urljoin
-
-import MySQLdb
-import bs4
-import requests
-
-conn = MySQLdb.connect(host='1.2.3.4', port=3306,
-                       user='hellokitty', password='Hellokitty.618',
-                       database='zhihu', charset='utf8',
-                       autocommit=True)
-
-
-def write_to_db(url, page, digest):
-    try:
-        with conn.cursor() as cursor:
-            cursor.execute(
-                'insert into tb_explore (url, page, digest) values (%s, %s, %s) ',
-                (url, page, digest)
-            )
-    except MySQLdb.MySQLError as err:
-        print(err)
-
-
-def main():
-    base_url = 'https://www.zhihu.com/'
-    seed_url = urljoin(base_url, 'explore')
-    headers = {'user-agent': 'Baiduspider'}
-    try:
-        resp = requests.get(seed_url, headers=headers)
-        soup = bs4.BeautifulSoup(resp.text, 'lxml')
-        href_regex = re.compile(r'^/question')
-        for a_tag in soup.find_all('a', {'href': href_regex}):
-            href = a_tag.attrs['href']
-            full_url = urljoin(base_url, href)
-            digest = hashlib.sha1(full_url.encode()).hexdigest()
-            html_page = requests.get(full_url, headers=headers).text
-            zipped_page = zlib.compress(pickle.dumps(html_page))
-            write_to_db(full_url, zipped_page, digest)
-    finally:
-        conn.close()
-
-
-if __name__ == '__main__':
-    main()
-```
-
-### 数据缓存
-
-通过[《网络数据采集和解析》](./67.数据采集和解析.md)一文，我们已经知道了如何从指定的页面中抓取数据，以及如何保存抓取的结果，但是我们没有考虑过这么一种情况，就是我们可能需要从已经抓取过的页面中提取出更多的数据，重新去下载这些页面对于规模不大的网站倒是问题也不大，但是如果能够把这些页面缓存起来，对应用的性能会有明显的改善。下面的例子演示了如何使用Redis来缓存知乎发现上的页面。
-
-```Python
-import hashlib
-import pickle
-import re
-import zlib
-from urllib.parse import urljoin
-
-import bs4
-import redis
-import requests
-
-
-def main():
-    base_url = 'https://www.zhihu.com/'
-    seed_url = urljoin(base_url, 'explore')
-    client = redis.Redis(host='1.2.3.4', port=6379, password='1qaz2wsx')
-    headers = {'user-agent': 'Baiduspider'}
-    resp = requests.get(seed_url, headers=headers)
-    soup = bs4.BeautifulSoup(resp.text, 'lxml')
-    href_regex = re.compile(r'^/question')
-    for a_tag in soup.find_all('a', {'href': href_regex}):
-        href = a_tag.attrs['href']
-        full_url = urljoin(base_url, href)
-        field_key = hashlib.sha1(full_url.encode()).hexdigest()
-        if not client.hexists('spider:zhihu:explore', field_key):
-            html_page = requests.get(full_url, headers=headers).text
-            zipped_page = zlib.compress(pickle.dumps(html_page))
-            client.hset('spider:zhihu:explore', field_key, zipped_page)
-    print('Total %d question pages found.' % client.hlen('spider:zhihu:explore'))
-
-
-if __name__ == '__main__':
-    main()
-```
-
-
-
diff --git a/Day61-65/64.并发下载.md b/Day61-65/64.并发下载.md
deleted file mode 100644
index 3b36f9c..0000000
--- a/Day61-65/64.并发下载.md
+++ /dev/null
@@ -1,236 +0,0 @@
-## 并发下载
-
-### 多线程和多进程补充知识点
-
-#### threading.local类
-
-使用线程时最不愿意遇到的情况就是多个线程竞争资源，在这种情况下为了保证资源状态的正确性，我们可能需要对资源进行加锁保护的处理，这一方面会导致程序失去并发性，另外如果多个线程竞争多个资源时，还有可能因为加锁方式的不当导致[死锁](https://zh.wikipedia.org/wiki/%E6%AD%BB%E9%94%81)。要解决多个线程竞争资源的问题，其中一个方案就是让每个线程都持有资源的副本（拷贝），这样每个线程可以操作自己所持有的资源，从而规避对资源的竞争。
-
-要实现将资源和持有资源的线程进行绑定的操作，最简单的做法就是使用`threading`模块的`local`类，在网络爬虫开发中，就可以使用`local`类为每个线程绑定一个MySQL数据库连接或Redis客户端对象，这样通过线程可以直接获得这些资源，既解决了资源竞争的问题，又避免了在函数和方法调用时传递这些资源。具体的请参考本章多线程爬取“手机搜狐网”（Redis版）的实例代码。
-
-#### concurrent.futures模块
-
-Python3.2带来了`concurrent.futures` 模块，这个模块包含了线程池和进程池、管理并行编程任务、处理非确定性的执行流程、进程/线程同步等功能。关于这部分的内容推荐大家阅读[《Python并行编程》](http://python-parallel-programmning-cookbook.readthedocs.io/zh_CN/latest/index.html)。
-
-#### 分布式进程 
-
-使用多进程的时候，可以将进程部署在多个主机节点上，Python的`multiprocessing`模块不但支持多进程，其中`managers`子模块还支持把多进程部署到多个节点上。当然，要部署分布式进程，首先需要一个服务进程作为调度者，进程之间通过网络进行通信来实现对进程的控制和调度，由于`managers`模块已经对这些做出了很好的封装，因此在无需了解网络通信细节的前提下，就可以编写分布式多进程应用。具体的请参照本章分布式多进程爬取“手机搜狐网”的实例代码。
-
-### 协程和异步I/O
-
-#### 协程的概念
-
-协程（coroutine）通常又称之为微线程或纤程，它是相互协作的一组子程序（函数）。所谓相互协作指的是在执行函数A时，可以随时中断去执行函数B，然后又中断继续执行函数A。注意，这一过程并不是函数调用（因为没有调用语句），整个过程看似像多线程，然而协程只有一个线程执行。协程通过`yield`关键字和 `send()`操作来转移执行权，协程之间不是调用者与被调用者的关系。
-
-协程的优势在于以下两点：
-
-1. 执行效率极高，因为子程序（函数）切换不是线程切换，由程序自身控制，没有切换线程的开销。
-2. 不需要多线程的锁机制，因为只有一个线程，也不存在竞争资源的问题，当然也就不需要对资源加锁保护，因此执行效率高很多。
-
-> **说明**：协程适合处理的是I/O密集型任务，处理CPU密集型任务并不是它擅长的，如果要提升CPU的利用率可以考虑“多进程+多线程”或者“多进程+协程”的工作模式。
-
-#### 历史回顾
-
-1. Python 2.2：第一次提出了生成器（最初称之为迭代器）的概念（PEP 255）。
-2. Python 2.5：引入了将对象发送回暂停了的生成器这一特性即生成器的`send()`方法（PEP 342）。
-3. Python 3.3：添加了`yield from`特性，允许从迭代器中返回任何值（注意生成器本身也是迭代器），这样我们就可以串联生成器并且重构出更好的生成器。
-4. Python 3.4：引入`asyncio.coroutine`装饰器用来标记作为协程的函数，协程函数和`asyncio`及其事件循环一起使用，来实现异步I/O操作。
-5. Python 3.5：引入了`async`和`await`，可以使用`async def`来定义一个协程函数，这个函数中不能包含任何形式的`yield`语句，但是可以使用`return`或`await`从协程中返回值。
-
-协程实现了协作式并发，通过提高CPU的利用率来达到改善性能的目的。著名的三方库[`aiohttp`](https://github.com/aio-libs/aiohttp)就是通过协程的方式实现了HTTP客户端和HTTP服务器的功能，较之`requests`有更好的获取数据的性能，有兴趣可以阅读它的[官方文档](https://aiohttp.readthedocs.io/en/stable/)。
-
-```Python
-import asyncio
-import aiohttp
-
-
-async def download(url):
-    print('Fetch:', url)
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url, ssl=False) as resp:
-            print(url, '--->', resp.status)
-            print(url, '--->', resp.headers)
-            print('\n\n', await resp.text())
-
-
-def main():
-    loop = asyncio.get_event_loop()
-    urls = [
-        'https://www.baidu.com',
-        'http://www.sohu.com/',
-        'http://www.sina.com.cn/',
-        'https://www.taobao.com/',
-        'http://jd.com/'
-    ]
-    tasks = [download(url) for url in urls]
-    loop.run_until_complete(asyncio.wait(tasks))
-    loop.close()
-
-
-if __name__ == '__main__':
-    main()
-```
-
-### 实例 - 多线程爬取“手机搜狐网”所有页面
-
-下面我们把之间讲的所有知识结合起来，用面向对象的方式实现一个爬取“手机搜狐网”的多线程爬虫。
-
-```Python
-import pickle
-import zlib
-from enum import Enum, unique
-from hashlib import sha1
-from random import random
-from threading import Thread, current_thread, local
-from time import sleep
-from urllib.parse import urlparse
-
-import pymongo
-import redis
-import requests
-from bs4 import BeautifulSoup
-from bson import Binary
-
-
-@unique
-class SpiderStatus(Enum):
-    IDLE = 0
-    WORKING = 1
-
-
-def decode_page(page_bytes, charsets=('utf-8',)):
-    page_html = None
-    for charset in charsets:
-        try:
-            page_html = page_bytes.decode(charset)
-            break
-        except UnicodeDecodeError:
-            pass
-    return page_html
-
-
-class Retry(object):
-
-    def __init__(self, *, retry_times=3,
-                 wait_secs=5, errors=(Exception, )):
-        self.retry_times = retry_times
-        self.wait_secs = wait_secs
-        self.errors = errors
-
-    def __call__(self, fn):
-
-        def wrapper(*args, **kwargs):
-            for _ in range(self.retry_times):
-                try:
-                    return fn(*args, **kwargs)
-                except self.errors as e:
-                    print(e)
-                    sleep((random() + 1) * self.wait_secs)
-            return None
-
-        return wrapper
-
-
-class Spider(object):
-
-    def __init__(self):
-        self.status = SpiderStatus.IDLE
-
-    @Retry()
-    def fetch(self, current_url, *, charsets=('utf-8', ),
-              user_agent=None, proxies=None):
-        thread_name = current_thread().name
-        print(f'[{thread_name}]: {current_url}')
-        headers = {'user-agent': user_agent} if user_agent else {}
-        resp = requests.get(current_url,
-                            headers=headers, proxies=proxies)
-        return decode_page(resp.content, charsets) \
-            if resp.status_code == 200 else None
-
-    def parse(self, html_page, *, domain='m.sohu.com'):
-        soup = BeautifulSoup(html_page, 'lxml')
-        for a_tag in soup.body.select('a[href]'):
-            parser = urlparse(a_tag.attrs['href'])
-            scheme = parser.scheme or 'http'
-            netloc = parser.netloc or domain
-            if scheme != 'javascript' and netloc == domain:
-                path = parser.path
-                query = '?' + parser.query if parser.query else ''
-                full_url = f'{scheme}://{netloc}{path}{query}'
-                redis_client = thread_local.redis_client
-                if not redis_client.sismember('visited_urls', full_url):
-                    redis_client.rpush('m_sohu_task', full_url)
-
-    def extract(self, html_page):
-        pass
-
-    def store(self, data_dict):
-        # redis_client = thread_local.redis_client
-        # mongo_db = thread_local.mongo_db
-        pass
-
-
-class SpiderThread(Thread):
-
-    def __init__(self, name, spider):
-        super().__init__(name=name, daemon=True)
-        self.spider = spider
-
-    def run(self):
-        redis_client = redis.Redis(host='1.2.3.4', port=6379, password='1qaz2wsx')
-        mongo_client = pymongo.MongoClient(host='1.2.3.4', port=27017)
-        thread_local.redis_client = redis_client
-        thread_local.mongo_db = mongo_client.msohu 
-        while True:
-            current_url = redis_client.lpop('m_sohu_task')
-            while not current_url:
-                current_url = redis_client.lpop('m_sohu_task')
-            self.spider.status = SpiderStatus.WORKING
-            current_url = current_url.decode('utf-8')
-            if not redis_client.sismember('visited_urls', current_url):
-                redis_client.sadd('visited_urls', current_url)
-                html_page = self.spider.fetch(current_url)
-                if html_page not in [None, '']:
-                    hasher = hasher_proto.copy()
-                    hasher.update(current_url.encode('utf-8'))
-                    doc_id = hasher.hexdigest()
-                    sohu_data_coll = mongo_client.msohu.webpages
-                    if not sohu_data_coll.find_one({'_id': doc_id}):
-                        sohu_data_coll.insert_one({
-                            '_id': doc_id,
-                            'url': current_url,
-                            'page': Binary(zlib.compress(pickle.dumps(html_page)))
-                        })
-                    self.spider.parse(html_page)
-            self.spider.status = SpiderStatus.IDLE
-
-
-def is_any_alive(spider_threads):
-    return any([spider_thread.spider.status == SpiderStatus.WORKING
-                for spider_thread in spider_threads])
-
-
-thread_local = local()
-hasher_proto = sha1()
-
-
-def main():
-    redis_client = redis.Redis(host='1.2.3.4', port=6379, password='1qaz2wsx')
-    if not redis_client.exists('m_sohu_task'):
-        redis_client.rpush('m_sohu_task', 'http://m.sohu.com/')
-
-    spider_threads = [SpiderThread('thread-%d' % i, Spider())
-                      for i in range(10)]
-    for spider_thread in spider_threads:
-        spider_thread.start()
-
-    while redis_client.exists('m_sohu_task') or is_any_alive(spider_threads):
-        sleep(5)
-
-    print('Over!')
-
-
-if __name__ == '__main__':
-    main()
-```
-
diff --git a/Day61-65/65.解析动态内容.md b/Day61-65/65.解析动态内容.md
deleted file mode 100644
index 23dc287..0000000
--- a/Day61-65/65.解析动态内容.md
+++ /dev/null
@@ -1,158 +0,0 @@
-## 解析动态内容
-
-根据权威机构发布的全球互联网可访问性审计报告，全球约有四分之三的网站其内容或部分内容是通过JavaScript动态生成的，这就意味着在浏览器窗口中“查看网页源代码”时无法在HTML代码中找到这些内容，也就是说我们之前用的抓取数据的方式无法正常运转了。解决这样的问题基本上有两种方案，一是JavaScript逆向工程；另一种是渲染JavaScript获得渲染后的内容。
-
-### JavaScript逆向工程
-
-下面我们以“360图片”网站为例，说明什么是JavaScript逆向工程。其实所谓的JavaScript逆向工程就是找到通过Ajax技术动态获取数据的接口。在浏览器中输入<http://image.so.com/z?ch=beauty>就可以打开“360图片”的“美女”版块，如下图所示。
-
-![](https://gitee.com/jackfrued/mypic/raw/master/20210824004714.png)
-
-但是当我们在浏览器中通过右键菜单“显示网页源代码”的时候，居然惊奇的发现页面的HTML代码中连一个`<img>`标签都没有，那么我们看到的图片是怎么显示出来的呢？原来所有的图片都是通过JavaScript动态加载的，而在浏览器的“开发人员工具”的“网络”中可以找到获取这些图片数据的网络API接口，如下图所示。
-
-![](https://gitee.com/jackfrued/mypic/raw/master/20210824004727.png)
-
-那么结论就很简单了，只要我们找到了这些网络API接口，那么就能通过这些接口获取到数据，当然实际开发的时候可能还要对这些接口的参数以及接口返回的数据进行分析，了解每个参数的意义以及返回的JSON数据的格式，这样才能在我们的爬虫中使用这些数据。
-
-### 使用Selenium
-
-尽管很多网站对自己的网络API接口进行了保护，增加了获取数据的难度，但是只要经过足够的努力，绝大多数还是可以被逆向工程的，但是在实际开发中，我们可以通过浏览器渲染引擎来避免这些繁琐的工作，WebKit就是一个利用的渲染引擎。
-
-WebKit的代码始于1998年的KHTML项目，当时它是Konqueror浏览器的渲染引擎。2001年，苹果公司从这个项目的代码中衍生出了WebKit并应用于Safari浏览器，早期的Chrome浏览器也使用了该内核。在Python中，我们可以通过Qt框架获得WebKit引擎并使用它来渲染页面获得动态内容，关于这个内容请大家自行阅读[《爬虫技术:动态页面抓取超级指南》](http://python.jobbole.com/84600/)一文。
-
-如果没有打算用上面所说的方式来渲染页面并获得动态内容，其实还有一种替代方案就是使用自动化测试工具Selenium，它提供了浏览器自动化的API接口，这样就可以通过操控浏览器来获取动态内容。首先可以使用pip来安装Selenium。
-
-```Shell
-pip3 install selenium
-```
-
-下面以“阿里V任务”的“直播服务”为例，来演示如何使用Selenium获取到动态内容并抓取主播图片。
-
-```Python
-import requests
-
-from bs4 import BeautifulSoup
-
-
-def main():
-    resp = requests.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
-    soup = BeautifulSoup(resp.text, 'lxml')
-    for img_tag in soup.select('img[src]'):
-        print(img_tag.attrs['src'])
-
-
-if __name__ == '__main__':
-    main()
-```
-
-运行上面的程序会发现没有任何的输出，因为页面的HTML代码上根本找不到`<img>`标签。接下来我们使用Selenium来获取到页面上的动态内容，再提取主播图片。
-
-```Python
-from bs4 import BeautifulSoup
-from selenium import webdriver
-from selenium.webdriver.common.keys import Keys
-
-
-def main():
-    driver = webdriver.Chrome()
-    driver.get('https://v.taobao.com/v/content/live?catetype=704&from=taonvlang')
-    soup = BeautifulSoup(driver.page_source, 'lxml')
-    for img_tag in soup.body.select('img[src]'):
-        print(img_tag.attrs['src'])
-
-
-if __name__ == '__main__':
-    main()
-```
-
-在上面的程序中，我们通过Selenium实现对Chrome浏览器的操控，如果要操控其他的浏览器，可以创对应的浏览器对象，例如Firefox、IE等。运行上面的程序，如果看到如下所示的错误提示，那是说明我们还没有将Chrome浏览器的驱动添加到PATH环境变量中，也没有在程序中指定Chrome浏览器驱动所在的位置。
-
-```Shell
-selenium.common.exceptions.WebDriverException: Message: 'chromedriver' executable needs to be in PATH. Please see https://sites.google.com/a/chromium.org/chromedriver/home
-```
-
-为了解决上面的问题，可以到Selenium的[官方网站](https://www.seleniumhq.org)找到浏览器驱动的下载链接并下载需要的驱动，在Linux或macOS系统下可以通过下面的命令来设置PATH环境变量，Windows下配置环境变量也非常简单，不清楚的可以自行了解。
-
-```Shell
-export PATH=$PATH:/Users/Hao/Downloads/Tools/chromedriver/
-```
-
-其中`/Users/Hao/Downloads/Tools/chromedriver/ `就是chromedriver所在的路径。当然，更为简单的办法是把chromedriver直接放在虚拟环境中，跟Python解释器位于同一个路径下就可以了。
-
-### WebDriver用法详解
-
-表1. 定位页面元素的方法
-
-
-
-表2. WebDriver的常用属性
-
-| 属性                  | 描述                          |
-| --------------------- | ----------------------------- |
-| current_url           | 当前页面的URL                 |
-| current_window_handle | 当前窗口的句柄（引用）        |
-| name                  | WebDriver实例底层浏览器的名称 |
-| orientation           | 当前设备的方向（横屏、竖屏）  |
-| page_source           | 当前页面的源代码（动态内容）  |
-| title                 | 当前页面的标题                |
-| window_handles        | WebDriver打开的所有窗口的句柄 |
-
-表3. WebDriver的常用方法
-
-| 方法                                | 描述                                   |
-| ----------------------------------- | -------------------------------------- |
-| back() / forward()                  | 在浏览历史记录中后退/前进              |
-| close() / quit()                    | 关闭当前浏览器窗口 / 退出WebDriver实例 |
-| get(url)                            | 加载指定URL的页面到浏览器中            |
-| maximize_window()                   | 将浏览器窗口最大化                     |
-| refresh()                           | 刷新当前页面                           |
-| switch_to_active_element()          | 获得页面上得到焦点的元素               |
-| switch_to_alert()                   | 把焦点切换至弹出的警告框               |
-| set_page_load_timeout(time_to_wait) | 设置页面加载超时时间                   |
-| set_script_timeout(time_to_wait)    | 设置JavaScript执行超时时间             |
-| implicit_wait(time_to_wait)         | 设置等待元素被找到或目标指令完成       |
-
-### WebElement用法
-
-表1. WebElement常用属性
-
-|      |      |
-| ---- | ---- |
-|      |      |
-|      |      |
-|      |      |
-
-表2. WebElement常用方法
-
-|      |      |
-| ---- | ---- |
-|      |      |
-|      |      |
-|      |      |
-|      |      |
-|      |      |
-|      |      |
-|      |      |
-|      |      |
-|      |      |
-
-### Select用法
-
-### Alert用法
-
-### 元素等待机制
-
-#### 隐式等待
-
-#### 显示等待
-
-### 高级特性
-
-#### 鼠标和键盘事件
-
-#### 调用JavaScript
-
-#### 屏幕截图和录制
-
-#### 操作Cookie
-
diff --git a/README.md b/README.md
index 2e2a3bc..8bf8e65 100644
--- a/README.md
+++ b/README.md
@@ -199,28 +199,23 @@ Python在以下领域都有用武之地。
 
 ### Day36~40 - [数据库基础和进阶](./Day36-40)
 
-- [关系型数据库MySQL](./Day36-40/36.关系型数据库和MySQL概述.md)
-  - 关系型数据库概述
-  - MySQL的安装和使用
-  - SQL的使用
-    - DDL - 数据定义语言 - `create` / `drop` / `alter`
-    - DML - 数据操作语言 - `insert` / `delete` / `update`
-    - DQL - 数据查询语言 - `select`
-    - DCL - 数据控制语言 - `grant` / `revoke`
-  - MySQL新特性
-    - 窗口函数的应用
-    - JSON数据类型
-  - 相关知识
-    - 数据完整性和一致性
-    - 视图、函数、过程、触发器
-    - 事务和锁
-    - 执行计划和索引
-    - 范式理论和反范式设计
-  - 在Python中操作MySQL
-- [NoSQL数据库入门](./Day36-40/39-40.NoSQL数据库入门.md)
-  - NoSQL概述
-  - Redis概述
-  - Mongo概述
+- 关系型数据库概述
+- MySQL的安装和使用
+- SQL的使用
+- DDL - 数据定义语言 - `create` / `drop` / `alter`
+- DML - 数据操作语言 - `insert` / `delete` / `update`
+- DQL - 数据查询语言 - `select`
+- DCL - 数据控制语言 - `grant` / `revoke`
+- MySQL新特性
+- 窗口函数的应用
+- JSON数据类型
+- 相关知识
+- 数据完整性和一致性
+- 视图、函数、过程、触发器
+- 事务和锁
+- 执行计划和索引
+- 范式理论和反范式设计
+- 在Python中操作MySQL
 
 ### Day41~55 - [实战Django](./Day41-55)
 
@@ -327,34 +322,23 @@ Python在以下领域都有用武之地。
 
 ### Day61~65 - [爬虫开发](./Day61-65)
 
-#### Day61 - [网络爬虫和相关工具](./Day61-65/61.网络爬虫和相关工具.md)
+#### Day61 - [网络数据采集概述](./Day61-65/61.网络数据采集概述.md)
 
 - 网络爬虫的概念及其应用领域
 - 网络爬虫的合法性探讨
 - 开发网络爬虫的相关工具
 - 一个爬虫程序的构成
 
-#### Day62 - [数据采集和解析](./Day61-65/62.数据采集和解析.md)
+#### Day62 - 数据抓取和解析
 
-- 数据采集的标准和三方库
+- 使用`requests`三方库实现数据抓取
 - 页面解析的三种方式：正则表达式解析 / XPath解析 / CSS选择器解析
 
-#### Day63 - [存储数据](./Day61-65/63.存储数据.md)
+#### Day63 - Python中的并发编程
 
-- 如何存储海量数据
-- 实现数据的缓存
-
-#### Day64 - [并发下载](./Day61-65/64.并发下载.md)
-
-- 多线程和多进程
-- 异步I/O和协程
-- `async`和`await`关键字的使用
-- 三方库`aiohttp`的应用
-
-#### Day65 - [解析动态内容](./Day61-65/65.解析动态内容.md)
-
-- JavaScript逆向工程
-- 使用Selenium获取动态内容
+- 多线程
+- 多进程
+- 异步I/O
 
 ### Day66~80 - [数据分析](./Day66-80)