框架Django原理及基础一

最新推荐文章于 2024-04-12 08:45:12 发布

HiFerry

最新推荐文章于 2024-04-12 08:45:12 发布

阅读量901

点赞数

分类专栏： django 文章标签： python django 数据库 web

本文链接：https://blog.csdn.net/weixin_49722641/article/details/109219554

版权

django 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

框架： framework

DRP原则： Don’t repeat yourself
特指为解决一个开放性问题而设计的具有一定约束性的支撑结构，使用框架可以快速开发特定系统。去除重复部分

web应用的流程：

//浏览器发送一个HTTP请求
//服务器收到请求，生成一个HTML文档
//服务器把HTML文件作为HTTP响应的BODY发送给浏览器
//浏览器最终收到HTTP响应，从BODY中读取HTML文件并显示

对于所有的Web应用，本质是一个socket服务端，用户的浏览器是一个socket客户端。

import socket
def main():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('localhost',8089))  # url为 127.0.0.1:8089
    sock.listen(5) # 监听数量

    while True:
        connection, address = sock.accept()
        buf = connection.recv(1024)
        print(buf.decode('utf8'))  # 客户端返回的数据

        connection.sendall(bytes("HTTP/1.1 201 OK\r\n\r\n","utf8"))  # 有些浏览器可以不用这句,因为浏览器解析方式不同 在这之后就可以发送网页代码
        # connection.sendall(bytes("<h1 style='color:yellow'>Hello,World</h1>", "utf8"))  # <h1 style='color:yellow'>html和css共同完成文字效果,js完成动态效果
        with open('lesson1.html','rb') as f:
            data=f.read()
        connection.sendall(data)
        connection.close()

if __name__ == '__main__':
    main()

# 浏览器访问127.0.0.1:8089 连接服务器后返回的信息 
GET / HTTP/1.1
Host: localhost:8089
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: Pycharm-a7943e9=3e8b6d40-197e-46ce-b197-ed89497751b3


GET /favicon.ico HTTP/1.1
Host: localhost:8089
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36
Accept: image/avif,image/webp,image/apng,image/*,*/*;q=0.8
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: no-cors
Sec-Fetch-Dest: image
Referer: http://localhost:8089/
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: Pycharm-a7943e9=3e8b6d40-197e-46ce-b197-ed89497751b3

最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从中读取HTML文件并返回。

如果要动态生成HTML，就需要把所有步骤自己实现。不过，接受HTTP请求、解析HTTP请求、发送HTTP响应都是底层代码。正确的做法是底层代码由专门的服务器软件实现。用Python专注于生成HTML文档。所以，需要一个统一的接口，使得可以只用Python编写Web业务。

WSGI：Web Server Gateway Interface。

from wsgiref.simple_server import make_server
# wsgiref为python内置服务器

def application(environ, start_response):
	# environ为请求对象 封装了所有收到的请求信息 
    start_response('200 OK', [('Content-Type', 'text/html')])
    # start_response可以很方便地设置发送的响应头 
    return [b'<h1>Hello, web!</h1>'] # 响应体

# 封装socket对象以及准备过程(socket bind listen)
httpd = make_server('', 8080, application) #ip地址 端口 函数名

print('Serving HTTP on port 8080...')
# 开始监听HTTP请求:
httpd.serve_forever()
# 浏览器访问 http://127.0.0.1:8080/

整个application()函数本身没有涉及到任何解析HTTP的部分，即底层代码不需要自己编写，只负责在更高层次上考虑如何响应请求就可以了。application()函数必须由WSGI服务器来调用。

Python内置了一个WSGI服务器，这个模块叫wsgiref。
application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数：environ：一个包含所有HTTP请求信息的dict对象；start_response：一个发送HTTP响应的函数。

在application()函数中，调用：start_response(‘200 OK’, [(‘Content-Type’, ‘text/html’)]) 就发送了HTTP响应的Header，注意Header只能发送一次，也就是只能调用一次start_response()函数。start_response()函数接收两个参数，一个是HTTP响应码，一个是一组list表示的HTTP Header，每个Header用一个包含两个str的tuple表示。

