Web框架

1.Web框架本质

我们可以这样理解：所有的Web应用本质上就是一个socket服务端，而用户的浏览器就是一个socket客户端。 这样我们就可以自己实现Web框架了。

• socket服务端

  import socket
   
  sk = socket.socket()   #创建一个socket对象
  sk.bind(('127.0.0.1',8000))    #绑定一个ip和端口
  sk.listen()    #监听
  ​
  #等待连接
  while True:
      conn,addr = sk.accept()
      conn.recv(1024)        #接受数据
      conn.send(b'ok')       #返回数据
      conn.close()           #断开连接

• 在浏览器中连接上述服务端时出现问题:

  我们可以一下可以发现浏览器向服务端发送请求时,无法响应,那么是什么导致这个原因呢?我们想到必须有一个统一的规则，让大家发送消息、接收消息的时候都有个格式依据，不能随便写。这个规则就是HTTP协议.HTTP协议主要规定了客户端和服务器之间的通信格式

• 让我们首先打印下我们在服务端接收到的消息是什么

  import socket    
      
  sk = socket.socket()    
  sk.bind(("127.0.0.1", 80))    
  sk.listen()    
      
      
  while True:    
      conn, addr = sk.accept()    
      data = conn.recv(8096)    
      print(data)  # 将浏览器发来的消息打印出来    
      conn.send(b"OK")    
      conn.close()  

  输出:

  b'GET / HTTP/1.1
  Host: 127.0.0.1:8080
  Connection: keep-alive
  Cache-Control: max-age=0
  Upgrade-Insecure-Requests: 1
  User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3355.4 Safari/537.36
  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
  Accept-Encoding: gzip, deflate, br
  Accept-Language: zh-CN,zh;q=0.9
  Cookie: csrftoken=CtHePYARJOKNx5oNVwxIteOJXpNyJ29L4bW4506YoVqFaIFFaHm0EWDZqKmw6Jm8
  
  '

  我们将 替换成换行看得更清晰点：

  GET / HTTP/1.1  
  Host: 127.0.0.1:8080  
  Connection: keep-alive  
  Cache-Control: max-age=0  
  Upgrade-Insecure-Requests: 1  
  User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3355.4 Safari/537.36  
  Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8  
  Accept-Encoding: gzip, deflate, br  
  Accept-Language: zh-CN,zh;q=0.9  
  Cookie: csrftoken=CtHePYARJOKNx5oNVwxIteOJXpNyJ29L4bW4506YoVqFaIFFaHm0EWDZqKmw6Jm8 

  然后我们再看一下我们访问博客园官网时浏览器收到的响应信息是什么。

  响应相关信息可以在浏览器调试窗口的Network标签页中看到。

  

  点击view source之后显示如下图：

  

  我们发现收发的消息需要按照一定的格式来，这里就需要了解一下HTTP协议了。

2.http协议

2.1HTTP协议概述

HTTP协议,又称超文本传输协议（英文：Hyper Text Transfer Protocol，HTTP）是一种用于分布式、协作式和超媒体信息系统的应用层协议,HTTP有很多应用，但最著名的是用于web浏览器和web服务器之间的双工通信。

HTTP是一个客户端终端（用户）和服务器端（网站）请求和应答的标准（TCP）。通过使用网页浏览器、网络爬虫或者其它的工具，客户端发起一个HTTP请求到服务器上指定端口（默认端口为80）。我们称这个客户端为用户代理程序（user agent）。应答的服务器上存储着一些资源，比如HTML文件和图像。我们称这个应答服务器为源服务器（origin server）。在用户代理和源服务器中间可能存在多个“中间层”，比如代理服务器、网关或者隧道（tunnel）。

2.2HTTP工作原理

HTTP协议定义Web客户端如何从Web服务器请求Web页面，以及服务器如何把Web页面传送给客户端。HTTP协议采用了请求/响应模型。客户端向服务器发送一个请求报文，请求报文包含请求的方法、URL、协议版本、请求头部和请求数据。服务器以一个状态行作为响应，响应的内容包括协议的版本、成功或者错误代码、服务器信息、响应头部和响应数据。

