model.object对象查询过滤、增删改、Q

vm.objects.all()[:10] #获得前10个对象，不支持负索引
vm.objects.get(name='vmname')
vm.objects.filter(name='vmname') #等价于vm.objects.filter(name__exact='vmname');name__iexact不区分大小写
vm.objects.filter(name__contains="vm")
vm.objects.filter(name__regex="^vm") # 正则查询
vm.objects.filter(name__contains="vm").exclude(ip='192.168.0.1') 
tb.objects.all().exists() #判断tb中是否为空
tb.objects.all().count() #查询tb中的对象数量
tb.objects.all().order_by('-name') #对tb中的对象按照name倒序查询
tb.objects.all().reverse() #倒序取值，但需要已经在model中进行了排序，否则无意义。

qb=tb.objects.filter(name__contains='b')
  qb.values() #返回值：[{'ip': u'192.168.1.1', 'rating': 0, u'id': 1, 'name': u'aa'}, {'ip': u'192.168.1.110', 'rating': 11, u'id': 3, 'name': u'aa'}]

qb.values_list() #返回值：[(1, u'aa', u'192.168.1.1', 0), (3, u'aa', u'192.168.1.110', 11)]

q1.values_list('name','ip') #返回值：[(u'aa', u'192.168.1.1'), (u'aa', u'192.168.1.110')

#新建对象：
vm.objects.create(name='vmname',ip='192.168.1.1')

item=vm(name='vmname',ip='192.168.1.1')
item.save()

item=vm()
item.ip='192.168.1.1'
item.save()
item=vm(name='vmname')
item.ip='192.168.1.1'
item.save()

vm.objects.get_or_create(name='vmname',ip='192.168.1.1') #先Get，不存在则Create，可以防止重复，但速度要相对慢些，返回一个元组，第一个为对象，第二个为True或False, 新建时返回的是True, 已经存在时返回False.

#修改对象：
item=vm.objects.get(name='vmname')
item.ip='192.168.1.1'
item.save()

Publisher.objects.all().delete() #删除所有

item.delete() #删除记录，直接删除

当key和value都是变量时，无法通过item.key=value方式赋值，可以使用如下方法：

item.__setattr__(key,value) 或者 setattr(obj, key, value)

item.save()

filter字段为变量时：

field_name='IPAddress__icontains'
v='192.168.1.3'
hvsrvs.objects.filter(**{field_name: v})

filterconitionname = request.GET['slctdname'] + '__icontains'
dnames = DomainNames.objects.filter(**{filterconitionname:q})

#get_or_create条件为变量：
condition = 'IP'
sdict = {condition:'1.1.1.2','APP':'weixin'}

kwargs = {condition:sdict[condition]}
#kwargs = {'{0}'.format('IP'): sdict[condition]} #实际上就是一个dict
IPs.objects.get_or_create(defaults=sdict,**kwargs) #kwargs必须要放在后面
IPs.objects.update_or_create(defaults=sdict,**kwargs)

kwargs = {
'{0}__{1}'.format('name', 'startswith'): 'A',
'{0}__{1}'.format('name', 'endswith'): 'Z'
}
Person.objects.filter(**kwargs)

#Get 条件为变量
condition = 'username'
upwords.objects.get(**{condition:'pymgmtuser'})

bulk_create批量创建，不需要显示调用.save():

aList = [
    Entry(headline="Django 1.0 Released"),
    Entry(headline="Django 1.1 Announced"),
    Entry(headline="Breaking: Django is awesome")
]
Entry.objects.bulk_create(aList)

d1 = {'APP': 'a13', 'cname': '1.2.3.4'}
IPs.objects.bulk_create([IPs(**d1)]) #使用字典的形式创建

d1['cname'] = hvsrvs.objects.get(serverip='1.1.1.2')  #当bulk_create的字段中存在foreignkey时，例如cname是一个foreignkey
  IPs.objects.bulk_create([IPs(**d1)])

ds = [IPs(**d1),IPs(**d2),IPs(**d3)] #d1,d2,d3均为dict
  IPs.objects.bulk_create(ds) #批量创建

时间过滤：

samples = Sample.objects.filter(sampledate__gt=datetime.date(2011, 1, 1),sampledate__lt=datetime.date(2011, 1, 31))