通常情况下，都应该把Content-Type头发送给浏览器。其他很多常用的HTTP Header也应该发送。然后，函数的返回值b'<h1>Hello, web!</h1>'将作为HTTP响应的Body发送给浏览器。

有了WSGI，我们关心的就是如何从environ这个dict对象拿到HTTP请求信息，然后构造HTML，通过start_response()发送Header，最后返回Body。

根据分析请求对象里不同的路径信息返回不同的页面

from wsgiref.simple_server import make_server
# wsgiref为python内置服务器

def application(environ, start_response):
	# environ为请求对象 封装了所有的请求信息
	# print("environ:",environ)
	# print(environ["PATH_INFO"]) # 返回请求路径/book 可以通过浏览器输入的不同的路径返回不同的页面
	path = environ["PATH_INFO"]
	start_response('200 OK', [('Content-Type', 'text/html')])

	if path=="/book":
		return [ b'<h1>Hello, book!</h1>' ]
	elif path=="/web":
		return [ b'<h1>Hello, web!</h1>' ]
	else:
		return [ b'<h1>404</h1>' ]
	#start_response可以很方便地设置响应头

# 封装socket对象以及准备过程(socket bind listen)
httpd = make_server('', 8080, application) #ip地址 端口 函数名

print('Serving HTTP on port 8080...')
# 开始监听HTTP请求:
httpd.serve_forever()

解耦操作：将返回页面独立成为函数，使得联系不那么紧密

from wsgiref.simple_server import make_server
# wsgiref为python内置服务器

def f1(request):
	return [ b'<h1>Hello, book!</h1>' ]

def f2(request):
	return [ b'<h1>Hello, web!</h1>' ]

def application(environ, start_response):
	# environ为请求对象 封装了所有的请求信息
	# print("environ:",environ)
	# print(environ["PATH_INFO"]) # 返回请求路径/book 可以通过浏览器输入的不同的路径返回不同的页面
	path = environ["PATH_INFO"]
	start_response('200 OK', [('Content-Type', 'text/html')])

	if path=="/book":
		return f1(environ) # 使得f1f2想用请求信息的时候也可以拿到
	elif path=="/web":
		return f2(environ)
	else:
		return [ b'<h1>404</h1>' ]
	#start_response可以很方便地设置响应头

# 封装socket对象以及准备过程(socket bind listen)
httpd = make_server('', 8080, application) #ip地址 端口 函数名
print('Serving HTTP on port 8080...')
# 开始监听HTTP请求:
httpd.serve_forever()

优化 if else 语句

from wsgiref.simple_server import make_server
# wsgiref为python内置服务器

def f1(request):
	return [ b'<h1>Hello, book!</h1>' ]

def f2(request):
	return [ b'<h1>Hello, web!</h1>' ]

def routers():
	urlpatterns = (
		('/book',f1),
		('/web',f2),
	)
	return urlpatterns

def application(environ, start_response):
	# environ为请求对象 封装了所有的请求信息
	# print("environ:",environ)
	# print(environ["PATH_INFO"]) # 返回请求路径/book 可以通过浏览器输入的不同的路径返回不同的页面
	path = environ["PATH_INFO"]
	start_response('200 OK', [('Content-Type', 'text/html')])

	urlpatterns = routers()
	func = None
	for item in urlpatterns: # 使用循环遍历简化if else
		if item[0] == path:
			func = item[1]
			break
	if func:
		return func(environ)
	else:
		return ["<h1>404</h1>".encode("utf8")]

# 封装socket对象以及准备过程(socket bind listen)
httpd = make_server('', 8080, application) #ip地址 端口 函数名
print('Serving HTTP on port 8080...')
# 开始监听HTTP请求:
httpd.serve_forever()

在后端改变HTML发送给浏览器渲染