• HTTP 请求/响应的步骤:

  # 1.客户端连接到Web服务器
  一个HTTP客户端，通常是浏览器，与Web服务器的HTTP端口（默认为80）建立一个TCP套接字连接。例如，http://www.luffycity.com。
  # 2.发送HTTP请求
  通过TCP套接字，客户端向Web服务器发送一个文本的请求报文，一个请求报文由请求行、请求头部、空行和请求数据4部分组成。
  # 3.服务器接受请求并返回HTTP响应
  Web服务器解析请求，定位请求资源。服务器将资源复本写到TCP套接字，由客户端读取。一个响应由状态行、响应头部、空行和响应数据4部分组成。
  # 4.释放连接TCP连接
  若connection 模式为close，则服务器主动关闭TCP连接，客户端被动关闭连接，释放TCP连接;若connection 模式为keepalive，则该连接会保持一段时间，在该时间内可以继续接收请求;
  # 5.客户端浏览器解析HTML内容
  客户端浏览器首先解析状态行，查看表明请求是否成功的状态代码。然后解析每一个响应头，响应头告知以下为若干字节的HTML文档和文档的字符集。客户端浏览器读取响应数据HTML，根据HTML的语法对其进行格式化，并在浏览器窗口中显示。

• 在浏览器地址栏键入URL，按下回车之后会经历以下流程：

  1.浏览器向 DNS 服务器请求解析该 URL 中的域名所对应的 IP 地址;
  2.解析出 IP 地址后，根据该 IP 地址和默认端口 80，和服务器建立TCP连接;
  3.浏览器发出读取文件(URL 中域名后面部分对应的文件)的HTTP 请求，该请求报文作为 TCP 三次握手的第三个报文的数据发送给服务器;
  4.服务器对浏览器请求作出响应，并把对应的 html 文本发送给浏览器;
  5.释放 TCP连接;
  6.浏览器将该 html 文本并显示内容; 

2.3http请求方法

• GET

  • 向指定的资源发出“显示”请求。使用GET方法应该只用在读取数据，而不应当被用于产生“副作用”的操作中，例如在Web Application中。其中一个原因是GET可能会被网络蜘蛛等随意访问。

• POST

  • 向指定资源提交数据，请求服务器进行处理（例如提交表单或者上传文件）。数据被包含在请求报文中。这个请求可能会创建新的资源或修改现有资源，或二者皆有。

• PUT

  • 向指定资源位置上传其最新内容。

• DELETE

  • 请求服务器删除Request-URI所标识的资源。

• TRACE

  • 回显服务器收到的请求，主要用于测试或诊断。

• HEAD

  • 与GET方法一样，都是向服务器发出指定资源的请求。只不过服务器将不传回资源的本文部分。它的好处在于，使用这个方法可以在不必传输全部内容的情况下，就可以获取其中“关于该资源的信息”（元信息或称元数据）。

• OPTIONS

  • 这个方法可使服务器传回该资源所支持的所有HTTP请求方法。用'*'来代替资源名称，向Web服务器发送OPTIONS请求，可以测试服务器功能是否正常运作。

• CONNECT

  • HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。通常用于SSL加密服务器的链接（经由非加密的HTTP代理服务器）。

  注意:

  • 1.方法名称是区分大小写,当某个请求所对应的资源部支持对应方法时,服务器应当返回状态码405（Method Not Allowed），当服务器不认识或者不支持对应的请求方法的时候，应当返回状态码501（Not Implemented）。

  • 2.HTTP服务器至少应该实现GET和HEAD方法，其他方法都是可选的。当然，所有的方法支持的实现都应当匹配下述的方法各自的语义定义。此外，除了上述方法，特定的HTTP服务器还能够扩展自定义的方法。例如PATCH（由 RFC 5789 指定的方法）用于将局部修改应用到资源

