Django ORM操作数据库，以及字段查询，聚合函数

## 添加数据
# 方式1：
test = Test(name='小王')
test.save()
# 方式2：
Test.objects.create(name='小王')

## 删除
Test.objects.get(id=1).delete()
Test.objects.filter(条件).delete()

## 修改
# 方式1：
test = Test.objects.get(条件)
test.age= 11
test.save()
# 方式2：
Test.objects.filter(条件).update(属性=值)

查询集

======返回查询集的方法，称为过滤器=====

all()
filter()
exclude()
order_by()
values()：一个对象构成一个字典，然后构成一个列表返回

写法：
filter(键1=值1,键2=值2)
等价于
filter(键1=值1).filter(键2=值2)

=====返回单个值的方法=====

get()：返回单个满足条件的对象，如果未找到会引发"模型类.DoesNotExist"异常
如果多条被返回，会引发"模型类.MultipleObjectsReturned"异常
count()：返回当前查询的总条数
first()：返回第一个对象
last()：返回最后一个对象
exists()：判断查询集中是否有数据，如果有则返回True

======限制查询集======

查询集返回列表，可以使用下标的方式进行限制，等同于sql中的limit和offset子句
（注意：不支持负数索引）
使用下标后返回一个新的查询集，不会立即执行查询
如果获取一个对象，直接使用[0]，等同于[0:1].get()，但是如果没有数据，[0]引发IndexError异常，[0:1].get()引发DoesNotExist异常

字段查询及聚合函数

exact（精确匹配。 默认的查找类型！）

Entry.objects.get(id__exact=14)
Entry.objects.get(id__exact=None)

======
iexact（不区分大小写的精确匹配。）

Blog.objects.get(name__iexact='beatles blog')
Blog.objects.get(name__iexact=None)
第一个查询将匹配 'Beatles Blog', 'beatles blog', 'BeAtLes BLoG'等等。

======
contains（大小写敏感的包含关系匹配。）

Entry.objects.get(headline__contains='Lennon')
这将匹配标题'Lennon honored today'，但不匹配'lennon honored today'。

======
icontains（不区分大小写的包含关系匹配。）

Entry.objects.get(headline__icontains='Lennon')

=====
in（在给定的列表里查找。）

Entry.objects.filter(id__in=[1, 3, 4])
还可以使用动态查询集，而不是提供文字值列表：

inner_qs = Blog.objects.filter(name__contains='Cheddar')
entries = Entry.objects.filter(blog__in=inner_qs)
或者从values()或values_list()中获取的QuerySet作为比对的对象：

inner_qs = Blog.objects.filter(name__contains='Ch').values('name')
entries = Entry.objects.filter(blog__name__in=inner_qs)
下面的例子将产生一个异常，因为试图提取两个字段的值，但是查询语句只需要一个字段的值：

# 错误的实例，将弹出异常。
inner_qs = Blog.objects.filter(name__contains='Ch').values('name', 'id')
entries = Entry.objects.filter(blog__name__in=inner_qs)

======
gt（大于）

Entry.objects.filter(id__gt=4)

======
gte（大于或等于）

======
lt（小于）

======
lte（小于或等于）

=====
startswith（区分大小写，从开始位置匹配。）

Entry.objects.filter(headline__startswith='Lennon')

======
istartswith（不区分大小写，从开始位置匹配。）

Entry.objects.filter(headline__istartswith='Lennon')

======
endswith（区分大小写，从结束未知开始匹配。）

Entry.objects.filter(headline__endswith='Lennon')

======
iendswith（不区分大小写，从结束未知开始匹配。）

Entry.objects.filter(headline__iendswith='Lennon')

======
range（范围测试（包含于之中））

import datetime
start_date = datetime.date(2005, 1, 1)
end_date = datetime.date(2005, 3, 31)
Entry.objects.filter(pub_date__range=(start_date, end_date))
警告:过滤具有日期的DateTimeField不会包含最后一天，因为边界被解释为“给定日期的0am”。

======
date（进行日期对比）

Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
当USE_TZ为True时，字段将转换为当前时区，然后进行过滤。

======
year（对年份进行匹配）

