字符串转换为字典
Django
可直接下载源码进行安装
Linux直接用yum install python-django -y 安装
直接用pip install Django 安装
检查是否安装成功：
在Python下输入：
>>> import django
>>> django.VERSION
(1, 9, 7, 'final', 0)
>>> django.get_version()
'1.9.7'
>>>
-------------------------------------------------------------------------------------
经确认是新版本的django包版本中只有zh_Hans目录，没有zh_CN,把zh_Hans目录复制一个zh_CN就Ok了
一楼评论的方法也不错，在settings里面直接改成zh-Hans，这样就不用升级完Django，还去改目录了。
-------------------------------------------------------------------------------------
让我们一览 Django 全貌
urls.py
网址入口，关联到对应的views.py中的一个函数（或者generic类），访问网址就对应一个函数。
views.py
处理用户发出的请求，从urls.py中对应过来, 通过渲染templates中的网页可以将显示内容，比如登陆后的用户名，用户请求的数据，输出到网页。
models.py
与数据库操作相关，存入或读取数据时用到这个，当然用不到数据库的时候 你可以不使用。
forms.py
表单，用户在浏览器上输入数据提交，对数据的验证工作以及输入框的生成等工作，当然你也可以不使用。
templates 文件夹
views.py 中的函数渲染templates中的Html模板，得到动态内容的网页，当然可以用缓存来提高速度。
admin.py
后台，可以用很少量的代码就拥有一个强大的后台。
settings.py
Django 的设置，配置文件，比如 DEBUG 的开关，静态文件的位置等。
-------------------------------------------------------------------------------------------------------------------------
1. 新建一个 django project
django-admin.py startproject project-name
一个 project 为一个项目，project-name 项目名称，改成你自己的，要符合Python 的变量命名规则（以下划线或字母开头）
2. 新建 app
python manage.py startapp app-name
或 django-admin.py startapp app-name
一般一个项目有多个app, 当然通用的app也可以在多个项目中使用。
3. 同步数据库
python manage.py syncdb
注意：Django 1.7.1及以上的版本需要用以下命令
python manage.py makemigrations
python manage.py migrate -----------------------1.9可用
这种方法可以创建表，当你在models.py中新增了类时，运行它就可以自动在数据库中创建表了，不用手动创建。
备注：对已有的 models 进行修改，Django 1.7之前的版本的Django都是无法自动更改表结构的，不过有第三方工具 south,详见 Django 数据库迁移(http://www.ziqiangxuetang.com/django/django-data-migration.html) 一节。
对于1.7后的调整，可将之前的字段设置允许为空 null=True，然后再通过 python manage.py makemigrations/python manage.py migrate 更新数据库。
4. 使用开发服务器
python manage.py runserver
Performing system checks...
System check identified no issues (0 silenced).
July 21, 2016 - 09:54:16
Django version 1.9.7, using settings 'dj_test.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
# 当提示端口被占用的时候，可以用其它端口：
python manage.py runserver 8001
python manage.py runserver 9999
（当然也可以kill掉占用端口的进程）
# 监听所有可用 ip （电脑可能有一个或多个内网ip，一个或多个外网ip，即有多个ip地址）
python manage.py runserver 0.0.0.0:8000
# 如果是外网或者局域网电脑上可以用其它电脑查看开发服务器
# 访问对应的 ip加端口，比如 http://172.16.20.2:8000
5. 清空数据库
python manage.py flush
此命令会询问是 yes 还是 no, 选择 yes 会把数据全部清空掉，只留下空表。
6. 创建超级管理员
python manage.py createsuperuser
# 按照提示输入用户名和对应的密码就好了邮箱可以留空，用户名和密码必填
# 修改 用户密码可以用：
python manage.py changepassword username
7. 导出数据 导入数据
python manage.py dumpdata appname > appname.json
python manage.py loaddata appname.json
关于数据操作 详见：数据导入数据迁移(http://www.ziqiangxuetang.com/django/django-data-migration.html)，现在了解有这个用法就可以了。
8. Django 项目环境终端
python manage.py shell
如果你安装了 bpython 或 ipython 会自动用它们的界面，推荐安装 bpython。
这个命令和 直接运行 python 或 bpython 进入 shell 的区别是：你可以在这个 shell 里面调用当前项目的 models.py 中的 API，对于操作数据，还有一些小测试非常方便。
9. 数据库命令行
python manage.py dbshell
Django 会自动进入在settings.py中设置的数据库，如果是 MySQL 或 postgreSQL,会要求输入数据库用户密码。
在这个终端可以执行数据库的SQL语句。如果您对SQL比较熟悉，可能喜欢这种方式。
10. 更多命令
终端上输入 python manage.py 可以看到详细的列表，在忘记子名称的时候特别有用。
Django 视图与网址
-------------------------------------------------------------
Django中网址是写在 urls.py 文件中，用正则表达式对应 views.py 中的一个函数(或者generic类),我们用一个项目来演示。
一，首先，新建一个项目(project), 名称为 mysite
django-admin startproject mysite
运行后,如果成功的话, 我们会看到如下的目录样式
mysite
├── manage.py
└── mysite
├── __init__.py
├── settings.py
├── urls.py
└── wsgi.py
二, 新建一个应用(app), 名称叫 learn
python manage.py startapp learn # learn 是一个app的名称
我们可以看到mysite中多个一个 learn 文件夹，其中有以下文件。
learn/
├── __init__.py
├── admin.py
├── models.py
├── tests.py
└── views.py
注：Django 1.8.x 以上的，还有一个 migrations 文件夹。Django 1.9.x 还会在 Django 1.8 的基础上多出一个 apps.py 文件。但是这些都与本文无关。
把我们新定义的app加到settings.py中的INSTALL_APPS中
修改 mysite/mysite/settings.py
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'learn',
)
备注,这一步是干什么呢? 新建的 app 如果不加到 INSTALL_APPS 中的话, django 就不能自动找到app中的模板文件(app-name/templates/下的文件)和静态文件(app-name/static/中的文件) , 后面你会学习到它们分别用来干什么.
定义视图函数（访问页面时的内容）
我们在learn这个目录中,把views.py打开,修改其中的源代码,改成下面的
***************************************************
#coding:utf-8
from django.http import HttpResponse
def index(request):
return HttpResponse(u"欢迎光临 自强学堂!")
*****************************************************
from django.shortcuts import render
from django.http import HttpResponse
def add(request):
a = request.GET['a']
b = request.GET['b']
c = int(a)+int(b)
return HttpResponse(str(c))
*********************************************************
第一行是声明编码为utf-8, 因为我们在代码中用到了中文,如果不声明就报错.
第二行引入HttpResponse，它是用来向网页返回内容的，就像Python中的 print 一样，只不过 HttpResponse 是把内容显示到网页上。
我们定义了一个index()函数，第一个参数必须是 request，与网页发来的请求有关，request 变量里面包含get或post的内容，用户浏览器，系统等信息在里面（后面会讲，先了解一下就可以）。
函数返回了一个 HttpResponse 对象，可以经过一些处理，最终显示几个字到网页上。
那问题来了，我们访问什么网址才能看到刚才写的这个函数呢？怎么让网址和函数关联起来呢？
定义视图函数相关的URL(网址) （即规定 访问什么网址对应什么内容）
我们打开 mysite/mysite/urls.py 这个文件, 修改其中的代码:
Django 1.8.x及以上，Django 官方鼓励（或说要求）先引入，再使用：
*****************************************************************
from django.conf.urls import url
from django.contrib import admin
from learn import views as learn_views # new
urlpatterns = [
url(r'^$', learn_views.index), # new
url(r'^admin/', admin.site.urls),
]
http://127.0.0.1:8000
*******************************************************************
from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('',
# Examples:
url(r'^add/$', 'calc.views.add', name='add'), # 注意修改了这一行
# url(r'^blog/', include('blog.urls')),
url(r'^admin/', include(admin.site.urls)),
)
可通过以下方式来访问，a和b 在页面上
http://127.0.0.1:8000/app2/?a=4&b=100
**********************************************************************
以上都修改并保存后,我们来看一下效果!
views:
----------------------------------
#coding:utf-8
from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
def app2(request):
a = request.GET['a']
b = request.GET['b']
c = int(a)+int(b)
return HttpResponse(str(c))
def app3(request,a,b):
c = int(a)+int(b)
return HttpResponse(str(c))
urls:
----------------------------------
from django.conf.urls import url
from django.contrib import admin
from learn import views as learn_views
from app2 import views as app2_views
urlpatterns = [
#http://127.0.0.1:8000/app3/4/6/ 可用此访问
url(r'^app3/(\d+)/(\d+)/$',app2_views.app3,name='app3'),
#http://127.0.0.1:8000/app2/?a=4&b=5 可用此访问
url(r'^app2/$',app2_views.app2,name='app2'),
#http://127.0.0.1:8000 可用此访问
url(r'^$',learn_views.index),
url(r'^admin/', admin.site.urls),
]
url(r'^app3/(\d+)/(\d+)/$',app2_views.app3,name='app3')
我们在开发的时候，刚开始想用的是 /add2/4/5/ ，后来需求发生变化，比如我们又想改成 /4_add_5/这样的格式，但是我们在网页中，代码中很多地方都写死的，这样就导致当我们改了 urls.py 后，对应的模板，甚至还视图中的跳转，以及 models.py 中也可能有获取网址的地方。每个地方都要改，修改的代价很大，一不小心，有的地方没改过来，那个就不能用了。可以用reverse来进行转换
#############################经部分后续处理#############################
Django 模板
-----------------------------------
判断条件为单{}：{% %}
变量输出为双{}： {{变量}}
{% for i in List1 %}
{{i}}{% if not forloop.last %},{% endif %}
{% endfor %}
{% if not forloop.last %},{% endif %}
判断是否到最后，不到最后输出逗号，否则不输出
在for循环中还有很多有用的东西，如下：
变量 描述
forloop.counter 索引从 1 开始算
forloop.counter0 索引从 0 开始算
forloop.revcounter 索引从最大长度到 1
forloop.revcounter0 索引从最大长度到 0
forloop.first 当遍历的元素为第一项时为真
forloop.last 当遍历的元素为最后一项时为真
forloop.parentloop 用在嵌套的 for 循环中，获取上一层 for 循环的 forloop
当列表中可能为空值时用 for empty
{% for athlete in athlete_list %}
<li>{{ athlete.name }}</li>
{% empty %}
<li>抱歉，列表为空</li>
{% endfor %}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
错误参考
Sql写入数据库变量需要加上引号
insert_sql = "insert into monitor_ping_report(data1,Line,Hostname,packet,pkloss,rtt)
VALUES('%s','%s','%s','%s','%s','%s')" % (date1,line,hostname,packet,pkloss,rtt)
sqlite3错误
如果错误的最后一行是
django.core.exceptions.ImproperlyConfigured: Error loading either pysqlite2 or sqlite3 modules (tried in that order): No module named _sqlite3
方法一：
则可以试一下命令
wget http://pysqlite.googlecode.com/files/pysqlite-2.6.3.tar.gz
tar -xzf pysqlite-2.6.3.tar.gz
cd pysqlite
python setup.py build_static install
方法二：
官网有解释说，python是自带sqlite3的，所以不应该出现这个问题。查找资料后，发现我使用的Python2.7所使用的库中没有_sqlite3.so这个静态文件，所以从别处将这个文件复制过来就ok了。
可安装以下：
yum install pyhon-sqlite
yum install sqlite-devel
完成后可在Python中直接导入测试，如测试不成功，可能是安装在默认的版本中了，直接CP一个So文件就可以了。
默认的文件在： /usr/lib64/python2.6/lib-dynload/_sqlite3.so
CP到正常版本的目录下：/usr/local/lib/python2.7/lib-dynload/
CSRF验证失败. 相应中断.
不使用 CSRF 验证
在 setting.py 文件中，将此标注掉：
#'django.middleware.csrf.CsrfViewMiddleware', ，
使用 CSRF 验证
在Html的表单Form后面加：{% csrf_token %}
同时在Views里：
from django.template import RequestContext
return render_to_response('search.html',{'f':f},context_instance=RequestContext(req))---加在最后
Pip安装出现Unicode错误
UnicodeDecodeError: 'ascii' codec can't decode byte 0xb1 in position 34: ordinal not in range(128)
原因是pip安装python包会加载我的用户目录，我的用户目录恰好是中文的，ascii不能编码。解决办法是：
python目录 Python27\Lib\site-packages 建一个文件sitecustomize.py
内容写：
import sys
sys.setdefaultencoding('gb2312')
python会自动运行这个文件。
升级Python出错
上面是在Python编译安装顺利的情况下的大体流程，但是我在编译的时候，Python出现了下面的提示信息：
http://www.tuicool.com/articles/FjmA3u
Python build finished, but the necessary bits to build these modules were not found:
_bsddb _sqlite3 _ssl
_tkinter bsddb185 bz2
dbm gdbm readline
sunaudiodev
To find the necessary bits, look in setup.py in detect_modules() for the module's name.
Yum install readline-devel sqlite-devel bzip2-devel.i686 openssl-devel.i686 gdbm-devel.i686 libdbi-devel.i686 ncurses-lib zlib-devel.i686
静态文件设定
------------------------------------------------------
在Manager同级目录下创建static的文件夹
在setting后加，告诉Django到哪找静态文件－－－－－－这样就不用写一个死的地址了
STATICFILES_DIRS = (
os.path.join(BASE_DIR, "static"),
)
1. admin中文显示：
----------------------------------------------------------------------------------------------
经确认是新版本的django包版本中只有zh_Hans目录，没有zh_CN,把zh_Hans目录复制一个zh_CN就Ok了
一楼评论的方法也不错，在settings里面直接改成zh-Hans，这样就不用升级完Django，还去改目录了。
-----------------------------------------------------------------------------------------------
2. 添加/更改 现有Model的字段
正常情况下添加字段会出现错误，可将之前的字段设置允许为空 null=True
然后再通过 python manage.py makemigrations/python manage.py migrate 更新数据库。
Blank=True 可在Admin后台中允许为空，无需同步数据库
Unique=True 设置数据库唯一值
表结构的修改
表结构修改后，原来表中已存在的数据，就会出现结构混乱，makemigrations更新表的时候就会出错
解决方法：
1、新增加的字段，设置允许为空。生成表的时候，之前数据新增加的字段就会为空。
(null=True允许数据库中为空，blank=True允许admin后台中为空)
2、新增加的字段，设置一个默认值。生成表的时候，之前的数据新增加字段就会应用这个默认值
3. 时间字段显示
models中的时间字段，可在时间Field中设定auto_now_add=True, auto_now=True,这样系统输入时页面上不显示，自动更新，默认为False，页面显示，可手动更改
格式（默认均为False，页面上显示，手工选择）
class DateField([auto_now=False, auto_now_add=False, **options])
class DateTimeField([auto_now=False, auto_now_add=False, **options])
pub_date = models.DateTimeField(u'创建时间',auto_now_add=True)－－－－－－auto_now_add 为创建时间，不会变化
update_time = models.DateTimeField(u'修改时间',auto_now=True)－－－－－－auto_now 为当前时间，可变化
4. admin:
--------------------------------------------------------------------
Admin放后台管理配置，所有的Model如果要在Django的Admin中显示，必须注册
from .models import Mpls_Ping,Mpls_Form
admin.site.register(Mpls_Ping,Ping_Admin)
如果想在后台显示相关的字段，可建类如下，参数用admin.ModelAdmin
class Ping_Admin(admin.ModelAdmin):
list_display =['POP','PE','A_end','B_end']－－－－－－admim后台可显示的列
5. Model如果在页面中显示字段本身内容，需在model类中添加__str__方法
def __str__(self):
return self.POP
6. From直接调用Model，可在Model中用以下方式：
from django.db import models
from django import forms
from django.contrib import admin
from django.forms import ModelForm
# Create your models here.
class Mpls_Ping(models.Model):
POP = models.CharField(max_length=50)
PE = models.CharField(max_length=50)
A_end = models.CharField(max_length=50)
B_end = models.CharField(max_length=50)
def __str__(self):
return self.POP
class Mpls_Form(ModelForm):
class Meta:
model = Mpls_Ping－－－－－－这里左边是model，右边是上面建的库名，不能有括号
fields = ['POP','PE','A_end','B_end']－－－－－－这里是表单中显示的列
7. 下拉框是一个二元数组
选择下拉框：
user_type = (
(1,'user'),
(2,'admin'),
)
user_t = models.IntegerField(choices=user_type,default=1,null=True)
9. 启用Mysql数据库：
将setting 中的 DATABASES改成如下
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
'NAME': 'dbname', （注意这个后缀名一定要写对） # Or path to database file if using sqlite3.
'USER': 'root', # Not used with sqlite3.
'PASSWORD': '', # Not used with sqlite3.
'HOST': '', # Set to empty string for localhost. Not used with sqlite3.
'PORT': '', # Set to empty string for default. Not used with sqlite3.
}
}
然后在主目录同名下的__init__编辑如下：
import pymysql
pymysql.install_mydqldb()
10. 模糊查询
Models放数据模型，建类，参数models.Model
如果是用Form方式加载Model库，Form类参数为forms.ModelForm
models.UserInfo.objects.all()
models.UserInfo.objects.all().values('user') #只取user列
models.UserInfo.objects.all().values_list('id','user') #取出id和user列，并生成一个列表
models.UserInfo.objects.get(id=1)
models.UserInfo.objects.get(user='yangmv')
可通过1a=models.objects.all()得到所有表数据，再通过
a.values() 显示所有内容，以字典方式
a.values('列') 显露所有列的内容
a.values_list() 显示所有内容，以元组方式
a.values_list(列，列) 显示所有列
可通过以下方式
a.objects.filter(user__contains='lo')
filter(name="abc") # 等于filter(name__exact="abc") 名称严格等于 "abc" 的人
filter(name__iexact="abc") # 名称为 abc 但是不区分大小写，可以找到 ABC, Abc, aBC，这些都符合条件
filter(name__contains="abc") # 名称中包含 "abc"的人
filter(name__icontains="abc") #名称中包含 "abc"，且abc不区分大小写
filter(name__regex="^abc") # 正则表达式查询
filter(name__iregex="^abc")# 正则表达式不区分大小写
exclude(name__contains="WZ") # 排除包含 WZ 的Person对象
filter(name__contains="abc").exclude(age=23) # 找出名称含有abc, 但是排除年龄是23岁的
objects.all() 得到是一个django.db.models.query.QuerySet ,可迭代，可用Value列出所有值
objects.filter() 得到是一个django.db.models.query.QuerySet ,可迭代，可用Value列出所有值
也可通过a[0].字段名
a = m.objects.get()
得到是一个django.db.models.query.QuerySet,不可迭代，可通过a.字段方式获取值
11. 可在Models中直接用ForginKey链接到User的用户库
author = models.ForeignKey(User)
12. 在显示页面上链接到实际的页面：
在原Html页面上：
<h1><a href="{% url 'blog.views.post_detail' pk=post.pk %}">{{ post.title }}</a></h1>－－－这里用变量的方式来表示，格式为：views函数 参数1 参数2
然后在urls:
这里采用正则表达式来接收：?P<name>... 来接收来自name的变量
url(r'^post/(?P<pk>[0-9]+)/$', views.post_detail)
在建一个post_detail方法：
from django.shortcuts import render, get_object_or_404
def post_detail(request, pk):
post = get_object_or_404(Post, pk=pk)------这里的Post是Model的库名
return render(request, 'blog/post_detail.html', {'post': post})
最后建一个显示的页面：
{% extends 'blog/base.html' %}
{% block content %}
<div class="date">
{% if post.published_date %}
{{ post.published_date }}
{% endif %}
</div>
<h1>{{ post.title }}</h1>
<p>{{ post.text|linebreaks }}</p>
<p>{{ post.mymail }}</p>
{% endblock %}
15. django ModelForm has no model class specified.
从Model创建From，老是跳出django ModelForm has no model class specified.
最后将以下form改为model就好了，搞了两天了
原配置：
class PostForm(forms.ModelForm):
class Meta:
form = Post
fields = ['title','text']
正确配置：
class PostForm(forms.ModelForm):
class Meta:
model = Post
fields = ['title','text']
models类型参考：
字段类型
1、models.AutoField 自增列= int(11)
如果没有的话，默认会生成一个名称为 id 的列，如果要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。
2、models.CharField 字符串字段
必须 max_length 参数
3、models.BooleanField 布尔类型=tinyint(1)
不能为空，Blank=True
4、models.ComaSeparatedIntegerField 用逗号分割的数字=varchar
继承CharField，所以必须 max_lenght 参数
5、models.DateField 日期类型 date
对于参数，auto_now =True则每次更新都会更新这个时间；auto_now_add 则只是第一次创建添加，之后的更新不再改变。
6、models.DateTimeField 日期类型 datetime
同DateField的参数
7、models.Decimal 十进制小数类型= decimal
必须指定整数位max_digits和小数位decimal_places
8、models.EmailField 字符串类型（正则表达式邮箱）=varchar
对字符串进行正则表达式
9、models.FloatField 浮点类型= double
10、models.IntegerField 整形
11、models.BigIntegerField 长整形
integer_field_ranges ={
'SmallIntegerField':(-32768,32767),
'IntegerField':(-2147483648,2147483647),
'BigIntegerField':(-9223372036854775808,9223372036854775807),
'PositiveSmallIntegerField':(0,32767),
'PositiveIntegerField':(0,2147483647),
}
12、models.IPAddressField 字符串类型（ip4正则表达式）
13、models.GenericIPAddressField 字符串类型（ip4和ip6是可选的）
参数protocol可以是：both、ipv4、ipv6
验证时，会根据设置报错
14、models.NullBooleanField 允许为空的布尔类型
15、models.PositiveIntegerFiel 正Integer
16、models.PositiveSmallIntegerField 正smallInteger
17、models.SlugField 减号、下划线、字母、数字
18、models.SmallIntegerField 数字
数据库中的字段有：tinyint、smallint、int、bigint
19、models.TextField 字符串=longtext
20、models.TimeField 时间 HH:MM[:ss[.uuuuuu]]
21、models.URLField 字符串，地址正则表达式
22、models.BinaryField 二进制
23、models.ImageField图片
24、models.FilePathField文件
更多参数
1、null=True
数据库中字段是否可以为空
2、blank=True
django的Admin中添加数据时是否可允许空值
3、primary_key =False
主键，对AutoField设置主键后，就会代替原来的自增 id 列
4、auto_now 和 auto_now_add
auto_now 自动创建---无论添加或修改，都是当前操作的时间
auto_now_add 自动创建---永远是创建时的时间
5、choices
GENDER_CHOICE =(
(u'M', u'Male'),
(u'F', u'Female'),
)
gender = models.CharField(max_length=2,choices = GENDER_CHOICE)
6、max_length
7、default 默认值
8、verbose_name Admin中字段的显示名称
9、name|db_column 数据库中的字段名称
10、unique=True 不允许重复
11、db_index =True 数据库索引
12、editable=True 在Admin里是否可编辑
13、error_messages=None 错误提示
14、auto_created=False 自动创建
15、help_text 在Admin中提示帮助信息
16、validators=[]
17、upload-to
数据库写入：
由于Blog.objects.create()每保存一条就执行一次SQL，而bulk_create()是执行一条SQL存入多条数据，做会快很多！当然用列表解析代替 for 循环会更快！！
vrflist = [Vrf_model(customer=’aaa’) for i in range(1,10)]
Vrf_model.objects.bulk_create(vrflist)
=========================================================================================
项目一：
1.创建一个模型，用于输入数据，在Admin里注册
2.在Views里定义两个函数，一个用于显示所有数据，一个用于查询
3.CSEF错误:在Form表单里加{% csrf_token %} ，在Views Return最后加context_instance=RequestContext(req)
4.通过Filter或All得到的数据，可用Values_list方法得到列表，再进行迭代出来
urls:
--------------------------------------------------------
from django.conf.urls import url
from django.contrib import admin
from app002 import views
urlpatterns = [
url(r'^search/', views.search),
url(r'^index/', views.getIP),
url(r'^admin/', admin.site.urls),
]
views:
--------------------------------------------------------
from django.shortcuts import render,render_to_response
from .models import MPLS_IP
from django.template import RequestContext
def getIP(req):
ipinfo = MPLS_IP.objects.all().values_list()
return render_to_response('index.html', {'ipinfo':ipinfo})
def search(req):
if req.method == 'POST':
pe1 = req.POST['pe']
f1 = MPLS_IP.objects.filter(PE=pe1)－－－－－－这里有点重复
f= f1.values_list()
直接这里就可以了：
f = MPLS_IP.objects.filter(PE=pe1).values()--------这是以字典方式显示，values_list以元组方式显示
else:
f = ''
return render_to_response('search.html',{'f':f},context_instance=RequestContext(req))
models:
--------------------------------------------------------
from django.db import models
# Create your models here.
class MPLS_IP(models.Model):
POP = models.CharField(u'站点',max_length=30)
PE = models.CharField(u'接入PE',max_length=30)
A_end = models.CharField(max_length=30)
B_end = models.CharField(max_length=30)
pub_date = models.DateTimeField(u'创建时间',auto_now_add=True)
update_time = models.DateTimeField(u'修改时间',auto_now=True)
def __str__(self):
return self.POP
index.html:
--------------------------------------------------------
<html>
<title>my page test</title>
<body>
<div>
<table >
<tr>
<td>ID</td>
<td>POP</td>
<td>PE</td>
<td>A-end</td>
<td>B-end</td>
<td>创建时间</td>
<td>修改时间</td>
</tr>
{% for i in ipinfo %}
<tr>
{% for j in i %}
<td>{{j}}</td>
{% endfor %}
</tr>
{% endfor %}
</table>
</div>
</body>
</html>
search.html:
--------------------------------------------------------
<html>
<title>my page test</title>
<body>
<form action='/search/' method="post">
{% csrf_token %}
<input type='text' name='pe'>
<input type='submit' value='查询'>
</form>
<div>
<table >
<tr>
<td>ID</td>
<td>POP</td>
<td>PE</td>
<td>A-end</td>
<td>B-end</td>
<td>创建时间</td>
<td>修改时间</td>
</tr>
{% for i in f %}
<tr>
{% for j in i %}－－－－－－这里两次For，用字典可能更好
<td>{{j}}</td>
{% endfor %}
</tr>
{% endfor %}
</table>
</div>
=====================================================================================
Django 模板标签
if/else 标签
基本语法格式如下：
{% if condition %}
... display
{% endif %}
或者：
{% if condition1 %}
... display 1
{% elif condiiton2 %}
... display 2
{% else %}
... display 3
{% endif %}
根据条件判断是否输出。if/else 支持嵌套。
{% if %} 标签接受 and ， or 或者 not 关键字来对多个变量做判断 ，或者对变量取反（ not )，例如：
{% if athlete_list and coach_list %}
athletes 和 coaches 变量都是可用的。
{% endif %}
for 标签
{% for %} 允许我们在一个序列上迭代。
与Python的 for 语句的情形类似，循环语法是 for X in Y ，Y是要迭代的序列而X是在每一个特定的循环中使用的变量名称。
每一次循环中，模板系统会渲染在 {% for %} 和 {% endfor %} 之间的所有内容。
例如，给定一个运动员列表 athlete_list 变量，我们可以使用下面的代码来显示这个列表：
<ul>
{% for athlete in athlete_list %}
<li>{{ athlete.name }}</li>
{% endfor %}
</ul>
给标签增加一个 reversed 使得该列表被反向迭代：
{% for athlete in athlete_list reversed %}
...
{% endfor %}
可以嵌套使用 {% for %} 标签：
{% for athlete in athlete_list %}
<h1>{{ athlete.name }}</h1>
<ul>
{% for sport in athlete.sports_played %}
<li>{{ sport }}</li>
{% endfor %}
</ul>
{% endfor %}
ifequal/ifnotequal 标签
{% ifequal %} 标签比较两个值，当他们相等时，显示在 {% ifequal %} 和 {% endifequal %} 之中所有的值。
下面的例子比较两个模板变量 user 和 currentuser :
{% ifequal user currentuser %}
<h1>Welcome!</h1>
{% endifequal %}
和 {% if %} 类似， {% ifequal %} 支持可选的 {% else%} 标签：8
{% ifequal section 'sitenews' %}
<h1>Site News</h1>
{% else %}
<h1>No News Here</h1>
{% endifequal %}
注释标签
-------------------------------------------------------------------------
Django 注释使用 {# #}。
{# 这是一个注释 #}
过滤器
模板过滤器可以在变量被显示前修改它，过滤器使用管道字符，如下所示：
{{ name|lower }}
{{ name }} 变量被过滤器 lower 处理后，文档大写转换文本为小写。
过滤管道可以被* 套接* ，既是说，一个过滤器管道的输出又可以作为下一个管道的输入：
{{ my_list|first|upper }}
以上实例将第一个元素并将其转化为大写。
有些过滤器有参数。 过滤器的参数跟随冒号之后并且总是以双引号包含。 例如：
{{ bio|truncatewords:"30" }}
这个将显示变量 bio 的前30个词。
其他过滤器：
addslashes : 添加反斜杠到任何反斜杠、单引号或者双引号前面。
date : 按指定的格式字符串参数格式化 date 或者 datetime 对象，实例：
{{ pub_date|date:"F j, Y" }}
length : 返回变量的长度。
include 标签
{% include %} 标签允许在模板中包含其它的模板的内容。
下面这两个例子都包含了 nav.html 模板：
{% include "nav.html" %}
模板继承
模板可以用继承的方式来实现复用。
接下来我们先创建之前项目的 templates 目录中添加 base.html 文件，代码如下：
<html>
<head>
<title>Hello World!</title>
</head>
<body>
<h1>Hello World!</h1>
{% block mainbody %}
<p>original</p>
{% endblock %}
</body>
</html>
以上代码中，名为mainbody的block标签是可以被继承者们替换掉的部分。
所有的 {% block %} 标签告诉模板引擎，子模板可以重载这些部分。
hello.html中继承base.html，并替换特定block，hello.html修改后的代码如下：
{% extends "base.html" %}
{% block mainbody %}
<p>继承了 base.html 文件</p>
{% endblock %}
第一行代码说明hello.html继承了 base.html 文件。可以看到，这里相同名字的block标签用以替换base.html的相应block。
前端调整
静态文件加载：
在Manager同级目录下创建static的文件夹
在setting后加，告诉Django到哪找静态文件－－－－－－这样就不用写一个死的地址了
STATICFILES_DIRS = (
os.path.join(BASE_DIR, "static"),
)
在Index页面上加载：{% load staticfiles %}
同时须更改所有CSS链接：
<link href="/static/css/bootstrap.css" rel="stylesheet">
<link href="/static/css/bootstrap-responsive.css" rel="stylesheet">
<script src="/static/js/bootstrap.js"></script>
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
.pull-left or .pull-right 左右调整
table:
class='table '显示表格
class='table table-striped' 行颜色不同
<table class="table table-hover"> 移到显示不同颜色
<table class="table table-bordered"> 显示表格
<caption>我的标题</caption> 显示表格标题
tr:
<tr class="success">
success 绿色
error 红色
warning 橙色
info 兰色
<span class="glyphicon glyphicon-plus"></span> + 图标
<a href="{% url 'blog.views.post_new' %}" > 可通过变量的方式链接到后台
前端想通过标题链接到详细页面：
<h1><a href="{% url 'blog.views.post_detail' pk=post.pk %}">{{ post.title }}</a></h1>
后端URL接收：
url(r'^post/(?P<pk>[0-9]+)/$', views.post_detail),
views接收
from django.shortcuts import render, get_object_or_404
def post_detail(request, pk):
post = get_object_or_404(Post, pk=pk)---------------这是主要的
return render(request, 'blog/post_detail.html', {'post': post})
前端Detial模块
{% extends 'blog/base.html' %}
{% block content %}
<div class="date">
{% if post.published_date %}
{{ post.published_date }}
{% endif %}
</div>
<h1>{{ post.title }}</h1>
<p>{{ post.text|linebreaks }}</p>
{% endblock %}
VIEWS
这里得到的是Model中定义显示的__str__名字
get_object_or_404(Ipinfo_model,pk=pk)
Ipinfo_model 是Model中定义的库名
Pk 是前端页面是返回的变量
这样就不需要抓取前面的ID，再通过ID来二次过滤
Reverse for 'add' with arguments '()' and keyword arguments '{}' not found. 0 pattern(s)
在Templates中写URL时，经常出现这个错误
<a href="{% url 'add' %}" class="top-menu">asdfasdfa</a>
url(r'^add/', views.add),
本来的url配置一般状况下是没有问题的，但是{% url %}这个命令要reverse url的配置，即通过 cal.views.month这个view找到对应的url，这时候django就会发现，找到了3个有month这个view的url的配置， 他不知道哪个市对的，所以默认是最后一个配置即(r"^month$", "month")，这时候，你可以看到这个配置的url是没有参数的，所以django才会报错说我的arguments是 '(2013, 1)' ， 但是url上没有参数的。
纠正的方法就是使用命名url，即给每个配置的url起个唯一的名字，如下：
<a href="{% url 'add' %}" class="top-menu">asdfasdfa</a>
url(r'^add/', views.add,name='add'),
Django Book 2.0学习
MVC设计模式
models
views
urls
templates
第三章：视图和URL配置
(r'^mysite/',include('mysite.urls'))可用此方式直接将URL引到mysite APP中
from django.conf.urls import url
from django.contrib import admin
动态视图：
内容动态，但URL是静态的
动态URL：
设计是这样的：
/time/plus/1/ 显示当前时间＋1个小时的页面
/time/plus/2/ 显示当前时间＋2个小时的页面
/time/plus/3/ 显示当前时间＋3个小时的页面，
以此类推。
正常可能是这样写的：
('^time/plus/2/$', two_hours_ahead),
('^time/plus/3/$', three_hours_ahead),
('^time/plus/4/$', four_hours_ahead),
我们可用以正则来实现：
(r'^time/plus/(\d{1,2})/$', hours_ahead),
这个URL模式将匹配类似 /time/plus/2/ , /time/plus/25/ ,甚至 /time/plus/XX/ 的任何URL
hours_ahead
--------------------------------------------------------
from django.http import Http404, HttpResponse
import datetime
def hours_ahead(request, offset):------这里Offset就是前面正则的变量值
try:
offset = int(offset)---这里如何不是数字，将引发异常
except ValueError:
raise Http404()
dt = datetime.datetime.now() + datetime.timedelta(hours=offset)
html = "<html><body>In %s hour(s), it will be %s.</body></html>" % (offset, dt)
return HttpResponse(html)
动态URL的理解：
在URL后中正则来表示动态的值，同时在Views里新建的函数将值放到参数里。
datetime.datetime.now() 显示当前时间
datetime.timedelta(hours=offset) 设定当时小时，默认为最后计时924776
datetime.datetime.now() + datetime.timedelta(3)
datetime.datetime(2016, 8, 20, 12, 9, 9, 924776)
第四章：模板
if / else ---可添加 and / or / not 等判断方式
for / endfor
forloop.last
forloop.first
ifequal比较两个值，不能用于字典，列表，布尔。
ifnotequal
多行注释：{% comment %} {% endcomment %}
过滤器，通常使用管道字符 | , 可套接
{{ my_list|first|upper }}-------取出第一个字符并大写
有些过滤器有参数。 过滤器的参数跟随冒号之后并且总是以双引号包含。 例如：
{{ bio|truncatewords:"30" }}----------显示变量 bio 的前30个词。
addslashes : 添加反斜杠到任何反斜杠、单引号或者双引号前面。 这在处理包含JavaScript的文本时是非常
有用的。
date : 按指定的格式字符串参数格式化 date 或者 datetime 对象， 范例：{{ pub_date|date:"F j, Y" }}
length : 返回变量的长度。 对于列表，这个参数将返回列表元素的个数。 对于字符串，这个参数将返回字
符串中字符的个数。 你可以对列表或者字符串，或者任何知道怎么测定长度的Python 对象使用这个方法
（也就是说，有 __len__() 方法的对象）。
在视图中使用模板
TEMPLATE_DIRS = (
'/home/django/mysite/templates', )
使用get_template自动加载一个模板文件，然后更改后输出。get_template直接引用Setting中的TEMPLATE_DIRS
from django.template.loader import get_template
t = get_template('current_datetime.html')
html = t.render(Context({'current_date': now}))
return HttpResponse(html)
直接使用render_to_response返回一个模板
return render_to_response('current_datetime.html', {'current_date': now})
locals()包含所有的变量,可在函数有多个变量时使用，方便省事
return render_to_response('current_datetime.html', locals())
get_template()中使用子目录
把所有的模板都存放在一个目录下可能会让事情变得难以掌控。 你可能会考虑把模板存放在你模板目录的子目录中
t = get_template('dateapp/current_datetime.html')---------只要加上主目录即可
{% include %}模板标签--该标签允许在（模板中）包含其它的模板的内容
模板继承
{% extends "base.html" %}
如果你需要访问父模板中的块的内容，使用 {{ block.super }}这个标签吧，这一个魔法变量将会表现出
父模板中的内容。 如果只想在上级代码块基础上添加内容，而不是全部重载，该变量就显得非常有用了
第五章：模型
数据查询
model.objects.all() <===> select * form table
数据过滤 filter--可有多个参数
过滤魔法：
字段__contaions 相当于LIKE
字段__contaions 加i不区分大小写
get() 获取单个对象，如果有多个对象或无对象 则出现异常
多个：MultipleObjectsReturned:
无：DoesNotExist: 是一个属性，可用Try方式获取异常
数据排序：
Publisher.objects.order_by("state_province", "address")---多个排序
可直接在Model中直接引用Meta：
class Meta:
ordering = ['name']
链式查询(连锁查询)
Publisher.objects.filter(country="U.S.A.").order_by("‐name") 查询后排序
Publisher.objects.order_by('name')[0] 显示第一个出版本商名称，切片方式[:3]显示前3个，不支持负索引
更新几列update
找出ID是52的然后更新Name
Publisher.objects.filter(id=52).update(name='Apress Publishing')
可同时更新多条记录
Publisher.objects.all().update(country='USA')
删除对象delete
Publisher.objects.filter(country='USA').delete()
Publisher.objects.all().delete()----删除所有记录
第六章：Django站点管理
django.contrib 包
如用户鉴别系统(django.contrib.auth)
支持匿名会话(django.contrib.sessioins)
用户评注系统(django.contrib.comments)
Admin是如何工作的
blank=True 可设置字段允许为空，即时生效，字段不再是粗体了
设置日期型和数字型字段可选 ，日期型、时间型和数字型字段不接受空字符串
如果你想允许一个日期型（DateField、TimeField、DateTimeField）或数字型
（IntegerField、DecimalField、FloatField）字段为空，你需要使用null=True * 和* blank=True。
null=True 需要更新数据库。
自定义字段标签
可直接在Model定义时加上标题：
name = models.CharField(u'出版商名称',max_length=30)
自定义ModelAdmi类
搜索框： search_fields = ('first_name', 'last_name')
显示框： list_display = ('first_name', 'last_name', 'email')
右边过滤：list_filter = ('publication_date',) 在页面右边显示
另外一种过滤日期的方式是使用date_hierarchy选项
date_hierarchy = 'publication_date'
值是一个字串，在页面上面返回一个条栏，显示日期汇总的内容
排序： ordering = ('-publication_date',)
自定义编辑表单
class BookAdmin(admin.ModelAdmin):
list_display = ('title', 'publisher', 'publication_date')
list_filter = ('publication_date',)
date_hierarchy = 'publication_date'
ordering = ('‐publication_date',)
自定义表单，可显示或隐藏相关字段
**fields = ('title', 'authors', 'publisher', 'publication_date')
对多选字段，可用filter_horizontal来显示一个多选择框，手工选择
filter_horizontal = ('authors',) 水平
filter_vertical = ('authors',) 垂直
单选下拉框不再显示，而显示一个放大镜样的，点击那个图标将会弹出一个窗口，在那里你可以选择想要添加的
raw_id_fields = ('publisher',)
所有的显示均为元组，只有date_hierarchy中字串
第七章：表单Form
URL相关信息---如果返回同一个相关的URL，action=''
属性/方法 说明 举例
request.path 除域名以外的请求路径，以正斜杠开头 "/hello/"
request.get_host() 主机名（比如，通常所说的域名） "127.0.0.1:8000" or
"www.example.com"
request.get_full_path() 请求路径，可能包含查询字符串 "/hello/?print=true"
request.is_secure() 如果通过HTTPS访问，则此方法返回True， 否则返回False True 或者 False
request.META 是一个Python字典，包含了所有本次HTTP请求的Header信息，比如用户IP地址和用户Agent（通常是浏览器的名称和版本号）。 注意，Header信息的完整列表取决于用户所发送的Header信息和服务器
端设置的Header信息。 这个字典中几个常见的键值有：
HTTP_REFERER，进站前链接网页，如果有的话。 （请注意，它是REFERRER的笔误。）
HTTP_USER_AGENT，用户浏览器的user-agent字符串，如果有的话。 例如："Mozilla/5.0 (X11; U; Linux i686; fr‐FR; rv:1.8.1.17) Gecko/20080829 Firefox/2.0.0.17" .
REMOTE_ADDR 客户端IP，如："12.345.67.89" 。(如果申请是经过代理服务器的话，那么它可能是以逗号分割的多个IP地址，如："12.345.67.89,23.456.78.90" 。)
request.GET和request.POST是类字典对象
request.GET和request.POST都有get()、keys()和values()方法
POST数据是来自HTML中的〈form〉标签提交的，而GET数据可能来自〈form〉提交也可能是URL中的查询字符串(the query string)。
这里：books|length 返回书的数量
books|pluralize 有多本书，在前面book后加s
{% if books %}
<p>Found {{ books|length }} book{{ books|pluralize }}.</p>
<ul>
{% for book in books %}
<li>{{ book.title }}</li>
{% endfor %}
</ul>
{% else %}
<p>No books matched your search criteria.</p>
{% endif %}
简单的验证
如果输入为空，提示，如果超过20字符，提示
编写Contact表单
django.core.mail.send_mail函数来发送e-mail。
这个函数有四个必选参数： 主题，正文，寄信人和收件人列表。
send_mail是Django的EmailMessage类的一个方便的包装，EmailMessage类提供了更高级的方法，比如附件，多部分邮件，以及对于邮件头部的完整控制。
我们应每次都给成功的POST请求做重定向。 这就是web开发的最佳实践。
HttpResponseRedirect
思路：我们每次判断用户输入，如果没有输入返回重新输入，那些已输入的则返回输入的值
可用字典的方式返回：request.GET.get('subject')
第一个Form类
每一个邦定Form实体都有一个errors属性，它为你提供了一个字段与错误消息相映射的字典表。
f['subject'].errors
form.as_table 用Form产生一个表格
Html中的Text域在Form中可通过widget=forms.Textarea显示
message = forms.CharField(widget=forms.Textarea)
限制最大(小)长度
subject = forms.CharField(max_length=100｜min_length=100 )
设置初始值
可在实例化对象时设定
form = ContactForm(initial={'subject': 'I love your site!'})
自定义校验规则
自定义长度，自定义提示消息，在类下创建一个方法
Django的form系统自动寻找匹配的函数方法，该方法名称以clean_开头，并以字段名称结束。
如果有这样的方法，它将在校验时被调用。
def clean_message(self):
message = self.cleaned_data['message']
num_words = len(message.split())
if num_words < 10:
raise forms.ValidationError("Not enough words,must be more then 4 words!")
return message
指定标签
用Lable，不能像Model中直接写字串方式。
email = forms.EmailField(required=False, label='Your e‐mail address' )
定制Form设计
{{form.as_table}}`` 显示表单
修改form的显示的最快捷的方式是使用CSS。 尤其是错误列表，可以增强视觉效果。
自动生成的错误列表精确的使用`` <ul class=”errorlist”>``，这样，我们就可以针对它们使用CSS。 下面的CSS让错误更加醒目了：
每一个字段部件(<input type=”text”>, <select>, <textarea>, 或者类似)都可以通过访问{{form.字段名}}进行单独的渲染。
第八章：高级视图和URL配置
URLconf 技巧
可以导入函数后用方法表示 (r'^time/$', views.current_datetime)
也可以直接使用，但以字串的方式 (r'^time/$', 'mysite.views.current_datetime' ),
还可以如下方式，可在头部将函数所属文件先列出来，后面直接写方法即可
urlpatterns = patterns('mysite.views' ,
(r'^hello/$', 'hello' ),
(r'^time/$', 'current_datetime' )
可通过此方式对多个APP进行URL指定
使用命名组
关键字参数 对比 位置参数
可混合使用，但位置参数要有关键字参数前面
在 Python 正则表达式中，命名的正则表达式组的语法是 (?P<name>pattern) ，这里 name 是组的名字，而pattern 是匹配的某个模式。
(r'^articles/(\d{4})/$', views.year_archive),
(r'^articles/(?P<year>\d{4})/$', views.year_archive),---命名组
可读性强，不用更改视图
理解匹配/分组算法
命名组和非命名组是不能同时存在于同一个URLconf的模式中的
1.如果有任何命名的组，Django会忽略非命名组而直接使用命名组。
2.否则，Django会把所有非命名组以位置参数的形式传递。
传递额外的参数到视图函数中
URLconf里面的每一个模式都可以包含第三个数据： 一个关键字参数字典
(r'^foo/$', views.foobar_view, {'template_name': 'template1.html'}),
(r'^bar/$', views.foobar_view, {'template_name': 'template2.html'}),
def foobar_view(request, template_name):
m_list = MyModel.objects.filter(is_new=True)
return render_to_response(template_name, {'m_list': m_list})
这样可用一个视图来返回两个不同的页面
伪造捕捉到的URLconf值
可产生这样的URL：/mydata/jan/01/
(r'^mydata/(?P<month>\w{3})/(?P<day>\d\d)/$', views.my_view),
def my_view(request, month, day):
如果要这样的 /mydata/birthday/ ， 这个URL等价于 /mydata/jan/06/
(r'^mydata/birthday/$', views.my_view, {'month': 'jan', 'day': '06'}),
你根本不用改变你的视图函数。 视图函数只会关心它 获得 了 参数
创建一个通用视图
用字典来显示不同的Model，传递给同一个视图
(r'^events/$', views.object_list, {'model': models.Event}),
(r'^blog/entries/$', views.object_list, {'model': models.BlogEntry}),
def object_list(request, model):
obj_list = model.objects.all()
template_name = 'mysite/%s_list.html' % model.__name__.lower()
return render_to_response(template_name, {'object_list': obj_list})
每个Python的类都有一个 __name__ 属性返回类名
提供视图配置选项
用户可能会希望配置上能有些自由度，用额外URLconf参数实现
了解捕捉值和额外参数之间的优先级 额外的选项
(r'^mydata/(?P<id>\d+)/$', views.my_view, {'id': 3}),
不管前端传什么值，22或40，URL均以3对待
使用缺省视图参数
(r'^blog/page(?P<num>\d+)/$', views.page),
def page(request, num='1'):
特殊情况下的视图
('^([^/]+)/([^/]+)/add/$', views.add_stage),
匹配像 /myblog/entries/add/ 和 /auth/groups/add/ 这样的URL
/auth/user/add/ 是个特殊情况
def add_stage(request, app_label, model_name):
if app_label == 'auth' and model_name == 'user':
# do special‐case code
else:
# do normal code
最好这样写，按顺利执行，不要放在Views里
('^auth/user/add/$', views.user_add_stage),
('^([^/]+)/([^/]+)/add/$', views.add_stage),
从URL中捕获文本
(r'^articles/(?P<year>\d{4})/$', views.year_archive),
在写视图要注意传入参数要变整形
决定URLconf搜索的东西
URL只匹配/后面的内容，不包括GET和POST请求
视图函数的高级概念
def some_page_get(request):
assert request.method == 'GET'
do_something_for_get()
return render_to_response('page.html')
assert语句用来声明某个条件是真的。
参数前1个星号，返回元组
参数前2个星号，返回字典
包装视图函数
用户登录后访问每个视图都要验证一次，
def my_view1(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('/accounts/login/')
def my_view2(request):
if not request.user.is_authenticated():
可用以下代码替换：
def requires_login(view):
def new_view(request, *args, **kwargs):
if not request.user.is_authenticated():
return HttpResponseRedirect('/accounts/login/')
return view(request, *args, **kwargs)
return new_view
包含其他URLconf
(r'^weblog/', include('mysite.blog.urls')),
自填写时间，可以设定字段，不显示在页面中，用户无法修改
pub_date = models.DateTimeField(u'创建时间',auto_now_add=True)
update_time = models.DateTimeField(u'修改时间',auto_now=True)
json越来越流行，通过python获取到json格式的字符串后，可以通过eval函数转换成dict格式：
>>> a='{"name":"yct","age":10}'
支持字符串和数字，其余格式的好像不支持：
NameError: name 'dddd' is not defined
