参考博客：

https://www.cnblogs.com/haiyan123/p/7778888.html

http://www.cnblogs.com/wupeiqi/articles/6144178.html

Form组件

    - 对用户请求的验证

        - AJax

        - Form

    - 生成HTML代码

    a. 创建一个类

    b. 类中创建字段（包含正则表达式）

    c. GET

        obj = Fr()

        obj.user = > 自动生成HTML

    d. POST

        obj = Fr(request.POST)

        if obj.is_valid():

            obj.cleaned_data

        else:

            obj.errors

            return .... obj

一、Form组件介绍

Form组件可以做的几件事情：

　　1、用户请求数据验证

　　2、自动生成错误信息

　　3、打包用户提交的正确信息

　　4、如果其中有一个错误了，其他的正确这，保留上次输入的内容

　　5、生成HTML标签

二、Form组件的使用

　　1、创建规则

class Foo(Form): #必须继承

    username = xxx

    password = xxx

    email = xxx

注意这里的字段必须和input的name字段一致

　　2、数据和规则进行匹配

先导入view.py

from django.forms import Form

from django.forms import fields

from django.forms import widgets
from django.shortcuts import render,redirect

from app01 import models

# Create your views here.

from django.forms import Form

from django.forms import fields

from django.forms import widgets

# 1、创建规则

class TeacherForm(Form):  #必须继承Form

    # 创建字段，本质上是正则表达式

    username = fields.CharField(

        required=True,     #必填字段

        error_messages={"required":"用户名不能为空！！"},  #显示中文错误提示

        widget=widgets.TextInput(attrs={"placeholder":"用户名","class":"form-control"})  #自动生成input框

       )

    password = fields.CharField(required=True, error_messages={'required': '密码不能为空'},

                                widget=widgets.TextInput(attrs={'placeholder': '密码', 'class': 'form-control'}))  # 不能为空

    email = fields.EmailField(

        required=True,

        error_messages={"required":"邮箱不能为空！！","invalid":"无效的邮箱"},

        widget=widgets.EmailInput(attrs={"placeholder": "邮箱", "class": "form-control"})  # 自动生成input框

    ) #不能为空且邮箱格式要一致

# 2、使用规则：将数据和规则进行匹配

def teacherindex(request):

    teacher_obj = models.UserInfo.objects.all()

    # print(teacher_obj)

    return render(request,"teacherindex.html",{"teacher_obj":teacher_obj})

def add(request):

    if request.method=="GET":

        form = TeacherForm()  #只是让显示一个input框

        return render(request,"add.html",{"form":form })

    else:

        form = TeacherForm(data=request.POST)

        # print(form)  #<QuerySet [<UserInfo: UserInfo object>, <UserInfo: UserInfo object>, <UserInfo: UserInfo object>]>

        if form.is_valid():# 开始验证

            # print('执行成功',form.cleaned_data)          # 所有匹配成功，字典

            # {'username': 'asd', 'password': 'sdf', 'email': 'sadf@live.com','ut_id':1}

            form.cleaned_data['ut_id'] = 1  #要分的清是班主任还是讲师

            models.UserInfo.objects.all().create(**form.cleaned_data)

            return redirect("/teacherindex/")

        else:

            # print("=====?",form.errors,type(form.errors))#返回失败的结果

            # print(form.errors["username"][0])   #拿到返回失败的结果，渲染到页面

            return render(request,"add.html",{"form":form})

html

{% block right %}

    <h1>添加老师信息</h1>

    <hr>

    <form method="post" novalidate>

        {% csrf_token %}

        <p>姓名：{{ form.username }}</p>{{ form.errors.username.0 }}

        <p>密码：{{ form.password }}</p>{{ form.errors.password.0 }}

        <p>邮箱：{{ form.email }}</p>{{ form.errors.email.0 }}

        <p><input type="submit" value="提交"></p>

    </form>

{% endblock %}

如果访问视图的是一个GET 请求，它将创建一个空的表单实例并将它放置到要渲染的模板的上下文中。这是我们在第一个访问该URL 时预期发生的情况。

如果表单的提交使用POST 请求，那么视图将再次创建一个表单实例并使用请求中的数据填充它：form = NameForm(request.POST)。这叫做”绑定数据至表单“（它现在是一个绑定的表单）。

