Django前戏

一、纯手撸web框架

版本①、超简易，只用了socket模块

  1. # 只用了socket模块
  2. # 做到传输html文件，以及自定义python的input输出到浏览器
  4. import socket
  6. server = socket.socket()
  7. server.bind(("127.0.0.1",8080))
  8. server.listen(5)
  10. while True:
  11.     conn, addr = server.accept()
  12.     data = conn.recv(1024).decode("utf-8")
  13.     # print(data)
  14.     target_url = data.split(" ")[1]
  15.     print(target_url)
  16.     conn.send(b"HTTP/1.1 200 OK\r\n\r\n")
  17.     if target_url == "/index":
  18.         # cont = input("请输入要传给浏览器的内容").strip()
  19.         cont = "from /index"
  20.         cont_send = bytes(cont, encoding="utf-8")
  21.         conn.send(cont_send)
  22.     elif target_url == "/func":
  23.         with open("func.html","rb") as f:
  24.             data = f.read()
  25.         conn.send(data)
  26.     else:
  27.         conn.send(b"other")
  28. -----------------------------------------------------------------------
  29. 存在的问题：
  30.     1、代码过于冗余，每个人创建服务端都重新写一份socket模块写的原始代码
  31.         每次都要绑定一次bind，监听端口等等操作
  32.     2、处理http数据繁杂
  34. 解决方法:
  35.     找一个其他模块，看能不能不用写这么复杂的代码，提高开发效率
  36.     # 下面尝试使用wsgiref模块

版本②、基于wsgiref模块撸web框架(python内置模块)

wsgi介绍

  1. wsgi：
  2.     Python Web Server Gateway Interface
  3.     """
  4.     是为Python语言定义的Web服务器和Web应用程序或框架之间的一种简单而通用的接口。
  5.     自从WSGI被开发出来以后，许多其它语言中也出现了类似接口。
  6.     """
  8. uwsgi
  9.     """
  10.     uwsgi是一种通信协议，不过跟WSGI分属两种东西，该协议下速度比较快。
  11.     """

wsgiref

  1. wsgiref模块
  2. """
  3.     wsgiref则是官方给出的一个实现了WSGI标准用于演示用的简单Python内置库,
  4.     它实现了一个简单的WSGI Server和WSGI Application（在simple_server模块中）
  5.     要分为五个模块：simple_server， util， headers， handlers， validate。
  6. """

面条版代码1(耦合程度高，未整合)

  1. from wsgiref.simple_server import make_server
  3. def run(request,response):
  4.     """
  5.     :param request: 跟请求相关的数据
  6.     :param response:跟相应相关的数据
  7.     :return: 返回值就是要返回给前端浏览器的数据
  8.     """
  9.     response("200 OK",[])        # 为run方法return方法的空列表
  10.     print(request)                          # request为一个字典，将每个信息都装成了K:V键值对。
  11.     target_url = request.get("PATH_INFO")   # PATH_INFO 为用户输入的网站后缀名
  12.     if target_url == "/index":
  13.         return [b"from /index"]             # 返回给一个列表，里面是二进制的数据
  14.     elif target_url == "/func":
  15.         with open("func.html", "rb") as f:
  16.             data = f.read()
  17.         return [data]
  18.     return [b"hello world"]        # 为response的空列表加值
  20. if __name__ == '__main__':
  21.     # 监听127.0.0.1:8080,一旦有请求发来，立马将第三个参数app加括号调用
  22.     server = make_server("127.0.0.1",8080,app=run)  # 第三个参数app是上面的run方法
  24.     # 启动服务端
  25.     server.serve_forever()
  26. -----------------------------------------------------------------------
  27. 存在的问题：
  28.     1、用户输入的网站名以及返回的方法还需要一个个的添加
  29.     2、实际工作中，返回的文件代码会有很多很多行，每次修改光查哪里错了，都要找很久
  31. 解决方法：
  32.     做一个代码的整合，解耦合
  33.     # 将

