网页伪静态
动态页
动态网页，页面代码虽然没有变，但是显示的内容却是可以随着时间、环境或者数据库操作的结果而发生改变的。
静态页
即静态网页，是实际存在的，无需经过 服务器 的 编译 ，直接加载到客户 浏览器 上显示出来。
特点
1、静态网页每个网页都有一个固定的URL，且网页URL以.htm、.html、.shtml等常见形式为后缀，而不含有“?”。2、静态网页是实实在在保存在服务器上的文件，每个网页都是一个独立的文件。
3、静态网页的内容相对稳定，因此容易被搜索引擎检索；
-------------缺点--------------------------------------------------------------
4、静态网页没有数据库的支持，在网站制作和维护方面工作量较大，因此当网站信息量很大时完全依靠静态网页制作方式比较困难；
5、静态网页的交互性较差，在功能方面有较大的限制。
6、页面浏览速度迅速，过程无需连接数据库，开启页面速度快于动态页面。
7、减轻了服务器的负担，工作量减少，也就降低了数据库的成本。
伪静态页
将动态网页伪装成静态网页，从而提升网页被搜索引擎收录的概率
表现形式就是网址看着像一个具体的文件路径
-------------=--------------------
#路由层urls.py可以直接写一个。
path('index.html',view.index)
伪静态页的缺点
使用伪静态将占用一定量的CPU占有率，大量使用将导致CPU超负荷；
降低服务器访问承载量比如服务器能承载1000人，开启大量伪静态后，三百人。
视图层
每新添加一个功能都应该在路由文件 urls.py 中添加一个路由与视图的对应关系(请求路径的时候才有对应的 视图函数/类 去处理)
最简单的步骤：
先创建app
配置路由(路由与视图函数的对应关系)
写视图函数(要用到 HttpResponse, redirect，记得自己导过来)
编写模板页面
1.视图层返回值问题,必须返回一个什么？
当我们在视图层返回None，或者不返回时，页面报错，需要我们必须返回一个HttpResponse对象；
小疑问？
那么视图层，三板斧中，除了返回HttpResponse我们比较觉得合理
返回的render和redirect为什么不报错呢？底层源码其实他俩调用的也是HttpResponse对象
from django.shortcuts import render, HttpResponse,redirect
#以下是部分源码
class HttpResponse(HttpResponseBase):
pass
-----------render源码中也是返回的HttpResponseBase对象-------------------------------------
def render(request, template_name, context=None, content_type=None, status=None, using=None):
"""
Return a HttpResponse whose content is filled with the result of calling
django.template.loader.render_to_string() with the passed arguments.
"""
content = loader.render_to_string(template_name, context, request, using=using)
return HttpResponse(content, content_type, status)
----------------redirect源码中也是返回的HttpResponseBase对象---------------------------------------
def redirect(to, *args, permanent=False, **kwargs):
redirect_class = HttpResponsePermanentRedirect if permanent else HttpResponseRedirect
return redirect_class(resolve_url(to, *args, **kwargs))
2.视图函数返回json格式数据
小需求：不借助模板语法，视图层返回数据给浏览器，如图
两种方法
1.借助httpResponse，jsondump
user_dict = {'name': 'lzl', 'pwd': 1111, 'hobby': ['read', 'music']}
json_str = json.dumps(user_dict, ensure_ascii=False) #有中文的情况，把转码关闭掉。
return HttpResponse(json_str)
2.借助JsonResponse [用这个]
from django.http import JsonResponse
def index(request):
user_dict = {'name': 'lzl中文不转码', 'pwd': 1111, 'hobby': ['read', 'music']}
return JsonResponse(user_dict)
return JsonResponse(user_dict, json_dumps_params={'ensure_ascii':False}) #中文不转码
如果想返回非字典类型数据
序列化非字典类型的数据还需要指定safe参数为False
from django.http import JsonResponse
def index(request):
l1 = [1,2,3,4,5,6,7,8,'lzl牛']
return JsonResponse(l1, json_dumps_params={'ensure_ascii':False},safe = False)
JasonResponse是源码底层封装json
def __init__(self, data, encoder=DjangoJSONEncoder, safe=True,
json_dumps_params=None, **kwargs):
if safe and not isinstance(data, dict):
raise TypeError(
'In order to allow non-dict objects to be serialized set the '
'safe parameter to False.'
)
if json_dumps_params is None:
json_dumps_params = {}
kwargs.setdefault('content_type', 'application/json')
data = json.dumps(data, cls=encoder, **json_dumps_params)
super().__init__(content=data, **kwargs)
3. form表单携带文件数据
小需求：浏览器上传文件数据，通过前端传给后端数据
1.前端form表单
2.后端
form表单需要具备的条件
1.method 属性必须是post
2.enctype属性必须是multipart/form-data
<form action="" method="post" enctype=multipart/form-data></form>
3.后端获取文件数据的操作
request.FILES
#示例 获取
#v
file_obj = request.FILE.get('file')
print(file_obj.name)
with open(file_obj.name, 'wb') as f:
for line in file_obj:
f.write(line)
return render(request,'index.html')
4.FBV与CBV[核心重点]
FBV：基于函数的视图
CBV：基于类的视图
FBV示例
#urls.py路由层
from django import views
urlpatterns = [
path('admin/', admin.site.urls),
path('index/', view.index),
]
#views视图层
from django import views
def index(request):
return HttpResponse()
CBV示例
#urls.py路由层
from django import views
urlpatterns = [
path('admin/', admin.site.urls),
path('index/', view.index),
path('func/', views.MyView.as_view())，
]
#views视图层
from django import views
class MyView(views.View):
def get(self,request):
return HttpResponse('我是cbv里面的get方法')
def post(self,request):
return HttpResponse('我是cbv里面的post方法')
path('func/',views.MyView.as_view())
CBV会自动根据请求方式的不同匹配类中定义的方法并自动执行
模板层
1.模板语法传值两种方式
方式1：指名道姓传参，不浪费资源，
def modal(request)
name = 'lzl'
return render(request,'modal.html',{'name':name})
方式二：关键字local() 将整个局部名称空间中的名字去全部 传入简单快捷
def modal(request)
name = 'lzl'
age = '18'
time = '7'
return render(request,'modal.html'，locals())
2.模板语法传值范围特性
1.基本数据类型(整型，浮点型，字符串，元组，列表)直接传递使用
#基本数据类型
#路由层
--------------------------------views.py--------------------------------------------
def modal(request):
i = 123
f = 11.11
s = 'hello world'
l = [11, 22, 33]
d = {'name':'jason', 'pwd':123, 'others':[11, {'a':123, 'b':[111, 222, 333]},22]}
t = (11, 22, 33)
se = {11, 22, 33}
b = True
return render(request,'modal.html')
#模板层
-------------------------------modal.html--------------------------------------------
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.js"></script>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css">
<script src="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/js/bootstrap.min.js"></script>
</head>
<body>内容
{# <p>{{ i }}</p>#}
{# <p>{{ f }}</p>#}
{# <p>{{ s }}</p>#}
{# <p>{{ l }}</p>#}
{# <p>{{ d }}</p>#}
{# <p>{{ t }}</p>#}
{# <p>{{ se }}</p>#}
{# <p>{{ b }}</p>#}
{# <p>{{ d.name }}</p>#}
{# <p>{{ l.2 }}</p>#}
{# <P>{{ d.others.1.b.2 }}</P>#}
2.函数名的传递会自动加括号执行并返回值展示到页面上
def modal(request):
def func1():
print('哈哈哈')
return '你到底行不行'
<p>{{ func1 }}</p>
------页面展示效果------------
你到底行不行
3.注意函数如果有参数则不会执行也不会展示，模板语法不支持有参函数
def modal(request):
def func1(a,b):
print('哈哈哈')
return '你到底行不行'
<p>{{ func1 }}</p>
------页面不展示效果（模板语法不支持传参）------------
4.类名的传递也会自动加括号产生对象并展示到页面上
def modal(request):
class MyClass(object):
def get_obj(self):
return 'obj'
@classmethod
def get_cls(cls):
return 'cls'
@staticmethod
def get_func():
return 'func'
obj = MyClass()
----------------模板层modal.html--------------------------------------------
#前端 body内容
<p>{{ MyClass }}</p>
#名的传递也会自动加括号产生对象并展示到页面上
如果类调用打印对象
<p>{{ obj.get_obj }}</p>
<p>{{ obj.get_cls }}</p>
<p>{{ obj.get_func }}</p>
5.对象的传递则直接使用即可
#前端 body内容
<p>{{ obj }}</p>
ps:模板语法会判断每个名字是否可调用，如何可以则调用
注意！！！
django的模板语法在操作容器类型的时候只允许使用句点符
3.模板语法的过滤器(类似于python内置函数)
过滤器大概有五六十个，我们简单的罗列一些。
#路由层
--------------------------------views.py-------------------------
def modal(request):
i = 123
f = 11.11
s = 'hello world'
l = [11, 22, 33]
d = {'name':'jason', 'pwd':123, 'others':[11, {'a':123, 'b':[111, 222, 333]},22]}
t = (11, 22, 33)
se = {11, 22, 33}
b = True
from datetime import datetime
#日期
res = datetime.today()
#文件大小
file_size = 214324322432344353234
return render(request,'modal.html')
=================modal.html==================================
#模板层body内容
<p>统计长度：{{s|length}}</p>
<p></p>加法运算:{{i|add:123}}、加法运算：<p>s|add:'heiheihei'</p>
<p>日期转换:{{s|date:'Y-m-d H:i:s'}}</p>
<p>文件大小:{{file_size|filesizeformat}}</p>
<p>数据切片:{{l|slice:'0:10'}</p>
<p>字符截取:{{s1|truncatechars:6}}</p>
<p>单词截取(一个空格算一个)</p>
重点掌握过滤器
过滤器重点:语法转义
#为什么要加safe参数？
因为前端默认是不加载视图层的脚本标签语法的，如果默认加载，后果就是一旦后端写死循环弹出框，或者不友好的脚本，浏览器会直接崩溃，如果我们写的一定要加载，在后面跟上safe参数即可，告诉前端页面，此代码可以加载。
#视图层
-----------------------视图层view.py-------------------------
def modal(request):
script_tag = '<h1>还认识我吗???</h1>'
from django.utils.safestring import mark_safe
script_tag1 = '<script>alert(666)</script>'
res = mark_safe(script_tag1)
return render(request,'modal.html')
----------------------前端模板层modal.html-------------------------------
#body内容
<p>语法转义:{{ script_tag|safe }}</p>
<p>语法转义:{{ script_tag1|safe }}</p>
from django.utils.safestring import mark_safe
script_tag1 = '<script>alert(666)</script>'
res = mark_safe(script_tag1)
ps：有时候html页面上的数据不一定非要在html页面上编写，也可以后端写好传入
django 模板语法中的符号就两个，一个{{}} 一个{%%}
需要使用数据的时候{{}}，类似于上述的取值操作
需要使用方法的时候{%%}，类似于之前的反向解析操作
4.模板语法标签（类似于python的流程控制）
以下是常用的，还有一些冷门的了解
#body内容
{% if 条件 %} 条件一般是模板语法传过来的数据 直接写名字使用即可
条件成立执行的代码
{% elif 条件1 %}
条件1成立执行的代码
{% else %}
条件都不成立执行的代码
{% endif %}
{% for i in s %}
{% if forloop.first %}
<p>这是第一次哟~</p>
{% elif forloop.last %}
<p>这是最后一次!</p>
{% else %}
<p>{{ i }}</p>
{% endif %}
{% empty %}
<p>你给我的是个空 怎么for循环呢</p>
{% endfor %}
5.自定义相关功能（了解）
一般写全栈的时候会用到。
1.标签函数，
2，过滤器
3.inclusion_tag
如果想自定义 必须先做以下三件事
1.在应用下创建一个名为templatetags文件夹（文件夹名字必须为templatetags）
2.在该文件夹创建任意名称的py文件
3.在该py文件内编写自定义相关代码
from django.template import Library
register = Library()
# 自定义过滤器
@register.filter(name='myfilter')
def my_add(a, b):
return a + b
---------------------------------------------------- -----------
# 自定义标签函数
@register.simple_tag(name='mt')
def func(a, b, c, d):
return a + b + c + d
-------------------------------------------------------------
# 自定义inclusion_tag
@register.inclusion_tag(filename='it.html')
def index(n):
html = []
for i in range(n):
html.append('第%s页'%i)
return locals()
{% load mytag %}
{{ i|myfilter:1 }}
{% mt 1 2 3 4 %}
{% index 10 %}
6.模板的继承
1.模板的继承作用?
为了减少代码的编写
2.使用方法
#主模板调用
{% block 名字 %}
模板内容
{% endblock %}
2.把字模板html文件内容清理
3.调用继承文件
#字模板调用
{% etends 'html文件名' %}
4.子板内容修改
{% block 名字 %}
子板内容
{% endblock %}
一般情况下母板中至少应该有三个区域使得扩展性更高!!!
css
content
js
-------#css---------------------------------
{% block css %}
{% endblock %}
-------#content---------------------------
{% block content %}
{% endblock %}
----#js-----------------
{% block js %}
{% endblock %}
'''子板中还可以使用母板的内容 {{ block.super }} '''
7.模板的导入(了解)
将html页面的某个部分当做模块的形式导入使用
{% include 'menu.html' %}