我们调用表单的is_valid()方法；如果它不为True，我们将带着这个表单返回到模板。这时表单不再为空（未绑定），所以HTML 表单将用之前提交的数据填充，然后可以根据要求编辑并改正它。

如果is_valid()为True，我们将能够在cleaned_data 属性中找到所有合法的表单数据。在发送HTTP 重定向给浏览器告诉它下一步的去向之前，我们可以用这个数据来更新数据库或者做其它处理。

注意： form = TeacherForm()  #没有参数，只是一个input框

　　　 form = TeacherForm(data=request.POST) # 数据和规则放置一起　（添加的时候用）

　　　 form = TeacherForm(initial={'username':obj.username,'password':obj.password,'email':obj.email})   # 显示input，并且将数据库中的默认值填写到input框中 （编辑的时候用）

简单实例(一)

class F1Form(forms.Form):

    user = fields.CharField(required=True,

                            max_length=18,

                            min_length=6,

                            error_messages={'required':'用户名不能为空','max_length': '太长了',

                                            'min_length':'太短了'},

                            widget=widgets.TextInput(attrs={'placeholder':"用户名"})

                            )

    pwd = fields.CharField(required=True, min_length=9, error_messages={'min_length': "太短了"})

    age = fields.IntegerField(required=True)

    email = fields.EmailField(required=True,min_length=8, error_messages={'invalid': "格式错误"})

def f1(request):

    if request.method == 'GET':

        obj = F1Form()

        return render(request, 'f1.html', {'obj': obj})

    if request.method == "POST":

        obj = F1Form(request.POST)

        if obj.is_valid():

            print("验证成功", obj.cleaned_data)

            return redirect('http://www.xiaohuar.com')

        else:

            print("验证失败", obj.errors)

            return render(request, 'f1.html', {"obj": obj})

views.py

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<form action="/f1/" method="post" novalidate>

    {% csrf_token %}

    <p>{{ obj.user }}{{ obj.errors.user.0 }}</p>

    <p>{{ obj.pwd }}{{ obj.errors.pwd.0 }}</p>

    <p>{{ obj.age }}{{ obj.errors.age.0 }}</p>

    <p>{{ obj.email }}{{ obj.errors.email.0 }}</p>

    <input type="submit" value="提交">

</form>

</body>

</html>

html

简单实例(二)

"""django_form URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:

    https://docs.djangoproject.com/en/2.1/topics/http/urls/

Examples:

Function views

    1. Add an import:  from my_app import views

    2. Add a URL to urlpatterns:  path('', views.home, name='home')

Class-based views

    1. Add an import:  from other_app.views import Home

    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')

Including another URLconf

    1. Import the include() function: from django.urls import include, path

    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))

"""

from django.contrib import admin

from django.urls import path,re_path

from app01 import views

urlpatterns = [

    path('admin/', admin.site.urls),

    path('users/', views.users),

    path('add_user/', views.add_user),

    re_path(r'edit_user-(\d+)/', views.edit_user),

]

urls.py

from django.shortcuts import render, redirect

from app01 import models

from app01 import forms

# Create your views here.

def users(request):

    obj_list = models.UserInfo.objects.all()

    return render(request, "user.html", {"obj_list": obj_list})

def add_user(request):

    if request.method == "GET":

        obj = forms.UserForm()

        return render(request, "add_user.html", {"obj": obj})

    if request.method == "POST":

        obj = forms.UserForm(request.POST)

        if obj.is_valid():

            models.UserInfo.objects.create(**obj.cleaned_data)

            return redirect("/users/")

        else:

            return render(request, "add_user.html", {"obj": obj})

def edit_user(request,nid):

    if request.method == "GET":

        data = models.UserInfo.objects.filter(id=nid).first()

        obj = forms.UserForm({'username': data.username,'email': data.email})

        return render(request, "edit_user.html", {'obj': obj, 'nid': nid})

    else:

        obj = forms.UserForm(request.POST)

        if obj.is_valid():

            models.UserInfo.objects.filter(id=nid).update(**obj.cleaned_data)

            return redirect("/users/")

        else:

            return render(request, 'edit_user.html', {'obj': obj, 'nid': nid})

views.py

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<a href="/add_user/">添加</a>

{% for item in obj_list %}

    <li>

        {{ item.id }}--{{ item.username }}--{{ item.email }}

        <a href="/edit_user-{{ item.id }}/">编辑</a>

    </li>

