Python自动化运维之27、Django(一)

时间：2016-09-09 12:02:16 阅读：1117 评论：0 收藏：0 [点我收藏+]

标签：

一、概述

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:8000
python manage.py startapp appname
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser
python manage.py changepassword
python manage.py clearsessions

其他命令：

python manage.py shell     #进入django shell
python manage.py dbshell   #进入django dbshell
python 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 pymysql
pymysql.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 include

urlpatterns = 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 template
t = template.Template(‘My name is {{ name }}.‘)
c = template.Context({‘name‘: ‘Adrian‘})
print(t.render(c))

django通过模板语言将变量嵌套html中(一)

import datetime
from django import template
import 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)

django通过模板语言将变量嵌套html中(二)

from django.template.loader import get_template
from django.template import Context
from django.http import HttpResponse
import 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)

django通过模板语言将变量嵌套html中(三)

return render_to_response(‘Account/Login.html‘,data,context_instance=RequestContext(request))
注意：当数据POST的时候，Django做了跨站请求伪造

2、模版语言

　模板中也有自己的语言，该语言可以实现数据展示

(1)模板取值

# views函数返回的是字符串,通过{{ k1 }}获取字符串v1
return render(‘index.html‘,{‘k1‘:‘v1‘}

# views函数返回的是列表,通过{{ list.0 }}获取字符串11,{{ list.1 }}获取字符串22
return render(‘index.html‘,{‘list‘:[11,22,33,44]}

# views函数返回的是字典,通过{{ dict.k1 }}获取字符串v1,{{ dict.k2 }}获取字符串v2
return 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-8
from django import template
from django.utils.safestring import mark_safe
from 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_tag
def 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 == ‘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="..." />
    <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="/userinfo">用户管理</a></li>
                <li><a id="assets" href="/assets">资产管理</a></li>
            </ul>
        </div>
        <div class="body-content">
            {% block body %}{% endblock %}
        </div>

    </div>
    <div class="pg-footer"></div>
    <script src="xxx"></script>
    {% block js %}{% endblock %}
</body>
</html>

layout.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 %}

assets.html

{% 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 %}

userinfo.html

<form>
    <input type="text" placeholder="请输入内容"/>
    <input type="text" placeholder="请输入内容"/>
    <input type="text" placeholder="请输入内容"/>
    <input type="text" placeholder="请输入内容"/>
</form>

xx.html

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})

views

from django.conf.urls import url
from django.contrib import admin
from cmdb import views


urlpatterns = [
    url(r‘^admin/‘, admin.site.urls),
    url(r‘^assets/‘, views.assets),
    url(r‘^userinfo/‘, views.userinfo),
]

urls

更多官网模板介绍：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

通过pymysql操作数据库

(二)、使用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=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正则表达式）,django1.10逐步废弃使用下面一种
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)

    gender_choice = (
        (0,‘男‘),
        (1,‘女‘),
    )
    gender = models.IntergetFiled(choice=gener_choice)  # 数据库中存储的是0，1但是显示的是男，女

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    指定上传的路径

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 、offset

models.类名.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 by
from 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 connection
cursor = 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()

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.username


class 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.name


class UserGroup(models.Model):

    caption = models.CharField(max_length=64)

    user_info = models.ManyToManyField(‘UserInfo‘)

    def __unicode__(self):
        return self.caption


class 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_type
print 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 models

class 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 createsuperuser
python manage.py changepassword

2、配置后台管理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：设置分组表单

Python自动化运维之27、Django(一)

标签：

原文地址：http://www.cnblogs.com/xiaozhiqi/p/5851360.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行