Python的WEB框架有Django、Tornado、Flask 等多种，Django相较与其他WEB框架其优势为：大而全，框架本身集成了ORM、模型绑定、模板引擎、缓存、Session等诸多功能。
一、创建django程序
- 终端命令：django-admin startproject sitename
- IDE创建Django程序时，本质上都是自动执行上述命令
其他常用命令：
python manage.py runserver 0.0.0.0
python manage.py startapp appname
python manage.py syncdb
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuse
到目前为止，当我们的程序涉及到数据库相关操作时，我们一般都会这么搞：
- 创建数据库，设计表结构和字段
- 使用 MySQLdb 来连接数据库，并编写数据访问层代码
- 业务逻辑层去调用数据访问层执行数据库操作
import MySQLdb def GetList(sql): db = MySQLdb.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 = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost') cursor = db.cursor() cursor.execute(sql) data = cursor.fetchone() db.close() return data
django为使用一种新的方式，即：关系对象映射（Object Relational Mapping，简称ORM）。
django中遵循 Code Frist 的原则，即：根据代码中定义的类来自动生成数据库表。
使用Django连接数据库，首先要在文件中进行相关配置ymysql配置：
import pymysql pymysql.install_as_MySQLdb()
路由映射配置：
from django.conf.urls import url from django.contrib import admin from app01 import views urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^index', views.index), ]
settings.py配置：
数据库
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'dbname', 'USER': 'root', 'PASSWORD': 'xxx', 'HOST': '', 'PORT': '', } } # 由于Django内部连接MySQL时使用的是MySQLdb模块，而python3中还无此模块，所以需要使用pymysql来代替 # 如下设置放置的与project同名的配置的 __init__.py文件中 import pymysql pymysql.install_as_MySQLdb()
models:
views.py:
一、创建表
1、基本结构
from django.db import models # Create your models here. class UserInfo(models.Model): user = models.CharField(max_length=32) email = models.EmailField(max_length=32) pwd = models.CharField(max_length=64) user_type = models.ForeignKey("UserType") class UserType(models.Model): nid = models.AutoField(primary_key=True) caption = models.CharField(max_length=16)
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正则表达式） 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) 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
class UserInfo(models.Model): nid = models.AutoField(primary_key=True) username = models.CharField(max_length=32) class Meta: # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名 db_table = "table_name" # 联合索引 index_together = [ ("pub_date", "deadline"), ] # 联合唯一索引 unique_together = (("driver", "restaurant"),) # admin中显示的表名称 verbose_name # verbose_name加s verbose_name_plural 更多：https://docs.djangoproject.com/en/1.10/ref/models/options/
1.触发Model中的验证和错误提示有两种方式： a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息 b. 调用Model对象的 clean_fields 方法，如： # models.py class UserInfo(models.Model): nid = models.AutoField(primary_key=True) username = models.CharField(max_length=32) email = models.EmailField(error_messages={'invalid': '格式错了.'}) # views.py def index(request): obj = models.UserInfo(username='11234', email='uu') try: print(obj.clean_fields()) except Exception as e: print(e) return HttpResponse('ok') # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。 2.Admin中修改错误提示 # admin.py from django.contrib import admin from model_club import models from django import forms class UserInfoForm(forms.ModelForm): username = forms.CharField(error_messages={'required': '用户名不能为空.'}) email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'}) age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'}) class Meta: model = models.UserInfo # fields = ('username',) fields = "__all__" class UserInfoAdmin(admin.ModelAdmin): form = UserInfoForm admin.site.register(models.UserInfo, UserInfoAdmin)
2、连表结构
- 一对多：models.ForeignKey(其他表)
- 多对多：models.ManyToManyField(其他表)
- 一对一：models.OneToOneField(其他表)
应用场景：
- 一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择）
例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。- 多对多：在某表中创建一行数据是，有一个可以多选的下拉框
例如：创建用户信息，需要为用户指定多个爱好- 一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了
例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据
ForeignKey(ForeignObject) # ForeignObject(RelatedField) to, # 要进行关联的表名 to_field=None, # 要关联的表中的字段名称 on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 - models.CASCADE，删除关联数据，与之关联也删除 - models.DO_NOTHING，删除关联数据，引发错误IntegrityError - models.PROTECT，删除关联数据，引发错误ProtectedError - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空） - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值） - models.SET，删除关联数据， a. 与之关联的值设置为指定值，设置：models.SET(值) b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象) def func(): return 10 class MyModel(models.Model): user = models.ForeignKey( to="User", to_field="id" on_delete=models.SET(func),) related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') db_constraint=True # 是否在数据库中创建外键约束 parent_link=False # 在Admin中是否显示关联数据 OneToOneField(ForeignKey) to, # 要进行关联的表名 to_field=None # 要关联的表中的字段名称 on_delete=None, # 当删除关联表中的数据时，当前表与其关联的行的行为 ###### 对于一对一 ###### # 1. 一对一其实就是 一对多 + 唯一索引 # 2.当两个类之间有继承关系时，默认会创建一个一对一字段 # 如下会在A表中额外增加一个c_ptr_id列且唯一： class C(models.Model): nid = models.AutoField(primary_key=True) part = models.CharField(max_length=12) class A(C): id = models.AutoField(primary_key=True) code = models.CharField(max_length=1) ManyToManyField(RelatedField) to, # 要进行关联的表名 related_name=None, # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all() related_query_name=None, # 反向操作时，使用的连接前缀，用于替换【表名】 如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名') limit_choices_to=None, # 在Admin或ModelForm中显示关联数据时，提供的条件： # 如： - limit_choices_to={'nid__gt': 5} - limit_choices_to=lambda : {'nid__gt': 5} from django.db.models import Q - limit_choices_to=Q(nid__gt=10) - limit_choices_to=Q(nid=8) | Q(nid__gt=10) - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') symmetrical=None, # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段 # 做如下操作时，不同的symmetrical会有不同的可选字段 models.BB.objects.filter(...) # 可选字段有：code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=True) # 可选字段有: bb, code, id, m1 class BB(models.Model): code = models.CharField(max_length=12) m1 = models.ManyToManyField('self',symmetrical=False) through=None, # 自定义第三张表时，使用字段用于指定关系表 through_fields=None, # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表 from django.db import models class Person(models.Model): name = models.CharField(max_length=50) class Group(models.Model): name = models.CharField(max_length=128) members = models.ManyToManyField( Person, through='Membership', through_fields=('group', 'person'), ) class Membership(models.Model): group = models.ForeignKey(Group, on_delete=models.CASCADE) person = models.ForeignKey(Person, on_delete=models.CASCADE) inviter = models.ForeignKey( Person, on_delete=models.CASCADE, related_name="membership_invites", ) invite_reason = models.CharField(max_length=64) db_constraint=True, # 是否在数据库中创建外键约束 db_table=None, # 默认创建第三张表时，数据库中表的名称
二、操作表
1、基本操作
# 增 # # models.Tb1.objects.create(c1='xx', c2='oo') 增加一条数据，可以接受字典类型数据 **kwargs # obj = models.Tb1(c1='xx', c2='oo') # obj.save() # 查 # # models.Tb1.objects.get(id=123) # 获取单条数据，不存在则报错（不建议） # models.Tb1.objects.all() # 获取全部 # models.Tb1.objects.filter(name='seven') # 获取指定条件的数据 # 删 # # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据 # 改 # models.Tb1.objects.filter(name='seven').update(gender='0') # 将指定条件的数据更新，均支持 **kwargs # obj = models.Tb1.objects.get(id=1) # obj.c1 = '111' # obj.save() # 修改单条数据
实例：增
def index(requeset): 增、删、改、查 return HttpResponse("ok")
#save添加 # obj = UserType(caption="管理员") # obj.save() # #create添加 # UserType.objects.create(caption="普通用户") # #字典添加 # user_dict = {"caption":"超级管理员"} # UserType.objects.create(**user_dict)
这里用到了字典添加，注意字典添加时要写**
注：
# 添加字典方法一 user_info_dict1 = { "user": "alex", "email": "alex123@163.com", "pwd": 123, "user_type":UserType.objects.get(nid=1) } UserInfo.objects.create(**user_info_dict1) # 添加字典方法二 user_info_dict2 = { "user": "eric", "email": "alex123@163.com", "pwd": 123, "user_type_id": 1 } UserInfo.objects.create(**user_info_dict2)
注：
user_type是我们自定义的列名，如果要添加，后面就要通过获取对象来添加。
user_type_id是自动帮我们创建之后生成的列名，所以可以直接写。
查
单标查询：结果都是queryset
all（）：列表里面是对象
#单表查询，结果都是queryset ret = UserType.objects.all() print(type(ret),ret,ret.query) #type(ret)是QuerySet。ret是列表里面封装每一条数据的对象。 ret.query查看SQL语句 for item in ret: print(item,item.nid,item.caption) #item是对象
如图：
all（）.values（）：列表里面是字典
ret1 = UserType.objects.all().values("nid") #获取UserType表中nid的值 print(type(ret1),ret1,ret1.query) #type(ret1)是QuerySet。ret1是列表里面有字典 for item in ret1: print(item,type(item)) #item是字典 print(item["nid"]) #获取nid的值
如图：
all（）.values_list（）：列表里面是元组
ret = UserType.objects.all().values_list("nid") print(type(ret),ret) #用values_list获取到的item是列表里有元组
如图：
2、进阶操作（了不起的双下划线）
利用双下划线将字段和对应的操作连接起来
# 获取个数 # # models.Tb1.objects.filter(name='seven').count() # 大于，小于 # # models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值 # models.Tb1.objects.filter(id__lt=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等于11、22、33的数据 # models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # 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 # limit 、offset # # models.Tb1.objects.all()[10:20] # 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"
注：.values().annotate()相当于MSQL里面的group by
3、连表操作（了不起的双下划线）
利用双下划线和 _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')
一对多：实例（表是创建表基本结构时候的UserInfo和UserType）：
通过查询UserInfo表所有user，关联UserType表中的caption，这里直接用双下划线进行连表操作：
user_type__caption
ret = UserInfo.objects.all().values("user","user_type__caption") print(ret) #结果：<QuerySet [{'user': 'alex', 'user_type__caption': '管理员'}, {'user': 'eric', 'user_type__caption': '管理员'}]> print(ret.query) #结果：SELECT `app01_userinfo`.`user`, `app01_usertype`.`caption` FROM `app01_userinfo` INNER JOIN `app01_usertype` ON (`app01_userinfo`.`user_type_id` = `app01_usertype`.`nid`)
查找用户类型是管理员的所有用户
正向查找：
连表查找UserType表中caption=管理员，再取出user、user_type__caption
ret = UserInfo.objects.filter(user_type__caption="管理员").values("user","user_type__caption") print(ret) #[{'user_type__caption': '管理员', 'user': 'alex'}, {'user_type__caption': '管理员', 'user': 'eric'}]
反向查找：
ret = UserType.objects.filter(caption="管理员").values("nid","userinfo__user") print(ret) #[{'nid': 1, 'userinfo__user': 'alex'}, {'nid': 1, 'userinfo__user': 'eric'}]
一对多总结：
外键查关联表的主键是正向：表中有Foreignkey找另一张关联表的primarykey
主键查关联表的外键是反向：表中有primarykey找另一张关联表的 Foreignkey
多对多实例：
创建表结构：
#方法一： class Host(models.Model): hid = models.AutoField(primary_key=True) hostname = models.CharField(max_length=32) ip = models.CharField(max_length=32) class Group(models.Model): gid = models.AutoField(primary_key=True) name = models.CharField(max_length=16) h2g = models.ManyToManyField(Host) #方法二： class Host(models.Model): hid = models.AutoField(primary_key=True) hostname = models.CharField(max_length=32) ip = models.CharField(max_length=32)
h2g = models.ManyToManyField("Group") class Group(models.Model): gid = models.AutoField(primary_key=True) name = models.CharField(max_length=16)
h2g = models.ManyToManyField（）会自动生成第三张表
自定义第三张表：
#方法三 class HostToGroup(models.Model): hgid = models.AutoField(primary_key=True) host_id = models.ForeignKey("Host") group_id = models.ForeignKey("Group") status = models.IntegerField() #自定义第三张表可以添加字段 class Host(models.Model): hid = models.AutoField(primary_key=True) hostname = models.CharField(max_length=32) ip = models.CharField(max_length=32) class Group(models.Model): gid = models.AutoField(primary_key=True) name = models.CharField(max_length=16) h2g = models.ManyToManyField(Host,through="HostToGroup")
我们使用方法一创建并添加数据：
以下加models.
# #Host插入数据 Host.objects.create(hostname="c1",ip="1.1.1.1") Host.objects.create(hostname="c2",ip="1.1.1.2") Host.objects.create(hostname="c3",ip="1.1.1.3") Host.objects.create(hostname="c4",ip="1.1.1.4") Host.objects.create(hostname="c5",ip="1.1.1.5") #Group插入数据 Group.objects.create(name="财务部") Group.objects.create(name="人事部") Group.objects.create(name="公关部") Group.objects.create(name="技术部") Group.objects.create(name="运营部") Group.objects.create(name="销售部") Group.objects.create(name="客服部")
向关系表中添加数据：
注：h2g在Group里面，通过Group可以查看第三张表数据
obj = Group.objects.get(gid=1) ret = obj.h2g.all() #第三张表的所有数据 print(ret) #因为现在第三张表中还没有插入数据，所以ret是空列表
正向操作：将多台机器分配给一组：财务组
obj = Group.objects.get(gid=1) #方法一 h1 = Host.objects.get(hid=1) obj.h2g.add(h1) #方法二 h = Host.objects.filter(hid__gt=3) obj.h2g.add(*h)
反向操作：将一台机器，分给多个组：_set
#方法一 # h = Host.objects.get(hid=1) # obj = Group.objects.get(gid=1) # obj.h2g.add(h) #方法二：基于Host表中隐含有group_set # h = Host.objects.get(hid=1) # h.group_set.add(*Group.objects.filter(gid__gt=2))
补充：
# Django默认创建第三张表时，添加方法补充 h = Host.objects.get(hid=1) # h.group_set.add(Group.objects.get(gid=1)) h.group_set.add(1) # h.group_set.add(*Group.objects.filter(gid__gt=1)) h.group_set.add(*[2,3])
多对多总结：
正向添加操作：通过表中有m2m操作：(*对象)。注：加*是因为后面获取到的是列表
反向添加操作：通过表中没有m2m操作：表名_set
删
remove：只删除关系表中的数据
h = Host.objects.get(hid=1)
h.group_set.remove(*Group.objects.filter(gid__gt=3))
delete：既删除关系表中的数据，也删除基础表（Group表）中的数据。注：all()是Queryset，里面有delete方法
h = Host.objects.get(hid=1)
h.group_set.all().delete()
改
注：Django自动帮我们在关系表中创建了联合唯一索引，所以改数据时，不能有重复，不然会报错
set：删除、添加。
注：如果关系表中有要设置的数据，保留设置数据，如果有其他数据，会将其他数据删除。
set设置filter数据列表，不用加*
h = Host.objects.get(hid=1) g = Group.objects.filter(gid=10) h.group_set.set(g)
#set设置filter数据列表，不用加* h = Host.objects.get(hid=1) g = Group.objects.filter(gid__gt=11) h.group_set.set(g)
get_or create 和 uptate_or create :如果关系表中有就不创建，基础表也不创建；如果关系表中没有就创建，基础表也创建。两者一样。
h = Host.objects.get(hid=1) r = h.group_set.get_or_create(name="财务部") r = h.group_set.update_or_create(name="技术部")
通过方法三自定义创建关联表，自定义关系表不能使用add，set，create命令，或者通过直接赋值方式来创建关系，可以通过all，filter获取。
class HostToGroup(models.Model): hgid = models.AutoField(primary_key=True) host_id = models.ForeignKey("Host") group_id = models.ForeignKey("Group") status = models.IntegerField() #自定义第三张表可以添加字段 class Meta: # index_together = ("host_id","group_id") #创建唯一索引 unique_together=[ ("host_id","group_id") ] #创建联合索引 class Host(models.Model): hid = models.AutoField(primary_key=True) hostname = models.CharField(max_length=32) ip = models.CharField(max_length=32) class Group(models.Model): gid = models.AutoField(primary_key=True) name = models.CharField(max_length=16) h2g = models.ManyToManyField(Host,through='HostToGroup')
注：联合索引
数据库：
总结：
直接使用M2M创建可以操作的：
获取值filter、all，add添加，remove删除，filter.delete()删除，set设置(删除、添加)，get_or_create和update_or_create创建。
补充：
自定义第三张关系表：
获取值：filter、all
# 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']) # F # # from django.db.models import F # models.Tb1.objects.update(num=F('num')+1) # Q # # 方式一： # Q(nid__gt=10) # Q(nid=8) | Q(nid__gt=10) # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root') # 方式二： # 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) # 执行原生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()
实例：Q
先将文件进行配置
STATIC_URL = '/static/' STATICFILES_DIRS = ( os.path.join(BASE_DIR,"static"), )
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'Django003', 'USER': 'root', 'PASSWORD': '', 'HOST': '', 'PORT': '', } }
MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', # 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ]
import pymysql pymysql.install_as_MySQLdb()
from django.db import models # Create your models here. class Author(models.Model): """ 作者 """ name = models.CharField(max_length=100) age = models.IntegerField() class BookType(models.Model): """ 图书类型 """ caption = models.CharField(max_length=64) class Book(models.Model): """ 图书 """ name = models.CharField(max_length=64) pages = models.IntegerField() price = models.DecimalField(max_digits=10,decimal_places=2) pubdate = models.DateField() authors = models.ManyToManyField(Author) book_type = models.ForeignKey(BookType) def __str__(self): return 'obj:%s-%s' %(self.name,self.price)
urlpatterns = [ url(r'^admin/', admin.site.urls), url(r'^test', views.test), url(r'^index', views.index), ]
from django.shortcuts import render,HttpResponse from app01 import models # Create your views here. # def test(request): # #数据库添加数据 # models.BookType.objects.create(caption='技术') # models.BookType.objects.create(caption='文学') # models.BookType.objects.create(caption='动漫') # models.BookType.objects.create(caption='男人装') # # models.Book.objects.create(name='文艺复兴',pages='100',price='40',pubdate='1992-11-2',book_type_id='1') # models.Book.objects.create(name='解密',pages='80',price='10', pubdate='2016-6-10',book_type_id='2') # models.Book.objects.create(name='刀锋',pages='50',price='3', pubdate='2014-02-16',book_type_id='2') # models.Book.objects.create(name='查令十字路84号',pages='260',price='40',pubdate='1999-10-12',book_type_id='3') # models.Book.objects.create(name='红楼',pages='1000',price='500', pubdate='1760-1-1',book_type_id='3') # models.Book.objects.create(name='将夜',pages='2000',price='300', pubdate='2010-3-3',book_type_id='1') # models.Book.objects.create(name='mysql从删库到跑路',pages='20',price='10',pubdate='1998-9-2',book_type_id='4') # models.Book.objects.create(name='马克思主义',pages='50',price='100',pubdate='1937-3-3',book_type_id='2') # # return HttpResponse('ok') import json from datetime import date from datetime import datetime from decimal import Decimal #序列化类 class JsonCustomEncoder(json.JSONEncoder): def default(self, field): if isinstance(field, datetime): return field.strftime('%Y-%m-%d %H:%M:%S') elif isinstance(field, date): return field.strftime('%Y-%m-%d') elif isinstance(field, Decimal): return str(field) else: return json.JSONEncoder.default(self, field) def index(request): if request.method == 'POST': #判断是否是post访问，接收post请求 ret = {'status': False, 'message': '', 'data':None} try: post_data = request.POST.get('post_data',None) #获取到前端发来的post_data，如果没有默认None post_data_dict = json.loads(post_data) #将post_data反序列化成字典 print(post_data_dict) # {'name': ['11', 'sdf']，'price': ['11', 'sdf']} # 构造搜索条件 去数据库进行搜索 from django.db.models import Q con = Q() for k,v in post_data_dict.items(): q = Q() q.connector = 'OR' #创建或的关系 for item in v: #循环列表 q.children.append((k, item)) #循环出来的多个item是添加到或的关系 con.add(q, 'AND') #将或的关系添加到and的关系中 """ 序列化 ret = models.Book.objects.filter(con) print(ret) # ret是queryset,[对象] from django.core import serializers data = serializers.serialize("json", ret) print(type(data),data) # 字符串 """ """ #ret = models.Book.objects.filter(con).values('name','book_type__caption') ret = models.Book.objects.filter(con).values_list('name', 'book_type__caption') print(ret,type(ret)) #ret外面是queryset对象，里面是字典 li = list(ret) #转换成列表，里面是字典 data = json.dumps(li) print(data,type(data)) """ result = models.Book.objects.filter(con).values('name','price','pubdate','book_type__caption') # result = models.Book.objects.filter(con)是queryset对象 li = list(result) #转换成列表，里面是字典，values_list内部元素的列表 ret['status'] = True ret['data'] = li #将列表信息添加到ret字典 except Exception as e: ret['message'] = str(e) ret_str = json.dumps(ret, cls=JsonCustomEncoder) #将queryset转换成字符串返回到前台 print(ret_str) return HttpResponse(ret_str) #返回字符串 return render(request, 'index.html')
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <style> .left{ float: left; } .clearfix:after{ content: '.'; clear: both; display: block; visibility: hidden; height: 0; } </style> </head> <body> <div class="condition"> <div class="item clearfix"> <div class="icon left" onclick="AddCondition(this);">+</div> <div class="left"> <select onchange="ChangeName(this);"> <option value="name">书名</option> <option value="book_type__caption">图书类型</option> <option value="price">价格</option> <option value="pages">页数</option> </select> </div> <div class="left"><input type="text" name="name" /></div> </div> </div> <div> <input type="button" onclick="Search();" value="搜索" /> </div> <div class="container"></div> <script src="/static/jquery-1.12.4.js"></script> <script> function AddCondition(ths) { var new_tag = $(ths).parent().clone(); //点加号时找到父级，克隆整个div new_tag.find('.icon').text('-'); //克隆的div将加号变成减号 new_tag.find('.icon').attr('onclick', 'RemoveCondition(this);'); //将减号绑定事件 $(ths).parent().parent().append(new_tag); //将克隆的div添加到指定位置 } function RemoveCondition(ths) { //减号绑定事件 $(ths).parent().remove(); //点击减号将会移除div } function ChangeName(ths) { //下拉框绑定事件 var v = $(ths).val(); //获得当前框的值：可获得name，book_type__caption，price，pages $(ths).parent().next().find('input').attr('name',v); //找到当前框对应的input标签的name属性和赋值，如：name=name，name=book_type__caption } function Search() { //将获取的值提交后台 var post_data_dict = {}; // 获取所有input的内容，提交数据 $('.condition input').each(function () { //循环div里面所有的input // console.log($(this)[0]) var n = $(this).attr('name'); //获取当前input的name var v = $(this).val(); //获取当前input标签里面输入的值 var v_list = v.split('，'); //将输入的值用中文逗号进行分割 post_data_dict[n] = v_list; //将name和分割后的值添加到字典中 }); {# console.log(post_data_dict);#} var post_data_str = JSON.stringify(post_data_dict); //将字典转换成字符串 $.ajax({ url:"/index/", //index后面必须加/ type:"POST", data:{"post_data":post_data_str}, dataType:"json", success:function (arg) { //arg返回的是json对象，写上dataType:"json"，就可以直接写arg.status。 if(arg.status){ //后端返回来的status为真 var table = document.createElement('table'); //创建table标签 table.setAttribute('border',1); //设置table边框 // [{,name,pubdate,price,caption},] $.each(arg.data, function(k,v){ //循环data列表，里面是字典 console.log(k); //k是data索引 console.log(v); //v是data里面的字典 //创建tr标签 var tr = document.createElement('tr'); //根据后台返回data里面的数组创建td var td1 = document.createElement('td'); td1.innerText = v['name']; var td2 = document.createElement('td'); td2.innerText = v['price']; var td3 = document.createElement('td'); td3.innerText = v['book_type__caption']; var td4 = document.createElement('td'); td4.innerText = v['pubdate']; //将所有td添加到tr tr.appendChild(td1); tr.appendChild(td2); tr.appendChild(td3); tr.appendChild(td4); //将tr添加到table table.appendChild(tr); }); $('.container').empty(); //显示table前将内容清空container $('.container').append(table); //将后台返回数据放在table里面添加到containerdiv显示在前端 }else{ alert(arg.message); } } }) } </script> </body> </html>
HTML之重点：
1、var new_tag = $(ths).parent().clone()获取的是通过jquery方法获得的对象。
dom对象和jquery对象之间的转换：
#dom对象： document.getElementsById("i1") #jquery对象： $("i1") #dom对象转换成jquery对象： $(document.getElementsByTagName("div")[0]) #jquery对象转换成dom对象 $("div").first()[0]
2、option的value属性值要和创建表里面的字段一样，每次ChangeName时$(this).val()，可以获得当前选中标签的属性，再找到后面的input，将获取的属性值设置成input的name属性名。也就是option选图书类型时，value是book_type__caption，后面的input框的name属性就是book_type__caption。代码结合注释看会更加理解。
3、发ajax时注意，不管urls.py路由配置有没有加/，发ajax请求时，url结尾都要加/，不加会出错：APPEND_SLASH 。
4、403错误是需要注释settings里面的csrf。
5、data:{"post_data":post_data_str}里面的post_data_str必须传字符串，索引要转换成字符串格式：var post_data_str = JSON.stringify(post_data_dict)
views.py之重点：
1、json序列化时只能是python的数据结构：字典、列表等
2、.filter()或者.all()得到的是queryset对象，用serializers.serialize实现序列化
3、JsonCustomEncoder是序列化类，字符串可以直接dumps，时间和小数（pubdate、price）不能dumps，有了序列化类就可以。