{% endfor %}

</body>

</html>

users.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<form action="/add_user/" method="post" novalidate>

    {% csrf_token %}

    <p>{{ obj.username }}{{ obj.errors.username.0 }}</p>

    <p>{{ obj.email }}{{ obj.errors.email.0 }}</p>

    <input type="submit" value="提交">

</form>

</body>

</html>

add_user.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <form action="/edit_user-{{ nid }}/" method="post" novalidate>

        {% csrf_token %}

        <p>{{ obj.username }}{{ obj.errors.username.0 }}</p>

        <p>{{ obj.email }}{{ obj.errors.email.0 }}</p>

        <input type="submit" value="提交">

    </form>

</body>

</html>

edit.html

from django import forms as dforms

from django.forms import fields

class UserForm(dforms.Form):

    username = fields.CharField()

    email = fields.EmailField()

forms.py

Widgets

每个表单字段都有一个对应的Widget 类，它对应一个HTML 表单Widget，例如<input type="text">。

在大部分情况下，字段都具有一个合理的默认Widget。例如，默认情况下，CharField 具有一个TextInput Widget，它在HTML 中生成一个<input type="text">。

字段的数据

不管表单提交的是什么数据，一旦通过调用is_valid() 成功验证（is_valid() 返回True），验证后的表单数据将位于form.cleaned_data 字典中。这些数据已经为你转换好为Python 的类型。

注：此时，你依然可以从request.POST 中直接访问到未验证的数据，但是访问验证后的数据更好一些。

在上面的联系表单示例中，is_married将是一个布尔值。类似地，IntegerField 和FloatField 字段分别将值转换为Python 的int 和float。

实例：

from django.forms import Form

from django.forms import widgets

from django.forms import fields

class MyForm(Form):

    user = fields.CharField(

        widget=widgets.TextInput(attrs={'id': 'i1', 'class': 'c1'})

    )

    gender = fields.ChoiceField(

        choices=((1, '男'), (2, '女'),),

        initial=2,

        widget=widgets.RadioSelect

    )

    city = fields.CharField(

        initial=2,

        widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))

    )

    pwd = fields.CharField(

        widget=widgets.PasswordInput(attrs={'class': 'c1'}, render_value=True)

    )

创建form类

from django.shortcuts import render, redirect

from .forms import MyForm

def index(request):

    if request.method == "GET":

        obj = MyForm()

        return render(request, 'index.html', {'form': obj})

    elif request.method == "POST":

        obj = MyForm(request.POST, request.FILES)

        if obj.is_valid():

            values = obj.clean()

            print(values)

        else:

            errors = obj.errors

            print(errors)

        return render(request, 'index.html', {'form': obj})

    else:

        return redirect('http://www.google.com')

views函数处理

<form action="/" method="POST" enctype="multipart/form-data">

    <p>{{ form.user }} {{ form.user.errors }}</p>

    <p>{{ form.gender }} {{ form.gender.errors }}</p>

    <p>{{ form.city }} {{ form.city.errors }}</p>

    <p>{{ form.pwd }} {{ form.pwd.errors }}</p>

    <input type="submit"/>

</form>

生成HTML

        obj = forms.MyForm()

        txt = "<input type='text'/>"

        from django.utils.safestring import mark_safe

        txt = mark_safe(txt)

        return render(request, "index.html", {'obj': obj, 'txt':txt})

#或者在html文件加{{ txt|safe }},使用以上方式不需要再加'|safe'

Form类

创建Form类时，主要涉及到 【字段】 和 【插件】，字段用于对用户请求数据的验证，插件用于自动生成HTML;