Sample.objects.filter(date__year='',
date__month='')

Sample.objects.filter(date__range=["2011-01-01", "2011-01-31"])

today = datetime.datetime.now()
  p1 = datetime.timedelta(days=1)
  users_today = lockoutusers.objects.filter(lockouttime__range=[today.date(),(today+p1).date()]) #过滤当天

过滤 OS_mark等于wd或wa的结果:

obj_list_filters = []
obj_list_filters += model.objects.filter(OS_mark='wa')
obj_list_filters += model.objects.filter(OS_mark='wd')

等价于如下：

from django.db.models import Q
upwords.objects.filter(Q(IP__OS_mark='wd') | Q(IP__OS_mark='wa'))  #|表示or

Django中的Q对象查询：

from django.db.models import Q

upwords.objects.filter(Q(OS_mark='wd') | Q(OS_mark='wa'))  # |表示or，过滤OS_mark=wd或=wa的条目

upwords.objects.filter(Q(OS_mark='wd') & Q(OS_mark='wa'))  # &表示and，过滤OS_mark=wd并且=wa的条目，等价于如下
upwords.objects.filter(Q(OS_mark='wd'),Q(OS_mark='wa'))  # &表示and，过滤OS_mark=wd并且=wa的条目

upwords.objects.filter(Q(IP__OS_mark__icontains='Windows Domain')) #过滤条件

#Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询
Poll.objects.get(
    Q(question__startswith='Who'),
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
) #等价于SELECT * from polls WHERE question LIKE 'Who%' AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

#查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面
Poll.objects.get(
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
    question__startswith='Who')
