django之视图层和部分模板层

视图层

小白必会三板斧（三个返回的都是HttpResponse对象，通过看源码，可以知道是内部实现）

1.HttpResponse  # 返回字符串

2.render  # 返回一个html页面 还可以给模板传递
from django.template import Template,Context
def index(request):
res = Template("<h1> {{ user }} </h1>")
con = Context({'user':{'username':'jason','pwd':'123'}})
ret = res.render(con)
print(ret)
return HttpResponse(ret)

3.redirect  # 重定向

JsonResponse

作用是返回json格式数据的

为什么要给前端返回json格式字符串？

前后端分离  就是基于json格式传输数据
后端就专门写接口 前端调用你这个接口 就能够拿到一个
json格式的字符串
然后前端利用序列化反序列转换成前端对应的数据类型

前端                          后端
JSON.stringify 序列化   >>>   json.dumps
JSON.parse     反序列   >>>   json.loads

js常用数据类型

数值类型
字符类型
数组  []
自定义对象 {}
undefined与null
布尔值 true false
symbol

JS中的六大数据类型

form表单上传文件

注意事项

1.提交方式必须是post

2.enctype参数必须有默认的urlencoded变成formdata

FBV与CBV 以及CBV源码分析

##FBV(Function Based View) 基于函数的视图（就是我们一直写的普通映射函数）

##CBV(Class Based View) 基于类的视图

你在类中写了两个方法 一个叫get一个叫post
为什么前端get请求来就会触发get方法
post请求来就会触发post方法  如何实现的？？？

 # CBV路由

    #urls.py
    url(r'^reg/',views.MyReg.as_view()) 

    #as_view()的源码
    @classonlymethod
    def as_view(cls, **initkwargs):
        def view(request, *args, **kwargs):
            self = cls(**initkwargs)  # cls就是我们自己的写的MyReg类
            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)
            # 对象在查找属性或方法的时候 顺序是什么？
            # 先从自己找 再从产生对象的类中找  再去类的父类中找...
            """也就意味着你在看源码的时候 你一定要牢记上面的话"""
        return view

    # views.py
    from django.views import View
    class MyReg(View):
        def get(self,request):
            return render(request,'reg.html')

        def post(self,request):
            return HttpResponse("我是MyReg类中post方法")

	***************CBV最精髓的部分****************
       def dispatch(self, request, *args, **kwargs):
            # 判断当前请求方式在不在默认的八个请求方式中
            if request.method.lower() in self.http_method_names:
                handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
                # handler = getattr(自己写的类产生的对象,'小写的请求方法(get\post)',
                # '获取不到对应的方法就报错')
                # handler就是我们自己定义的跟请求方法相对应的方法的函数内存地址
            else:
                handler = self.http_method_not_allowed
            return handler(request, *args, **kwargs)  # 在调用获取到的方法

django settings源码分析及实际应用

​ django的配置文件有两个

​ 一个是暴露给用户可以自定义配置的

​ 一个是默认的全局配置文件

​ 用户指定了就用用户的

​ 用户没有指定就用默认的

​

   from django.conf import settings

   settings = LazySettings()

   class LazySettings(LazyObject):
        def _setup(self, name=None):

            # os.environ你可以把它看成是一个全局的大字典
            settings_module = os.environ.get(ENVIRONMENT_VARIABLE)  # 从大字典中取值
            # settings_module = 'day59.settings'

            self._wrapped = Settings(settings_module)  # Settings('day59.settings')

    class Settings(object):
        def __init__(self, settings_module):  # settings_module = 'day59.settings'
            for setting in dir(global_settings):  # 循环获取global_settings文件中所有的名字
                if setting.isupper():  # 在判断名字是否是大写
                    # 如果是大写 利用反射 获取到大写的名字所对应的值  不停地添加到对象中
                    setattr(self, setting, getattr(global_settings, setting))
            # store the settings module in case someone later cares
            self.SETTINGS_MODULE = settings_module
            mod = importlib.import_module(self.SETTINGS_MODULE)  # 'day59.settings'
            # from day59 import settings
            # mod 指代的就是暴露给用户的配置文件模块名

            for setting in dir(mod):  # 循环获取暴露给用户配置文件中所有的名字
                if setting.isupper():  # 判断是否是大写
                    setting_value = getattr(mod, setting)  # 如果是大写 获取大写的变量名所对应的值
                    setattr(self, setting, setting_value)  # 不停的给对象设置值

模板传值

​ 传函数名的时候 会自动加括号调用函数 将函数的返回值展示在html页面上