1、Django内置字段如下：

 Field

     required=True,               是否允许为空

     widget=None,                 HTML插件

     label=None,                  用于生成Label标签或显示内容

     initial=None,                初始值

     help_text='',                帮助信息(在标签旁边显示)

     error_messages=None,         错误信息 {'required': '不能为空', 'invalid': '格式错误'}

     show_hidden_initial=False,   是否在当前插件后面再加一个隐藏的且具有默认值的插件（可用于检验两次输入是否一直）

     validators=[],               自定义验证规则

     localize=False,              是否支持本地化

     disabled=False,              是否可以编辑

     label_suffix=None            Label内容后缀

 CharField(Field)

     max_length=None,             最大长度

     min_length=None,             最小长度

     strip=True                   是否移除用户输入空白

 IntegerField(Field)

     max_value=None,              最大值

     min_value=None,              最小值

 FloatField(IntegerField)

     ...

 DecimalField(IntegerField)

     max_value=None,              最大值

     min_value=None,              最小值

     max_digits=None,             总长度

     decimal_places=None,         小数位长度

 BaseTemporalField(Field)

     input_formats=None          时间格式化   

 DateField(BaseTemporalField)    格式：2015-09-01

 TimeField(BaseTemporalField)    格式：11:12

 DateTimeField(BaseTemporalField)格式：2015-09-01 11:12

 DurationField(Field)            时间间隔：%d %H:%M:%S.%f

     ...

 RegexField(CharField)

     regex,                      自定制正则表达式

     max_length=None,            最大长度

     min_length=None,            最小长度

     error_message=None,         忽略，错误信息使用 error_messages={'invalid': '...'}

 EmailField(CharField)

     ...

 FileField(Field)

     allow_empty_file=False     是否允许空文件

 ImageField(FileField)

     ...

     注：需要PIL模块，pip3 install Pillow

     以上两个字典使用时，需要注意两点：

         - form表单中 enctype="multipart/form-data"

         - view函数中 obj = MyForm(request.POST, request.FILES)

 URLField(Field)

     ...

 BooleanField(Field)

     ...

 NullBooleanField(BooleanField)

     ...

 ChoiceField(Field)

     ...

     choices=(),                选项，如：choices = ((0,'上海'),(1,'北京'),)

     required=True,             是否必填

     widget=None,               插件，默认select插件

     label=None,                Label内容

     initial=None,              初始值

     help_text='',              帮助提示

 ModelChoiceField(ChoiceField)

     ...                        django.forms.models.ModelChoiceField

     queryset,                  # 查询数据库中的数据

     empty_label="---------",   # 默认空显示内容

     to_field_name=None,        # HTML中value的值对应的字段

     limit_choices_to=None      # ModelForm中对queryset二次筛选

 ModelMultipleChoiceField(ModelChoiceField)

     ...                        django.forms.models.ModelMultipleChoiceField

 TypedChoiceField(ChoiceField)

     coerce = lambda val: val   对选中的值进行一次转换

     empty_value= ''            空值的默认值

 MultipleChoiceField(ChoiceField)

     ...

 TypedMultipleChoiceField(MultipleChoiceField)

     coerce = lambda val: val   对选中的每一个值进行一次转换

     empty_value= ''            空值的默认值

 ComboField(Field)

     fields=()                  使用多个验证，如下：即验证最大长度20，又验证邮箱格式

                                fields.ComboField(fields=[fields.CharField(max_length=20), fields.EmailField(),])

 MultiValueField(Field)

     PS: 抽象类，子类中可以实现聚合多个字典去匹配一个值，要配合MultiWidget使用

 SplitDateTimeField(MultiValueField)

     input_date_formats=None,   格式列表：['%Y--%m--%d', '%m%d/%Y', '%m/%d/%y']

     input_time_formats=None    格式列表：['%H:%M:%S', '%H:%M:%S.%f', '%H:%M']

 FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中

     path,                      文件夹路径

     match=None,                正则匹配

     recursive=False,           递归下面的文件夹

     allow_files=True,          允许文件

     allow_folders=False,       允许文件夹

     required=True,

     widget=None,

     label=None,

     initial=None,

     help_text=''

 GenericIPAddressField

     protocol='both',           both,ipv4,ipv6支持的IP格式

     unpack_ipv4=False          解析ipv4地址，如果是::ffff:192.0.2.1时候，可解析为192.0.2.1， PS：protocol必须为both才能启用

 SlugField(CharField)           数字，字母，下划线，减号（连字符）

     ...

 UUIDField(CharField)           uuid类型

     ...

注：UUID是根据MAC以及当前时间等创建的不重复的随机字符串

