django 路由层 模板语法

render:
render返回一个html页面 并且还能够给该页面传数据
render内部原理
from django.template import Template,Context
def index(request):
temp = Template('<h1>{{ user }}</h1>')
con = Context({"user":{"name":'jason',"password":'123'}})
res = temp.render(con)
print(res)
return HttpResponse(res)

FBV与CBV --视图函数并不只是指函数 也可以是类
FBV(基于函数的视图) 面向函数式编程
CBV(基于类的视图) 面向对象式编程

1.在cbv中 get请求来就会走类里面get方法,post请求来就会走类里面post方法 为什么?

urls.py中
url(r'^login/',views.MyLogin.as_view())
views.py中
from django.views import View

class MyLogin(View):
　　def get(self,request):
　　　　print("from MyLogin get方法")
　　　　return render(request,'login.html')
　　def post(self,request):
　　　　return HttpResponse("from MyLogin post方法")


研究方向
1.从url入手
url(r'^login/',views.MyLogin.as_view()) 由于函数名加括号执行优先级最高,所以这一句话一写完会立刻执行as_view()方法

@classonlymethod
def as_view(cls, **initkwargs): # cls就是我们自己的写的类 MyLogin
def view(request, *args, **kwargs):
　　self = cls(**initkwargs) # 实例化产生MyLogin的对象 self = MyLogin(**ininkwargs)
　　if hasattr(self, 'get') and not hasattr(self, 'head'):
　　self.head = self.get
　　self.request = request
　　self.args = args
　　self.kwargs = kwargs
# 上面的几句话都仅仅是在给对象新增属性
　　return self.dispatch(request, *args, **kwargs) # dispatch返回什么 浏览器就会收到什么
# 对象在查找属性或者方法的时候 你一定要默念 先从对象自己这里找 然后从产生对象的类里面找 最后类的父类依次往后
　　return view

通过源码发现url匹配关系可以变形成
url(r'^login/',views.view) # FBV和CBV在路由匹配上是一致的 都是url后面跟函数的内存地址
2.当浏览器中输入login 会立刻触发view函数的运行
def dispatch(self, request, *args, **kwargs):
# Try to dispatch to the right method; if a method doesn't exist,
# defer to the error handler. Also defer to the error handler if the
# request method isn't on the approved list.
# 我们先以GET为例
if request.method.lower() in self.http_method_names: # 判断当前请求方法是否在默认的八个方法内
# 反射获取我们自己写的类产生的对象的属性或者方法
# 以GET为例 handler = getattr(self,'get','取不到报错的信息')
# handler = get(request)
handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
return handler(request, *args, **kwargs) # 直接调用我们自己的写类里面的get方法
# 源码中先通过判断请求方式是否符合默认的八个请求方法 然后通过反射获取到自定义类中的对应的方法执行



2.django settings源码
前提:
1.django除了暴露给用户一个settings.py配置文件之外 自己内部还有一个全局的配置文件
2.我们在使用配置文件的时候 可以直接直接导入暴露给用户的settings.py也可以使用django全局的配置文件 并且后者居多
from django.conf import settings
3.django的启动入口是manage.py

import os
import sys

if __name__ == "__main__":
# django在启动的时候 就会往全局的大字典中设置一个键值对 值是暴露给用户的配置文件的路径字符串
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day54.settings")

class Settings(object):
def __init__(self, settings_module): # settings_module = 'day54.settings'
# update this dict from global settings (but only for ALL_CAPS settings)
for setting in dir(global_settings): # django全局配置文件
# dir获取django全局配置文件中所有的变量名
if setting.isupper(): # 判断文件中的变量名是否是大写 如果是大写才会执行/生效
setattr(self, setting, getattr(global_settings, setting)) # 给settings对象设置键值对
# 给settings对象设置键值对 settings[配置文件中大写的变量名] = 配置文件中大写的变量名所对应的值

# store the settings module in case someone later cares
self.SETTINGS_MODULE = settings_module # 'day54.settings'

mod = importlib.import_module(self.SETTINGS_MODULE) # mod = 模块settings(暴露给用户的配置文件)
for setting in dir(mod): # for循环获取暴露给用户的配置文件中所有的变量名
if setting.isupper(): # 判断变量名是否是大写
setting_value = getattr(mod, setting) # 获取大写的变量名所对应的值
setattr(self, setting, setting_value) # 给settings对象设置键值对
"""
d = {}
d['username'] = 'jason'
d['username'] = 'egon'
用户如果配置了就用用户的
用户如果没有配置就用系统默认的
其实本质就是利用字典的键存在就是替换的原理 实现了用户配置就用用户的用户没配置就用默认的
"""

class LazySettings(LazyObject):
def _setup(self, name=None):
# os.environ你可以把它看成是一个全局的大字典
settings_module = os.environ.get(ENVIRONMENT_VARIABLE) # 从大字典中取值键为DJANGO_SETTINGS_MODULE所对应的值:day54.settings
# settings_module = 'day54.settings'
self._wrapped = Settings(settings_module) # Settings('day54.settings')


settings = LazySettings() # 单例模式

模板层
模板语法: django的模板语法不支持给函数传参,传函数名,会调用函数,前端展示返回值
django模板语法在取值的时候 ,统一使用句点符,不能用get
两大类
{{}} 变量相关
{%%} 逻辑相关