2.4http状态码

所有HTTP响应的第一行都是状态行，依次是当前HTTP版本号，3位数字组成的状态代码，以及描述状态的短语，彼此由空格分隔。

状态代码的第一个数字代表当前响应的类型：

• 1xx消息——请求已被服务器接收，继续处理

• 2xx成功——请求已成功被服务器接收、理解、并接受

• 3xx重定向——需要后续操作才能完成这一请求

• 4xx请求错误——请求含有词法错误或者无法被执行

• 5xx服务器错误——服务器在处理某个正确请求时发生错误

虽然 RFC 2616 中已经推荐了描述状态的短语，例如"200 OK"，"404 Not Found"，但是WEB开发者仍然能够自行决定采用何种短语，用以显示本地化的状态描述或者自定义信息。

2.5资源定位符url

超文本传输协议（HTTP）的统一资源定位符将从因特网获取信息的五个基本元素包括在一个简单的地址中：

• 传送协议。

• 层级URL标记符号(为[//],固定不变)

• 访问资源需要的凭证信息（可省略）

• 服务器（通常为域名，有时为IP地址）

• 端口号（以数字方式表示，若为HTTP的默认值“:80”可省略）

• 路径（以“/”字符区别路径中的每一个目录名称）

• 查询（GET模式的窗体参数，以“?”字符为起点，每个参数以“&”隔开，再以“=”分开参数名称与数据，通常以UTF8的URL编码，避开字符冲突的问题）

• 片段。以“#”字符为起点

以http://www.luffycity.com:80/news/index.html?id=250&page=1 为例:

http默认端口80,https默认端口443

2.6HTTP请求格式

#请求（request）
#浏览器  —— 》 服务器  
############   GET请求 没有请求数据
“请求方式 url路径 协议版本

k1:v1

k2:v2



数据”

2.7HTTP响应格式

#响应（response）
#服务器  —— 》 浏览器 
“协议版本 状态码 状态码描述

k1:v1

k2:v2



响应数据（响应体）”

2.8web框架的功能

• 1.socket收发消息 - wsgiref wsgiref (本地测试) uwsgi(线上)

• 2.根据不同的路径返回不同的内容

• 3.返回动态页面（字符串的替换------->模板的渲染） —— jinja2

django	flask	tornado
2 3	2	1 2 3

 

2.9 自定义web框架

经过上面的学习，那我们基于socket服务端的十几行代码写一个我们自己的web框架。我们先不处理浏览器发送的请求，先让浏览器能显示我们web框架返回的信息，那我们就要按照HTTP协议的格式来发送响应。

import socket    
    
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)    
sock.bind(('127.0.0.1', 8000))    
sock.listen()    
    
while True:    
    conn, addr = sock.accept()    
    data = conn.recv(8096)    
    # 给回复的消息加上响应状态行    
    conn.send(b"HTTP/1.1 200 OK

")    
    conn.send(b"OK")    
    conn.close() 

• 根据不同的路径返回不同的内容

  如何让我们的Web服务根据用户请求的URL不同而返回不同的内容呢？

  import socket  
    
  sk = socket.socket()  
  sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
  sk.listen()  # 监听  
    
  while True:  
      # 等待连接  
      conn, add = sk.accept()  
      data = conn.recv(8096)  # 接收客户端发来的消息  
      # 从data中取到路径  
      data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
      # 按
  分割  
      data1 = data.split("
  ")[0]  
      url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
      conn.send(b'HTTP/1.1 200 OK
  
  ')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
      # 根据不同的路径返回不同内容  
      if url == "/index/":  
          response = b"index"  
      elif url == "/home/":  
          response = b"home"  
      else:  
          response = b"404 not found!"  
    
      conn.send(response)  
      conn.close()  

• 根据不同的路径返回不同的内容--函数版

  上面的代码解决了不同URL路径返回不同内容的需求。

  我们返回的内容是简单的几个字符，那如果我可以将返回的结果封装成一个函数呢

  import socket  
    
  sk = socket.socket()  
  sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
  sk.listen()  # 监听  
    
  # 将返回不同的内容部分封装成函数  
  def func(url):  
      s = "这是{}页面！".format(url)  
      return bytes(s, encoding="utf8")  
    
  while True:  
      # 等待连接  
      conn, add = sk.accept()  
      data = conn.recv(8096)  # 接收客户端发来的消息  
      # 从data中取到路径  
      data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
      # 按
  分割  
      data1 = data.split("
  ")[0]  
      url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
      conn.send(b'HTTP/1.1 200 OK
  
  ')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
      # 根据不同的路径返回不同内容，response是具体的响应体  
      if url == "/index/":  
          response = func(url)  
      elif url == "/home/":  
          response = func(url)  
      else:  
          response = b"404 not found!"  
    
      conn.send(response)  
      conn.close() 

• 根据不同的路径返回不同的内容--函数进阶版

  看起来上面的代码写了一个函数，那肯定可以写多个函数，不同的路径对应执行不同的函数拿到结果，但是我们要一个个判断路径，是不是很麻烦？我们有简单的办法来解决。

  import socket  
    
  sk = socket.socket()  
  sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
  sk.listen()  # 监听  
    
    
  # 将返回不同的内容部分封装成不同的函数  
  def index(url):  
      s = "这是{}页面XX！".format(url)  
      return bytes(s, encoding="utf8")  
    
    
  def home(url):  
      s = "这是{}页面。。！".format(url)  
      return bytes(s, encoding="utf8")  
    
    
  # 定义一个url和实际要执行的函数的对应关系  
  list1 = [  
      ("/index/", index),  
      ("/home/", home),  
  ]  
    
  while True:  
      # 等待连接  
      conn, add = sk.accept()  
      data = conn.recv(8096)  # 接收客户端发来的消息  
      # 从data中取到路径  
      data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
      # 按
  分割  
      data1 = data.split("
  ")[0]  
      url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
      conn.send(b'HTTP/1.1 200 OK
  
  ')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
      # 根据不同的路径返回不同内容  
      func = None  # 定义一个保存将要执行的函数名的变量  
      for item in list1:  
          if item[0] == url:  
              func = item[1]  
              break  
      if func:  
          response = func(url)  
      else:  
          response = b"404 not found!"  
    
      # 返回具体的响应消息  
      conn.send(response)  
      conn.close()  

• 返回具体的HTML文件

  但是我不想仅仅返回几个字符串，我想给浏览器返回完整的HTML内容，这又该怎么办呢？

  import socket  
    
  sk = socket.socket()  
  sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
  sk.listen()  # 监听  
    
    
  # 将返回不同的内容部分封装成不同的函数  
  def index(url):  
      # 读取index.html页面的内容  
      with open("index.html", "r", encoding="utf8") as f:  
          s = f.read()  
      # 返回字节数据  
      return bytes(s, encoding="utf8")  
    
    
  def home(url):  
      with open("home.html", "r", encoding="utf8") as f:  
          s = f.read()  
      return bytes(s, encoding="utf8")  
    
    
  # 定义一个url和实际要执行的函数的对应关系  
  list1 = [  
      ("/index/", index),  
      ("/home/", home),  
  ]  
    
  while True:  
      # 等待连接  
      conn, add = sk.accept()  
      data = conn.recv(8096)  # 接收客户端发来的消息  
      # 从data中取到路径  
      data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
      # 按
  分割  
      data1 = data.split("
  ")[0]  
      url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
      conn.send(b'HTTP/1.1 200 OK
  
  ')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
      # 根据不同的路径返回不同内容  
      func = None  # 定义一个保存将要执行的函数名的变量  
      for item in list1:  
          if item[0] == url:  
              func = item[1]  
              break  
      if func:  
          response = func(url)  
      else:  
          response = b"404 not found!"  
    
      # 返回具体的响应消息  
      conn.send(response)  
      conn.close()  

  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <meta http-equiv="x-ua-compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width, initial-scale=1">
      <title>index</title>
  </head>
  <body>
  <div>这是index页面</div>
  </body>
  </html>

  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <meta http-equiv="x-ua-compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width, initial-scale=1">
      <title>index</title>
  </head>
  <body>
  <div>这是home页面</div>
  </body>
  </html>

• 让网页动态起来

  这网页能够显示出来了，但是都是静态的啊。页面的内容都不会变化的，我想要的是动态网站。

  没问题，我也有办法解决。我选择使用字符串替换来实现这个需求。（这里使用时间戳来模拟动态的数据）

  import socket  
    
  sk = socket.socket()  
  sk.bind(("127.0.0.1", 8080))  # 绑定IP和端口  
  sk.listen()  # 监听  
    
    
  # 将返回不同的内容部分封装成不同的函数  
  def index(url):  
      # 读取index.html页面的内容  
      with open("index.html", "r", encoding="utf8") as f:  
          s = f.read()  
      # 返回字节数据  
      return bytes(s, encoding="utf8")  
    
    
  def home(url):  
      with open("home.html", "r", encoding="utf8") as f:  
          s = f.read()  
      return bytes(s, encoding="utf8")  
    
    
  def timer(url):  
      import time  
      with open("time.html", "r", encoding="utf8") as f:  
          s = f.read()  
          s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S"))  
      return bytes(s, encoding="utf8")  
    
    
  # 定义一个url和实际要执行的函数的对应关系  
  list1 = [  
      ("/index/", index),  
      ("/home/", home),  
      ("/time/", timer),  
  ]  
    
  while True:  
      # 等待连接  
      conn, add = sk.accept()  
      data = conn.recv(8096)  # 接收客户端发来的消息  
      # 从data中取到路径  
      data = str(data, encoding="utf8")  # 把收到的字节类型的数据转换成字符串  
      # 按
  分割  
      data1 = data.split("
  ")[0]  
      url = data1.split()[1]  # url是我们从浏览器发过来的消息中分离出的访问路径  
      conn.send(b'HTTP/1.1 200 OK
  
  ')  # 因为要遵循HTTP协议，所以回复的消息也要加状态行  
      # 根据不同的路径返回不同内容  
      func = None  # 定义一个保存将要执行的函数名的变量  
      for item in list1:  
          if item[0] == url:  
              func = item[1]  
              break  
      if func:  
          response = func(url)  
      else:  
          response = b"404 not found!"  
    
      # 返回具体的响应消息  
      conn.send(response)  
      conn.close()  

2.10服务器程序和应用程序

python web程序一般会分为两部分：服务器程序和应用程序。

• 服务器程序负责对socket服务端进行封装，并在请求到来时，对请求的各种数据进行整理。

• 应用程序则负责具体的逻辑处理。为了方便应用程序的开发，就出现了众多的Web框架，例如：Django、Flask、web.py 等。不同的框架有不同的开发方式，但是无论如何，开发出的应用程序都要和服务器程序配合，才能为用户提供服务。

WSGI（Web Server Gateway Interface）就是一种规范，它定义了使用Python编写的web应用程序与web服务器程序之间的接口格式，实现web应用程序与web服务器程序间的解耦。常用的WSGI服务器有uWSGI、Gunicorn。而Python标准库提供的独立WSGI服务器叫wsgiref，Django开发环境用的就是这个模块来做服务器。

wsgiref

我们利用wsgiref模块来替换我们自己写的web框架的socket server部分：

from wsgiref.simple_server import make_server   
     
     
# 将返回不同的内容部分封装成函数   
def index(url):   
    # 读取index.html页面的内容   
    with open("index.html", "r", encoding="utf8") as f:   
        s = f.read()   
    # 返回字节数据   
    return bytes(s, encoding="utf8")   
     
     
def home(url):   
    with open("home.html", "r", encoding="utf8") as f:   
        s = f.read()   
    return bytes(s, encoding="utf8")   
     
     
def timer(url):   
    import time   
    with open("time.html", "r", encoding="utf8") as f:   
        s = f.read()   
        s = s.replace('@@time@@', time.strftime("%Y-%m-%d %H:%M:%S"))   
    return bytes(s, encoding="utf8")   
     
     
# 定义一个url和实际要执行的函数的对应关系   
list1 = [   
    ("/index/", index),   
    ("/home/", home),   
    ("/time/", timer),   
]   
     
     
def run_server(environ, start_response):   
    start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 设置HTTP响应的状态码和头信息   
    url = environ['PATH_INFO']  # 取到用户输入的url   
    func = None   
    for i in list1:   
        if i[0] == url:   
            func = i[1]   
            break   
    if func:   
        response = func(url)   
    else:   
        response = b"404 not found!"   
    return [response, ]   
     
     
if __name__ == '__main__':   
    httpd = make_server('127.0.0.1', 8090, run_server)   
    print("我在8090等你哦...")   
    httpd.serve_forever()  

jinja2

上面的代码实现了一个简单的动态，我完全可以从数据库中查询数据，然后去替换我html中的对应内容，然后再发送给浏览器完成渲染。 这个过程就相当于HTML模板渲染数据。 本质上就是HTML内容中利用一些特殊的符号来替换要展示的数据。 我这里用的特殊符号是我定义的，其实模板渲染有个现成的工具： jinja2

下载jinja2: pip install jinja2

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
</head>
<body>
    <h1>姓名：{{name}}</h1>
    <h1>爱好：</h1>
    <ul>
        {% for hobby in hobby_list %}
        <li>{{hobby}}</li>
        {% endfor %}
    </ul>
</body>
</html>

使用jinja2渲染index2.html文件：

from wsgiref.simple_server import make_server  
from jinja2 import Template  
  
def index(url):  
    # 读取HTML文件内容  
    with open("index2.html", "r", encoding="utf8") as f:  
        data = f.read()  
        template = Template(data)   # 生成模板文件  
        ret = template.render({'name': 'alex', 'hobby_list': ['抽烟', '喝酒', '烫头']})   # 把数据填充到模板中  
    return bytes(ret, encoding="utf8")  
  
  
def home(url):  
    with open("home.html", "r", encoding="utf8") as f:  
        s = f.read()  
    return bytes(s, encoding="utf8")  
  
  
# 定义一个url和实际要执行的函数的对应关系  
list1 = [  
    ("/index/", index),  
    ("/home/", home),  
]  
  
  
def run_server(environ, start_response):  
    start_response('200 OK', [('Content-Type', 'text/html;charset=utf8'), ])  # 设置HTTP响应的状态码和头信息  
    url = environ['PATH_INFO']  # 取到用户输入的url  
    func = None  
    for i in list1:  
        if i[0] == url:  
            func = i[1]  
            break  
    if func:  
        response = func(url)  
    else:  
        response = b"404 not found!"  
    return [response, ]  
  
  
if __name__ == '__main__':  
    httpd = make_server('127.0.0.1', 8090, run_server)  
    print("我在8090等你哦...")  
    httpd.serve_forever()  

现在的数据是我们自己手写的，那可不可以从数据库中查询数据，来填充页面呢？

使用pymysql连接数据库：

conn = pymysql.connect(host="127.0.0.1", port=3306, user="root", passwd="xxx", db="xxx", charset="utf8")
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select name, age, department_id from userinfo")
user_list = cursor.fetchall()
cursor.close()
conn.close()

创建一个测试的user表：

CREATE TABLE user(
  id int auto_increment PRIMARY KEY,
  name CHAR(10) NOT NULL,
  hobby CHAR(20) NOT NULL
)engine=innodb DEFAULT charset=UTF8;

模板的原理就是字符串替换，我们只要在HTML页面中遵循jinja2的语法规则写上，其内部就会按照指定的语法进行相应的替换，从而达到动态的返回内容。