#如下不合法：
Poll.objects.get(
    question__startswith='Who',
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

QuerySet结果集合并：

如果用户隶属于某个组，则取出其所有的机器列表

u_groups = [x['name'] for x in request.user.groups.values()]
obj_list_filters = model.objects.none() #设置一个空的QuerySet
if 'upwords-win' in u_groups:
   obj_list_filters = obj_list_filters | model.objects.filter(Q(IP__OS_mark='wa')) | model.objects.filter(Q(IP__OS_mark='waa'))
if 'upwords-linux' in u_groups:
   obj_list_filters = obj_list_filters | model.objects.filter(Q(IP__OS_mark='Linux'))
if 'upwords-network' in u_groups:
   obj_list_filters = obj_list_filters | model.objects.filter(Q(IP__OS_mark='Network'))

print obj_list_filters #中间obj_list_filters变量为空也不受影响，如果用户属于多个组，则返回结果为多个obj_list_filters结果相加

QuerySet取并集（必须是同一个model）：

r1 = model.objects.filter(Q(IP__OS_mark='wa'))
r2 = model.objects.filter(Q(IP__OS_mark='wd'))
r = r1 | r2
print r #返回r1 + r2结果集合，要求r1或r2均不能为空值

QuerySet取并集（可以是不同的model）：

from itertools import chain
from yihaomen.common.models import Article, UserID

articles1 = Article.objects.order_by("autoid").filter(autoid__lt = 16).values('autoid','title')
users = UserID.objects.all()

items = chain(articles1, users)
for item in items:
    print item

get_or_create(defaults=None,**kwargs)   参考：http://www.lihuai.net/program/python/1526.html

obj, created = Person.objects.get_or_create(first_name='John', last_name='Lennon',
                  defaults={'birthday': date(1940, 10, 9)})

它根据所给的筛选条件查询对象，如果对象不存在就创建一个新对象。

它返回的是一个 (object, created) 元组，其中的 object 是所读取或是创建的对象，而 created 则是一个布尔值，它表示前面提到的 object 是否是新创建的。

update字段：

IPs.objects.get(IP='1.1.12.3') #get结果集不能使用update进行更新，无此方法
IPs.objects.filter(IP='1.1.12.3').update(APP='test333') #filter结果集可以通过update进行更新，无需再save()

update_or_create:

srvs = serverinfors.objects.all()
if request.method == 'POST':
    sdict={}
    for k,v in request.POST.items():
        if k <> 'csrfmiddlewaretoken' and len(v) > 0:
            sdict[k] = v.encode('u8') #直接pop(key)不成功
    print sdict
    serverinfors.objects.update_or_create(IP=sdict['IP'],defaults=sdict) #如果sdict['IP']在数据库中不存在，则新建，存在则更新（defaults内容不检查）

bulk_create(objs, batch_size=None)

Entry.objects.bulk_create([
    Entry(headline="Django 1.0 Released"),
    Entry(headline="Django 1.1 Announced"),
    Entry(headline="Breaking: Django is awesome")

参考：http://www.lihuai.net/program/python/1526.html

reverse()

使用 reverse() 方法会对查询结果进行反向排序。调用两次 reverse() 方法相当于排序没发生改过。

要得到查询结果中最后五个对象，可以这样写：

my_queryset.reverse()[:5]

要注意这种方式与 Python 语法中的从尾部切片是完全不一样的。在上面的例子中，是先得到最后一个元素，然后是倒数第二个，依次处理。但是如果我们有一个 Python 队列，使用 seq[-5:]时，却是先得到倒数第五个元素。Django 之所以采用 reverse 来获取倒数的记录，而不支持切片的方法，原因就是后者在 SQL 中难以做好。

还有一点要注意，就是 reverse() 方法应该只作用于已定义了排序项 QuerySet (例如，在查询时使用了order_by()方法，或是在 model 类当中直接定义了排序项). 如果并没有明确定义排序项，那么调用 QuerySet, calling reverse() 就没什么实际意义（因为在调用 reverse() 之前，数据没有定义排序，所以在这之后也不会进行排序。)

models.py:

from django.db import models

# Create your models here.
class tb(models.Model):
    name=models.CharField(max_length=100)
    ip=models.GenericIPAddressField()
    rating = models.IntegerField()

    def __str__(self):
        return self.name

    class Meta:
        ordering = ['Name']  #排序

dates(field, kind, order=’ASC’)

返回一个 DateQuerySet ，就是提取 QuerySet 查询中所包含的日期，将其组成一个新的 datetime.date 对象的列表。

field 是你的 model 中的 DateField 字段名称。

kind 是 “year”, “month” 或 “day” 之一。 每个 datetime.date对象都会根据所给的 type 进行截减。

“year” 返回所有时间值中非重复的年分列表。
“month” 返回所有时间值中非重复的年／月列表。
“day” 返回所有时间值中非重复的年／月／日列表。
order, 默认是 ‘ASC’，只有两个取值 ‘ASC’ 或 ‘DESC’。它决定结果如何排序。

例子：

>>> Entry.objects.dates('pub_date', 'year')
[datetime.date(2005, 1, 1)]
>>> Entry.objects.dates('pub_date', 'month')
[datetime.date(2005, 2, 1), datetime.date(2005, 3, 1)]
>>> Entry.objects.dates('pub_date', 'day')
[datetime.date(2005, 2, 20), datetime.date(2005, 3, 20)]
>>> Entry.objects.dates('pub_date', 'day', order='DESC')
[datetime.date(2005, 3, 20), datetime.date(2005, 2, 20)]
>>> Entry.objects.filter(headline__contains='Lennon').dates('pub_date', 'day')
[datetime.date(2005, 3, 20)]

datetimes(field, kind, order=’ASC’)

返回一个 DateTimeQuerySet ，就是提取 QuerySet 查询中所包含的日期，将其组成一个新的 datetime.datetime 对象的列表。

none()

返回一个 EmptyQuerySet — 它是一个运行时只返回空列表的 QuerySet。它经常用在这种场合：你要返回一个空列表，但是调用者却需要接收一个 QuerySet 对象。（这时，就可以用它代替空列表）

filter条件过滤：

条件选取querySet的时候，filter表示=，exclude表示!=。
querySet.distinct() 去重复
__exact 精确等于 like 'aaa'
__iexact 精确等于 忽略大小写 ilike 'aaa'
__contains 包含 like '%aaa%'
__icontains 包含 忽略大小写 ilike '%aaa%'，但是对于sqlite来说，contains的作用效果等同于icontains。
__gt 大于
__gte 大于等于
__lt 小于
__lte 小于等于
__in 存在于一个list范围内
__startswith 以...开头
__istartswith 以...开头 忽略大小写
__endswith 以...结尾
__iendswith 以...结尾，忽略大小写
__range 在...范围内
__year 日期字段的年份
__month 日期字段的月份
__day 日期字段的日
__isnull=True/False