django框架<三>
1、ORM操做html
一、django orm建立数据库的方法python
（1）指定链接pymysql(python3.x)，先配置__init__.pymysql
import pymysql
pymysql.install_as_MySQLdb()
（2）、配置链接mysql文件信息linux
settings.pysql
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'django_orm', #你的数据库名称
'USER': 'root', #你的数据库用户名
'PASSWORD': '', #你的数据库密码
'HOST': '', #你的数据库主机，留空默认为localhost
'PORT': '3306', #你的数据库端口
}
}
（3）、在mysql数据库中，建立数据库。数据库
mysql> create database Django_ORM character set utf8;
Query OK, 1 row affected (0.01 sec)
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| abc |
| crm |
| django_orm |
| mysql |
| performance_schema |
| s1 |
| sys |
| t2 |
+--------------------+
rows in set (0.00 sec)
mysql> use django_orm
Database changed
#####################################3
若是是链接linux系统上的mysql数据库，须要先受权，才能链接。
受权语句以下：
grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;
flush privileges;
（4）、在app01下面的models.py里面写建表语句django
from django.db import models
"""
增:
models.UserGroup.objects.create(title='销售部')，建立列
删：
models.UserGroup.objects.filter(id=2).delete()，将id=2的那一行删除
改：
models.UserGroup.objects.filter(id=2).update(title='公关部')，将ID=2的那一列的内容改为公关部
查：
group_list = models.UserGroup.objects.all()，查看用户组的全部信息
group_list = models.UserGroup.objects.filter(id=1)，查看用户组id=1的全部信息
group_list = models.UserGroup.objects.filter(id__gt=1)，查看用户组的id>1的全部信息
group_list = models.UserGroup.objects.filter(id__lt=1)，查看用户组的id<1的全部信息
"""
class Userinfo(models.Model):
nid=models.BigAutoField(primary_key=True)
username=models.CharField(max_length=32)
password=models.CharField(max_length=64)
（5）、在终端执行命令python3.x
建立表app
python manage.py makemigrationside
写入数据库
python manage.py migrate
二、操做
（1）基本操做
from django.shortcuts import render,redirect,HttpResponse
from app01 import models
# ============关于数据库的相关操做==============
# 数据库的增、删、改、查
def ChangeSql(request):
# 新增：
# models.Userinfo.objects.create(username="hahaha",password="h123")
# 查询：
group_list=models.Userinfo.objects.all()
# group_list=models.Userinfo.objects.filter(nid=2)
# group_list=models.Userinfo.objects.filter(nid_gt=1)
# group_list=models.Userinfo.objects.filter(nid_lt=1)
# 改
# models.Userinfo.objects.filter(nid=3).update(username="lailailai",password="la123")
# 删除：
models.Userinfo.objects.filter(nid=3).delete()
print(group_list)
for i in group_list:
print(i.nid,i.username,i.password)
return render(request,"ChangeSql.html",{"group_list":group_list})
（2）进阶操做
# 获取个数
#
# models.Tb1.objects.filter(name='seven').count()
# 大于，小于
#
# models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
# models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值
# in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于十一、2二、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in
# isnull
# Entry.objects.filter(pub_date__isnull=True)
# contains
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven")
# range
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and
# 其余相似
#
# startswith，istartswith, endswith, iendswith,
# order by
#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc
# models.Tb1.objects.filter(name='seven').order_by('-id') # desc
# group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
# limit 、offset
#
# models.Tb1.objects.all()[10:20]
# regex正则匹配，iregex 不区分大小写
#
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +')
# date
#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
# year
#
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005)
# month
#
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6)
# day
#
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3)
# week_day
#
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2)
# hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12)
# minute
#
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29)
# second
#
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31)
（3）、高级操做
# ============其余的关于moders的应用=========================
# 排序
# user_list=models.Userinfo.objects.all().order_by("id","username")#从小到大排序，当出现id同样的话，则按照名字排序
# user_list2=models.Userinfo.objects.all().order_by("-id")#从大到小排序
# print(user_list)
# print(user_list2)
# 分组
from django.db.models import Count,Sum,Min,Max
# res=models.Userinfo.objects.values("ut_id").annotate(a=Count("id"))
# print(res.query)#==>至关于SELECT `app01_userinfo`.`ut_id`, COUNT(`app01_userinfo`.`id`) AS `a` FROM `app01_userinfo` GROUP BY `app01_userinfo`.`ut_id`
# res=models.Userinfo.objects.values("ut_id").annotate(b=Count("id")).filter(id__lt=2)
# print(res)#==><QuerySet [{'ut_id': 1, 'b': 1}]>
# print(res.query)#=>SELECT `app01_userinfo`.`ut_id`, COUNT(`app01_userinfo`.`id`) AS `b` FROM `app01_userinfo` WHERE `app01_userinfo`.`id` < 2 GROUP BY `app01_userinfo`.`ut_id` ORDER BY NULL
# 过滤
# res =models.Userinfo.objects.filter(id__lt=5)#小于
# res =models.Userinfo.objects.filter(id__gt=5)#大于
# res =models.Userinfo.objects.filter(id__lte=5)#小于等于
# res =models.Userinfo.objects.filter(id__gte=5)#大于等于
# res =models.Userinfo.objects.filter(id__in=[1,2,3])#id在列表中
# res =models.Userinfo.objects.filter(id__range=[1,3])#id的范围属于1-3(包含1和3）
# res=models.Userinfo.objects.filter(username__startswith="ha")
# res=models.Userinfo.objects.filter(username__endswith="ha")
# res=models.Userinfo.objects.filter(username__contains="xu")#包含
# res=models.Userinfo.objects.exclude(id=1)#排除id=1的
# print(res)
# ======关于F、Q、extra
# F:
from django.db.models import F
#将数据库中的年级那一列都自加一
# models.Userinfo.objects.all().update(age=F("age")+1)
# Q:
# res=models.Userinfo.objects.filter(id=1,username="xuyuanyuan")#里面是and的关系
# print(res)#==><QuerySet []>
# dict={
# "id":1,
# "username":"xuyuanyuan"
# }#里面是and的关系
# ret=models.Userinfo.objects.filter(**dict)
# print(ret)#===><QuerySet []>
from django.db.models import Q
# Q使用有两种方式：对象方式，方法方式 *
# res=models.Userinfo.objects.filter(Q(id__lt=5))
# res=models.Userinfo.objects.filter(Q(id__lt=5)|Q(id__gt=315))#或
# res=models.Userinfo.objects.filter(Q(id__lt=5)&Q(id__gt=310))
# print(res)
# q1=Q()
# q1.connector="OR"
# q1.children.append(("id__gte",1))
# q1.children.append(("id",3))
# q1.children.append(("id",4))
#
# q2 = Q()
# q2.connector = 'OR'
# q2.children.append(('id', 11))
# q2.children.append(('id', 1))
# q2.children.append(('id', 10))
#
# q3 = Q()
# q3.connector = 'AND'
# q3.children.append(('id', 111))
# q3.children.append(('id', 200))
# q2.add(q3,'OR')
#
# con = Q()
# con.add(q1, 'AND')
# con.add(q2, 'AND')
# res=models.Userinfo.objects.filter(con)
# print(res)#===><QuerySet [<Userinfo: 1-hahaha-19>]>
# print(res.query)#==>上面定义的就至关于下面的sql语句：
# SELECT `app01_userinfo`.`id`,
# `app01_userinfo`.`username`,
# `app01_userinfo`.`age`,
# `app01_userinfo`.`ut_id`
# FROM `app01_userinfo`
# WHERE ((`app01_userinfo`.`id` >= 1 OR `app01_userinfo`.`id` = 3 OR `app01_userinfo`.`id` = 4)
# AND (`app01_userinfo`.`id` = 11 OR `app01_userinfo`.`id` = 1 OR `app01_userinfo`.`id` = 10
# OR (`app01_userinfo`.`id` = 111 AND `app01_userinfo`.`id` = 200)))
# condition_dict = {
# 'k1':[1,2,3,4],
# 'k2':[1,2,10,11],
# "k3":[1,2,100,111,200],
# }
# con = Q()
# for k,v in condition_dict.items():
# q = Q()
# q.connector = 'OR'
# for i in v:
# q.children.append(('id', i))
# con.add(q,'AND')
# res=models.Userinfo.objects.filter(con)
# print(res)
# print(res.query)
# extra：额外的
#
# extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
# Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
# Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
# Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
# Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
#原生sql
# name_map = {'title': 'titles'}
# v1 = models.Userinfo.objects.raw('SELECT id,title FROM app01_usertype',translations=name_map)
# print(v1.query)
# print(v1)
# for i in v1:
# print(i,type(i))
其它
（4）、其余操做
from django.shortcuts import render,redirect,HttpResponse from app01 import models def all(self) # 获取全部的数据对象
def filter(self, *args, **kwargs) # 条件查询
# 条件能够是：参数，字典，Q
def exclude(self, *args, **kwargs) # 条件查询
# 条件能够是：参数，字典，Q
def select_related(self, *fields) 性能相关：表之间进行join连表操做，一次性获取关联的数据。 model.tb.objects.all().select_related() model.tb.objects.all().select_related('外键字段') model.tb.objects.all().select_related('外键字段__外键字段') def prefetch_related(self, *lookups) 性能相关：多表连表操做时速度会慢，使用其执行屡次SQL查询在Python代码中实现连表操做。 # 获取全部用户表
# 获取用户类型表where id in (用户表中的查到的全部用户ID)
models.UserInfo.objects.prefetch_related('外键字段') from django.db.models import Count, Case, When, IntegerField Article.objects.annotate( numviews=Count(Case( When(readership__what_time__lt=treshold, then=1), output_field=CharField(), )) ) students = Student.objects.all().annotate(num_excused_absences=models.Sum( models.Case( models.When(absence__type='Excused', then=1), default=0, output_field=models.IntegerField() ))) def annotate(self, *args, **kwargs) # 用于实现聚合group by查询
from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')) # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id
v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1) # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1) # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
def distinct(self, *field_names) # 用于distinct去重
models.UserInfo.objects.values('nid').distinct() # select distinct nid from userinfo
注：只有在PostgreSQL中才能使用distinct进行去重 def order_by(self, *field_names) # 用于排序
models.UserInfo.objects.all().order_by('-id','age') def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # 构造额外的查询条件或者映射，如：子查询
Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) def reverse(self): # 倒序
models.UserInfo.objects.all().order_by('-nid').reverse() # 注：若是存在order_by，reverse则是倒序，若是多个排序则一一倒序
def defer(self, *fields): models.UserInfo.objects.defer('username','id') 或 models.UserInfo.objects.filter(...).defer('username','id') #映射中排除某列数据
def only(self, *fields): #仅取某个表中的数据
models.UserInfo.objects.only('username','id') 或 models.UserInfo.objects.filter(...).only('username','id') def using(self, alias): 指定使用的数据库，参数为别名（setting中的设置） ################################################## # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS # ##################################################
def raw(self, raw_query, params=None, translations=None, using=None): # 执行原生SQL
models.UserInfo.objects.raw('select * from userinfo') # 若是SQL是其余表时，必须将名字设置为当前UserInfo对象的主键列名
models.UserInfo.objects.raw('select id as nid from 其余表') # 为原生SQL设置参数
models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) # 将获取的到列名转换为指定列名
name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'} Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) # 指定数据库
models.UserInfo.objects.raw('select * from userinfo', using="default") ################### 原生SQL ###################
from django.db import connection, connections cursor = connection.cursor() # cursor = connections['default'].cursor()
cursor.execute("""SELECT * from auth_user where id = %s""", [1]) row = cursor.fetchone() # fetchall()/fetchmany(..)
def values(self, *fields): # 获取每行数据为字典格式
def values_list(self, *fields, **kwargs): # 获取每行数据为元祖
def dates(self, field_name, kind, order='ASC'): # 根据时间进行某一部分进行去重查找并截取指定内容
# kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
# order只能是："ASC" "DESC"
# 并获取转换后的时间
- year : 年-01-01
- month: 年-月-01
- day : 年-月-日 models.DatePlus.objects.dates('ctime','day','DESC') def datetimes(self, field_name, kind, order='ASC', tzinfo=None): # 根据时间进行某一部分进行去重查找并截取指定内容，将时间转换为指定时区时间
# kind只能是 "year", "month", "day", "hour", "minute", "second"
# order只能是："ASC" "DESC"
# tzinfo时区对象
models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC) models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) """ pip3 install pytz import pytz pytz.all_timezones pytz.timezone(‘Asia/Shanghai’) """
def none(self): # 空QuerySet对象
#################################### # METHODS THAT DO DATABASE QUERIES # ####################################
def aggregate(self, *args, **kwargs): # 聚合函数，获取字典类型聚合结果
from django.db.models import Count, Avg, Max, Min, Sum result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid')) ===> {'k': 3, 'n': 4} def count(self): # 获取个数
def get(self, *args, **kwargs): # 获取单个对象
def create(self, **kwargs): # 建立对象
def bulk_create(self, objs, batch_size=None): # 批量插入
# batch_size表示一次插入的个数
objs = [ models.DDD(name='r11'), models.DDD(name='r22') ] models.DDD.objects.bulk_create(objs, 10) def get_or_create(self, defaults=None, **kwargs): # 若是存在，则获取，不然，建立
# defaults 指定建立时，其余字段的值
obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2}) def update_or_create(self, defaults=None, **kwargs): # 若是存在，则更新，不然，建立
# defaults 指定建立时或更新时的其余字段
obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1}) def first(self): # 获取第一个
def last(self): # 获取最后一个
def in_bulk(self, id_list=None): # 根据主键ID进行查找
id_list = [11,21,31] models.DDD.objects.in_bulk(id_list) def delete(self): # 删除
def update(self, **kwargs): # 更新
def exists(self): # 是否有结果
重点：连表操做（正反）
（5）、一对一和一对多正反操做
a、正向和反向操做
.all()=====》查看到的数据类型都是Queryset类型，相似于列表，里面都是一个个对象
.values()===》使用.values查看数据，所查看的数据是Queryset里面套的字典，
.values_list()===》使用.values_list的方法查看的话，所查看的数据是列表里面套字典的方式
示例：
model.py
from django.db import models
from django.views import View
"""
增:
models.UserGroup.objects.create(title='销售部')，建立列
删：
models.UserGroup.objects.filter(id=2).delete()，将id=2的那一行删除
改：
models.UserGroup.objects.filter(id=2).update(title='公关部')，将ID=2的那一列的内容改为公关部
查：
group_list = models.UserGroup.objects.all()，查看用户组的全部信息
group_list = models.UserGroup.objects.filter(id=1)，查看用户组id=1的全部信息
group_list = models.UserGroup.objects.filter(id__gt=1)，查看用户组的id>1的全部信息
group_list = models.UserGroup.objects.filter(id__lt=1)，查看用户组的id<1的全部信息
"""
class UserType(models.Model):
# 用户类型
title=models.CharField(max_length=32)
class Userinfo(models.Model):
# 用户表
# nid=models.BigAutoField(primary_key=True)
username=models.CharField(max_length=32)
age=models.IntegerField()
ut=models.ForeignKey("UserType")
def __str__(self):
return "%s-%s" %(self.id,self.username)
views.py
from django.shortcuts import render,HttpResponse
from django.views import View
from app01 import models
# 关于查看和获取数据(正向操做和反向操做）
# 1.models.Userinfo.objects.all()查看到的数据类型都是Queryset类型，相似于列表，里面都是一个个对象
# Queryset[obj,obj,obj,]
# res=models.Userinfo.objects.all()
# # print(res)
# for obj in res:
# print(obj.username,obj.age,obj.ut_id,obj.ut.title)
#（1）一个用户对应一个用户类型
# UserInfo，ut是外键字段，能够经过点的方式连表 - 正向操做
# PS: 一个用户只有一个用户类型
# Queryset[obj,obj,obj,]
# res=models.Userinfo.objects.all().first()
# print(res.username, res.age, res.ut_id, res.ut.title)
#（2）一个用户类型能够对应多个用户(将同一类型下的用户所有取出）
# UserType, 表名小写_set.all() - 反向操做
# PS: 一个用户类型下能够有不少用户
# obj = models.UserType.objects.all().first()
# print(obj) #=====>UserType object
# print(obj.userinfo_set.all())#====><QuerySet [<Userinfo: Userinfo object>, <Userinfo: Userinfo object>]>
# print('用户类型',obj.id,obj.title)#===>用户类型 1 普通用户
# for row in obj.userinfo_set.all():
# print(row.username,row.age)
# result = models.UserType.objects.all()
# for item in result:
# print(item.title,item.userinfo_set.filter(username='hahaha'))
# 2.使用.values查看数据，所查看的数据是Queryset里面套的字典，
# 没法向上面的1同样进行obj.取值
# result=models.Userinfo.objects.all().values()
# print(result)#===>
# """
# < QuerySet[{'id': 1, 'username': 'hahaha', 'age': 18, 'ut_id': 1},
# {'id': 2, 'username': 'xuyuanyuan', 'age': 18,'ut_id': 3} 'ut_id': 1}] >
# """
# for i in result:
# print(i)#===>{'id': 1, 'username': 'hahaha', 'age': 18, 'ut_id': 1}
# 3.使用.values_list的方法查看的话，所查看的数据是列表里面套字典的方式
# result=models.Userinfo.objects.all().values_list("username","age")
# print(result)
# """
# < QuerySet[('hahaha', 18),
# ('xuyuanyuan', 18),
# ('leileilei', 10),
# ('kkkkk', 18),
# ('bob', 18),
# ('rose', 18),
# ('jack', 18),
# ('nack', 18)] >
# """
# for i in result:
# print(i)
#return HttpResponse("hello")
b、多对多连表（正向和反向操做）
.all()=====》查看到的数据类型都是Queryset类型，相似于列表，里面都是一个个对象
.values()===》使用.values查看数据，所查看的数据是Queryset里面套的字典，
.values_list()===》使用.values_list的方法查看的话，所查看的数据是列表里面套字典的方式
from django.shortcuts import render,HttpResponse
from django.views import View
from app01 import models
from django.core.paginator import
def test(request):
# 当数据获取多个数据时，分别用上述1.2.3来实现正反向连表操做：
# 1.
# （1）正向操做=====>根据userinfo来查询操做
# [obj,obj,obj]正向操做：
# models.Userinfo.objects.all()
# models.Userinfo.objects.filter(ut_id__gt=2)
# res=models.Userinfo.objects.filter(ut_id__gt=2)
# for i in res:
# print(i.username,i.age,i.ut.title)
#（2）一个用户类型能够对应多个用户(将同一类型下的用户所有取出）
# UserType, 表名小写_set.all() - 反向操做
# PS: 一个用户类型下能够有不少用户
# obj = models.UserType.objects.all().first()
# print(obj) #=====>UserType object
# print(obj.userinfo_set.all())#====><QuerySet [<Userinfo: Userinfo object>, <Userinfo: Userinfo object>]>
# print('用户类型',obj.id,obj.title)#===>用户类型 1 普通用户
# for row in obj.userinfo_set.all():
# print(row.username,row.age)
# result = models.UserType.objects.all()
# for item in result:
# print(item.title,item.userinfo_set.filter(username='hahaha'))
# 2.[{"id":1,"username":"xuyuanyuan"}]
# （1）正向操做：====>根据userinfo来操做
# models.Userinfo.objects.all().values("username","age")
# models.Userinfo.objects.filter(id__gt=2).values("username","age")
# res=models.Userinfo.objects.filter(id__gt=7).values("username","age")
# # 根据字典的key取值，没法连表，没法跨表去取usertype的title值
# for i in res:
# print(i["username"],i["age"]) #===>nack 18
#解决办法： 可是若是一开始取值的时候连表的话，则for循环能够取得连表后的值
# res=models.Userinfo.objects.all().values("username", "age","ut__title")
# for i in res:
# print(i["username"],i["age"],i["ut__title"])
# （2）反向操做====>根据usertype来操做：
# models.UserType.objects.all().values("id","title")
# models.UserType.objects.filter(id__1t=4).values("id","title")
# res=models.UserType.objects.filter(id__1t=4).values("id","title")
# 根据字典的key取值，没法连表，没法跨表去取userinfo的值
# 解决办法： 可是若是一开始取值的时候连表的话，则for循环能够取得连表后的值
# res1=models.UserType.objects.filter(id=1).values("id","title","userinfo")
# res2=models.UserType.objects.filter(id=1).values("id","title","userinfo__username")
# res3=models.UserType.objects.filter(id=1).values("id","title","userinfo__age")
# print(res1)
# print(res2)
# print(res3)
# 3.[("xuyuanyuan",18),("kkkk",18)]
# （1）正向操做：====>根据userinfo来操做
# models.Userinfo.objects.all().values_list()
# models.Userinfo.objects.filter(ut_id__gt=2).values_list()
# res=models.Userinfo.objects.filter(ut_id__gt=2).values_list()
# 根据元祖的索引取值，没法实现连表，没法获取usertype内的信息
# for i in res:
# print(i[0],i[1],i[2])
# 解决办法：一开始查询的时候就连表，则for循环便可取值
# models.Userinfo.objects.all().values_list("username","age","ut__title")
# res=models.Userinfo.objects.filter(ut_id__gt=3).values_list("username","age","ut__title")
# for i in res:
# print(i[0],i[2])#===>kkkkk 牛逼用户
# （2）反向操做====>根据usertype来操做：
# models.UserType.objects.all().values_list("id","title")
# 根据字典的key取值，没法连表，没法跨表去取userinfo的值
# 解决办法： 可是若是一开始取值的时候连表的话，则for循环能够取得连表后的值
# res1 = models.UserType.objects.filter(id=1).values_list("id", "title", "userinfo")
# res2 = models.UserType.objects.filter(id=1).values_list("id", "title", "userinfo__username")
# res3 = models.UserType.objects.filter(id=1).values_list("id", "title", "userinfo__age")
# print(res1)#===><QuerySet [(1, '普通用户', 1), (1, '普通用户', 8)]>
# print(res2)#===><QuerySet [(1, '普通用户', 'hahaha'), (1, '普通用户', 'nack')]>
# print(res3)#===><QuerySet [(1, '普通用户', 18), (1, '普通用户', 18)]>
# return render(request,"test.html")
相关文章
- 1. Django框架<一>
- 2. django框架<二>
- 3. day15<集合框架>
- 4. day16<集合框架+>
- 5. day17<集合框架+>
- 6. day18<集合框架+>
- 7. python ==> Django框架
- 8. Java框架集合：Collection<E>、Iterable<T>和Iterator<E>接口
- 9. eclipse中SSH三大框架环境搭建<三>
- 10. asp.net <%%> <%#%><%=%><%@%><%$%>用法区别
- 更多相关文章...
- • Docker 架构 - Docker教程
- • SSH框架（Struts2+Spring+Hibernate）搭建整合详细步骤 - Spring教程
- • RxJava操作符（三）Filtering
- • 三篇文章了解 TiDB 技术内幕——说存储
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Appium入门
- 2. Spring WebFlux 源码分析(2)-Netty 服务器启动服务流程 --TBD
- 3. wxpython入门第六步（高级组件）
- 4. CentOS7.5安装SVN和可视化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig对象缺少setMaxIdle、setMaxWaitMillis等方法，问题记录
- 6. 一步一图一代码，一定要让你真正彻底明白红黑树
- 7. 2018-04-12—（重点）源码角度分析Handler运行原理
- 8. Spring AOP源码详细解析
- 9. Spring Cloud（1）
- 10. python简单爬去油价信息发送到公众号
欢迎关注本站公众号,获取更多信息
