首页 > 代码库 > Python自动化运维之27、Django(一)
Python自动化运维之27、Django(一)
一、概述
1、什么是框架？
框架，即framework，特指为解决一个开放性问题而设计的具有一定约束性的支撑结构，使用框架可以帮你快速开发特定的系统，简单说就是使用别人搭好的舞台，你来做表演。
2、常见的Python Web框架：
Full-Stack Frameworks（全栈框架、重量级框架）：
Django、web2py、TurboGears、Pylons、...
Non Full-Stack Frameworks（非全栈框架、轻量级的框架）：
tornado、Flask、Bottle、web.py、Pyramid、...
详见：https://wiki.python.org/moin/WebFrameworks
3、这么多框架，如何选择？
a、根据项目需求去选择。
b、根据框架的特点去选择
国内常用：django、tornado、flask、bottle，Django相较与其他WEB框架其优势为：大而全，框架本身集成了ORM、模型绑定、模板引擎、缓存、Session等诸多功能。
Django官网：https://docs.djangoproject.com/en/1.9/
二、基本配置
1、创建django程序
- 终端命令：django-admin startproject sitename
- IDE创建Django程序时，本质上都是自动执行上述命令
常用命令：
python manage.py runserver 0.0.0.0:8000python manage.py startapp appnamepython manage.py makemigrationspython manage.py migratepython manage.py createsuperuserpython manage.py changepasswordpython manage.py clearsessions其他命令：
python manage.py shell #进入django shellpython manage.py dbshell #进入django dbshellpython manage.py check #检查django项目完整性python manage.py flush #清空数据库python manage.py compilemessages #编译语言文件python manage.py makemessages #创建语言文件python manage.py showmigrations #查看生成的数据库同步脚本python manage.py sqlflush #查看生成清空数据库的脚本python manage.py sqlmigrate #查看数据库同步的sql语句python manage.py dumpdata #导出数据python manage.py loaddata #导入数据python manage.py diffsettings #查看你的配置和django默认配置的不同之处
2、程序目录
3、配置文件
(1)APP配置
INSTALLED_APPS = [ ‘django.contrib.admin‘, ‘django.contrib.auth‘, ‘django.contrib.contenttypes‘, ‘django.contrib.sessions‘, ‘django.contrib.messages‘, ‘django.contrib.staticfiles‘, ‘cmdb‘,]
(2)数据库配置
DATABASES = { ‘default‘: { ‘ENGINE‘: ‘django.db.backends.mysql‘, ‘NAME‘:‘dbname‘, ‘USER‘: ‘root‘, ‘PASSWORD‘: ‘123456‘, ‘HOST‘: ‘‘, ‘PORT‘: ‘‘, }}由于Django内部连接MySQL时使用的是MySQLdb模块，而python3中还无此模块，所以需要使用pymysql来代替
如下设置放置的与project同名的配置的 __init__.py文件中
import pymysqlpymysql.install_as_MySQLdb()
(3)模版配置
TEMPLATE_DIRS = ( os.path.join(BASE_DIR,‘templates‘),)
(4)静态文件配置
STATICFILES_DIRS = ( os.path.join(BASE_DIR,‘static‘),)
三、路由系统
1、每个路由规则对应一个view中的函数
url(r‘^index/(\d*)‘, views.index),
url(r‘^list/(\d*)/(\d*)/$‘, views.list), url(r‘^manage/(?P<name>\w*)/(?P<id>\d*)‘, views.manage),url(r‘^login/(?P<name>\w*)‘, views.login,{‘id‘:333}),
def index(request,id): # id形参的名字是随便定义的 return render_to_response(‘index.html‘) def list(request,id1,id2): # id1,id2形参的名字是随便定义的 return render_to_response(‘list.html‘)def manage(request,name,id): # name,id形参的名字是和(?P<name>\w*)/(?P<id>\d*)是一样的 return render_to_response(‘index.html‘)def login(request,name,id): # name,id形参的名字是和(?P<name>\w*)，{‘id‘:333}是一样的 return render_to_response(‘login.html‘)
2、根据app对路由规则进行一次分类
from django.conf.urls import includeurlpatterns = patterns[ url(r‘^web/‘, include(‘web.url‘)), url(r‘^app01/‘, include(‘app01.url‘)),]
django中的路由系统和其他语言的框架有所不同，在django中每一个请求的url都要有一条路由映射，这样才能将请求交给对一个的view中的函数去处理。其他大部分的Web框架则是对一类的url请求做一条路由映射，从而是路由系统变得简洁。
通过反射机制，为django开发一套动态的路由系统Demo： 点击下载
四、模板
1、模版的执行
模版的创建过程，对于模版，其实就是读取模版（其中嵌套着模版标签），然后将 Model 中获取的数据插入到模版中，最后将信息返回给用户。
def current_datetime(request): now = datetime.datetime.now() html = "<html><body>It is now %s.</body></html>" % now return HttpResponse(html)
from django import templatet = template.Template(‘My name is {{ name }}.‘)c = template.Context({‘name‘: ‘Adrian‘})print(t.render(c))
import datetimefrom django import templateimport DjangoDemo.settings now = datetime.datetime.now()fp = open(settings.BASE_DIR+‘/templates/Home/Index.html‘)t = template.Template(fp.read())fp.close()html = t.render(template.Context({‘current_date‘: now}))return HttpResponse(html)
from django.template.loader import get_templatefrom django.template import Contextfrom django.http import HttpResponseimport datetime def current_datetime(request): now = datetime.datetime.now() t = get_template(‘current_datetime.html‘) html = t.render(Context({‘current_date‘: now})) return HttpResponse(html)
return render_to_response(‘Account/Login.html‘,data,context_instance=RequestContext(request))注意：当数据POST的时候，Django做了跨站请求伪造
2、模版语言
模板中也有自己的语言，该语言可以实现数据展示
(1)模板取值
# views函数返回的是字符串,通过{{ k1 }}获取字符串v1return render(‘index.html‘,{‘k1‘:‘v1‘}# views函数返回的是列表,通过{{ list.0 }}获取字符串11,{{ list.1 }}获取字符串22return render(‘index.html‘,{‘list‘:[11,22,33,44]}# views函数返回的是字典,通过{{ dict.k1 }}获取字符串v1,{{ dict.k2 }}获取字符串v2return render(‘index.html‘,{‘dict‘:{‘k1‘:‘v1‘,‘k2‘:‘v2‘}}(2)流程控制
{% if a > b %} .......{% elif a == b %} .......{% else %} .......{% endif %}(3)for循环
{% for item in data %} {{ item }}
{# 下面几个是特殊变量 #} forloop.counter {# 索引从0开始 #} forloop.counter0 {# 索引从1开始 #} forloop.first {# 是否是循环的第一个 #} forloop.last {# 是否是循环的最后一个 #}{% endfor %}(4)内置过滤器
{{ item.event_start|date:"Y-m-d H:i:s"}}{{ bio|truncatewords:"30" }}{{ my_list|first|upper }}{{ name|lower }}(5)自定义方法filter或者simple_tag
a、在app01中创建templatetags模块(templatetags名字是不能变)
b、创建任意 .py 文件，如：mysimple.py
#!/usr/bin/env python#coding:utf-8from django import templatefrom django.utils.safestring import mark_safefrom django.template.base import resolve_variable, Node, TemplateSyntaxError register = template.Library() # 这一句一定是这样写的 @register.simple_tag def my_simple_time(v1,v2,v3): # 传递多个参数 return v1 + v2 + v3 @register.simple_tagdef my_input(id,arg): result = "<input type=‘text‘ id=‘%s‘ class=‘%s‘ />" %(id,arg,) return mark_safe(result)
@register.filter
def f1(value):
return value + ‘1000‘
@register.filter
def f2(value,arg): # 传递一个参数
return value + ‘1000‘ + arg
@register.filter
def f3(value):
if value =http://www.mamicode.com/= ‘vvv‘:
return True
return False
c、在使用自定义simple_tag的html文件中导入之前创建的 mysimple.py 文件名
{% load mysimple %}d、使用simple_tag和filter,它们使用是不一样的
{% my_simple_time 1 2 3%} {# 可以传递多个参数 #}{% my_input ‘id_username‘ ‘hide‘%}
{{ k1 | f1 }}
{{ k1 | f2:‘python‘ }} {# 只能传递一个参数 #}
{% if k1 | f3 %}
<h1>True</h1>
{% else %}
<h1>False</h1>
{% endif %}e、在settings中配置当前app，不然django无法找到自定义的simple_tag
INSTALLED_APPS = ( ‘django.contrib.admin‘, ‘django.contrib.auth‘, ‘django.contrib.contenttypes‘, ‘django.contrib.sessions‘, ‘django.contrib.messages‘, ‘django.contrib.staticfiles‘, ‘app01‘,)
filter和simple_tag的区别：
filter：限制传参，支持 if 条件
simple_tag：不限制传参，不支持 if 条件
(六)模板继承
母板：{% block title %}{% endblock %}子板：{% extends "base.html" %}
{% include "xx.html" %} # 在子板中使用其他模板 {% block title %}{% endblock %}<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <title></title> <link rel="stylesheet" href=http://www.mamicode.com/"..." /> <style> .pg-header{ height: 48px; background-color: cadetblue; } .pg-body{ min-height: 500px; } .pg-body .body-menu{ width: 20%; float: left; } .pg-body .body-content{ width: 80%; float: left; } .pg-footer{ height: 100px; background-color: brown; } .active{ background-color: aquamarine; color: white; } </style> {% block css %}{% endblock %}</head><body> <div class="pg-header"> 后台系统V1 </div> <div class="pg-body"> <div class="body-menu"> <ul> <li><a id="userinfo" href=http://www.mamicode.com/"/userinfo">用户管理</a></li> <li><a id="assets" href=http://www.mamicode.com/"/assets">资产管理</a></li> </ul> </div> <div class="body-content"> {% block body %}{% endblock %} </div> </div> <div class="pg-footer"></div> <script src=http://www.mamicode.com/"xxx"></script> {% block js %}{% endblock %}</body></html>
{% extends ‘layout.html‘ %}{% block body %} {% include ‘xx.html‘ %} <table> {% for item in assets_list %} <tr> <td>{{ item.hostname }}</td> <td>{{ item.port }}</td> </tr> {% endfor %} </table>{% endblock %}{% block js %} <script> document.getElementById(‘assets‘).className = ‘active‘; </script>{% endblock %}{% extends ‘layout.html‘ %}{% block css %} <style></style>{% endblock %}{% block body %} {% include ‘xx.html‘ %} <ul> {% for item in user_list %} <li>{{ item.username }},{{ item.salary }}</li> {% endfor %} </ul>{% endblock %}{% block js %} <script> document.getElementById(‘userinfo‘).className = ‘active‘; </script>{% endblock %}<form> <input type="text" placeholder="请输入内容"/> <input type="text" placeholder="请输入内容"/> <input type="text" placeholder="请输入内容"/> <input type="text" placeholder="请输入内容"/></form>
from django.shortcuts import render,HttpResponse# Create your views here.USER_LSIT = []for item in range(94): temp = {"id":item, "ip":"192.168.1." + str(item),"username":"user" + str(item)} USER_LSIT.append(temp)def index(request,page): page = int(page) start = (page - 1) * 10 end = page * 10 user_list = USER_LSIT[start:end] return render(request,‘index.html‘,{‘user_list‘:user_list})def detail(request,nid): nid = int(nid) current_detail_dict = USER_LSIT[nid] return render(request,"detail.html",{"current_detail_dict":current_detail_dict})def assets(request): assets_list = [] for i in range(10): temp = {‘hostname‘:‘192.168.1.‘+str(i),‘port‘:80} assets_list.append(temp) return render(request,‘assets.html‘,{‘assets_list‘:assets_list})def userinfo(request): user_list = [] for i in range(10): temp = {‘username‘: ‘user‘ + str(i),‘salary‘:80} user_list.append(temp) return render(request,‘userinfo.html‘,{‘user_list‘:user_list})
from django.conf.urls import urlfrom django.contrib import adminfrom cmdb import viewsurlpatterns = [ url(r‘^admin/‘, admin.site.urls), url(r‘^assets/‘, views.assets), url(r‘^userinfo/‘, views.userinfo),]
更多官网模板介绍：https://docs.djangoproject.com/en/1.9/ref/templates/builtins/
https://docs.djangoproject.com/en/1.9/ref/templates/builtins/#extends
https://docs.djangoproject.com/en/1.9/ref/templates/builtins/#block
https://docs.djangoproject.com/en/1.9/ref/templates/builtins/#include
五、Model
(一)、使用原生SQL
到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：
- 创建数据库，设计表结构和字段
- 使用 MySQLdb 来连接数据库，并编写数据访问层代码
- 业务逻辑层去调用数据访问层执行数据库操作
import pymysql def GetList(sql): db = pymysql.connect(user=‘root‘, db=‘wupeiqidb‘, passwd=‘1234‘, host=‘localhost‘) cursor = db.cursor() cursor.execute(sql) data = cursor.fetchall() db.close() return data def GetSingle(sql): db = pymysql.connect(user=‘root‘, db=‘wupeiqidb‘, passwd=‘1234‘, host=‘localhost‘) cursor = db.cursor() cursor.execute(sql) data = cursor.fetchone() db.close() return data
(二)、使用ORM
django为使用一种新的方式，即：关系对象映射（Object Relational Mapping，简称ORM）。
PHP：activerecord
Java：Hibernate
C#：Entity Framework
django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。
1、创建Model，之后可以根据Model来创建数据库表
from django.db import models class userinfo(models.Model): name = models.CharField(max_length=30) email = models.EmailField() memo = models.TextField()
更多字段：
1、models.AutoField 自增列 = int(11) 如果没有的话，默认会生成一个名称为 id 的列，如果要显示的自定义一个自增列，必须将给列设置为主键 primary_key=True。2、models.CharField 字符串字段 必须 max_length 参数3、models.BooleanField 布尔类型=tinyint(1) 不能为空，Blank=True4、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_places8、models.EmailField 字符串类型（正则表达式邮箱） =varchar 对字符串进行正则表达式9、models.FloatField 浮点类型 = double10、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正则表达式）,django1.10逐步废弃使用下面一种13、models.GenericIPAddressField 字符串类型（ip4和ip6是可选的） 参数protocol可以是：both、ipv4、ipv6 验证时，会根据设置报错14、models.NullBooleanField 允许为空的布尔类型15、models.PositiveIntegerFiel 正Integer16、models.PositiveSmallIntegerField 正smallInteger17、models.SlugField 减号、下划线、字母、数字18、models.SmallIntegerField 数字 数据库中的字段有：tinyint、smallint、int、bigint19、models.TextField 字符串=longtext20、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)
gender_choice = (
(0,‘男‘),
(1,‘女‘),
)
gender = models.IntergetFiled(choice=gener_choice) # 数据库中存储的是0，1但是显示的是男，女
6、max_length7、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 指定上传的路径
2、数据库操作
增加：create()
# 第一种方式models.类名.objects.create(hostname=name) # 第二种方式obj = models.类名(hostname=name)obj.save()注意：hostname是数据库中的字段名，name是变量
更新：update()
# 第一种方式models.类名.objects.filter(id=2).update(hostname=‘tomcat‘) # 第二种方式obj = models.类名.objects.get(id=2)obj.hostname = ‘tomcat‘obj.save()
删除：delete()
models.类名.objects.get(id=2).delete()models.类名.objects.filter(id=2).delete()models.类名.objects.all().delete()
获取：filter(),get(),all()
models.类名.objects.get(id=123) # 获取单条数据，不存在则报错（不建议）models.类名.objects.all() # 获取全部models.类名.objects.filter(name=‘tomcat‘) # 获取指定条件的数据
数量：count()
models.类名.objects.filter(name=‘tomcat‘).count()models.类名.objects.get(name=‘tomcat‘).count()models.类名.objects.all().count()
大于小于：gt,lt
models.类名.objects.filter(id__gt=1) # 获取id大于1的值models.类名.objects.filter(id__lt=10) # 获取id小于10的值models.类名.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
等于多个值：in
models.类名.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据models.类名.objects.exclude(id__in=[11, 22, 33]) # not in
模糊查询：contains,icontains
models.类名.objects.filter(name__contains="ven")models.类名.objects.filter(name__icontains="ven") # icontains大小写不敏感models.类名.objects.exclude(name__icontains="ven")
范围查询：range
models.类名.objects.filter(id__range=[1, 2]) # 范围bettwen and
其他类似：startswith和endswith, ‘iendswith‘, ‘istartswith‘
排序：order_by("name") 相当于asc；order_by("-name") 相当于desc；
models.类名.objects.filter(name=‘seven‘).order_by(‘id‘) # asc,从小到大models.类名.objects.filter(name=‘seven‘).order_by(‘-id‘) # desc,从大到小
返回第n-m条：第n条[0]；前两条[0:2]
# limit 、offsetmodels.类名.objects.all()[10:20]
分组与聚合：group_by,annotate,aggregate
先看看两个函数：
1、annotate(*args, **kwargs)：可以为 QuerySet 中的每个对象添加注解。可以通过计算查询结果中每个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和，等等), 用于分组查询
2、aggregate(*args, **kwargs)：通过对 QuerySet 进行计算，返回一个聚合值的字典。 aggregate() 中每个参数都指定一个包含在字典中的返回值。用于聚合查询
- Avg(返回所给字段的平均值)
- Count(根据所给的关联字段返回被关联 model 的数量)
- Max(返回所给字段的最大值)
- Min(返回所给字段的最小值)
- Sum(计算所给字段值的总和)
# group byfrom django.db.models import Count, Min, Max, Sum# models.类名.objects.filter(c1=1).values(‘id‘).annotate(c=Count(‘num‘))# SELECT "app01_类名"."id", COUNT("app01_类名"."num") AS "c" FROM "app01_类名" WHERE "app01_类名"."c1" = 1 GROUP BY "app01_类名"."id"更多实例：
>>> Publisher.objects.filter(name=‘广东人民出版社‘).aggregate(Count(‘name‘))还可以自定义别名>>> Publisher.objects.filter(name=‘广东人民出版社‘).aggregate(mycount = Count(‘name‘))查询胡大海出的书的总价格是多少>>> Book.objects.filter(authors__name=‘胡大海‘).aggregate(Sum(‘price‘))查询各个作者出的书的总价格是多少>>> Book.objects.values(‘authors__name‘).annotate(Sum(‘price‘))查询各个出版社最便宜的书价是多少>>> Book.objects.values(‘publisher__name‘).annotate(Min(‘price‘))
原始SQL
注意：使用原生sql的方式主要目的是解决一些很复杂的sql，不能用ORM的方式写出的问题。
- extra：结果集修改器 - 一种提供额外查询参数的机制
- raw：执行原始sql并返回模型实例，最适合用于查询
- 直接执行自定义SQL（这种方式完全不依赖model，前面两种方式还是要依赖于model），适合增删改
A.使用extra：>>> Book.objects.filter(publisher__name=‘广东人民出版社‘).extra(where=[‘price>50’])>>> Book.objects.filter(publisher__name=‘广东人民出版社‘, price__gt=50)>>> Book.objects.extra(select={‘count‘:‘select count(*) from hello_book‘})B.使用raw：>>> Book.objects.raw(‘select * from hello_book‘)C.自定义sql：from django.db import connectioncursor = connection.cursor() #获得一个游标(cursor)对象 cursor.execute("insert into hello_author(name) values(‘郭敬明‘)") #插入操作cursor.execute("update hello_author set name = ‘韩寒‘ where name=‘郭敬明‘") #更新操作 cursor.execute("delete from hello_author where name=‘韩寒‘") #删除操作cursor.execute(‘select * from hello_author‘) #查询操作raw = cursor.fetchone() #返回结果行cursor.fetchall()
更多详见：
https://docs.djangoproject.com/en/1.9/ref/models/querysets/
3、连表操作：
- 一对多，models.ForeignKey(ColorDic)
- 一对一，models.OneToOneField(OneModel)
- 多对多，authors = models.ManyToManyField(Author)
应用场景：
- 一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了）。
例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据。- 一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）。
例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。- 多对多：在某表中创建一行数据是，有一个可以多选的下拉框。
例如：创建用户信息，需要为用户指定多个爱好。
利用双下划线和 _set 将表之间的操作连接起来
class UserProfile(models.Model): user_info = models.OneToOneField(‘UserInfo‘) username = models.CharField(max_length=64) password = models.CharField(max_length=64) def __unicode__(self): return self.usernameclass UserInfo(models.Model): user_type_choice = ( (0, u‘普通用户‘), (1, u‘高级用户‘), ) user_type = models.IntegerField(choices=user_type_choice) name = models.CharField(max_length=32) email = models.CharField(max_length=32) address = models.CharField(max_length=128) def __unicode__(self): return self.nameclass UserGroup(models.Model): caption = models.CharField(max_length=64) user_info = models.ManyToManyField(‘UserInfo‘) def __unicode__(self): return self.captionclass Host(models.Model): hostname = models.CharField(max_length=64) ip = models.GenericIPAddressField() user_group = models.ForeignKey(‘UserGroup‘) def __unicode__(self): return self.hostname
user_info_obj = models.UserInfo.objects.filter(id=1).first()print user_info_obj.user_typeprint user_info_obj.get_user_type_display()print user_info_obj.userprofile.password user_info_obj = models.UserInfo.objects.filter(id=1).values(‘email‘, ‘userprofile__username‘).first()print user_info_obj.keys()print user_info_obj.values()
类似一对一1、搜索条件使用 __ 连接2、获取值时使用 . 连接
user_info_obj = models.UserInfo.objects.get(name=u‘武沛齐‘)user_info_objs = models.UserInfo.objects.all() group_obj = models.UserGroup.objects.get(caption=‘CEO‘)group_objs = models.UserGroup.objects.all() # 添加数据#group_obj.user_info.add(user_info_obj)#group_obj.user_info.add(*user_info_objs) # 删除数据#group_obj.user_info.remove(user_info_obj)#group_obj.user_info.remove(*user_info_objs) # 添加数据#user_info_obj.usergroup_set.add(group_obj)#user_info_obj.usergroup_set.add(*group_objs) # 删除数据#user_info_obj.usergroup_set.remove(group_obj)#user_info_obj.usergroup_set.remove(*group_objs) # 获取数据#print group_obj.user_info.all()#print group_obj.user_info.all().filter(id=1) # 获取数据#print user_info_obj.usergroup_set.all()#print user_info_obj.usergroup_set.all().filter(caption=‘CEO‘)#print user_info_obj.usergroup_set.all().filter(caption=‘DBA‘)
# F 使用查询条件的值 # # from django.db.models import F # models.Tb1.objects.update(num=F(‘num‘)+1) # Q 构建搜索条件 from django.db.models import Q # con = Q() # # q1 = Q() # q1.connector = ‘OR‘ # q1.children.append((‘id‘, 1)) # q1.children.append((‘id‘, 10)) # q1.children.append((‘id‘, 9)) # # q2 = Q() # q2.connector = ‘OR‘ # q2.children.append((‘c1‘, 1)) # q2.children.append((‘c1‘, 10)) # q2.children.append((‘c1‘, 9)) # # con.add(q1, ‘AND‘) # con.add(q2, ‘AND‘) # # models.Tb1.objects.filter(con) # # from django.db import connection # cursor = connection.cursor() # cursor.execute("""SELECT * from tb where name = %s""", [‘Lennon‘]) # row = cursor.fetchone()
注意：xx_set中的【_set】是多对多中的固定搭配
4、扩展：
(1)自定义上传
def upload_file(request): if request.method == "POST": obj = request.FILES.get(‘fafafa‘) f = open(obj.name, ‘wb‘) for chunk in obj.chunks(): f.write(chunk) f.close() return render(request, ‘file.html‘)
(2)Form上传文件实例
form.py
class FileForm(forms.Form): ExcelFile = forms.FileField()
model.py
from django.db import modelsclass UploadFile(models.Model): userid = models.CharField(max_length = 30) file = models.FileField(upload_to = ‘./upload/‘) date = models.DateTimeField(auto_now_add=True)
view.py
def UploadFile(request): uf = AssetForm.FileForm(request.POST,request.FILES) if uf.is_valid(): upload = models.UploadFile() upload.userid = 1 upload.file = uf.cleaned_data[‘ExcelFile‘] upload.save() print upload.file
更多model相关：https://docs.djangoproject.com/en/1.9/topics/db/models/
六、admin
django amdin是django提供的一个后台管理页面，改管理页面提供完善的html和css，使得你在通过Model创建完数据库表之后，就可以对数据进行增删改查，而使用django admin 则需要以下步骤：
- 创建后台管理员
- 配置url
- 注册和配置django admin后台管理页面
1、创建后台管理员
python manage.py createsuperuserpython manage.py changepassword2、配置后台管理url
url(r‘^admin/‘, include(admin.site.urls))
3、注册和配置django admin 后台管理页面
a、在admin中执行如下配置
from django.contrib import admin from app01 import models admin.site.register(models.UserType)admin.site.register(models.UserInfo)admin.site.register(models.UserGroup)admin.site.register(models.Asset)
b、设置数据表名称
class UserType(models.Model): name = models.CharField(max_length=50) class Meta: verbose_name = ‘用户类型‘ verbose_name_plural = ‘用户类型‘
c、打开表之后，设定默认显示，需要在model中作如下配置
class UserType(models.Model): name = models.CharField(max_length=50) def __unicode__(self): return self.name
from django.contrib import admin from app01 import models class UserInfoAdmin(admin.ModelAdmin): list_display = (‘username‘, ‘password‘, ‘email‘) admin.site.register(models.UserType)admin.site.register(models.UserInfo,UserInfoAdmin)admin.site.register(models.UserGroup)admin.site.register(models.Asset)
d、为数据表添加搜索功能
from django.contrib import admin from app01 import models class UserInfoAdmin(admin.ModelAdmin): list_display = (‘username‘, ‘password‘, ‘email‘) search_fields = (‘username‘, ‘email‘) admin.site.register(models.UserType)admin.site.register(models.UserInfo,UserInfoAdmin)admin.site.register(models.UserGroup)admin.site.register(models.Asset)
e、添加快速过滤
from django.contrib import admin from app01 import models class UserInfoAdmin(admin.ModelAdmin): list_display = (‘username‘, ‘password‘, ‘email‘) search_fields = (‘username‘, ‘email‘) list_filter = (‘username‘, ‘email‘) admin.site.register(models.UserType)admin.site.register(models.UserInfo,UserInfoAdmin)admin.site.register(models.UserGroup)admin.site.register(models.Asset)
一些常用的设置技巧：
list_display：指定要显示的字段
search_fields：指定搜索的字段
list_filter：指定列表过滤器
ordering：指定排序字段
fields\exclude：指定编辑表单需要编辑\不需编辑的字段
fieldsets：设置分组表单
更多：https://docs.djangoproject.com/en/1.9/ref/contrib/admin/
Python自动化运维之27、Django(一)
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。