面条版代码2(解耦合，整合)

  1. from wsgiref.simple_server import make_server
  3. def index(request):
  4.     return "index页面"
  6. def login(request):
  7.     return "login页面"
  9. def error(request):
  10.     return "error页面"
  12. urls = [
  13.     ("/index",index),
  14.     ("/login",login),
  15. ]
  18. def run(request,response):
  19.     """
  20.     :param request: 跟请求相关的数据
  21.     :param response:跟相应相关的数据
  22.     :return: 返回值就是要返回给前端浏览器的数据
  23.     """
  24.     response("200 OK",[])
  25.     print(request)                          # request为一个字典，将每个信息都装成了K:V键值对。
  26.     target_url = request.get("PATH_INFO")   # PATH_INFO 为用户输入的网站后缀名
  27.     # 提前定义一个存储函数名的变量
  28.     func = None
  29.     for url_tuple in urls:
  30.         if target_url == url_tuple[0]:
  31.             func = url_tuple[1]
  32.             break
  33.     if func:
  34.         res = func(request)
  35.     else:
  36.         res = error(request)
  37.     return [res.encode("utf8")]
  39. if __name__ == '__main__':
  40.     server = make_server("127.0.0.1",8080,app=run)
  41.     server.serve_forever()
  42. -----------------------------------------------------------------------
  43. 存在的问题：
  44.     1、面条版的代码，只有一个py文件，功能不清晰
  45.     2、
  47. 解决方法：
  48.     将每个功能分别做成py文件，解耦合程度更高一些

py代码整合为多文件

  1. """
  2. 以后新增功能，只需要先在 "views文件" 内写一个函数，
  3.             然后在 "urls文件" 加一组对应关系即可
  5. 目录:
  6. [项目名]--
  7.         |--templates            # 文件夹，专门存放html文件
  8.         |--wsgi服务端代码启动.py
  9.         |--urls.py                # 专门存放路径对应关系
  10.         |--views.py                # 专门存放核心业务逻辑
  11. """
  12. ----------------------"wsgi服务端代码启动.py"----------------------
  13. from wsgiref.simple_server import make_server
  14. from urls import urls
  15. from views import error
  17. def run(request,response):
  18.     response("200 OK",[])
  19.     print(request)                          
  20.     target_url = request.get("PATH_INFO")   
  21.     func = None
  22.     for url_tuple in urls:
  23.         if target_url == url_tuple[0]:
  24.             func = url_tuple[1]
  25.             break
  26.     if func:
  27.         res = func(request)
  28.     else:
  29.         res = error(request)
  30.     return [res.encode("utf8")]
  32. if __name__ == '__main__':
  33.     server = make_server("127.0.0.1",8080,app=run)
  34.     server.serve_forever()
  36. -----------------------------"urls.py"--------------------------
  37. from views import *
  38. urls = [
  39.     ("/index",index),
  40.     ("/login",login),
  41. ]
  43. -----------------------------"views.py"--------------------------
  44. def index(request):
  45.     return "index页面"
  47. def login(request):
  48.     return "login页面"
  50. def error(request):
  51.     return "error页面"
  54. ----------------------------------------------------------------

二、动静态网页

  1. 动静态网页
  2.     动态网页
  3.         数据不是直接写死在html页面上的 而是动态获取(后端)
  4.     静态网页
  5.         数据是直接写死在页面上的
  7. 使用我们自己写的web框架 完成一个动态页面的返回

三、jinja2模块

  1. 该模块提供了"模板语法"
  2.     支持后端给html页面传递数据并且支持后端语法
  3. 1、安装jinja2模块
  4.     pip3 install jinja2
  6. 2、在上面的views.py下
  7. from jinja2 import Template
  9. user = {"username": "yly", "pwd": 123, "hobby": ["play python","play ball"]}
  10. def get_dict(request):
  11.     with open(r"Templates/get_dict.html", "r", encoding="utf8") as f:
  12.         data = f.read()
  13.     res = Template(data)
  14.     temp = res.render({"user_dict": user})
  15.     return temp
  17. 3、创建"Templates/get_dict.html" 文件
  18. <!DOCTYPE html>
  19. <html lang="en">
  20. <head>
  21.     <meta charset="UTF-8">
  22.     <title>Title</title>
  23.     <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
  24. </head>
  25. <body>
  26.     <h1>{{user_dict}}</h1>
  27.      <h1>{{user_dict}}</h1>
  28.      <h1>{{user_dict['username']}}</h1>
  29.      <h1>{{user_dict.get('pwd')}}</h1>
  30.      <h1>{{user_dict.hobby}}</h1>
  31. <div>
  32.     {% for key in user_dict%}
  33.         <p>{{ key }}</p>
  34.     {% endfor %}
  35. </div>
  36. </body>
  37. </html>
  39. 4、打开web浏览器，输入"127.0.0.1:8080/get_dict"，就显示字典内容
  42. # 总结，jinja2的模板语法:
  43. <h1>{{user_dict}}</h1>
  44. <h1>{{user_dict['username']}}</h1>
  45. <h1>{{user_dict.get('pwd')}}</h1>
  46. <h1>{{user_dict.hobby}}</h1>
  47. <div>
  48.     {% for key in user_dict%}
  49.         <p>{{ key }}</p>
  50.     {% endfor %}
  51. </div>

四、前端、web框架、数据库三者结合

需求：

  1. 查找后端数据库的数据，通过代码传到前端html页面展示出来

