diff --git a/Day61-65/.gitkeep b/Day61-65/.gitkeep
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git "a/Day66-75/66.\347\275\221\347\273\234\347\210\254\350\231\253\345\222\214\347\233\270\345\205\263\345\267\245\345\205\267.md" "b/Day61-65/61.\347\275\221\347\273\234\347\210\254\350\231\253\345\222\214\347\233\270\345\205\263\345\267\245\345\205\267.md"
similarity index 100%
rename from "Day66-75/66.\347\275\221\347\273\234\347\210\254\350\231\253\345\222\214\347\233\270\345\205\263\345\267\245\345\205\267.md"
rename to "Day61-65/61.\347\275\221\347\273\234\347\210\254\350\231\253\345\222\214\347\233\270\345\205\263\345\267\245\345\205\267.md"
diff --git "a/Day61-65/61.\351\242\204\345\244\207\347\237\245\350\257\206.md" "b/Day61-65/61.\351\242\204\345\244\207\347\237\245\350\257\206.md"
deleted file mode 100644
index 4a95122c324f9cff4faa83d70afc3141f2903035..0000000000000000000000000000000000000000
--- "a/Day61-65/61.\351\242\204\345\244\207\347\237\245\350\257\206.md"
+++ /dev/null
@@ -1,140 +0,0 @@
-## 预备知识
-
-### 并发编程
-
-所谓并发编程就是让程序中有多个部分能够并发或同时执行，并发编程带来的好处不言而喻，其中最为关键的两点是提升了执行效率和改善了用户体验。下面简单阐述一下Python中实现并发编程的三种方式：
-
-1. 多线程：Python中通过`threading`模块的`Thread`类并辅以`Lock`、`Condition`、`Event`、`Semaphore`和`Barrier`等类来支持多线程编程。Python解释器通过GIL（全局解释器锁）来防止多个线程同时执行本地字节码，这个锁对于CPython（Python解释器的官方实现）是必须的，因为CPython的内存管理并不是线程安全的。因为GIL的存在，Python的多线程并不能利用CPU的多核特性。
-
-2. 多进程：使用多进程可以有效的解决GIL的问题，Python中的`multiprocessing`模块提供了`Process`类来实现多进程，其他的辅助类跟`threading`模块中的类类似，由于进程间的内存是相互隔离的（操作系统对进程的保护），进程间通信（共享数据）必须使用管道、套接字等方式，这一点从编程的角度来讲是比较麻烦的，为此，Python的`multiprocessing`模块提供了一个名为`Queue`的类，它基于管道和锁机制提供了多个进程共享的队列。
-
- ```Python
- """
- 用下面的命令运行程序并查看执行时间，例如：
- time python3 example06.py
- real 0m20.657s
- user 1m17.749s
- sys 0m0.158s
- 使用多进程后实际执行时间为20.657秒，而用户时间1分17.749秒约为实际执行时间的4倍
- 这就证明我们的程序通过多进程使用了CPU的多核特性，而且这台计算机配置了4核的CPU
- """
- import concurrent.futures
- import math
-
- PRIMES = [
- 1116281,
- 1297337,
- 104395303,
- 472882027,
- 533000389,
- 817504243,
- 982451653,
- 112272535095293,
- 112582705942171,
- 112272535095293,
- 115280095190773,
- 115797848077099,
- 1099726899285419
- ] * 5
-
-
- def is_prime(num):
- """判断素数"""
- assert num > 0
- for i in range(2, int(math.sqrt(num)) + 1):
- if num % i == 0:
- return False
- return num != 1
-
-
- def main():
- """主函数"""
- with concurrent.futures.ProcessPoolExecutor() as executor:
- for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
- print('%d is prime: %s' % (number, prime))
-
-
- if __name__ == '__main__':
- main()
- ```
-
-3. 异步编程（异步I/O）：所谓异步编程是通过调度程序从任务队列中挑选任务，调度程序以交叉的形式执行这些任务，我们并不能保证任务将以某种顺序去执行，因为执行顺序取决于队列中的一项任务是否愿意将CPU处理时间让位给另一项任务。异步编程通常通过多任务协作处理的方式来实现，由于执行时间和顺序的不确定，因此需要通过钩子函数（回调函数）或者`Future`对象来获取任务执行的结果。目前我们使用的Python 3通过`asyncio`模块以及`await`和`async`关键字（Python 3.5中引入，Python 3.7中正式成为关键字）提供了对异步I/O的支持。
-
- ```Python
- import asyncio
-
-
- async def fetch(host):
- """从指定的站点抓取信息(协程函数)"""
- print(f'Start fetching {host}\n')
- # 跟服务器建立连接
- reader, writer = await asyncio.open_connection(host, 80)
- # 构造请求行和请求头
- writer.write(b'GET / HTTP/1.1\r\n')
- writer.write(f'Host: {host}\r\n'.encode())
- writer.write(b'\r\n')
- # 清空缓存区(发送请求)
- await writer.drain()
- # 接收服务器的响应(读取响应行和响应头)
- line = await reader.readline()
- while line != b'\r\n':
- print(line.decode().rstrip())
- line = await reader.readline()
- print('\n')
- writer.close()
-
-
- def main():
- """主函数"""
- urls = ('www.sohu.com', 'www.douban.com', 'www.163.com')
- # 获取系统默认的事件循环
- loop = asyncio.get_event_loop()
- # 用生成式语法构造一个包含多个协程对象的列表
- tasks = [fetch(url) for url in urls]
- # 通过asyncio模块的wait函数将协程列表包装成Task（Future子类）并等待其执行完成
- # 通过事件循环的run_until_complete方法运行任务直到Future完成并返回它的结果
- loop.run_until_complete(asyncio.wait(tasks))
- loop.close()
-
-
- if __name__ == '__main__':
- main()
- ```
-
- > 说明：目前大多数网站都要求基于HTTPS通信，因此上面例子中的网络请求不一定能收到正常的响应，也就是说响应状态码不一定是200，有可能是3xx或者4xx。当然我们这里的重点不在于获得网站响应的内容，而是帮助大家理解`asyncio`模块以及`async`和`await`两个关键字的使用。
-
-我们对三种方式的使用场景做一个简单的总结。
-
-以下情况需要使用多线程：
-
-1. 程序需要维护许多共享的状态（尤其是可变状态），Python中的列表、字典、集合都是线程安全的，所以使用线程而不是进程维护共享状态的代价相对较小。
-2. 程序会花费大量时间在I/O操作上，没有太多并行计算的需求且不需占用太多的内存。
-
-以下情况需要使用多进程：
-
-1. 程序执行计算密集型任务（如：字节码操作、数据处理、科学计算）。
-2. 程序的输入可以并行的分成块，并且可以将运算结果合并。
-3. 程序在内存使用方面没有任何限制且不强依赖于I/O操作（如：读写文件、套接字等）。
-
-最后，如果程序不需要真正的并发性或并行性，而是更多的依赖于异步处理和回调时，异步I/O就是一种很好的选择。另一方面，当程序中有大量的等待与休眠时，也应该考虑使用异步I/O。
-
-> 扩展：关于进程，还需要做一些补充说明。首先，为了控制进程的执行，操作系统内核必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程使之继续执行，这种行为被称为进程切换（也叫调度）。进程切换是比较耗费资源的操作，因为在进行切换时首先要保存当前进程的上下文（内核再次唤醒该进程时所需要的状态，包括：程序计数器、状态寄存器、数据栈等），然后还要恢复准备执行的进程的上下文。正在执行的进程由于期待的某些事件未发生，如请求系统资源失败、等待某个操作完成、新数据尚未到达等原因会主动由运行状态变为阻塞状态，当进程进入阻塞状态，是不占用CPU资源的。这些知识对于理解到底选择哪种方式进行并发编程也是很重要的。
-
-### I/O模式和事件驱动
-
-对于一次I/O操作（以读操作为例），数据会先被拷贝到操作系统内核的缓冲区中，然后从操作系统内核的缓冲区拷贝到应用程序的缓冲区（这种方式称为标准I/O或缓存I/O，大多数文件系统的默认I/O都是这种方式），最后交给进程。所以说，当一个读操作发生时（写操作与之类似），它会经历两个阶段：(1)等待数据准备就绪；(2)将数据从内核拷贝到进程中。
-
-由于存在这两个阶段，因此产生了以下几种I/O模式：
-
-1. 阻塞 I/O（blocking I/O）：进程发起读操作，如果内核数据尚未就绪，进程会阻塞等待数据直到内核数据就绪并拷贝到进程的内存中。
-2. 非阻塞 I/O（non-blocking I/O）：进程发起读操作，如果内核数据尚未就绪，进程不阻塞而是收到内核返回的错误信息，进程收到错误信息可以再次发起读操作，一旦内核数据准备就绪，就立即将数据拷贝到了用户内存中，然后返回。
-3. 多路I/O复用（ I/O multiplexing）：监听多个I/O对象，当I/O对象有变化（数据就绪）的时候就通知用户进程。多路I/O复用的优势并不在于单个I/O操作能处理得更快，而是在于能处理更多的I/O操作。
-4. 异步 I/O（asynchronous I/O）：进程发起读操作后就可以去做别的事情了，内核收到异步读操作后会立即返回，所以用户进程不阻塞，当内核数据准备就绪时，内核发送一个信号给用户进程，告诉它读操作完成了。
-
-通常，我们编写一个处理用户请求的服务器程序时，有以下三种方式可供选择：
-
-1. 每收到一个请求，创建一个新的进程，来处理该请求；
-2. 每收到一个请求，创建一个新的线程，来处理该请求；
-3. 每收到一个请求，放入一个事件列表，让主进程通过非阻塞I/O方式来处理请求
-
-第1种方式实现比较简单，但由于创建进程开销比较大，会导致服务器性能比较差；第2种方式，由于要涉及到线程的同步，有可能会面临竞争、死锁等问题；第3种方式，就是所谓事件驱动的方式，它利用了多路I/O复用和异步I/O的优点，虽然代码逻辑比前面两种都复杂，但能达到最好的性能，这也是目前大多数网络服务器采用的方式。
diff --git "a/Day61-65/62.Tornado\345\205\245\351\227\250.md" "b/Day61-65/62.Tornado\345\205\245\351\227\250.md"
deleted file mode 100644
index e1249f8375eeb6b2d82a7bda6e5ee11c931356d3..0000000000000000000000000000000000000000
--- "a/Day61-65/62.Tornado\345\205\245\351\227\250.md"
+++ /dev/null
@@ -1,377 +0,0 @@
-## Tornado入门
-
-### Tornado概述
-
-Python的Web框架种类繁多（比Python语言的关键字还要多），但在众多优秀的Web框架中，Tornado框架最适合用来开发需要处理长连接和应对高并发的Web应用。Tornado框架在设计之初就考虑到性能问题，通过对非阻塞I/O和epoll（Linux 2.5.44内核引入的一种多路I/O复用方式，旨在实现高性能网络服务，在BSD和macOS中是kqueue）的运用，Tornado可以处理大量的并发连接，更轻松的应对C10K（万级并发）问题，是非常理想的实时通信Web框架。
-
-> 扩展：基于线程的Web服务器产品（如：Apache）会维护一个线程池来处理用户请求，当用户请求到达时就为该请求分配一个线程，如果线程池中没有空闲线程了，那么可以通过创建新的线程来应付新的请求，但前提是系统尚有空闲的内存空间，显然这种方式很容易将服务器的空闲内存耗尽（大多数Linux发行版本中，默认的线程栈大小为8M）。想象一下，如果我们要开发一个社交类应用，这类应用中，通常需要显示实时更新的消息、对象状态的变化和各种类型的通知，那也就意味着客户端需要保持请求连接来接收服务器的各种响应，在这种情况下，服务器上的工作线程很容易被耗尽，这也就意味着新的请求很有可能无法得到响应。
-
-Tornado框架源于FriendFeed网站，在FriendFeed网站被Facebook收购之后得以开源，正式发布的日期是2009年9月10日。Tornado能让你能够快速开发高速的Web应用，如果你想编写一个可扩展的社交应用、实时分析引擎，或RESTful API，那么Tornado框架就是很好的选择。Tornado其实不仅仅是一个Web开发的框架，它还是一个高性能的事件驱动网络访问引擎，内置了高性能的HTTP服务器和客户端（支持同步和异步请求），同时还对WebSocket提供了完美的支持。
-
-了解和学习Tornado最好的资料就是它的官方文档，在[tornadoweb.org](http://www.tornadoweb.org)上面有很多不错的例子，你也可以在Github上找到Tornado的源代码和历史版本。
-
-### 5分钟上手Tornado
-
-1. 创建并激活虚拟环境。
-
- ```Shell
- mkdir hello-tornado
- cd hello-tornado
- python3 -m venv venv
- source venv/bin/activate
- ```
-
-2. 安装Tornado。
-
- ```Shell
- pip install tornado
- ```
-
-3. 编写Web应用。
-
- ```Python
- """
- example01.py
- """
- import tornado.ioloop
- import tornado.web
-
-
- class MainHandler(tornado.web.RequestHandler):
-
- def get(self):
- self.write('Hello, world!
')
-
-
- def main():
- app = tornado.web.Application(handlers=[(r'/', MainHandler), ])
- app.listen(8888)
- tornado.ioloop.IOLoop.current().start()
-
-
- if __name__ == '__main__':
- main()
- ```
-
-4. 运行并访问应用。
-
- ```Shell
- python example01.py
- ```
-
- 
-
-在上面的例子中，代码example01.py通过定义一个继承自`RequestHandler`的类（`MainHandler`）来处理用户请求，当请求到达时，Tornado会实例化这个类（创建`MainHandler`对象），并调用与HTTP请求方法（GET、POST等）对应的方法，显然上面的`MainHandler`只能处理GET请求，在收到GET请求时，它会将一段HTML的内容写入到HTTP响应中。`main`函数的第1行代码创建了Tornado框架中`Application`类的实例，它代表了我们的Web应用，而创建该实例最为重要的参数就是`handlers`，该参数告知`Application`对象，当收到一个请求时应该通过哪个类的对象来处理这个请求。在上面的例子中，当通过HTTP的GET请求访问站点根路径时，就会调用`MainHandler`的`get`方法。 `main`函数的第2行代码通过`Application`对象的`listen`方法指定了监听HTTP请求的端口。`main`函数的第3行代码用于获取Tornado框架的`IOLoop`实例并启动它，该实例代表一个条件触发的I/O循环，用于持续的接收来自于客户端的请求。
-
-> 扩展：在Python 3中，`IOLoop`实例的本质就是`asyncio`的事件循环，该事件循环在非Windows系统中就是`SelectorEventLoop`对象，它基于`selectors`模块（高级I/O复用模块），会使用当前操作系统最高效的I/O复用选择器，例如在Linux环境下它使用`EpollSelector`，而在macOS和BSD环境下它使用的是`KqueueSelector`；在Python 2中，`IOLoop`直接使用`select`模块（低级I/O复用模块）的`epoll`或`kqueue`函数，如果这两种方式都不可用，则调用`select`函数实现多路I/O复用。当然，如果要支持高并发，你的系统最好能够支持epoll或者kqueue这两种多路I/O复用方式中的一种。
-
-如果希望通过命令行参数来指定Web应用的监听端口，可以对上面的代码稍作修改。
-
-```Python
-"""
-example01.py
-"""
-import tornado.ioloop
-import tornado.web
-
-from tornado.options import define, options, parse_command_line
-
-
-# 定义默认端口
-define('port', default=8000, type=int)
-
-
-class MainHandler(tornado.web.RequestHandler):
-
- def get(self):
- self.write('Hello, world!
')
-
-
-def main():
- # python example01.py --port=8000
- parse_command_line()
- app = tornado.web.Application(handlers=[(r'/', MainHandler), ])
- app.listen(options.port)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
-```
-
-在启动Web应用时，如果没有指定端口，将使用`define`函数中设置的默认端口8000，如果要指定端口，可以使用下面的方式来启动Web应用。
-
-```Shell
-python example01.py --port=8000
-```
-
-### 路由解析
-
-上面我们曾经提到过创建`Application`实例时需要指定`handlers`参数，这个参数非常重要，它应该是一个元组的列表，元组中的第一个元素是正则表达式，它用于匹配用户请求的资源路径；第二个元素是`RequestHandler`的子类。在刚才的例子中，我们只在`handlers`列表中放置了一个元组，事实上我们可以放置多个元组来匹配不同的请求（资源路径），而且可以使用正则表达式的捕获组来获取匹配的内容并将其作为参数传入到`get`、`post`这些方法中。
-
-```Python
-"""
-example02.py
-"""
-import os
-import random
-
-import tornado.ioloop
-import tornado.web
-
-from tornado.options import define, options, parse_command_line
-
-
-# 定义默认端口
-define('port', default=8000, type=int)
-
-
-class SayingHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- sayings = [
- '世上没有绝望的处境，只有对处境绝望的人',
- '人生的道路在态度的岔口一分为二，从此通向成功或失败',
- '所谓措手不及，不是说没有时间准备，而是有时间的时候没有准备',
- '那些你认为不靠谱的人生里，充满你没有勇气做的事',
- '在自己喜欢的时间里，按照自己喜欢的方式，去做自己喜欢做的事，这便是自由',
- '有些人不属于自己，但是遇见了也弥足珍贵'
- ]
- # 渲染index.html模板页
- self.render('index.html', message=random.choice(sayings))
-
-
-class WeatherHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self, city):
- # Tornado框架会自动处理百分号编码的问题
- weathers = {
- '北京': {'temperature': '-4~4', 'pollution': '195 中度污染'},
- '成都': {'temperature': '3~9', 'pollution': '53 良'},
- '深圳': {'temperature': '20~25', 'pollution': '25 优'},
- '广州': {'temperature': '18~23', 'pollution': '56 良'},
- '上海': {'temperature': '6~8', 'pollution': '65 良'}
- }
- if city in weathers:
- self.render('weather.html', city=city, weather=weathers[city])
- else:
- self.render('index.html', message=f'没有{city}的天气信息')
-
-
-class ErrorHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- # 重定向到指定的路径
- self.redirect('/saying')
-
-
-def main():
- """主函数"""
- parse_command_line()
- app = tornado.web.Application(
- # handlers是按列表中的顺序依次进行匹配的
- handlers=[
- (r'/saying/?', SayingHandler),
- (r'/weather/([^/]{2,})/?', WeatherHandler),
- (r'/.+', ErrorHandler),
- ],
- # 通过template_path参数设置模板页的路径
- template_path=os.path.join(os.path.dirname(__file__), 'templates')
- )
- app.listen(options.port)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
-```
-
-模板页index.html。
-
-```HTML
-
-
-
-
-
- Tornado基础
-
-
- {{message}}
-
-
-```
-
-模板页weather.html。
-
-```HTML
-
-
-
-
-
- Tornado基础
-
-
- {{city}}
-
- 温度：{{weather['temperature']}}摄氏度
- 污染指数：{{weather['pollution']}}
-
-
-```
-
-Tornado的模板语法与其他的Web框架中使用的模板语法并没有什么实质性的区别，而且目前的Web应用开发更倡导使用前端渲染的方式来减轻服务器的负担，所以这里我们并不对模板语法和后端渲染进行深入的讲解。
-
-### 请求处理器
-
-通过上面的代码可以看出，`RequestHandler`是处理用户请求的核心类，通过重写`get`、`post`、`put`、`delete`等方法可以处理不同类型的HTTP请求，除了这些方法之外，`RequestHandler`还实现了很多重要的方法，下面是部分方法的列表：
-
-1. `get_argument` / `get_arguments` / `get_body_argument` / `get_body_arguments` / `get_query_arugment` / `get_query_arguments`：获取请求参数。
-2. `set_status` / `send_error` / `set_header` / `add_header` / `clear_header` / `clear`：操作状态码和响应头。
-3. `write` / `flush` / `finish` / `write_error`：和输出相关的方法。
-4. `render` / `render_string`：渲染模板。
-5. `redirect`：请求重定向。
-6. `get_cookie` / `set_cookie` / `get_secure_cookie` / `set_secure_cookie` / `create_signed_value` / `clear_cookie` / `clear_all_cookies`：操作Cookie。
-
-我们用上面讲到的这些方法来完成下面的需求，访问页面时，如果Cookie中没有读取到用户信息则要求用户填写个人信息，如果从Cookie中读取到用户信息则直接显示用户信息。
-
-```Python
-"""
-example03.py
-"""
-import os
-import re
-
-import tornado.ioloop
-import tornado.web
-
-from tornado.options import define, options, parse_command_line
-
-
-# 定义默认端口
-define('port', default=8000, type=int)
-
-users = {}
-
-
-class User(object):
- """用户"""
-
- def __init__(self, nickname, gender, birthday):
- self.nickname = nickname
- self.gender = gender
- self.birthday = birthday
-
-
-class MainHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- # 从Cookie中读取用户昵称
- nickname = self.get_cookie('nickname')
- if nickname in users:
- self.render('userinfo.html', user=users[nickname])
- else:
- self.render('userform.html', hint='请填写个人信息')
-
-
-class UserHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def post(self):
- # 从表单参数中读取用户昵称、性别和生日信息
- nickname = self.get_body_argument('nickname').strip()
- gender = self.get_body_argument('gender')
- birthday = self.get_body_argument('birthday')
- # 检查用户昵称是否有效
- if not re.fullmatch(r'\w{6,20}', nickname):
- self.render('userform.html', hint='请输入有效的昵称')
- elif nickname in users:
- self.render('userform.html', hint='昵称已经被使用过')
- else:
- users[nickname] = User(nickname, gender, birthday)
- # 将用户昵称写入Cookie并设置有效期为7天
- self.set_cookie('nickname', nickname, expires_days=7)
- self.render('userinfo.html', user=users[nickname])
-
-
-def main():
- """主函数"""
- parse_command_line()
- app = tornado.web.Application(
- handlers=[
- (r'/', MainHandler), (r'/register', UserHandler)
- ],
- template_path=os.path.join(os.path.dirname(__file__), 'templates')
- )
- app.listen(options.port)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
-```
-
-模板页userform.html。
-
-```HTML
-
-
-
-
-
- Tornado基础
-
-
-
- 填写用户信息
-
- {{hint}}
-
-
-
-```
-
-模板页userinfo.html。
-
-```HTML
-
-
-
-
-
- Tornado基础
-
-
- 用户信息
-
- 昵称：{{user.nickname}}
- 性别：{{user.gender}}
- 出生日期：{{user.birthday}}
-
-
-```
diff --git "a/Day66-75/67.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md" "b/Day61-65/62.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md"
similarity index 100%
rename from "Day66-75/67.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md"
rename to "Day61-65/62.\346\225\260\346\215\256\351\207\207\351\233\206\345\222\214\350\247\243\346\236\220.md"
diff --git "a/Day61-65/63.Tornado\344\270\255\347\232\204\345\274\202\346\255\245\345\214\226.md" "b/Day61-65/63.Tornado\344\270\255\347\232\204\345\274\202\346\255\245\345\214\226.md"
deleted file mode 100644
index a450534a5c6d76d96b5fa91198354c444f164e88..0000000000000000000000000000000000000000
--- "a/Day61-65/63.Tornado\344\270\255\347\232\204\345\274\202\346\255\245\345\214\226.md"
+++ /dev/null
@@ -1,152 +0,0 @@
-## Tornado中的异步化
-
-在前面的例子中，我们并没有对`RequestHandler`中的`get`或`post`方法进行异步处理，这就意味着，一旦在`get`或`post`方法中出现了耗时间的操作，不仅仅是当前请求被阻塞，按照Tornado框架的工作模式，其他的请求也会被阻塞，所以我们需要对耗时间的操作进行异步化处理。
-
-在Tornado稍早一些的版本中，可以用装饰器实现请求方法的异步化或协程化来解决这个问题。
-
-- 给`RequestHandler`的请求处理函数添加`@tornado.web.asynchronous`装饰器，如下所示：
-
- ```Python
- class AsyncReqHandler(RequestHandler):
-
- @tornado.web.asynchronous
- def get(self):
- http = httpclient.AsyncHTTPClient()
- http.fetch("http://example.com/", self._on_download)
-
- def _on_download(self, response):
- do_something_with_response(response)
- self.render("template.html")
- ```
-
-- 给`RequestHandler`的请求处理函数添加`@tornado.gen.coroutine`装饰器，如下所示：
-
- ```Python
- class GenAsyncHandler(RequestHandler):
-
- @tornado.gen.coroutine
- def get(self):
- http_client = AsyncHTTPClient()
- response = yield http_client.fetch("http://example.com")
- do_something_with_response(response)
- self.render("template.html")
- ```
-
-- 使用`@return_future`装饰器，如下所示：
-
- ```Python
- @return_future
- def future_func(arg1, arg2, callback):
- # Do stuff (possibly asynchronous)
- callback(result)
-
- async def caller():
- await future_func(arg1, arg2)
- ```
-
-在Tornado 5.x版本中，这几个装饰器都被标记为**deprcated**（过时），我们可以通过Python 3.5中引入的`async`和`await`（在Python 3.7中已经成为正式的关键字）来达到同样的效果。当然，要实现异步化还得靠其他的支持异步操作的三方库来支持，如果请求处理函数中用到了不支持异步操作的三方库，就需要靠自己写包装类来支持异步化。
-
-下面的代码演示了在读写数据库时如何实现请求处理的异步化。我们用到的数据库建表语句如下所示：
-
-```SQL
-create database hrs default charset utf8;
-
-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)
-);
-
-insert into tb_dept values
- (10, '会计部', '北京'),
- (20, '研发部', '成都'),
- (30, '销售部', '重庆'),
- (40, '运维部', '深圳');
-```
-
-我们通过下面的代码实现了查询和新增部门两个操作。
-
-```Python
-import json
-
-import aiomysql
-import tornado
-import tornado.web
-
-from tornado.ioloop import IOLoop
-from tornado.options import define, parse_command_line, options
-
-define('port', default=8000, type=int)
-
-
-async def connect_mysql():
- return await aiomysql.connect(
- host='120.77.222.217',
- port=3306,
- db='hrs',
- user='root',
- password='123456',
- )
-
-
-class HomeHandler(tornado.web.RequestHandler):
-
- async def get(self, no):
- async with self.settings['mysql'].cursor(aiomysql.DictCursor) as cursor:
- await cursor.execute("select * from tb_dept where dno=%s", (no, ))
- if cursor.rowcount == 0:
- self.finish(json.dumps({
- 'code': 20001,
- 'mesg': f'没有编号为{no}的部门'
- }))
- return
- row = await cursor.fetchone()
- self.finish(json.dumps(row))
-
- async def post(self, *args, **kwargs):
- no = self.get_argument('no')
- name = self.get_argument('name')
- loc = self.get_argument('loc')
- conn = self.settings['mysql']
- try:
- async with conn.cursor() as cursor:
- await cursor.execute('insert into tb_dept values (%s, %s, %s)',
- (no, name, loc))
- await conn.commit()
- except aiomysql.MySQLError:
- self.finish(json.dumps({
- 'code': 20002,
- 'mesg': '添加部门失败请确认部门信息'
- }))
- else:
- self.set_status(201)
- self.finish()
-
-
-def make_app(config):
- return tornado.web.Application(
- handlers=[(r'/api/depts/(.*)', HomeHandler), ],
- **config
- )
-
-
-def main():
- parse_command_line()
- app = make_app({
- 'debug': True,
- 'mysql': IOLoop.current().run_sync(connect_mysql)
- })
- app.listen(options.port)
- IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
-```
-
-上面的代码中，我们用到了`aiomysql`这个三方库，它基于`pymysql`封装，实现了对MySQL操作的异步化。操作Redis可以使用`aioredis`，访问MongoDB可以使用`motor`，这些都是支持异步操作的三方库。
\ No newline at end of file
diff --git "a/Day66-75/68.\345\255\230\345\202\250\346\225\260\346\215\256.md" "b/Day61-65/63.\345\255\230\345\202\250\346\225\260\346\215\256.md"
similarity index 100%
rename from "Day66-75/68.\345\255\230\345\202\250\346\225\260\346\215\256.md"
rename to "Day61-65/63.\345\255\230\345\202\250\346\225\260\346\215\256.md"
diff --git "a/Day61-65/64.WebSocket\347\232\204\345\272\224\347\224\250.md" "b/Day61-65/64.WebSocket\347\232\204\345\272\224\347\224\250.md"
deleted file mode 100644
index ef25c9e0c149f2d57af1cb5154c9c0fdd45c0206..0000000000000000000000000000000000000000
--- "a/Day61-65/64.WebSocket\347\232\204\345\272\224\347\224\250.md"
+++ /dev/null
@@ -1,228 +0,0 @@
-## WebSocket的应用
-
-Tornado的异步特性使其非常适合处理高并发的业务，同时也适合那些需要在客户端和服务器之间维持长连接的业务。传统的基于HTTP协议的Web应用，服务器和客户端（浏览器）的通信只能由客户端发起，这种单向请求注定了如果服务器有连续的状态变化，客户端（浏览器）是很难得知的。事实上，今天的很多Web应用都需要服务器主动向客户端（浏览器）发送数据，我们将这种通信方式称之为“推送”。过去很长一段时间，程序员都是用定时轮询（Polling）或长轮询（Long Polling）等方式来实现“推送”，但是这些都不是真正意义上的“推送”，而且浪费资源且效率低下。在HTML5时代，可以通过一种名为WebSocket的技术在服务器和客户端（浏览器）之间维持传输数据的长连接，这种方式可以实现真正的“推送”服务。
-
-### WebSocket简介
-
-WebSocket 协议在2008年诞生，2011年成为国际标准（[RFC 6455](https://tools.ietf.org/html/rfc6455)），现在的浏览器都能够支持它，它可以实现浏览器和服务器之间的全双工通信。我们之前学习或了解过Python的Socket编程，通过Socket编程，可以基于TCP或UDP进行数据传输；而WebSocket与之类似，只不过它是基于HTTP来实现通信握手，使用TCP来进行数据传输。WebSocket的出现打破了HTTP请求和响应只能一对一通信的模式，也改变了服务器只能被动接受客户端请求的状况。目前有很多Web应用是需要服务器主动向客户端发送信息的，例如股票信息的网站可能需要向浏览器发送股票涨停通知，社交网站可能需要向用户发送好友上线提醒或聊天信息。
-
-
-
-WebSocket的特点如下所示：
-
-1. 建立在TCP协议之上，服务器端的实现比较容易。
-2. 与HTTP协议有着良好的兼容性，默认端口是80（WS）和443（WSS），通信握手阶段采用HTTP协议，能通过各种 HTTP 代理服务器（不容易被防火墙阻拦）。
-3. 数据格式比较轻量，性能开销小，通信高效。
-4. 可以发送文本，也可以发送二进制数据。
-5. 没有同源策略的限制，客户端（浏览器）可以与任意服务器通信。
-
-
-
-### WebSocket服务器端编程
-
-Tornado框架中有一个`tornado.websocket.WebSocketHandler`类专门用于处理来自WebSocket的请求，通过继承该类并重写`open`、`on_message`、`on_close` 等方法来处理WebSocket通信，下面我们对`WebSocketHandler`的核心方法做一个简单的介绍。
-
-1. `open(*args, **kwargs)`方法：建立新的WebSocket连接后，Tornado框架会调用该方法，该方法的参数与`RequestHandler`的`get`方法的参数类似，这也就意味着在`open`方法中可以执行获取请求参数、读取Cookie信息这样的操作。
-
-2. `on_message(message)`方法：建立WebSocket之后，当收到来自客户端的消息时，Tornado框架会调用该方法，这样就可以对收到的消息进行对应的处理，必须重写这个方法。
-
-3. `on_close()`方法：当WebSocket被关闭时，Tornado框架会调用该方法，在该方法中可以通过`close_code`和`close_reason`了解关闭的原因。
-
-4. `write_message(message, binary=False)`方法：将指定的消息通过WebSocket发送给客户端，可以传递utf-8字符序列或者字节序列，如果message是一个字典，将会执行JSON序列化。正常情况下，该方法会返回一个`Future`对象；如果WebSocket被关闭了，将引发`WebSocketClosedError`。
-
-5. `set_nodelay(value)`方法：默认情况下，因为TCP的Nagle算法会导致短小的消息被延迟发送，在考虑到交互性的情况下就要通过将该方法的参数设置为`True`来避免延迟。
-
-6. `close(code=None, reason=None)`方法：主动关闭WebSocket，可以指定状态码（详见[RFC 6455 7.4.1节](https://tools.ietf.org/html/rfc6455#section-7.4.1)）和原因。
-
-### WebSocket客户端编程
-
-1. 创建WebSocket对象。
-
- ```JavaScript
- var webSocket = new WebSocket('ws://localhost:8000/ws');
- ```
-
- >说明：webSocket对象的readyState属性表示该对象当前状态，取值为CONNECTING-正在连接，OPEN-连接成功可以通信，CLOSING-正在关闭，CLOSED-已经关闭。
-
-2. 编写回调函数。
-
- ```JavaScript
- webSocket.onopen = function(evt) { webSocket.send('...'); };
- webSocket.onmessage = function(evt) { console.log(evt.data); };
- webSocket.onclose = function(evt) {};
- webSocket.onerror = function(evt) {};
- ```
-
- > 说明：如果要绑定多个事件回调函数，可以用addEventListener方法。另外，通过事件对象的data属性获得的数据可能是字符串，也有可能是二进制数据，可以通过webSocket对象的binaryType属性（blob、arraybuffer）或者通过typeof、instanceof运算符检查类型进行判定。
-
-### 项目：Web聊天室
-
-```Python
-"""
-handlers.py - 用户登录和聊天的处理器
-"""
-import tornado.web
-import tornado.websocket
-
-nicknames = set()
-connections = {}
-
-
-class LoginHandler(tornado.web.RequestHandler):
-
- def get(self):
- self.render('login.html', hint='')
-
- def post(self):
- nickname = self.get_argument('nickname')
- if nickname in nicknames:
- self.render('login.html', hint='昵称已被使用，请更换昵称')
- self.set_secure_cookie('nickname', nickname)
- self.render('chat.html')
-
-
-class ChatHandler(tornado.websocket.WebSocketHandler):
-
- def open(self):
- nickname = self.get_secure_cookie('nickname').decode()
- nicknames.add(nickname)
- for conn in connections.values():
- conn.write_message(f'~~~{nickname}进入了聊天室~~~')
- connections[nickname] = self
-
- def on_message(self, message):
- nickname = self.get_secure_cookie('nickname').decode()
- for conn in connections.values():
- if conn is not self:
- conn.write_message(f'{nickname}说：{message}')
-
- def on_close(self):
- nickname = self.get_secure_cookie('nickname').decode()
- del connections[nickname]
- nicknames.remove(nickname)
- for conn in connections.values():
- conn.write_message(f'~~~{nickname}离开了聊天室~~~')
-
-```
-
-```Python
-"""
-run_chat_server.py - 聊天服务器
-"""
-import os
-
-import tornado.web
-import tornado.ioloop
-
-from handlers import LoginHandler, ChatHandler
-
-
-if __name__ == '__main__':
- app = tornado.web.Application(
- handlers=[(r'/login', LoginHandler), (r'/chat', ChatHandler)],
- template_path=os.path.join(os.path.dirname(__file__), 'templates'),
- static_path=os.path.join(os.path.dirname(__file__), 'static'),
- cookie_secret='MWM2MzEyOWFlOWRiOWM2MGMzZThhYTk0ZDNlMDA0OTU=',
- )
- app.listen(8888)
- tornado.ioloop.IOLoop.current().start()
-```
-
-```HTML
-
-
-
-
-
- Tornado聊天室
-
-
-
-
-
-
-```
-
-```HTML
-
-
-
-
-
- Tornado聊天室
-
-
- 聊天室
-
-
-
-
-
-
-
-
-
- 退出聊天室
-
-
-
-
-
-```
-
diff --git "a/Day66-75/69.\345\271\266\345\217\221\344\270\213\350\275\275.md" "b/Day61-65/64.\345\271\266\345\217\221\344\270\213\350\275\275.md"
similarity index 100%
rename from "Day66-75/69.\345\271\266\345\217\221\344\270\213\350\275\275.md"
rename to "Day61-65/64.\345\271\266\345\217\221\344\270\213\350\275\275.md"
diff --git "a/Day66-75/70.\350\247\243\346\236\220\345\212\250\346\200\201\345\206\205\345\256\271.md" "b/Day61-65/65.\350\247\243\346\236\220\345\212\250\346\200\201\345\206\205\345\256\271.md"
similarity index 100%
rename from "Day66-75/70.\350\247\243\346\236\220\345\212\250\346\200\201\345\206\205\345\256\271.md"
rename to "Day61-65/65.\350\247\243\346\236\220\345\212\250\346\200\201\345\206\205\345\256\271.md"
diff --git "a/Day61-65/65.\351\241\271\347\233\256\345\256\236\346\210\230.md" "b/Day61-65/65.\351\241\271\347\233\256\345\256\236\346\210\230.md"
deleted file mode 100644
index dbbae84d758e448acfe95faf9761348ab864364d..0000000000000000000000000000000000000000
--- "a/Day61-65/65.\351\241\271\347\233\256\345\256\236\346\210\230.md"
+++ /dev/null
@@ -1,2 +0,0 @@
-## 项目实战
-
diff --git "a/Day66-75/75.\345\270\270\350\247\201\345\217\215\347\210\254\347\255\226\347\225\245\345\217\212\345\272\224\345\257\271\346\226\271\346\241\210.md" "b/Day61-65/75.\345\270\270\350\247\201\345\217\215\347\210\254\347\255\226\347\225\245\345\217\212\345\272\224\345\257\271\346\226\271\346\241\210.md"
similarity index 100%
rename from "Day66-75/75.\345\270\270\350\247\201\345\217\215\347\210\254\347\255\226\347\225\245\345\217\212\345\272\224\345\257\271\346\226\271\346\241\210.md"
rename to "Day61-65/75.\345\270\270\350\247\201\345\217\215\347\210\254\347\255\226\347\225\245\345\217\212\345\272\224\345\257\271\346\226\271\346\241\210.md"
diff --git a/Day61-65/code/.gitkeep b/Day61-65/code/.gitkeep
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/Day66-75/code/asyncio01.py b/Day61-65/code/asyncio01.py
similarity index 100%
rename from Day66-75/code/asyncio01.py
rename to Day61-65/code/asyncio01.py
diff --git a/Day66-75/code/asyncio02.py b/Day61-65/code/asyncio02.py
similarity index 100%
rename from Day66-75/code/asyncio02.py
rename to Day61-65/code/asyncio02.py
diff --git a/Day66-75/code/coroutine01.py b/Day61-65/code/coroutine01.py
similarity index 100%
rename from Day66-75/code/coroutine01.py
rename to Day61-65/code/coroutine01.py
diff --git a/Day66-75/code/coroutine02.py b/Day61-65/code/coroutine02.py
similarity index 100%
rename from Day66-75/code/coroutine02.py
rename to Day61-65/code/coroutine02.py
diff --git a/Day61-65/code/project_of_tornado/service/__init__.py b/Day61-65/code/douban/douban/__init__.py
similarity index 100%
rename from Day61-65/code/project_of_tornado/service/__init__.py
rename to Day61-65/code/douban/douban/__init__.py
diff --git a/Day66-75/code/douban/douban/items.py b/Day61-65/code/douban/douban/items.py
similarity index 100%
rename from Day66-75/code/douban/douban/items.py
rename to Day61-65/code/douban/douban/items.py
diff --git a/Day66-75/code/douban/douban/middlewares.py b/Day61-65/code/douban/douban/middlewares.py
similarity index 100%
rename from Day66-75/code/douban/douban/middlewares.py
rename to Day61-65/code/douban/douban/middlewares.py
diff --git a/Day66-75/code/douban/douban/pipelines.py b/Day61-65/code/douban/douban/pipelines.py
similarity index 100%
rename from Day66-75/code/douban/douban/pipelines.py
rename to Day61-65/code/douban/douban/pipelines.py
diff --git a/Day66-75/code/douban/douban/settings.py b/Day61-65/code/douban/douban/settings.py
similarity index 100%
rename from Day66-75/code/douban/douban/settings.py
rename to Day61-65/code/douban/douban/settings.py
diff --git a/Day66-75/code/douban/douban/spiders/__init__.py b/Day61-65/code/douban/douban/spiders/__init__.py
similarity index 100%
rename from Day66-75/code/douban/douban/spiders/__init__.py
rename to Day61-65/code/douban/douban/spiders/__init__.py
diff --git a/Day66-75/code/douban/douban/spiders/movie.py b/Day61-65/code/douban/douban/spiders/movie.py
similarity index 100%
rename from Day66-75/code/douban/douban/spiders/movie.py
rename to Day61-65/code/douban/douban/spiders/movie.py
diff --git a/Day66-75/code/douban/scrapy.cfg b/Day61-65/code/douban/scrapy.cfg
similarity index 100%
rename from Day66-75/code/douban/scrapy.cfg
rename to Day61-65/code/douban/scrapy.cfg
diff --git a/Day66-75/code/example01.py b/Day61-65/code/example01.py
similarity index 100%
rename from Day66-75/code/example01.py
rename to Day61-65/code/example01.py
diff --git a/Day66-75/code/example02.py b/Day61-65/code/example02.py
similarity index 100%
rename from Day66-75/code/example02.py
rename to Day61-65/code/example02.py
diff --git a/Day66-75/code/example03.py b/Day61-65/code/example03.py
similarity index 100%
rename from Day66-75/code/example03.py
rename to Day61-65/code/example03.py
diff --git a/Day66-75/code/example04.py b/Day61-65/code/example04.py
similarity index 100%
rename from Day66-75/code/example04.py
rename to Day61-65/code/example04.py
diff --git a/Day66-75/code/example05.py b/Day61-65/code/example05.py
similarity index 100%
rename from Day66-75/code/example05.py
rename to Day61-65/code/example05.py
diff --git a/Day66-75/code/example06.py b/Day61-65/code/example06.py
similarity index 100%
rename from Day66-75/code/example06.py
rename to Day61-65/code/example06.py
diff --git a/Day66-75/code/example07.py b/Day61-65/code/example07.py
similarity index 100%
rename from Day66-75/code/example07.py
rename to Day61-65/code/example07.py
diff --git a/Day66-75/code/example08.py b/Day61-65/code/example08.py
similarity index 100%
rename from Day66-75/code/example08.py
rename to Day61-65/code/example08.py
diff --git a/Day66-75/code/example09.py b/Day61-65/code/example09.py
similarity index 100%
rename from Day66-75/code/example09.py
rename to Day61-65/code/example09.py
diff --git a/Day66-75/code/example10.py b/Day61-65/code/example10.py
similarity index 100%
rename from Day66-75/code/example10.py
rename to Day61-65/code/example10.py
diff --git a/Day66-75/code/example10a.py b/Day61-65/code/example10a.py
similarity index 100%
rename from Day66-75/code/example10a.py
rename to Day61-65/code/example10a.py
diff --git a/Day66-75/code/example11.py b/Day61-65/code/example11.py
similarity index 100%
rename from Day66-75/code/example11.py
rename to Day61-65/code/example11.py
diff --git a/Day66-75/code/example11a.py b/Day61-65/code/example11a.py
similarity index 100%
rename from Day66-75/code/example11a.py
rename to Day61-65/code/example11a.py
diff --git a/Day66-75/code/example12.py b/Day61-65/code/example12.py
similarity index 100%
rename from Day66-75/code/example12.py
rename to Day61-65/code/example12.py
diff --git a/Day66-75/code/generator01.py b/Day61-65/code/generator01.py
similarity index 100%
rename from Day66-75/code/generator01.py
rename to Day61-65/code/generator01.py
diff --git a/Day66-75/code/generator02.py b/Day61-65/code/generator02.py
similarity index 100%
rename from Day66-75/code/generator02.py
rename to Day61-65/code/generator02.py
diff --git a/Day66-75/code/guido.jpg b/Day61-65/code/guido.jpg
similarity index 100%
rename from Day66-75/code/guido.jpg
rename to Day61-65/code/guido.jpg
diff --git a/Day61-65/code/hello-tornado/chat_handlers.py b/Day61-65/code/hello-tornado/chat_handlers.py
deleted file mode 100644
index 528d8a1edb035fd378cd7755ea206e1a6980bfb3..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/chat_handlers.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""
-handlers.py - 用户登录和聊天的处理器
-"""
-import tornado.web
-import tornado.websocket
-
-nicknames = set()
-connections = {}
-
-
-class LoginHandler(tornado.web.RequestHandler):
-
- def get(self):
- self.render('login.html', hint='')
-
- def post(self):
- nickname = self.get_argument('nickname')
- if nickname in nicknames:
- self.render('login.html', hint='昵称已被使用，请更换昵称')
- self.set_secure_cookie('nickname', nickname)
- self.render('chat.html')
-
-
-class ChatHandler(tornado.websocket.WebSocketHandler):
-
- def open(self):
- nickname = self.get_secure_cookie('nickname').decode()
- nicknames.add(nickname)
- for conn in connections.values():
- conn.write_message(f'~~~{nickname}进入了聊天室~~~')
- connections[nickname] = self
-
- def on_message(self, message):
- nickname = self.get_secure_cookie('nickname').decode()
- for conn in connections.values():
- if conn is not self:
- conn.write_message(f'{nickname}说：{message}')
-
- def on_close(self):
- nickname = self.get_secure_cookie('nickname').decode()
- del connections[nickname]
- nicknames.remove(nickname)
- for conn in connections.values():
- conn.write_message(f'~~~{nickname}离开了聊天室~~~')
diff --git a/Day61-65/code/hello-tornado/chat_server.py b/Day61-65/code/hello-tornado/chat_server.py
deleted file mode 100644
index 4985acdd70444aab610ca48574707cedff7e4d5d..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/chat_server.py
+++ /dev/null
@@ -1,24 +0,0 @@
-"""
-chat_server.py - 聊天服务器
-"""
-import os
-
-import tornado.web
-import tornado.ioloop
-
-from chat_handlers import LoginHandler, ChatHandler
-
-
-def main():
- app = tornado.web.Application(
- handlers=[(r'/login', LoginHandler), (r'/chat', ChatHandler)],
- template_path=os.path.join(os.path.dirname(__file__), 'templates'),
- static_path=os.path.join(os.path.dirname(__file__), 'static'),
- cookie_secret='MWM2MzEyOWFlOWRiOWM2MGMzZThhYTk0ZDNlMDA0OTU=',
- )
- app.listen(8888)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example01.py b/Day61-65/code/hello-tornado/example01.py
deleted file mode 100644
index 6005256b0b7cb47b262db24fc3d0fdf839d7de99..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example01.py
+++ /dev/null
@@ -1,36 +0,0 @@
-"""
-example01.py - 五分钟上手Tornado
-"""
-import tornado.ioloop
-import tornado.web
-
-from tornado.options import define, options, parse_command_line
-
-# 定义默认端口
-define('port', default=8000, type=int)
-
-
-class MainHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- # 向客户端（浏览器）写入内容
- self.write('Hello, world!
')
-
-
-def main():
- """主函数"""
- # 解析命令行参数，例如：
- # python example01.py --port 8888
- parse_command_line()
- # 创建了Tornado框架中Application类的实例并指定handlers参数
- # Application实例代表了我们的Web应用，handlers代表了路由解析
- app = tornado.web.Application(handlers=[(r'/', MainHandler), ])
- # 指定了监听HTTP请求的TCP端口（默认8000，也可以通过命令行参数指定）
- app.listen(options.port)
- # 获取Tornado框架的IOLoop实例并启动它（默认启动asyncio的事件循环）
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example02.py b/Day61-65/code/hello-tornado/example02.py
deleted file mode 100644
index c9ff9c0c91a0cc198048af8f064900680aaa3161..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example02.py
+++ /dev/null
@@ -1,77 +0,0 @@
-"""
-example02.py - 路由解析
-"""
-import os
-import random
-
-import tornado.ioloop
-import tornado.web
-
-from tornado.options import define, options, parse_command_line
-
-
-# 定义默认端口
-define('port', default=8000, type=int)
-
-
-class SayingHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- sayings = [
- '世上没有绝望的处境，只有对处境绝望的人',
- '人生的道路在态度的岔口一分为二，从此通向成功或失败',
- '所谓措手不及，不是说没有时间准备，而是有时间的时候没有准备',
- '那些你认为不靠谱的人生里，充满你没有勇气做的事',
- '在自己喜欢的时间里，按照自己喜欢的方式，去做自己喜欢做的事，这便是自由',
- '有些人不属于自己，但是遇见了也弥足珍贵'
- ]
- # 渲染index.html模板页
- self.render('index.html', message=random.choice(sayings))
-
-
-class WeatherHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self, city):
- # Tornado框架会自动处理百分号编码的问题
- weathers = {
- '北京': {'temperature': '-4~4', 'pollution': '195 中度污染'},
- '成都': {'temperature': '3~9', 'pollution': '53 良'},
- '深圳': {'temperature': '20~25', 'pollution': '25 优'},
- '广州': {'temperature': '18~23', 'pollution': '56 良'},
- '上海': {'temperature': '6~8', 'pollution': '65 良'}
- }
- if city in weathers:
- self.render('weather.html', city=city, weather=weathers[city])
- else:
- self.render('index.html', message=f'没有{city}的天气信息')
-
-
-class ErrorHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- # 重定向到指定的路径
- self.redirect('/saying')
-
-
-def main():
- """主函数"""
- parse_command_line()
- app = tornado.web.Application(
- # handlers是按列表中的顺序依次进行匹配的
- handlers=[
- (r'/saying/?', SayingHandler),
- (r'/weather/([^/]{2,})/?', WeatherHandler),
- (r'/.+', ErrorHandler),
- ],
- # 通过template_path参数设置模板页的路径
- template_path=os.path.join(os.path.dirname(__file__), 'templates')
- )
- app.listen(options.port)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example03.py b/Day61-65/code/hello-tornado/example03.py
deleted file mode 100644
index 16ff8e5a7de70872dfdbfa4ee86e86aa6c004c56..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example03.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""
-example03.py - RequestHandler解析
-"""
-import os
-import re
-
-import tornado.ioloop
-import tornado.web
-
-from tornado.options import define, options, parse_command_line
-
-
-# 定义默认端口
-define('port', default=8000, type=int)
-
-users = {}
-
-
-class User(object):
- """用户"""
-
- def __init__(self, nickname, gender, birthday):
- self.nickname = nickname
- self.gender = gender
- self.birthday = birthday
-
-
-class MainHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- # 从Cookie中读取用户昵称
- nickname = self.get_cookie('nickname')
- if nickname in users:
- self.render('userinfo.html', user=users[nickname])
- else:
- self.render('userform.html', hint='请填写个人信息')
-
-
-class UserHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def post(self):
- # 从表单参数中读取用户昵称、性别和生日信息
- nickname = self.get_body_argument('nickname').strip()
- gender = self.get_body_argument('gender')
- birthday = self.get_body_argument('birthday')
- # 检查用户昵称是否有效
- if not re.fullmatch(r'\w{6,20}', nickname):
- self.render('userform.html', hint='请输入有效的昵称')
- elif nickname in users:
- self.render('userform.html', hint='昵称已经被使用过')
- else:
- users[nickname] = User(nickname, gender, birthday)
- # 将用户昵称写入Cookie并设置有效期为7天
- self.set_cookie('nickname', nickname, expires_days=7)
- self.render('userinfo.html', user=users[nickname])
-
-
-def main():
- """主函数"""
- parse_command_line()
- app = tornado.web.Application(
- handlers=[
- (r'/', MainHandler),
- (r'/register', UserHandler),
- ],
- template_path=os.path.join(os.path.dirname(__file__), 'templates'),
- )
- app.listen(options.port)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example04.py b/Day61-65/code/hello-tornado/example04.py
deleted file mode 100644
index 405b00c3b50e75d2fdb7166d3b261c40f99c6874..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example04.py
+++ /dev/null
@@ -1,44 +0,0 @@
-"""
-example04.py - 同步请求的例子
-"""
-import json
-import os
-
-import requests
-import tornado.gen
-import tornado.ioloop
-import tornado.web
-import tornado.websocket
-import tornado.httpclient
-from tornado.options import define, options, parse_command_line
-
-define('port', default=8888, type=int)
-
-# 请求天行数据提供的API数据接口
-REQ_URL = 'http://api.tianapi.com/guonei/'
-# 在天行数据网站注册后可以获得API_KEY
-API_KEY = 'your_personal_api_key'
-
-
-class MainHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- def get(self):
- resp = requests.get(f'{REQ_URL}?key={API_KEY}')
- newslist = json.loads(resp.text)['newslist']
- self.render('news.html', newslist=newslist)
-
-
-def main():
- """主函数"""
- parse_command_line()
- app = tornado.web.Application(
- handlers=[(r'/', MainHandler), ],
- template_path=os.path.join(os.path.dirname(__file__), 'templates'),
- )
- app.listen(options.port)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example05.py b/Day61-65/code/hello-tornado/example05.py
deleted file mode 100644
index 5ae1ced69e498c61008aedbdccfd080357d07549..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example05.py
+++ /dev/null
@@ -1,47 +0,0 @@
-"""
-example05.py - 异步请求的例子
-"""
-import aiohttp
-import json
-import os
-
-import tornado.gen
-import tornado.ioloop
-import tornado.web
-import tornado.websocket
-import tornado.httpclient
-from tornado.options import define, options, parse_command_line
-
-define('port', default=8888, type=int)
-
-# 请求天行数据提供的API数据接口
-REQ_URL = 'http://api.tianapi.com/guonei/'
-# 在天行数据网站注册后可以获得API_KEY
-API_KEY = 'your_personal_api_key'
-
-
-class MainHandler(tornado.web.RequestHandler):
- """自定义请求处理器"""
-
- async def get(self):
- async with aiohttp.ClientSession() as session:
- resp = await session.get(f'{REQ_URL}?key={API_KEY}')
- json_str = await resp.text()
- print(json_str)
- newslist = json.loads(json_str)['newslist']
- self.render('news.html', newslist=newslist)
-
-
-def main():
- """主函数"""
- parse_command_line()
- app = tornado.web.Application(
- handlers=[(r'/', MainHandler), ],
- template_path=os.path.join(os.path.dirname(__file__), 'templates'),
- )
- app.listen(options.port)
- tornado.ioloop.IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example06.py b/Day61-65/code/hello-tornado/example06.py
deleted file mode 100644
index bcb02bfc7d99ca96588e4254ba69cb6d583fa37f..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example06.py
+++ /dev/null
@@ -1,80 +0,0 @@
-"""
-example06.py - 异步操作MySQL
-"""
-import json
-
-import aiomysql
-import tornado
-import tornado.web
-
-from tornado.ioloop import IOLoop
-from tornado.options import define, parse_command_line, options
-
-define('port', default=8888, type=int)
-
-
-async def connect_mysql():
- return await aiomysql.connect(
- host='1.2.3.4',
- port=3306,
- db='hrs',
- charset='utf8',
- use_unicode=True,
- user='yourname',
- password='yourpass',
- )
-
-
-class HomeHandler(tornado.web.RequestHandler):
-
- async def get(self, no):
- async with self.settings['mysql'].cursor(aiomysql.DictCursor) as cursor:
- await cursor.execute("select * from tb_dept where dno=%s", (no, ))
- if cursor.rowcount == 0:
- self.finish(json.dumps({
- 'code': 20001,
- 'mesg': f'没有编号为{no}的部门'
- }))
- return
- row = await cursor.fetchone()
- self.finish(json.dumps(row))
-
- async def post(self, *args, **kwargs):
- no = self.get_argument('no')
- name = self.get_argument('name')
- loc = self.get_argument('loc')
- conn = self.settings['mysql']
- try:
- async with conn.cursor() as cursor:
- await cursor.execute('insert into tb_dept values (%s, %s, %s)',
- (no, name, loc))
- await conn.commit()
- except aiomysql.MySQLError:
- self.finish(json.dumps({
- 'code': 20002,
- 'mesg': '添加部门失败请确认部门信息'
- }))
- else:
- self.set_status(201)
- self.finish()
-
-
-def make_app(config):
- return tornado.web.Application(
- handlers=[(r'/api/depts/(.*)', HomeHandler), ],
- **config
- )
-
-
-def main():
- parse_command_line()
- app = make_app({
- 'debug': True,
- 'mysql': IOLoop.current().run_sync(connect_mysql)
- })
- app.listen(options.port)
- IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example07.py b/Day61-65/code/hello-tornado/example07.py
deleted file mode 100644
index df3898098565426a84e3c355e2e0d6fffed50927..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example07.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""
-example07.py - 将非异步的三方库封装为异步调用
-"""
-import asyncio
-import concurrent
-import json
-
-import tornado
-import tornado.web
-import pymysql
-
-from pymysql import connect
-from pymysql.cursors import DictCursor
-
-from tornado.ioloop import IOLoop
-from tornado.options import define, parse_command_line, options
-from tornado.platform.asyncio import AnyThreadEventLoopPolicy
-
-define('port', default=8888, type=int)
-
-
-def get_mysql_connection():
- return connect(
- host='1.2.3.4',
- port=3306,
- db='hrs',
- charset='utf8',
- use_unicode=True,
- user='yourname',
- password='yourpass',
- )
-
-
-class HomeHandler(tornado.web.RequestHandler):
- executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
-
- async def get(self, no):
- return await self._get(no)
-
- @tornado.concurrent.run_on_executor
- def _get(self, no):
- con = get_mysql_connection()
- try:
- with con.cursor(DictCursor) as cursor:
- cursor.execute("select * from tb_dept where dno=%s", (no, ))
- if cursor.rowcount == 0:
- self.finish(json.dumps({
- 'code': 20001,
- 'mesg': f'没有编号为{no}的部门'
- }))
- return
- row = cursor.fetchone()
- self.finish(json.dumps(row))
- finally:
- con.close()
-
- async def post(self, *args, **kwargs):
- return await self._post(*args, **kwargs)
-
- @tornado.concurrent.run_on_executor
- def _post(self, *args, **kwargs):
- no = self.get_argument('no')
- name = self.get_argument('name')
- loc = self.get_argument('loc')
- conn = get_mysql_connection()
- try:
- with conn.cursor() as cursor:
- cursor.execute('insert into tb_dept values (%s, %s, %s)',
- (no, name, loc))
- conn.commit()
- except pymysql.MySQLError:
- self.finish(json.dumps({
- 'code': 20002,
- 'mesg': '添加部门失败请确认部门信息'
- }))
- else:
- self.set_status(201)
- self.finish()
-
-
-def main():
- asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
- parse_command_line()
- app = tornado.web.Application(
- handlers=[(r'/api/depts/(.*)', HomeHandler), ]
- )
- app.listen(options.port)
- IOLoop.current().start()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example_of_aiohttp.py b/Day61-65/code/hello-tornado/example_of_aiohttp.py
deleted file mode 100644
index 362f6ff20441be5b45261abc1947c2adbf8a7993..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example_of_aiohttp.py
+++ /dev/null
@@ -1,30 +0,0 @@
-import asyncio
-import re
-
-import aiohttp
-
-PATTERN = re.compile(r'\(?P.*)\<\/title\>')
-
-
-async def show_title(url):
- async with aiohttp.ClientSession() as session:
- resp = await session.get(url, ssl=False)
- html = await resp.text()
- print(PATTERN.search(html).group('title'))
-
-
-def main():
- urls = ('https://www.python.org/',
- 'https://git-scm.com/',
- 'https://www.jd.com/',
- 'https://www.taobao.com/',
- 'https://www.douban.com/')
- # asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
- # 获取事件循环（）
- loop = asyncio.get_event_loop()
- tasks = [show_title(url) for url in urls]
- loop.run_until_complete(asyncio.wait(tasks))
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example_of_asyncio.py b/Day61-65/code/hello-tornado/example_of_asyncio.py
deleted file mode 100644
index 0851f38ba6fa8c0ac6e31f7efe126443712bc59a..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example_of_asyncio.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import asyncio
-
-
-async def fetch(host):
- """从指定的站点抓取信息(协程函数)"""
- print(f'Start fetching {host}\n')
- # 跟服务器建立连接
- reader, writer = await asyncio.open_connection(host, 80)
- # 构造请求行和请求头
- writer.write(b'GET / HTTP/1.1\r\n')
- writer.write(f'Host: {host}\r\n'.encode())
- writer.write(b'\r\n')
- # 清空缓存区(发送请求)
- await writer.drain()
- # 接收服务器的响应(读取响应行和响应头)
- line = await reader.readline()
- while line != b'\r\n':
- print(line.decode().rstrip())
- line = await reader.readline()
- print('\n')
- writer.close()
-
-
-def main():
- """主函数"""
- urls = ('www.sohu.com', 'www.douban.com', 'www.163.com')
- # 获取系统默认的事件循环
- loop = asyncio.get_event_loop()
- # 用生成式语法构造一个包含多个协程对象的列表
- tasks = [fetch(url) for url in urls]
- # 通过asyncio模块的wait函数将协程列表包装成Task（Future子类）并等待其执行完成
- # 通过事件循环的run_until_complete方法运行任务直到Future完成并返回它的结果
- futures = asyncio.wait(tasks)
- print(futures, type(futures))
- loop.run_until_complete(futures)
- loop.close()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example_of_coroutine.py b/Day61-65/code/hello-tornado/example_of_coroutine.py
deleted file mode 100644
index 070dad2453eec2a545a35f21e76e1f6c367068dc..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example_of_coroutine.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""
-协程（coroutine）- 可以在需要时进行切换的相互协作的子程序
-"""
-import asyncio
-
-from example_of_multiprocess import is_prime
-
-
-def num_generator(m, n):
- """指定范围的数字生成器"""
- for num in range(m, n + 1):
- print(f'generate number: {num}')
- yield num
-
-
-async def prime_filter(m, n):
- """素数过滤器"""
- primes = []
- for i in num_generator(m, n):
- if is_prime(i):
- print('Prime =>', i)
- primes.append(i)
-
- await asyncio.sleep(0.001)
- return tuple(primes)
-
-
-async def square_mapper(m, n):
- """平方映射器"""
- squares = []
- for i in num_generator(m, n):
- print('Square =>', i * i)
- squares.append(i * i)
-
- await asyncio.sleep(0.001)
- return squares
-
-
-def main():
- """主函数"""
- loop = asyncio.get_event_loop()
- start, end = 1, 100
- futures = asyncio.gather(prime_filter(start, end), square_mapper(start, end))
- futures.add_done_callback(lambda x: print(x.result()))
- loop.run_until_complete(futures)
- loop.close()
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/example_of_multiprocess.py b/Day61-65/code/hello-tornado/example_of_multiprocess.py
deleted file mode 100644
index bef4c0f84940933ad9975cae9c1b94836706ea07..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/example_of_multiprocess.py
+++ /dev/null
@@ -1,49 +0,0 @@
-"""
-用下面的命令运行程序并查看执行时间，例如：
-time python3 example05.py
-real 0m20.657s
-user 1m17.749s
-sys 0m0.158s
-使用多进程后实际执行时间为20.657秒，而用户时间1分17.749秒约为实际执行时间的4倍
-这就证明我们的程序通过多进程使用了CPU的多核特性，而且这台计算机配置了4核的CPU
-"""
-import concurrent.futures
-import math
-
-PRIMES = [
- 1116281,
- 1297337,
- 104395303,
- 472882027,
- 533000389,
- 817504243,
- 982451653,
- 112272535095293,
- 112582705942171,
- 112272535095293,
- 115280095190773,
- 115797848077099,
- 1099726899285419
-] * 5
-
-
-def is_prime(num):
- """判断素数"""
- assert num > 0
- if num % 2 == 0:
- return False
- for i in range(3, int(math.sqrt(num)) + 1, 2):
- if num % i == 0:
- return False
- return num != 1
-
-
-def main():
- """主函数"""
- with concurrent.futures.ProcessPoolExecutor() as executor:
- for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
- print('%d is prime: %s' % (number, prime))
-
-
-if __name__ == '__main__':
- main()
diff --git a/Day61-65/code/hello-tornado/requirements.txt b/Day61-65/code/hello-tornado/requirements.txt
deleted file mode 100644
index 619660c5f4dc78b3df311fbe6b6bc3df0991fc65..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/requirements.txt
+++ /dev/null
@@ -1,18 +0,0 @@
-aiohttp==3.5.4
-aiomysql==0.0.20
-asn1crypto==0.24.0
-async-timeout==3.0.1
-attrs==19.1.0
-certifi==2019.3.9
-cffi==1.12.2
-chardet==3.0.4
-cryptography==2.6.1
-idna==2.8
-multidict==4.5.2
-pycparser==2.19
-PyMySQL==0.9.2
-requests==2.21.0
-six==1.12.0
-tornado==5.1.1
-urllib3==1.24.1
-yarl==1.3.0
diff --git a/Day61-65/code/hello-tornado/templates/chat.html b/Day61-65/code/hello-tornado/templates/chat.html
deleted file mode 100644
index d83fd5cf2dfd74f14247c2fdb2b0bcc1c761a58e..0000000000000000000000000000000000000000
--- a/Day61-65/code/hello-tornado/templates/chat.html
+++ /dev/null
@@ -1,67 +0,0 @@
-<!-- chat.html -->
-<!DOCTYPE html>
-<html lang="en">
-<head>
- <meta charset="UTF-8">
- <title>Tornado聊天室
-
-
- 聊天室
-
-
-
-
-
-
-
-
-
- 退出聊天室
-
-
-
-
-