​ django模板语法不支持函数传参

​ django模板语法在获取容器类型内部元素的值的时候 统一只采用 句点符(.)

​

## 过滤器(|)
    (前端代码并不一定非要在前端写  你也可以在后端写好 传递给前端页面)
    前后端取消转义
       方法一：
       		后端：<p>我是在后端写的</p>
       		在前端，用过滤器
            	|safe (告诉前端，我在后端写的前端语句是可以有实际意义的)
       方法二：
        	在后端
                from django.utils.safestring import mark_safe
                sss2 = "<a href='http://www.xiaohuar.com'>下午上课 需要激情</a>"
                res = mark_safe(sss2)
            前端
            	{{res}}
        """
        模板语法的符号就两种
            {{}}  变量相关
            {%%}  逻辑相关

        """

​

## 标签
        if判断
        for循环

自定义过滤器、标签
    步骤：
        1 在应用名下面新建一个templatetags文件夹(必须叫这个名字)
        2 在改文件夹下 新建一个任意名称的py文件
        3 在该py文件内 固定先写两行代码
            from django.template import Library
            register = Library()

    自定义的过滤器

    自定义的标签
        @register.filter(name='myplus')
        def index(a,b):
            return a + b
        @register.simple_tag(name='mysm')
        def login(a,b,c,d):
            return '%s/%s/%s/%s'%(a,b,c,d)

        # 过滤器取值
        {% load my_tag %}
		{{ 123|myplus:123 }}

        #标签取值
        {% load my_tag %}
		{% mysm 1 2 3 4 %}

        区别 标签不能再if中使用
        {% if 0|myplus:123 %}  可以用
            <p>有值</p>
        {% endif %}
        {% if mysm 1 2 3 4 %}  不能用
            <p>有值</p>
        {% endif %}

## 几个例子

#例子1
forloop的用法

l= [1,2,3,4,5,6] 是后端传过来的

{% for foo in l %}
	{{ forloop.counter }}
    {% if forloop.first %}
        <p>这是我的第一次</p>
    {% elif forloop.last %}
        <p>这是最后一次了啊</p>
    {% else %}
        <p>嗨起来 大宝贝~</p>
    {% endif %}
{% endfor %}

##打印结果
1
这是我的第一次
2
嗨起来 大宝贝~
3
嗨起来 大宝贝~
4
嗨起来 大宝贝~
5
嗨起来 大宝贝~
6
这是最后一次了啊

"""
forloop.counter 可以作为序号，它不会出现主键删除之后出现断片的效果
"""

#例子2
. 取值

#后端代码
 yyy = {'user_list':[1,'22',{'username':['jason','egon']}]}

#前端
<p>{{ yyy.user_list.2.username.1 }}</p>

#上述语句可以取到 egon

​

模板的继承和导入

    事先需要再模板中 通过block划定区域

            {% block 区域名字 %}

            {% endblock %}

	#例如：在html文件中的下个语句设置为block划定的区域，即在页面右侧划分出来，这块的名字叫content这个就是子板中拿到区域的标识

              <div class="panel-body">
                  {% block content %}
                  <div class="jumbotron">
                      <h1>Hello, world!</h1>
                      <p>...</p>
                      <p><a class="btn btn-primary btn-lg" href="#" role="button">Learn more</a></p>
                    </div>
                  {% endblock %}
              </div>

    子板中如何使用
            {% extends '模板的名字'%}

            {% block 区域名字 %}
                <h1>登录页面</h1>
            {% endblock %}
	#例如
    	{% extends 'home.html' %}

        {% block content %}
        <h1>登录页面</h1>
            {% include 'good_page.html' %} #新增的另一个html文件内容
        {% endblock %}

    一个页面上 block块越多 页面的扩展性越高
    通常情况下 都应该有三片区域
            {% block css %}

            {% endblock %}

            {% block content %}

            {% endblock %}

            {% block js %}

            {% endblock %}
	#例如
    	{% block css %}
    <style>
        h1 {
            color: red;
        }
    </style>
		{% endblock %}
        # 用来修饰子板的文字属性

    子板中还可以通过
        {{ block.super }}  来继续使用母版的内容

    #例如子板通过这个语句可以把母版里面的内容加到子板里了，且可以多次加

## 模板的导入
    当你写了一个特别好看的form表单 你想再多个页面上都使用这个form表单
    你就可以将你写的form表单当作模块的形式导入 导入过来之后 就可以直接展示

    {% include 'good_page.html' %}