from wsgiref.simple_server import make_server
# wsgiref为python内置服务器
import time

def f1(request):
	return [b'<h1>Hello, book!</h1>']

def f2(request):
	return [b'<h1>Hello, web!</h1>']

def curtime(request):
	# print(time.time()) #1603349683.058512
	curttime=time.ctime(time.time())
	# print(curttime) #Thu Oct 22 14:54:43 2020
	return ['<h1>current_time:!curttime!</h1>'.replace("!curttime!",str(curttime)).encode("utf8")]

def routers():
	urlpatterns = (
		('/book',f1),
		('/web',f2),
		('/time',curtime),
	)
	return urlpatterns

def application(environ, start_response):
	# environ为请求对象 封装了所有的请求信息
	# print("environ:",environ)
	# print(environ["PATH_INFO"]) # 返回请求路径/book 可以通过浏览器输入的不同的路径返回不同的页面
	path = environ["PATH_INFO"]
	start_response('200 OK', [('Content-Type', 'text/html')])

	urlpatterns = routers()
	func = None
	for item in urlpatterns: # 使用循环遍历简化if else
		if item[0] == path:
			func = item[1]
			break
	if func:
		return func(environ)
	else:
		return ["<h1>404</h1>".encode("utf8")]

# 封装socket对象以及准备过程(socket bind listen)
httpd = make_server('', 8080, application) #ip地址 端口 函数名
print('Serving HTTP on port 8080...')
# 开始监听HTTP请求:
httpd.serve_forever()

将上述代码解耦，将不同功能的代码块存入对应名称的py文件中。

MVC模式
经典MVC模式。所谓MVC就是将web应用分为模型(M),控制器©,视图(V)三层；他们之间以一种松耦合的方式连接在一起。
模型M负责业务对象与数据库的对象(ORM),视图V负责与用户的交互(页面)，控制器C接受用户的输入调用模型和视图完成用户的请求。

若函数中需要进行数据库相关操作则在模型M中进行。
视图存储传输给浏览器页面的请求体HTML文件
控制器C存储上述代码中的自定义函数

浏览器发送请求给控制器C，C对模型M中的数据库进行操作，且对视图view的前端代码操作后返回响应信息。

MTV模式
Django使用MTV模式。本质上与MVC模式没有什么差别，也是各组件之间保持松耦合关系
Model(模型)：负责业务对象与数据库的对象(ORM)
Template(模版)：负责如何把页面展示给用户 相当于MVC的view
View(视图)：负责业务逻辑，并在适当的时候调用Model和Template 相当于MVC的controller

此外，Django还有一个url分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template

具体流程如下：
在浏览器里输入url，通过url分发器匹配相应的视图函数，视图函数通过models从数据库中取数据，后把要展示的数据返回给模板，模板就是HTML文件返回给浏览器。

Django文件创建流程：

django
    #  安装：pip3 install django
    
    #  创建project
       # 打开文件夹，在路径栏中输入cmd
       django-admin startproject mysite
       ---mysite
		   ---mysite
		       ---settings.py(包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。)
		       ---url.py(负责把URL模式映射到应用程序VIEWS。)
		   ---- manage.py(Django项目里面的工具，通过它可以调用django shell和数据库等。)  
       
    #  创建APP   在mannage.py目录下执行
       python manage.py startapp app01
       ---mysite
		   ---mysite
		       ---settings.py
		       ---url.py
		   ---app01
		       ---views.py
		       ---models.py
		       ...
		   ---- manage.py
    #  使用模版
        render(req,"index.html")  # setting中有路径拼接，此时不需要进行绝对路径
        
    #  启动项目
        python manage.py runserver  127.0.0.1:8090
        访问：http://127.0.0.1:8080/
        可以在cmd下或者在pycharm的terminal下运行
    
    #   生成同步数据库的脚本：
        python manage.py makemigrations  
    #   同步数据库:  
        python manage.py migrate

在url文件中进行url配置