准备：

  1. 准备mysql数据库表：
  2. create database db_666;
  3. use db_666;
  4. create table user(id int primary key auto_increment,name varchar(32),pwd int);
  5. insert into user(name,pwd) values('yly',111),('zpx',222),('aaa',333),('bbb',444),('ccc',555);
  6. mysql> select * from user;
  7. +----+------+------+
  8. | id | name | pwd  |
  9. +----+------+------+
  10. |  1 | yly  |  111 |
  11. |  2 | zpx  |  222 |
  12. |  3 | aaa  |  333 |
  13. |  4 | bbb  |  444 |
  14. |  5 | ccc  |  555 |
  15. +----+------+------+
  16. 5 rows in set (0.00 sec)

代码:

  1. ---------------------------------'urls.py'-------------------------------------
  2. from views import *
  3. urls = [
  4.     ("/index",index),
  5.     ("/login",login),
  6.     ("/get_dict",get_dict),
  7.     ("/get_user", get_user)
  8. ]
  10. ---------------------------------'views.py'-------------------------------------
  11. import pymysql
  14. def get_user(request):
  15.     conn = pymysql.connect(
  16.         host='127.0.0.1',
  17.         port=3306,
  18.         user='root',
  19.         passwd='123',
  20.         database='db_666',
  21.         charset='utf8',
  22.         autocommit=True
  23.     )
  24.     cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
  25.     sql = "select * from user;"
  26.     cursor.execute(sql)
  27.     data_list = cursor.fetchall()
  29.     with open(r"Templates/get_user.html", "r", encoding="utf8") as f:
  30.         data = f.read()
  31.     # jinja2模块
  32.     res = Template(data)
  33.     tmp = res.render({"data_list": data_list})
  34.     return tmp

html文件

  1. ----------------------------"Templates/get_user.html"---------------------------
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Title</title>
  7.     <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
  8.     <link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/css/bootstrap.min.css" rel="stylesheet">
  9. </head>
  10. <body>
  11. <a href="/index">进入index界面</a>
  12. <a href="/get_dict">进入get_dict界面</a>
  13.     <div class="container">
  14.         <div class="row">
  15.             <h1 class="text-center">用户数据</h1>
  16.             <div class="col-md-8 col-md-offset-2">
  17.                 <table class="table table-hover table-striped">
  18.                     <thead>
  19.                         <tr>
  20.                             <th>编号</th>
  21.                             <th>姓名</th>
  22.                             <th>密码</th>
  23.                         </tr>
  24.                     </thead>
  25.                     <tbody>
  26.                         {% for user_dict in data_list %}
  27.                             <tr>
  28.                                 <td>{{user_dict.id}}</td>
  29.                                 <td>{{user_dict.name}}</td>
  30.                                 <td>{{user_dict.pwd}}</td>
  31.                             </tr>
  32.                         {% endfor %}
  33.                     </tbody>
  34.                 </table>
  35.             </div>
  36.         </div>
  38.     </div>
  39. </body>
  40. </html>

运行

  1. 1、运行开始python代码
  3. 2、打开web,输入"127.0.0.1:8080/get_user"

五、python主流web框架

  1. '''千万不要同时学习多个框架!!!'''
  2. django框架
  3.     大而全 内部自带的组件特别特别多 类似于航空母舰
  4.     有时候可能会过于"笨重"
  6. flask框架
  7.     小而精 内部几乎没有什么自带的组件 全部依赖于第三方模块 类似于游骑兵
  8.     如果将flask所有的第三方模块集合到一起甚至可以盖过django
  9.     有时候可能会出现第三方模块无法兼容的情况
  11. tornado框架
  12.     异步非阻塞
  13.     """
  14.     同步异步
  15.         同步:提交任务之后原地等待任务的返回结果 期间不做任何事
  16.         异步:提交任务之后不原地等待任务返回结果 有结果会通过回调机制反馈
  17.     阻塞非阻塞
  18.         阻塞:程序被剥夺了CPU执行权限
  19.         非阻塞:运行态 就绪态
  20.     """
  22. ------------------------------------------------
  23. A:socket部分
  24. B:路由匹配
  25. C:模板语法
  27. django
  28.     A:不是自己写的 用的wsgiref模块
  29.     B:自己写的
  30.     C:自己写的
  31. flask
  32.     A:不是自己写的 werkzeug(依赖于wsgiref模块)
  33.     B:自己写的
  34.     C:不是自己写的 jinja2
  35. Tornado
  36.     A,B,C全部都是自己写的
  39. 知识储备:    
  40.     fastapi框架
  41.         异步框架

六、Django框架正式介绍

