前端——>数据库

  1. 前端---->后端---->数据库
  2. 数据库---->后端---->前端
  3. 前端接受的信息通过后端传输给数据库，数据库的返回结果经过前端处理返回给前端

软件开发架构

  1. cs架构 客户端/服务器架构
  2. bs架构 浏览器/服务器架构
  3. #本质bs也是cs

web框架的简短概念

  1. 可以将web框架理解成服务端

自定义简易版本的web框架

  1. 网络协议
  2. HTTP协议                数据传输是明文
  3. HTTPS协议                数据传输是密文
  4. websocket协议        数据传输是密文
  6. 四大特性
  7.     1.基于请求响应
  8.     2.基于TCP、IP作用于应用层之上的协议
  9.     3.无状态
  10.     4.短/无链接
  12. 数据格式
  13.     请求首行
  14.     请求头
  16.     请求体
  18. 响应状态码
  19.     1XX
  20.     2XX            200
  21.     3XX            
  22.     4XX            403 404
  23.     5XX            500
  24. """
  25. # 如何做到后缀的不同返回不同的内容
  26.     # 拿到用户输入的后缀 做判断 
  28. # 不足之处
  29.     1.代码重复(服务端代码所有人都要重复写)
  30.   2.手动处理http格式的数据 并且只能拿到url后缀 其他数据获取繁琐(数据格式一样处理的代码其实也大致一样 重复写)
  31.   3.并发的问题

流程分析

  1. socket服务端建立起来以后
  2. 访问--->获得客户端发送过来的信息--->将数据编译成utf8形式--->获得请求头-->（打上HTTP/1.1 200 OK）进行if判断并且返回相应结果--->返回给客户端

代码

  1. # 你可以将web框架理解成服务端
  2. import socket
  5. server = socket.socket()  # TCP  三次握手四次挥手  osi七层
  6. server.bind(('127.0.0.1',8080))  # IP协议 以太网协议 arp协议...
  7. server.listen(5)  # 池 ...
  9. """
  10. b'GET / HTTP/1.1\r\n
  11. Host: 127.0.0.1:8082\r\n
  12. Connection: keep-alive\r\n
  13. Upgrade-Insecure-Requests: 1\r\n
  14. User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36\r\n
  15. 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\r\n
  16. Sec-Fetch-Site: none\r\n
  17. Sec-Fetch-Mode: navigate\r\n
  18. Sec-Fetch-User: ?1\r\n
  19. Sec-Fetch-Dest: document\r\n
  20. Accept-Encoding: gzip, deflate, br\r\n
  21. Accept-Language: zh-CN,zh;q=0.9\r\n
  22. Cookie: csrftoken=KYJnVBLPpJxwt09TOmTXzpb5qkFJwHVxVGpi0NxEGIg4z5VUuazZ1O2RMwSisu14\r\n
  23. \r\n'
  26. """
  27. while True:
  28.     conn, addr = server.accept()
  29.     data = conn.recv(1024)
  30.     # print(data)  # 二进制数据
  31.     data = data.decode('utf-8')  # 字符串
  32.     # 获取字符串中特定的内容       正则  如果字符串有规律也可以考虑用切割
  33.     conn.send(b'HTTP/1.1 200 OK\r\n\r\n')
  34.     current_path = data.split(' ')[1]
  35.     # print(current_path)
  36.     if current_path == '/index':
  37.         # conn.send(b'index heiheihei')
  38.         with open(r'templates/01 myhtml.html', 'rb') as f:
  39.             conn.send(f.read())
  40.     elif current_path == '/login':
  41.         conn.send(b'login')
  42.     else:
  43.         # 你直接忽略favicon.ico
  44.         conn.send(b'hello web')
  45.     conn.close()

借助于wsgiref模块

  1. """
  2. urls.py                        路由与视图函数对应关系
  3. views.py                    视图函数(后端业务逻辑)
  4. templates文件夹        专门用来存储html文件
  5. """
  6. # 按照功能的不同拆分之后 后续添加功能只需要在urls.py书写对应关系然后取views.py书写业务逻辑即可

流程推导

  1. 基于wsgiref先获得请求头--->定义一个变量为空 for循环urls判断请求头内容对应不同事件--->判断是否有事件最后再返回客户端

流程代码

  1. from wsgiref.simple_server import make_server
  2. from urls import urls
  3. from views import *
  6. def run(env, response):
  7.     """
  8.     :param env:请求相关的所有数据
  9.     :param response:响应相关的所有数据
  10.     :return: 返回给浏览器的数据
  11.     """
  12.     # print(env)  # 大字典  wsgiref模块帮你处理好http格式的数据 封装成了字典让你更加方便的操作
  13.     # 从env中取
  14.     response('200 OK', [])  # 响应首行 响应头
  15.     current_path = env.get('PATH_INFO')
  16.     # if current_path == '/index':
  17.     #     return [b'index']
  18.     # elif current_path == '/login':
  19.     #     return [b'login']
  20.     # return [b'404 error']
  21.     # 定义一个变量 存储匹配到的函数名
  22.     func = None
  23.     for url in urls:  # url (),()
  24.         if current_path == url[0]:
  25.             # 将url对应的函数名赋值给func
  26.             func = url[1]
  27.             break  # 匹配到一个之后 应该立刻结束for循环
  28.     # 判断func是否有值
  29.     if func:
  30.         res = func(env)
  31.     else:
  32.         res = error(env)
  34.     return [res.encode('utf-8')]
  37. if __name__ == '__main__':
  38.     server = make_server('127.0.0.1',8080,run)
  39.     """
  40.     会实时监听127.0.0.1:8080地址 只要有客户端来了
  41.     都会交给run函数处理(加括号触发run函数的运行)
  43.     flask启动源码
  44.         make_server('127.0.0.1',8080,obj)
  45.         __call__
  46.     """
  47.     server.serve_forever()  # 启动服务端

动静态网页

  1. """
  2. 静态网页
  3.     页面上的数据是直接写死的 万年不变
  4. 动态网页
  5.     数据是实时获取的
  6.     eg:
  7.         1.后端获取当前时间展示到html页面上
  8.         2.数据是从数据库中获取的展示到html页面上
  9. """
  10. # 动态网页制作
  11. import datetime
  12. def get_time(env):
  13.     current_time = datetime.datetime.now().strftime('%Y-%m-%d %X')
  14.     # 如何将后端获取到的数据"传递"给html文件？
  15.     with open(r'templates/03 mytime.html','r',encoding='utf-8') as f:
  16.         data = f.read()
  17.         # data就是一堆字符串
  18.     data = data.replace('dwadasdsadsadasdas',current_time)   # 在后端将html页面处理好之后再返回给前端
  19.     return data
  21. # 将一个字典传递给html文件 并且可以在文件上方便快捷的操作字典数据
  22. from jinja2 import Template
  23. def get_dict(env):
  24.     user_dic = {'username':'jason','age':18,'hobby':'read'}
  25.     with open(r'templates/04 get_dict.html','r',encoding='utf-8') as f:
  26.         data = f.read()
  27.     tmp = Template(data)
  28.     res = tmp.render(user=user_dic)
  29.     # 给get_dict.html传递了一个值 页面上通过变量名user就能够拿到user_dict
  30.     return res
  32. # 后端获取数据库中数据展示到前端页面

jinja2模板语法

  1. pip3 install jinja2
  2. """模版语法是在后端起作用的"""
  4. # 模版语法(非常贴近python语法)
  5. {{ user }}
  6. {{ user.get('username')}}
  7. {{ user.age }}
  8. {{ user['hobby'] }}
  11. {% for user_dict in user_list %}
  12.                         <tr>
  13.                             <td>{{ user_dict.id}}</td>
  14.                             <td>{{ user_dict.username}}</td>
  15.                             <td>{{ user_dict.password}}</td>
  16.                             <td>{{ user_dict.hobby}}</td>
  17.                         </tr>
  18. {% endfor%}

web框架流程图

  1. """
  2. wsgiref模块
  3.     1.请求来的时候解析http格式的数据 封装成大字典
  4.     2.响应走的时候给数据打包成符合http格式 再返回给浏览器
  5. 基于wsgiref先获得请求头--->定义一个变量为空 for循环urls判断请求头内容对应不同事件--->判断是否有事件最后再返回客户端
  6. """

python三大主流web框架

  1. """
  2. Django
  3.     特点：大而全 自带的功能特别多 
  4.     缺点：有时候过于笨重
  5. flask
  6.     特点：小而精 自带功能特别少
  7.           第三方模块非常多
  8.     缺点：比较依赖于第三方的开发者 
  9. tornado
  10.     特点：异步非阻塞 支持高并发
  11.           甚至可以开发游戏服务器
  12.     缺点：不会
  13. """
  14. A:socket部分
  15. B:路由与视图函数对应关系(路由匹配)
  16. C:模版语法
  18. django
  19.     A用的是别人的        wsgiref模块
  20.   B用的是自己的
  21.   C用的是自己的(没有jinja2好用 但是也很方便)
  23. flask
  24.     A用的是别人的        werkzeug(内部还是wsgiref模块)
  25.   B自己写的
  26.   C用的别人的(jinja2)
  28. tornado
  29.     A，B，C都是自己写的

django注意事项

  1. # 如何让你的计算机能够正常的启动django项目
  2.     1.计算机的名称不能有中文
  3.   2.一个pycharm窗口只开一个项目
  4.   3.项目里面所有的文件也尽量不要出现中文
  5.   4.python解释器尽量使用3.4~3.6之间的版本
  6.       (如果你的项目报错 你点击最后一个报错信息
  7.     去源码中把逗号删掉)
  9. # django版本问题
  10.     1.X 2.X 3.X(直接忽略)
  11.   1.X和2.X本身差距也不大 我们讲解主要以1.X为例 会讲解2.X区别
  12.   公司之前用的1.8 满满过渡到了1.11版本 有一些项目用的2.0
  14. # django安装
  15.     pip3 install django==1.11.11
  16.   如果已经安装了其他版本 无需自己卸载
  17.   直接重新装 会自动卸载安装新的
  19.   如果报错 看看是不是timeout 如果是 那么只是网速波动
  20.   重新安装即可
  22.   验证是否安装成功的方式1
  23.       终端输入django-admin看看有没有反应

pyCharm安装Django：

image.png
image.png

django基本操作

  1. 命令行创建项目
  2. 1.创建django项目 创建命令 django-admin startproject 项目名字(不能是中文)
  3.                                                     mysite
  4. '''
  5. 切换到你想要创建的盘，再进行创建
  6. '''
  7. 2.启动django项目 python3 manage.py runserver
  8. '''
  9. 需要切换到对应项目目录内
  10. cd/mysite
  11. '''
  12. 3.创建应用 python3 manage.py startapp app01
  13. '''
  14. Next, start your first app by running python manage.py startapp [app_label].
  15.     应用名应该做到见名知意
  16.       user
  17.       order
  18.       web
  19.       ...
  20.       但是我们教学统一就用app01/02/03/04
  21. '''
  22. pyCharm创建项目
  23. 1.创建Django项目 new project 选择左侧第二个django即可(建议使用2.2左右版本1.x真的太容易报错了)
  24. 2.启动
  25.           1.还是用命令行启动
  26.         2.点击绿色小箭头即可
  27. 3.创建应用
  28.         1.pycharm提供的终端直接直接创建 python3.5 manage.py startapp app01
  29.         2.pycharm 
  30.               tools 
  31.                 run manage.py
  32.                     appstart app02 -->这东西还有提示就离谱

应用

  1. """
  2. django是一款专门用来开发app的web框架
  4. django框架就类似于是一所大学(空壳子)
  5. app就类似于大学里面各个学院(具体功能的app)
  6.     比如开发淘宝
  7.         订单相关
  8.         用户相关
  9.         投诉相关
  10.         创建不同的app对应不同的功能
  12.     选课系统
  13.         学生功能
  14.         老师功能
  16. 一个app就是一个独立的功能模块
  17. """
  18. **********创建应用一定要去配置文件中注册
  20. INSTALLED_APPS = [
  21.     'django.contrib.admin',
  22.     'django.contrib.auth',
  23.     'django.contrib.contenttypes',
  24.     'django.contrib.sessions',
  25.     'django.contrib.messages',
  26.     'django.contrib.staticfiles',
  27.     'app01.apps.App01Config',#全写
  28.     'app02'#简写
  29. ]
  30. #创建出来的应用第一步就是先去配置文件中注册 其他的都先不要管
  31. 在使用pycharm创建项目的时候 pycharm可以帮助你创建一个app并且注册 （个人觉得还是手动比较舒服）

主要文件介绍

  1. -mysite项目文件夹
  2.     --mysite文件夹
  3.         --settings.py 配置文件
  4.         --urls.py 路由与视图函数对应关系文件
  5.         --wsgi.py wsgiref模块（不需要考虑）
  6.     --manage.py django的入口文件
  7.     --db.sqlite3 django自带的sqlite3数据库(小型数据库 功能不多且有bug)
  8. -app01文件夹
  9.     --admin.py django后台管理
  10.     --apps.py 注册使用
  11.     --models.py 数据库相关 模型类(orm)
  12.     --tests.py 测试文件
  13.     --views.py 视图函数(视图层)

命令行创建与pycharm创建的区别

  1. 1.命令行创建不会自动创建template文件夹 需要自己动手创建而pycharm会自动帮你创建并且还会自动在配置文件中对应相应的路径
  2. pycharm创建
  3. TEMPLATES = [
  4.     {
  5.         'BACKEND': 'django.template.backends.django.DjangoTemplates',
  6.         'DIRS': [str.format(BASE_DIR, '/templates')]
  7.         ,
  8.         'APP_DIRS': True,
  9.         'OPTIONS': {
  10.             'context_processors': [
  11.                 'django.template.context_processors.debug',
  12.                 'django.template.context_processors.request',
  13.                 'django.contrib.auth.context_processors.auth',
  14.                 'django.contrib.messages.context_processors.messages',
  15.             ],
  16.         },
  17.     },
  18. ]
  19. 命令行创建
  20. TEMPLATES = [
  21.     {
  22.         'BACKEND': 'django.template.backends.django.DjangoTemplates',
  23.         'DIRS': [],
  24.         'APP_DIRS': True,
  25.         'OPTIONS': {
  26.             'context_processors': [
  27.                 'django.template.context_processors.debug',
  28.                 'django.template.context_processors.request',
  29.                 'django.contrib.auth.context_processors.auth',
  30.                 'django.contrib.messages.context_processors.messages',
  31.             ],
  32.         },
  33.     },
  34. ]
  36. 所以在使用命令行创建django项目的时候不单单需创建template文件夹还需要配置文件配置路径
  37. 'DIRS': [os.path.join(BASE_DIR, 'templates')]

django小白必会三板斧

  1. from django.shortcuts import HttpResponse,render,redirect
  2. HttpResponse
  3.     返回字符串类型的数据
  4.     return HttpResponse('hello word')
  5. render
  6.     返回html文件的
  7.     return render(request,'dd.html') 显示不出来一般就是路径有问题，参考上面的区别即可
  8. redirect
  9.     重定向
  10.     return redirect('https://www.mzitu.com/')
  11.     return redirect('/home/')--->相当于render

课后练习

  1. """
  2. 1.整理web框架推导思路
  3. 2.安装django并正常启动访问，测试三板斧
  4. 3.整理今日日考题，django内容
  5. 选做题
  6. 1.结合前端，django，MySQL，pymysql模块实现数据库数据动态展示到前端
  7. 2.尝试着摸索django模版语法
  8. """