from django.contrib import admin
from django.conf.urls import url
from app01 import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^cur_time',views.cur_time),# r表示原生字符串 ^匹配开头
    url(r'^userinfo', views.info),
]

里面涉及到的函数在app01 中的views文件中定义

from django.shortcuts import render,HttpResponse
import datetime

def cur_time(request):
	times=datetime.datetime.now()
	# HttpResponse 返回字符串
	# return HttpResponse("<h1>ok</h1>")
	# 渲染 解析后再实例化发送
	return render(request,"cur_time.html",{'abc':times}) # 模板规则，用变量times代替html文件中的{{abc}}

user_list=list()
def info(req):
	# print("method:::",req.method) # 在浏览器中输入网址回车时 采用的是get
	if req.method=="POST":
		name=req.POST.get("username",None)
		sex=req.POST.get("gender",None)
		email=req.POST.get("email",None)
		user={"name":name,"sex":sex,"email":email}
		user_list.append(user) # 但是放在列表中会断电后丢失数据 所以需要使用数据库
		print(user_list)
	return render(req,"index.html",{"user_list":user_list})

使用post请求submit时，网页会出现forbidden来保证安全性，此时可以通过注释setting文件中的django.middleware.csrf.CsrfViewMiddleware, 防止表单提交时出现forbidden页面

render里面的参数html文件不需要写路径是因为需要在setting中设置BASE_DIR1=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
以及TEMPLATES中设置'DIRS'：[os.path.join(BASE_DIR1,"templates")]

文件使用的模板放入项目下的templates文件夹内
cur_time.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>当前时间:{{abc}}{{request.path}}</h1>
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<!--action 处理数据的url 且默认当前的域名和端口-->
<form action="/userinfo/" method="post">
    <p>姓名<input type="text" name="username"></p>
    <p>性别<input type="text" name="gender"></p>
    <p>邮箱<input type="text" name="email"></p>
    <p><input type="submit" value="submit"></p>
</form>
    <hr>
    <h1>数据展示</h1>
    <table border="1px">
        <tr>
        <td>姓名</td>
        <td>性别</td>
        <td>邮箱</td>
        </tr>
        <!--后端render根据模板语言的语法规范渲染出来的 前端不做渲染-->
        {% for i in user_list %}
        <tr>
        <td>{{i.name}}</td>
        <td>{{i.sex}}</td>
        <td>{{i.email}}</td>
        </tr>
        {% endfor %}
    </table>
</body>
</html>

若要使用数据库，则需要用到models模块
首先需要在setting的INSTALLED_APPS中加入’app01’,

INSTALLED_APPS = 
    'app01',

在models中创建表

from django.db import models
class UserInfor(models.Model):
    username=models.CharField(max_length=64,null=True)
    sex=models.CharField(max_length=64,null=True)
    email=models.CharField(max_length=64,null=True)

在views中设置函数

from app01 import models
def info(req):
	if req.method=="POST":
		u = req.POST.get("username", None)
		s = req.POST.get("gender", None)
		e = req.POST.get("email", None)
		models.UserInfor.objects.create(
			username=u,
			sex=s,
			email=e
		)
	user_list=models.UserInfor.objects.all() # 取数据
	return render(req,"index.html",{"user_list":user_list})

并将html文件中的<td>{{i.name}}</td>改为<td>{{i.username}}</td>

HiFerry

关注

0
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
框架Django原理及基础一

框架： frameworkDRP原则： Don’t repeat yourself特指为解决一个开放性问题而设计的具有一定约束性的支撑结构，使用框架可以快速开发特定系统。去除重复部分web应用的流程：//浏览器发送一个HTTP请求//服务器收到请求，生成一个HTML文档//服务器把HTML文件作为HTTP响应的BODY发送给浏览器//浏览器最终受到HTTP响应，从BODY中读取HTML文件并显示对于所有的Web应用，本质是一个socket服务端，用户的浏览器是一个socket客户端。im
复制链接

扫一扫