Entry.objects.filter(pub_date__year=2005)
Entry.objects.filter(pub_date__year__gte=2005)
当USE_TZ为True时，在过滤之前，datetime字段将转换为当前时区。

======
month（对月份进行匹配。取整数1（1月）至12（12月））

Entry.objects.filter(pub_date__month=12)
Entry.objects.filter(pub_date__month__gte=6)
当USE_TZ为True时，在过滤之前，datetime字段将转换为当前时区。

======
day（对具体到某一天的匹配）

Entry.objects.filter(pub_date__day=3)
Entry.objects.filter(pub_date__day__gte=3)
当USE_TZ为True时，在过滤之前，datetime字段将转换为当前时区。

======
week_day
进行“星期几”匹配。 取整数值，星期日为1，星期一为2，星期六为7。

Entry.objects.filter(pub_date__week_day=2)
Entry.objects.filter(pub_date__week_day__gte=2)
当USE_TZ为True时，在过滤之前，datetime字段将转换为当前时区。

======
hour（对小时进行匹配。 取0和23之间的整数）

Event.objects.filter(timestamp__hour=23)
Event.objects.filter(time__hour=5)
Event.objects.filter(timestamp__hour__gte=12)
当USE_TZ为True时，值将过滤前转换为当前时区。

======
minute（对分钟匹配。取0和59之间的整数）

Event.objects.filter(timestamp__minute=29)
Event.objects.filter(time__minute=46)
Event.objects.filter(timestamp__minute__gte=29)
当USE_TZ为True时，值将被过滤前转换为当前时区。

======
second（对秒数进行匹配。取0和59之间的整数）

Event.objects.filter(timestamp__second=31)
Event.objects.filter(time__second=2)
Event.objects.filter(timestamp__second__gte=31)
当USE_TZ为True时，值将过滤前转换为当前时区。

======
isnull（值为False或True, 相当于SQL语句IS NULL和IS NOT NULL）

Entry.objects.filter(pub_date__isnull=True)

======
regex（区分大小写的正则表达式匹配。）

Entry.objects.get(title__regex=r'^(An?|The) +')
建议使用原始字符串（例如，r'foo'而不是'foo'）来传递正则表达式语法。

======
iregex（不区分大小写的正则表达式匹配）

Entry.objects.get(title__iregex=r'^(an?|the) +')


========聚合函数========
Django的django.db.models模块提供以下聚合函数。

expression（引用模型字段的一个字符串，或者一个query expression）
output_field（用来表示返回值的model field，一个可选的参数）
**extra（关键字参数可以给聚合函数生成的SQL提供额外的信息）

======Avg
class Avg(expression, output_field=FloatField(), **extra)[source]
返回给定表达式的平均值，它必须是数值，除非指定不同的output_field。

默认的别名：<field>__avg
返回类型：float（或指定任何output_field的类型）

=====Count
class Count(expression, distinct=False, **extra)[source]
返回与expression相关的对象的个数。
默认的别名：<field>__count
返回类型：int
有一个可选的参数：distinct。如果distinct=True，Count 将只计算唯一的实例。默认值为False。

======Max
class Max(expression, output_field=None, **extra)[source]
返回expression的最大值。
默认的别名：<field>__max
返回类型：与输入字段的类型相同，如果提供则为`output_field`类型

======Min
class Min(expression, output_field=None, **extra)[source]
返回expression的最小值。
默认的别名：<field>__min
返回类型：与输入字段的类型相同，如果提供则为`output_field`类型

======StdDev
class StdDev(expression, sample=False, **extra)[source]
返回expression的标准差。
默认的别名：<field>__stddev
返回类型：float
有一个可选的参数：sample。默认情况下，返回群体的标准差。如果sample=True，返回样本的标准差。
SQLite 没有直接提供StdDev。

======Sum
class Sum(expression, output_field=None, **extra)[source]
计算expression的所有值的和。
默认的别名：<field>__sum
返回类型：与输入字段的类型相同，如果提供则为output_field类型

======Variance
class Variance(expression, sample=False, **extra)[source]
返回expression的方差。
默认的别名：<field>__variance
返回类型：float
有一个可选的参数：sample。
SQLite 没有直接提供Variance。