>>> import uuid

    # make a UUID based on the host ID and current time

    >>> uuid.uuid1()    # doctest: +SKIP

    UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')

    # make a UUID using an MD5 hash of a namespace UUID and a name

    >>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')

    UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')

    # make a random UUID

    >>> uuid.uuid4()    # doctest: +SKIP

    UUID('16fd2706-8baf-433b-82eb-8c7fada847da')

    # make a UUID using a SHA-1 hash of a namespace UUID and a name

    >>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')

    UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')

    # make a UUID from a string of hex digits (braces and hyphens ignored)

    >>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')

    # convert a UUID to a string of hex digits in standard form

    >>> str(x)

    '00010203-0405-0607-0809-0a0b0c0d0e0f'

    # get the raw 16 bytes of the UUID

    >>> x.bytes

    b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'

    # make a UUID from a 16-byte string

    >>> uuid.UUID(bytes=x.bytes)

    UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')

UUID

2、Django内置插件：

# 单radio，值为字符串

# user = fields.CharField(

#     initial=2,

#     widget=widgets.RadioSelect(choices=((1,'上海'),(2,'北京'),))

# )

# 单radio，值为字符串

# user = fields.ChoiceField(

#     choices=((1, '上海'), (2, '北京'),),

#     initial=2,

#     widget=widgets.RadioSelect

# )

# 单select，值为字符串

# user = fields.CharField(

#     initial=2,

#     widget=widgets.Select(choices=((1,'上海'),(2,'北京'),))

# )

# 单select，值为字符串

# user = fields.ChoiceField(

#     choices=((1, '上海'), (2, '北京'),),

#     initial=2,

#     widget=widgets.Select

# )

# 多选select，值为列表

# user = fields.MultipleChoiceField(

#     choices=((1,'上海'),(2,'北京'),),

#     initial=[1,],

#     widget=widgets.SelectMultiple

# )

# 单checkbox

# user = fields.CharField(

#     widget=widgets.CheckboxInput()

# )

# 多选checkbox,值为列表

# user = fields.MultipleChoiceField(

#     initial=[2, ],

#     choices=((1, '上海'), (2, '北京'),),

#     widget=widgets.CheckboxSelectMultiple

# )

注意：

在使用选择标签时，需要注意choices的选项可以从数据库中获取，但是由于是静态字段 ***获取的值无法实时更新***，那么需要自定义构造方法从而达到此目的。

方式一：

from django.forms import Form

from django.forms import widgets

from django.forms import fields

from django.core.validators import RegexValidator

class MyForm(Form):

    user = fields.ChoiceField(

        # choices=((1, '上海'), (2, '北京'),),

        initial=2,

        widget=widgets.Select

    )

    def __init__(self, *args, **kwargs):

        super(MyForm,self).__init__(*args, **kwargs)

        # self.fields['user'].widget.choices = ((1, '上海'), (2, '北京'),)

        # 或

        self.fields['user'].widget.choices = models.Classes.objects.all().value_list('id','caption')

self.fields语句一定要在调用父类构造函数之后，因为调用父类构造函数之后才有字段fields

方式二：

使用django提供的ModelChoiceField和ModelMultipleChoiceField字段来实现

from django import forms

from django.forms import fields

from django.forms import widgets

from django.forms import models as form_model

from django.core.exceptions import ValidationError

from django.core.validators import RegexValidator

class FInfo(forms.Form):

    authors = form_model.ModelMultipleChoiceField(queryset=models.NNewType.objects.all())

    # authors = form_model.ModelChoiceField(queryset=models.NNewType.objects.all())
Form重点：

    - 字段

        用于保存正则表达式

        ChoiceField *****

        MultipleChoiceField

        CharField

        IntegerField

        DecimalField

        DateField

        DateTimeField

        EmailField

        GenericIPAddressField

        FileField

        RegexField

实例

from django.shortcuts import render

from django import forms

from django.forms import fields

from django.forms import widgets

class TestForm(forms.Form):

    user = fields.CharField(

        required=True, # 是否必填

        max_length=12, # 最大长度

        min_length=3,  # 最小长度

        error_messages={}, # 错误提示

        #widget = widgets.Select(), # 定制HTML插件

        label='用户名',

        initial='请输入用户',

        help_text='asdfasdf',

        show_hidden_initial=False,

        # validators=[]

        disabled=True,

        label_suffix='->' # obj.as_p 会显示出来

    )

    age = fields.IntegerField(

        label='年龄',

        max_value= 12,

        min_value=5,

        error_messages={

            'max_value':'太大了'

        }

    )

    email = fields.EmailField(

        label='邮箱'

    )

    img = fields.FileField()

    city = fields.TypedChoiceField(

        coerce=lambda x: int(x),

        choices=[(1,'上海',),(2,'北京'),(3,'沙河'),],

        initial=2

    )

    bobby = fields.MultipleChoiceField(

        choices=[(1,'刚娘'),(2,'铁娘'),(3,'钢弹')],

        initial=[1,2]

    )

    xoo = fields.FilePathField(

        path='app01'

    )