1、安装及介绍

  1. # 如何让你的计算机能够正常的启动Django项目
  2. 1、计算机名称不能有中文
  3. 2、一个pycharm窗口只开一个项目
  4. 3、项目里面的文件也尽量不要出现中文
  5. 4、python解释器尽量使用3.4~3.6之间的版本
  7. # django版本问题
  8.     django1.X
  9.     django2.X
  10.     django3.X
  12. # django安装
  13. pip3 install django==1.11.11
  14. 如果已经安装了其他版本 无需自己卸载
  15. 直接重新装 会自动卸载安装新的
  18. # 验证django是否下载完毕(命令自动安装放在pip下的scripts文件夹内)
  19.     django-admin
  22. """
  23. 3.X支持异步(但是目前写的不好)
  24. 1.X 2.X 3.X在使用上几乎没有太大差距
  26. 针对django版本我们以1.11.11为学习对象
  27. """

2、Django规划

3、Django前戏，重点是创建app的习惯 - 图1

3、django基本使用

  1. ----------------------------------"命令行"----------------------------------
  2.     1.创建django项目     # 运行这行代码，会在当前路径生成项目文件夹
  3.         django-admin startproject [项目名]
  4.     2.如何运行django项目
  5.         切到项目目录下
  6.             cd 项目名
  7.         python3 manage.py runserver
  8.             # 可能会报错 需要删除widgets.py152行逗号,python3.8解释器的错误
  9.             # 文件在Python3\lib\site-packages\django\contrib\admin\widgets.py
  10.     3.创建app
  11.         python3 manage.py startapp app名字
  13. """ 
  14. 命令行创建不会自动创建templates文件夹 并且 [项目]/settings.py 配置文件中也不会配置
  15. 需要自己创建文件夹并修改 "DIRS"
  16. vim settings.py
  17. TEMPLATES = [
  18.     {
  19.         'BACKEND': 'django.template.backends.django.DjangoTemplates',
  20.         'DIRS': [],        # 需要加入:  os.path.join(BASE_DIR, 'templates')
  21.                         # 这个参数是固定的，所以pycharm创建，会自动添加
  22.         'APP_DIRS': True,
  23.         'OPTIONS': {
  24.             'context_processors': [
  25.                 'django.template.context_processors.debug',
  26.                 'django.template.context_processors.request',
  27.                 'django.contrib.auth.context_processors.auth',
  28.                 'django.contrib.messages.context_processors.messages',
  29.             ],
  30.         },
  31.     },
  32. ]
  33. """
  36. ----------------------------------"pycharm启动"----------------------------------
  37. 1、new project 选择左侧第二个django即可
  39. 2、点击pycharm绿色小箭头即可启动
  41. 3、创建应用

pycharm使用django一些功能介绍

  1. 1、创建server以及配置启动ip及端口等等

3、Django前戏，重点是创建app的习惯 - 图2

  1. 2、pycharm便捷控制django,增加提示功能
  2.     例如：
  3.         startapp

3、Django前戏，重点是创建app的习惯 - 图3

3、Django前戏，重点是创建app的习惯 - 图4

4、什么是app应用

  1. """
  2. django是一款专门用来开发app的web框架
  4. django框架就类似于是一所大学
  5. app就类似于大学里面各个学院
  6.     比如开发淘宝：
  7.         订单相关
  8.         用户相关
  9.         投诉相关
  10.         创建不同的app对应不同的功能
  12.     选课系统
  13.         学生功能
  14.         老师功能
  15. 一个app就是一个独立的功能模块
  16. """
  19. django相当于一所大学(空壳子)
  20.     app相当于大学里面的各个学院(功能主题)

注意事项

  1. # 如何让你的计算机能够正常的启动Django项目
  2. 1、计算机名称不能有中文
  3. 2、一个pycharm窗口只开一个项目
  4. 3、项目里面的文件也尽量不要出现中文
  5. 4、python解释器尽量使用3.4~3.6之间的版本
  7. templates    放html文件

python小tips：

1、字符串与bytes类型的转换

3、Django前戏，重点是创建app的习惯 - 图5

  1. str -> bytes
  2.     1、    
  3.         bytes1 = "yly".encode(encoding="utf8")
  4.     2、
  5.         bytes2 = bytes("yly",encoding="utf8")
  7. bytes -> str
  8.     1、
  9.         str1 = bytes1.decode(encoding="utf8")
  10.     2、
  11.         str2 = str(bytes2,encoding="utf8")

2、类、对象也可以加括号调用

  1. 类加括号是实例化一个对象
  3. 对象加括号是调用__call__方法
  4. 如果直接print一个对象，则是调用__str__方法，获得他的return返回值(必须是字符串)

3、html请求地址

  1. remote_addr 发起请求的ip