为模板传值
1. 用render 也就是说 通过字典的键值对,指名道姓一一传递
注:内容 多的话 会很麻烦
2. 用locals 会把它所在的名层空间的所用名字都传给前端
注: 一定程度上造成资源浪费



标签(**|**):内部原理(会将|前面的当做第一个参数传入标签中
""" |safe |filesizeformat |date """ *****
<p>{{ l|length }}</p> 获取长度
<p>{{ n|length }}</p>

<p>{{ ss|default:'当|左边的变量为空就会返回|右边的值' }} default跟你后端get方法很想</p>
<p>{{ ss|default:'' }} default必须要有两个参数</p>

<p>{{ file_size|filesizeformat }}</p> 获取对对象的大小

<p>{{ info|truncatewords:3 }}按空格截取内容 三个点不算</p>

<p>{{ info|truncatechars:6 }}按字符截取内容 三个点也算</p>

<p>{{ xxx|safe }}</p> 取消转义
eg:前后端取消转义
前端:
<p>{{ zzz }}</p>
后端:
from django.utils.safestring import mark_safe
zzz = mark_safe('<h1>阿萨德搜啊第三款垃圾袋</h1>')

<p>{{ ctime }}</p> 展示时间
<p>{{ ctime|date:'Y-m-d' }} </p>

<p>{{ n|add:100 }}</p> 相加
<p>{{ s|add:'hahah 翻车啦' }}</p>
注:数字与数字, 字符串与字符串 都可 相加

<p>{{ l|slice:'0:3' }}</p> 切片 顾头不顾尾
<p>{{ l|slice:'0:5:2' }}</p> 支持步长

逻辑相关: {%%}
for:{#{% for foo in l %}#}
{# <p>{{ forloop }}</p>#}
{#{% endfor %}#}
注({{forloop}}):
1.当first 为True是 是第一次循环 当last 为False时 是最后一次循环
2.counter0 类比索引
3.counter1 为计数次数

if: {#{% if '' %}#}
{#<p>xxx条件为true</p>#}
{# {% else %}#}
{# <p>xxx条件为false</p>#}
{#{% endif %}#}

嵌套:{#{% for foo in '' %}#}
{# {% if forloop.first %}#}
{# <p>这是我的第一次</p>#}
{# {% elif forloop.last %}#}
{# <p>这是最后一次了啊</p>#}
{# {% else %}#}
{# <p>来啊来啊!!!</p>#}
{# {% endif %}#}
{# {% empty %}#}
{# <p>当for循环的对象为空的时候 会走empty</p>#}
{#{% endfor %}#}

with:
{# {% with l.6.3.name as ttt %} #可以给一个比较复杂的取值操作取一个别名 之后在with语句中 就可以使用该别名
{# {{ ttt }}#}
{# {{ l.6.3.name }}#}
{# {% endwith %}#}

字典k,v 的获取方式:
{% for foo in d.keys %}
<p>{{ foo }}</p>
{% endfor %}
{% for foo in d.values %}
<p>{{ foo }}</p>
{% endfor %}
{% for foo in d.items %}
<p>{{ foo }}</p>
{% endfor %}

自定义标签 过滤器 inclusion_tag
自定义固定的三步走战略:
1.必须在你的应用下新建一个名为templatetags文件夹
2.在该文件夹内新建一个任意名称的py文件
3.在该py文件中固定先写下面两句代码
from django import template

register = template.Library()

@register.filter(name='baby')
def index(a,b):
return a + b

前端用法:{% load mytag %}
{{123|baby:1}}
注: 自定义过滤器只能有两个参数,但是可以在给第二个参数传值时传一个字符串
eg:
{{123|baby:'1,3,5'}}

# 自定义标签
# 支持传多个值
@register.simple_tag(name='jason')
def xxx(a,b,c,year):
return '%s?%s|%s{%s'%(a,b,c,year)

自定义inclusion_tag
使用场景:当你的页面上有一部分html代码需要经常被各个地方使用 并且需要传参才能
渲染出来,这样这部分html代码可以制作成inclusion_tag

"""
接收用户传入的参数 然后作用于一个html页面
在该页面上渲染数据 之后将渲染好的页面
放到用户调用inclusion_tag的地方
"""

# 自定义inclusion_tag
@register.inclusion_tag('bigplus.html')
def bigplus(n):
l = []
for i in range(n):
l.append('第%s项'%i)
return {'l':l}


模板的继承
当多个页面整体的样式都大差不差的情况下 可以设置一个模板文件
在该模板文件中 使用block块划分多个区域,之后子版在使用模板的时候
可以通过block块的名字 来选定到底需要修改哪一部分区域

模板一般情况下 应该至少有三个可以被修改的区域
1. {% block css %}
子页面自己的css代码
{% endblock %}

2. {% block content %}
子页面自己的html代码
{% endblock %}

3. {% block js %}
子页面自己的js代码
{% endblock %}

模板的继承 使用方式
{% extends 'home.html' %}

1. {% block css %}
<style>
h1 {
color: red;
}
</style>
{% endblock %}

2. {% block content %}
<h1>登陆页面</h1>
<form action="">
<p>username:<input type="text" class="form-control"></p>
<p>password:<input type="text" class="form-control"></p>
<input type="submit" class="btn btn-danger">
</form>
{% endblock %}

3. {% block js %}

{% endblock %}

模板的导入
{% include 'beautiful.html' %}