def test(request):

    if request.method == 'GET':

        #obj = TestForm({'city':3})

        obj = TestForm()

        return render(request,'test.html',{'obj':obj})

    else:

        obj = TestForm(request.POST,request.FILES)

        obj.is_valid()

        print(obj.cleaned_data)

        return render(request, 'test.html', {'obj': obj})

views

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <form method="POST" action="/test/" novalidate enctype="multipart/form-data">

        {% csrf_token %}

        <p>{{ obj.user.label }}{{ obj.user }}</p>

        <p>{{ obj.age.label }}{{ obj.age }}{{ obj.errors.age.0 }}</p>

        <p>{{ obj.email.label }}{{ obj.email }}</p>

        <p>{{ obj.img.label }}{{ obj.img }}</p>

        <p>{{ obj.city.label }}{{ obj.city }}</p>

        <p>{{ obj.bobby.label }}{{ obj.bobby }}</p>

        <p>{{ obj.xoo.label }}{{ obj.xoo }}</p>

        <input  type="submit" value="提交"/>

    </form>

</body>

</html>

html

ModelChoiceField

特殊的单选或多选时，数据源是否能实时更新？

ModelChoiceField获取的值可以实时更新

from app01 import models

from django.forms.models import ModelChoiceField

class LoveForm(forms.Form):

    price = fields.IntegerField()

    user_id = fields.IntegerField(

        # widget=widgets.Select(choices=[(0,'alex'),(1,'刘皓宸'),(2,'杨建'),])

        widget=widgets.Select()

    )

    user_id2 = ModelChoiceField(

        queryset=models.UserInfo.objects.all(),

        to_field_name='id'

    )

    def __init__(self,*args,**kwargs):

        # 拷贝所有的静态字段，复制给self.fields

        super(LoveForm,self).__init__(*args,**kwargs)

        self.fields['user_id'].widget.choices = models.UserInfo.objects.values_list('id', 'username')

def love(request):

    obj = LoveForm()

    return render(request,'love.html',{'obj':obj})

Views.py

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <p>价格：{{ obj.price }}</p>

    <p>姓名：{{ obj.user_id }}</p>

    <p>姓名：{{ obj.user_id2 }}</p>

</body>

</html>

html

 注意：依赖models中的str方法

最新文章

  1. Mysql时间类型处理
  2. 将rabbitmq整合到Spring中手动Ack
  3. 注意自己的dns设置 - 阿权的书房
  4. HTTP脚本化——XMLHttpRequest对象的学习笔记
  5. win7下制作ubuntu系统安装启动盘和U盘安装ubuntu全过程
  6. C# 多线程网络爬虫
  7. jmeter测试本地myeclips调试状态下的tomcat程序死锁
  8. JQuery的Ajax跨域请求的
  9. 2.2.4 转换 Path
  10. linkin大话数据结构--字符串，数组，list之间的互转
  11. Windows下Java如何调用本地获取mac地址
  12. JS特效实现微博评论逻辑
  13. GridView控件的属性、事件
  14. loadrunner基础学习笔记四
  15. （转）Geth控制台使用及Web3.js使用实战
  16. linux命令总结kill命令详解
  17. 22、整合mybatis
  18. maven介绍 极客学院
  19. Kubernetes-Envoy（一种全新的Ingress实现方式）
  20. jwt手动生成access_token

热门文章

  1. Flutter的Appbar
  2. Laravel数据库操作的三种方式
  3. 在 Ubuntu14.04 上搭建 Spark 2.3.1(latest version)
  4. Golang的select多路复用以及channel使用实践
  5. docker 列出每个容器的IP
  6. 用dbexpress连接sqlserver数据库
  7. Lodop部署web网站 客户端本地打印角色
  8. captive portal
  9. PCIE
  10. JS实现控制HTML5背景音乐播放暂停