Django - 表与ORM操作

一. 模板语言

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

  1. - {{  变量 }}
  2. - 循环
  3.       {%  for i in  all_publisher %}
  4.           {{ forloop.counter }}   #  当前循环的测试
  5.       {%  endfor %}
  1. •{{ item }}
  2. •{% for item in item_list %}  <a>{{ item }}</a>  {% endfor %}
  3. 　　forloop.counter
  4. 　　forloop.first
  5. 　　forloop.last
  6. •{% if ordered_warranty %}  {% else %} {% endif %}
  7. •母板：{% block title %}{% endblock %}
  8. 子板：{% extends "base.html" %}
  9. 　　　{% block title %}{% endblock %}
  10. •帮助方法：
  11. {{ item.event_start|date:"Y-m-d H:i:s"}}
  12. {{ bio|truncatewords:"" }}
  13. {{ my_list|first|upper }}
  14. {{ name|lower }}
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6.     <link rel="stylesheet" href="/static/plugins/bootstrap-3.3.7/css/bootstrap.css">
  7.     <link rel="stylesheet" href="/static/css/dsb.css">
  8. </head>
  9. <body>
  10.     <nav class="navbar navbar-inverse navbar-fixed-top">
  11.     <div class="container-fluid">
  12.         <div class="navbar-header">
  13.             <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar"
  14.                     aria-expanded="false" aria-controls="navbar">
  15.                 <span class="sr-only">Toggle navigation</span>
  16.                 <span class="icon-bar"></span>
  17.                 <span class="icon-bar"></span>
  18.                 <span class="icon-bar"></span>
  19.             </button>
  20.             <a class="navbar-brand" href="#">图书管理系统</a>
  21.         </div>
  22.         <div id="navbar" class="navbar-collapse collapse">
  23.             <ul class="nav navbar-nav navbar-right">
  24.                 <li><a href="#">Dashboard</a></li>
  25.                 <li><a href="#">Settings</a></li>
  26.                 <li><a href="#">Profile</a></li>
  27.                 <li><a href="#">Help</a></li>
  28.             </ul>
  29.             <form class="navbar-form navbar-right">
  30.                 <input type="text" class="form-control" placeholder="Search...">
  31.             </form>
  32.         </div>
  33.     </div>
  34. </nav>
  35.  
  36.     <div class="container-fluid">
  37.     <div class="row">
  38.         <div class="col-sm-3 col-md-2 sidebar">
  39.             <ul class="nav nav-sidebar">
  40.                 <li ><a href="/index/">作家列表 <span class="sr-only">(current)</span></a></li>
  41.                 <li><a href="/book_list/">书籍列表</a></li>
  42.                 <li class="active"><a href="/auth_list/">作家列表</a></li>
  43.                 <li><a href="#">Export</a></li>
  44.             </ul>
  45.         </div>
  46.         <div class="col-sm-9 col-sm-offset-3 col-md-10 col-md-offset-2 main">
  47.  
  48.             <div class="panel panel-primary">
  49.                 <div class="panel-heading">
  50.                     <h3 class="panel-title">作家展示</h3>
  51.                 </div>
  52.                 <div class="panel-body">
  53.                     <a class="btn btn-primary " href="/add_auth/">添加</a>
  54.                     <div class="table-responsive">
  55.                         <table class="table table-striped table-hover">
  56.                             <thead>
  57.                             <tr>
  58.                                 <th>序号</th>
  59.                                 <th>ID</th>
  60.                                 <th>姓名</th>
  61.                                 <th>代表作</th>
  62.                                 <th>操作</th>
  63.                             </tr>
  64.                             </thead>
  65.                             <tbody>
  66.                             {% for i in all_auth %}
  67.                                 <tr>
  68.                                     <td>{{ forloop.counter }}</td>
  69.                                     <td>{{ i.pk }}</td>
  70.                                     <td>{{ i.name }}</td>
  71.                                     <td>
  72.                                         {% for book in i.books.all %}
  73.                                             {{ book.title }}
  74.                                          {% endfor %}
  75.                                     </td>
  76.                                     <td>
  77.                                         <a class="btn btn-success btn-sm" href="/edit_auth/?pk={{ i.pk }}">编辑</a>
  78.                                         <a class="btn btn-danger btn-sm" href="/del_auth/?pk={{ i.pk }}">删除</a>
  79.                                     </td>
  80.                                 </tr>
  81.                             {% endfor %}
  82.                             </tbody>
  83.                         </table>
  84.                     </div>
  85.                 </div>
  86.             </div>
  87.  
  88.         </div>
  89.     </div>
  90. </div>
  91.  
  92. </body>
  93. </html>

实例

二. 表结构

　　1. 基本表结构

  1. from django.db import models
  2.  
  3. class userinfo(models.Model):
  4.     name = models.CharField(max_length=30)
  5.     email = models.EmailField()
  6.     memo = models.TextField()
  1. AutoField(Field)
  2.         - int自增列，必须填入参数 primary_key=True
  3.  
  4.     BigAutoField(AutoField)
  5.         - bigint自增列，必须填入参数 primary_key=True
  6.  
  7.         注：当model中如果没有自增列，则自动会创建一个列名为id的列
  8.         from django.db import models
  9.  
  10.         class UserInfo(models.Model):
  11.             # 自动创建一个列名为id的且为自增的整数列
  12.             username = models.CharField(max_length=32)
  13.  
  14.         class Group(models.Model):
  15.             # 自定义自增列
  16.             nid = models.AutoField(primary_key=True)
  17.             name = models.CharField(max_length=32)
  18.  
  19.     SmallIntegerField(IntegerField):
  20.         - 小整数 -32768 ～ 32767
  21.  
  22.     PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
  23.         - 正小整数 0 ～ 32767
  24.     IntegerField(Field)
  25.         - 整数列(有符号的) -2147483648 ～ 2147483647
  26.  
  27.     PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
  28.         - 正整数 0 ～ 2147483647
  29.  
  30.     BigIntegerField(IntegerField):
  31.         - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807
  32.  
  33.     自定义无符号整数字段
  34.  
  35.         class UnsignedIntegerField(models.IntegerField):
  36.             def db_type(self, connection):
  37.                 return 'integer UNSIGNED'
  38.  
  39.         PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
  40.             'AutoField': 'integer AUTO_INCREMENT',
  41.             'BigAutoField': 'bigint AUTO_INCREMENT',
  42.             'BinaryField': 'longblob',
  43.             'BooleanField': 'bool',
  44.             'CharField': 'varchar(%(max_length)s)',
  45.             'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
  46.             'DateField': 'date',
  47.             'DateTimeField': 'datetime',
  48.             'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
  49.             'DurationField': 'bigint',
  50.             'FileField': 'varchar(%(max_length)s)',
  51.             'FilePathField': 'varchar(%(max_length)s)',
  52.             'FloatField': 'double precision',
  53.             'IntegerField': 'integer',
  54.             'BigIntegerField': 'bigint',
  55.             'IPAddressField': 'char(15)',
  56.             'GenericIPAddressField': 'char(39)',
  57.             'NullBooleanField': 'bool',
  58.             'OneToOneField': 'integer',
  59.             'PositiveIntegerField': 'integer UNSIGNED',
  60.             'PositiveSmallIntegerField': 'smallint UNSIGNED',
  61.             'SlugField': 'varchar(%(max_length)s)',
  62.             'SmallIntegerField': 'smallint',
  63.             'TextField': 'longtext',
  64.             'TimeField': 'time',
  65.             'UUIDField': 'char(32)',
  66.  
  67.     BooleanField(Field)
  68.         - 布尔值类型
  69.  
  70.     NullBooleanField(Field):
  71.         - 可以为空的布尔值
  72.  
  73.     CharField(Field)
  74.         - 字符类型
  75.         - 必须提供max_length参数， max_length表示字符长度
  76.  
  77.     TextField(Field)
  78.         - 文本类型
  79.  
  80.     EmailField(CharField)：
  81.         - 字符串类型，Django Admin以及ModelForm中提供验证机制
  82.  
  83.     IPAddressField(Field)
  84.         - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制
  85.  
  86.     GenericIPAddressField(Field)
  87.         - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
  88.         - 参数：
  89.             protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
  90.             unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"
  91.  
  92.     URLField(CharField)
  93.         - 字符串类型，Django Admin以及ModelForm中提供验证 URL
  94.  
  95.     SlugField(CharField)
  96.         - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）
  97.  
  98.     CommaSeparatedIntegerField(CharField)
  99.         - 字符串类型，格式必须为逗号分割的数字
  100.  
  101.     UUIDField(Field)
  102.         - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证
  103.  
  104.     FilePathField(Field)
  105.         - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
  106.         - 参数：
  107.                 path,                      文件夹路径
  108.                 match=None,                正则匹配
  109.                 recursive=False,           递归下面的文件夹
  110.                 allow_files=True,          允许文件
  111.                 allow_folders=False,       允许文件夹
  112.  
  113.     FileField(Field)
  114.         - 字符串，路径保存在数据库，文件上传到指定目录
  115.         - 参数：
  116.             upload_to = ""      上传文件的保存路径
  117.             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
  118.  
  119.     ImageField(FileField)
  120.         - 字符串，路径保存在数据库，文件上传到指定目录
  121.         - 参数：
  122.             upload_to = ""      上传文件的保存路径
  123.             storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
  124.             width_field=None,   上传图片的高度保存的数据库字段名（字符串）
  125.             height_field=None   上传图片的宽度保存的数据库字段名（字符串）
  126.  
  127.     DateTimeField(DateField)
  128.         - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
  129.  
  130.     DateField(DateTimeCheckMixin, Field)
  131.         - 日期格式      YYYY-MM-DD
  132.  
  133.     TimeField(DateTimeCheckMixin, Field)
  134.         - 时间格式      HH:MM[:ss[.uuuuuu]]
  135.  
  136.     DurationField(Field)
  137.         - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型
  138.  
  139.     FloatField(Field)
  140.         - 浮点型
  141.  
  142.     DecimalField(Field)
  143.         - 10进制小数
  144.         - 参数：
  145.             max_digits，小数总长度
  146.             decimal_places，小数位长度
  147.  
  148.     BinaryField(Field)
  149.         - 二进制类型

字段

  1. null                数据库中字段是否可以为空
  2.     db_column           数据库中字段的列名
  3.     db_tablespace
  4.     default             数据库中字段的默认值
  5.     primary_key         数据库中字段是否为主键
  6.     db_index            数据库中字段是否可以建立索引
  7.     unique              数据库中字段是否可以建立唯一索引
  8.     unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
  9.     unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
  10.     unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
  11.  
  12.     verbose_name        Admin中显示的字段名称
  13.     blank               Admin中是否允许用户输入为空
  14.     editable            Admin中是否可以编辑
  15.     help_text           Admin中该字段的提示信息
  16.     choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
  17.                         如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
  18.  
  19.     error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
  20.                         字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
  21.                         如：{'null': "不能为空.", 'invalid': '格式错误'}
  22.  
  23.     validators          自定义错误验证（列表类型），从而定制想要的验证规则
  24.                         from django.core.validators import RegexValidator
  25.                         from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
  26.                         MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
  27.                         如：
  28.                             test = models.CharField(
  29.                                 max_length=32,
  30.                                 error_messages={
  31.                                     'c1': '优先错信息1',
  32.                                     'c2': '优先错信息2',
  33.                                     'c3': '优先错信息3',
  34.                                 },
  35.                                 validators=[
  36.                                     RegexValidator(regex='root_\d+', message='错误了', code='c1'),
  37.                                     RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
  38.                                     EmailValidator(message='又错误了', code='c3'), ]
  39.                             )

参数

  1. class UserInfo(models.Model):
  2.         nid = models.AutoField(primary_key=True)
  3.         username = models.CharField(max_length=32)
  4.         class Meta:
  5.             # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
  6.             db_table = "table_name"
  7.  
  8.             # 联合索引
  9.             index_together = [
  10.                 ("pub_date", "deadline"),
  11.             ]
  12.  
  13.             # 联合唯一索引
  14.             unique_together = (("driver", "restaurant"),)
  15.  
  16.             # admin中显示的表名称
  17.             verbose_name
  18.  
  19.             # verbose_name加s
  20.             verbose_name_plural
  21.  
  22.     更多：https://docs.djangoproject.com/en/1.10/ref/models/options/

元信息

  1. 1.触发Model中的验证和错误提示有两种方式：
  2.         a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息
  3.         b. 调用Model对象的 clean_fields 方法，如：
  4.             # models.py
  5.             class UserInfo(models.Model):
  6.                 nid = models.AutoField(primary_key=True)
  7.                 username = models.CharField(max_length=32)
  8.  
  9.                 email = models.EmailField(error_messages={'invalid': '格式错了.'})
  10.  
  11.             # views.py
  12.             def index(request):
  13.                 obj = models.UserInfo(username='', email='uu')
  14.                 try:
  15.                     print(obj.clean_fields())
  16.                 except Exception as e:
  17.                     print(e)
  18.                 return HttpResponse('ok')
  19.  
  20.            # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。
  21.  
  22.     2.Admin中修改错误提示
  23.         # admin.py
  24.         from django.contrib import admin
  25.         from model_club import models
  26.         from django import forms
  27.  
  28.         class UserInfoForm(forms.ModelForm):
  29.             username = forms.CharField(error_messages={'required': '用户名不能为空.'})
  30.             email = forms.EmailField(error_messages={'invalid': '邮箱格式错误.'})
  31.             age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'})
  32.  
  33.             class Meta:
  34.                 model = models.UserInfo
  35.                 # fields = ('username',)
  36.                 fields = "__all__"
  37.  
  38.         class UserInfoAdmin(admin.ModelAdmin):
  39.             form = UserInfoForm
  40.  
  41.         admin.site.register(models.UserInfo, UserInfoAdmin)

拓展知识

　　2. 连表结构

　　　　一对多: models.ForeignKey(其他表)

　　　　多对多: models.ManyToManyField(其他表)

　　　　一对一:models.OneToOneFileld(其他表)

　　应用场景:　　　

  • 一对多：当一张表中创建一行数据时，有一个单选的下拉框（可以被重复选择） 例如：创建用户信息时候，需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。
  • 多对多：在某表中创建一行数据是，有一个可以多选的下拉框 例如：创建用户信息，需要为用户指定多个爱好
  • 一对一：在某表中创建一行数据时，有一个单选的下拉框（下拉框中的内容被用过一次就消失了 例如：原有含10列数据的一张表保存相关信息，经过一段时间之后，10列无法满足需求，需要为原来的表再添加5列数据
  1. ForeignKey(ForeignObject) # ForeignObject(RelatedField)
  2.         to,                         # 要进行关联的表名
  3.         to_field=None,              # 要关联的表中的字段名称
  4.         on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为
  5.                                         - models.CASCADE，删除关联数据，与之关联也删除
  6.                                         - models.DO_NOTHING，删除关联数据，引发错误IntegrityError
  7.                                         - models.PROTECT，删除关联数据，引发错误ProtectedError
  8.                                         - models.SET_NULL，删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）
  9.                                         - models.SET_DEFAULT，删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）
  10.                                         - models.SET，删除关联数据，
  11.                                                       a. 与之关联的值设置为指定值，设置：models.SET(值)
  12.                                                       b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)
  13.  
  14.                                                         def func():
  15.                                                             return 10
  16.  
  17.                                                         class MyModel(models.Model):
  18.                                                             user = models.ForeignKey(
  19.                                                                 to="User",
  20.                                                                 to_field="id"
  21.                                                                 on_delete=models.SET(func),)
  22.         related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
  23.         related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
  24.         limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
  25.                                     # 如：
  26.                                             - limit_choices_to={'nid__gt': 5}
  27.                                             - limit_choices_to=lambda : {'nid__gt': 5}
  28.  
  29.                                             from django.db.models import Q
  30.                                             - limit_choices_to=Q(nid__gt=10)
  31.                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
  32.                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
  33.         db_constraint=True          # 是否在数据库中创建外键约束
  34.         parent_link=False           # 在Admin中是否显示关联数据
  35.  
  36.     OneToOneField(ForeignKey)
  37.         to,                         # 要进行关联的表名
  38.         to_field=None               # 要关联的表中的字段名称
  39.         on_delete=None,             # 当删除关联表中的数据时，当前表与其关联的行的行为
  40.  
  41.                                     ###### 对于一对一 ######
  42.                                     # 1. 一对一其实就是 一对多 + 唯一索引
  43.                                     # 2.当两个类之间有继承关系时，默认会创建一个一对一字段
  44.                                     # 如下会在A表中额外增加一个c_ptr_id列且唯一：
  45.                                             class C(models.Model):
  46.                                                 nid = models.AutoField(primary_key=True)
  47.                                                 part = models.CharField(max_length=12)
  48.  
  49.                                             class A(C):
  50.                                                 id = models.AutoField(primary_key=True)
  51.                                                 code = models.CharField(max_length=1)
  52.  
  53.     ManyToManyField(RelatedField)
  54.         to,                         # 要进行关联的表名
  55.         related_name=None,          # 反向操作时，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
  56.         related_query_name=None,    # 反向操作时，使用的连接前缀，用于替换【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
  57.         limit_choices_to=None,      # 在Admin或ModelForm中显示关联数据时，提供的条件：
  58.                                     # 如：
  59.                                             - limit_choices_to={'nid__gt': 5}
  60.                                             - limit_choices_to=lambda : {'nid__gt': 5}
  61.  
  62.                                             from django.db.models import Q
  63.                                             - limit_choices_to=Q(nid__gt=10)
  64.                                             - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
  65.                                             - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
  66.         symmetrical=None,           # 仅用于多对多自关联时，symmetrical用于指定内部是否创建反向操作的字段
  67.                                     # 做如下操作时，不同的symmetrical会有不同的可选字段
  68.                                         models.BB.objects.filter(...)
  69.  
  70.                                         # 可选字段有：code, id, m1
  71.                                             class BB(models.Model):
  72.  
  73.                                             code = models.CharField(max_length=12)
  74.                                             m1 = models.ManyToManyField('self',symmetrical=True)
  75.  
  76.                                         # 可选字段有: bb, code, id, m1
  77.                                             class BB(models.Model):
  78.  
  79.                                             code = models.CharField(max_length=12)
  80.                                             m1 = models.ManyToManyField('self',symmetrical=False)
  81.  
  82.         through=None,               # 自定义第三张表时，使用字段用于指定关系表
  83.         through_fields=None,        # 自定义第三张表时，使用字段用于指定关系表中那些字段做多对多关系表
  84.                                         from django.db import models
  85.  
  86.                                         class Person(models.Model):
  87.                                             name = models.CharField(max_length=50)
  88.  
  89.                                         class Group(models.Model):
  90.                                             name = models.CharField(max_length=128)
  91.                                             members = models.ManyToManyField(
  92.                                                 Person,
  93.                                                 through='Membership',
  94.                                                 through_fields=('group', 'person'),
  95.                                             )
  96.  
  97.                                         class Membership(models.Model):
  98.                                             group = models.ForeignKey(Group, on_delete=models.CASCADE)
  99.                                             person = models.ForeignKey(Person, on_delete=models.CASCADE)
  100.                                             inviter = models.ForeignKey(
  101.                                                 Person,
  102.                                                 on_delete=models.CASCADE,
  103.                                                 related_name="membership_invites",
  104.                                             )
  105.                                             invite_reason = models.CharField(max_length=64)
  106.         db_constraint=True,         # 是否在数据库中创建外键约束
  107.         db_table=None,              # 默认创建第三张表时，数据库中表的名称

字段以及参数

三.  表操作

　　1. 基本操作

  1.  # 增
  2.     #
  3.     # models.Tb1.objects.create(c1='xx', c2='oo')  增加一条数据，可以接受字典类型数据 **kwargs
  4.  
  5.     # obj = models.Tb1(c1='xx', c2='oo')
  6.     # obj.save()
  7.  
  8.     # 查
  9.     #
  10.     # models.Tb1.objects.get(id=123)         # 获取单条数据，不存在则报错（不建议）
  11.     # models.Tb1.objects.all()               # 获取全部
  12.     # models.Tb1.objects.filter(name='seven') # 获取指定条件的数据
  13.  
  14.     # 删
  15.     #
  16.     # models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据
  17.  
  18.     # 改
  19.     # models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新，均支持 **kwargs
  20.     # obj = models.Tb1.objects.get(id=1)
  21.     # obj.c1 = '111'
  22.     # obj.save()                                                 # 修改单条数据

　　2. 进阶操作(上下滑线滑线)

　　　　利用上下滑线将字段和对应的操作连接起来

  1. # 获取个数
  2.         #
  3.         # models.Tb1.objects.filter(name='seven').count()
  4.  
  5.         # 大于，小于
  6.         #
  7.         # models.Tb1.objects.filter(id__gt=1)              # 获取id大于1的值
  8.         # models.Tb1.objects.filter(id__gte=1)              # 获取id大于等于1的值
  9.         # models.Tb1.objects.filter(id__lt=10)             # 获取id小于10的值
  10.         # models.Tb1.objects.filter(id__lte=10)             # 获取id小于10的值
  11.         # models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
  12.  
  13.         # in
  14.         #
  15.         # models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
  16.         # models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
  17.  
  18.         # isnull
  19.         # Entry.objects.filter(pub_date__isnull=True)
  20.  
  21.         # contains
  22.         #
  23.         # models.Tb1.objects.filter(name__contains="ven")
  24.         # models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
  25.         # models.Tb1.objects.exclude(name__icontains="ven")
  26.  
  27.         # range
  28.         #
  29.         # models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
  30.  
  31.         # 其他类似
  32.         #
  33.         # startswith，istartswith, endswith, iendswith,
  34.  
  35.         # order by
  36.         #
  37.         # models.Tb1.objects.filter(name='seven').order_by('id')    # asc
  38.         # models.Tb1.objects.filter(name='seven').order_by('-id')   # desc
  39.  
  40.         # group by
  41.         #
  42.         # from django.db.models import Count, Min, Max, Sum
  43.         # models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
  44.         # SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id"
  45.  
  46.         # limit 、offset
  47.         #
  48.         # models.Tb1.objects.all()[10:20]
  49.  
  50.         # regex正则匹配，iregex 不区分大小写
  51.         #
  52.         # Entry.objects.get(title__regex=r'^(An?|The) +')
  53.         # Entry.objects.get(title__iregex=r'^(an?|the) +')
  54.  
  55.         # date
  56.         #
  57.         # Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
  58.         # Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1))
  59.  
  60.         # year
  61.         #
  62.         # Entry.objects.filter(pub_date__year=2005)
  63.         # Entry.objects.filter(pub_date__year__gte=2005)
  64.  
  65.         # month
  66.         #
  67.         # Entry.objects.filter(pub_date__month=12)
  68.         # Entry.objects.filter(pub_date__month__gte=6)
  69.  
  70.         # day
  71.         #
  72.         # Entry.objects.filter(pub_date__day=3)
  73.         # Entry.objects.filter(pub_date__day__gte=3)
  74.  
  75.         # week_day
  76.         #
  77.         # Entry.objects.filter(pub_date__week_day=2)
  78.         # Entry.objects.filter(pub_date__week_day__gte=2)
  79.  
  80.         # hour
  81.         #
  82.         # Event.objects.filter(timestamp__hour=23)
  83.         # Event.objects.filter(time__hour=5)
  84.         # Event.objects.filter(timestamp__hour__gte=12)
  85.  
  86.         # minute
  87.         #
  88.         # Event.objects.filter(timestamp__minute=29)
  89.         # Event.objects.filter(time__minute=46)
  90.         # Event.objects.filter(timestamp__minute__gte=29)
  91.  
  92.         # second
  93.         #
  94.         # Event.objects.filter(timestamp__second=31)
  95.         # Event.objects.filter(time__second=2)
  96.         # Event.objects.filter(timestamp__second__gte=31)

　　3. 其他操作

  1. # extra
  2.     #
  3.     # extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
  4.     #    Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,))
  5.     #    Entry.objects.extra(where=['headline=%s'], params=['Lennon'])
  6.     #    Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"])
  7.     #    Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid'])
  8.  
  9.     # F
  10.     #
  11.     # from django.db.models import F
  12.     # models.Tb1.objects.update(num=F('num')+1)
  13.  
  14.     # Q
  15.     #
  16.     # 方式一：
  17.     # Q(nid__gt=10)
  18.     # Q(nid=8) | Q(nid__gt=10)
  19.     # Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')
  20.     # 方式二：
  21.     # con = Q()
  22.     # q1 = Q()
  23.     # q1.connector = 'OR'
  24.     # q1.children.append(('id', 1))
  25.     # q1.children.append(('id', 10))
  26.     # q1.children.append(('id', 9))
  27.     # q2 = Q()
  28.     # q2.connector = 'OR'
  29.     # q2.children.append(('c1', 1))
  30.     # q2.children.append(('c1', 10))
  31.     # q2.children.append(('c1', 9))
  32.     # con.add(q1, 'AND')
  33.     # con.add(q2, 'AND')
  34.     #
  35.     # models.Tb1.objects.filter(con)
  36.  
  37.     # 执行原生SQL
  38.     #
  39.     # from django.db import connection, connections
  40.     # cursor = connection.cursor()  # cursor = connections['default'].cursor()
  41.     # cursor.execute("""SELECT * from auth_user where id = %s""", [1])
  42.     # row = cursor.fetchone()

　　4. 连表操作

　　　　利用下划线和_set将表之间的操作连接起来

  1. class UserProfile(models.Model):
  2.     user_info = models.OneToOneField('UserInfo')
  3.     username = models.CharField(max_length=64)
  4.     password = models.CharField(max_length=64)
  5.  
  6.     def __unicode__(self):
  7.         return self.username
  8.  
  9. class UserInfo(models.Model):
  10.     user_type_choice = (
  11.         (0, u'普通用户'),
  12.         (1, u'高级用户'),
  13.     )
  14.     user_type = models.IntegerField(choices=user_type_choice)
  15.     name = models.CharField(max_length=32)
  16.     email = models.CharField(max_length=32)
  17.     address = models.CharField(max_length=128)
  18.  
  19.     def __unicode__(self):
  20.         return self.name
  21.  
  22. class UserGroup(models.Model):
  23.  
  24.     caption = models.CharField(max_length=64)
  25.  
  26.     user_info = models.ManyToManyField('UserInfo')
  27.  
  28.     def __unicode__(self):
  29.         return self.caption
  30.  
  31. class Host(models.Model):
  32.     hostname = models.CharField(max_length=64)
  33.     ip = models.GenericIPAddressField()
  34.     user_group = models.ForeignKey('UserGroup')
  35.  
  36.     def __unicode__(self):
  37.         return self.hostname

表结构实例

  1. user_info_obj = models.UserInfo.objects.filter(id=1).first()
  2. print user_info_obj.user_type
  3. print user_info_obj.get_user_type_display()
  4. print user_info_obj.userprofile.password
  5.  
  6. user_info_obj = models.UserInfo.objects.filter(id=1).values('email', 'userprofile__username').first()
  7. print user_info_obj.keys()
  8. print user_info_obj.values()

一对一操作

  1. 类似一对一
  2. 1、搜索条件使用 __ 连接
  3. 2、获取值时使用 .    连接

一对多

  1. user_info_obj = models.UserInfo.objects.get(name=u'武沛齐')
  2. user_info_objs = models.UserInfo.objects.all()
  3.  
  4. group_obj = models.UserGroup.objects.get(caption='CEO')
  5. group_objs = models.UserGroup.objects.all()
  6.  
  7. # 添加数据
  8. #group_obj.user_info.add(user_info_obj)
  9. #group_obj.user_info.add(*user_info_objs)
  10.  
  11. # 删除数据
  12. #group_obj.user_info.remove(user_info_obj)
  13. #group_obj.user_info.remove(*user_info_objs)
  14.  
  15. # 添加数据
  16. #user_info_obj.usergroup_set.add(group_obj)
  17. #user_info_obj.usergroup_set.add(*group_objs)
  18.  
  19. # 删除数据
  20. #user_info_obj.usergroup_set.remove(group_obj)
  21. #user_info_obj.usergroup_set.remove(*group_objs)
  22.  
  23. # 获取数据
  24. #print group_obj.user_info.all()
  25. #print group_obj.user_info.all().filter(id=1)
  26.  
  27. # 获取数据
  28. #print user_info_obj.usergroup_set.all()
  29. #print user_info_obj.usergroup_set.all().filter(caption='CEO')
  30. #print user_info_obj.usergroup_set.all().filter(caption='DBA')

多对多

　　扩展:

　　　　a.自定义上传

  1. def upload_file(request):
  2.     if request.method == "POST":
  3.         obj = request.FILES.get('fafafa')
  4.         f = open(obj.name, 'wb')
  5.         for chunk in obj.chunks():
  6.             f.write(chunk)
  7.         f.close()
  8.     return render(request, 'file.html')

　　　　b.Form上传文件实例

  1. class FileForm(forms.Form):
  2.     ExcelFile = forms.FileField()

from

  1. from django.db import models
  2.  
  3. class UploadFile(models.Model):
  4.     userid = models.CharField(max_length = 30)
  5.     file = models.FileField(upload_to = './upload/')
  6.     date = models.DateTimeField(auto_now_add=True)

Model

  1. def UploadFile(request):
  2.     uf = AssetForm.FileForm(request.POST,request.FILES)
  3.     if uf.is_valid():
  4.             upload = models.UploadFile()
  5.             upload.userid = 1
  6.             upload.file = uf.cleaned_data['ExcelFile']
  7.             upload.save()
  8.  
  9.             print upload.file

四. ORM

　　1. ORM的对应关系

　　　　类 -> 表

　　　　对象 -> 记录(数据行)

　　　　属性 -> 字段

　　2. ORM操作

　　　　a. 查询

  1. 1. models.Publisher(既类名).objects.all()    #查询所有的数据 -> 对象列表
  2. 2. models.(类名).objects.get(条件)    #获取满足条件的一个对象 -> 单独的对象
  3. 3. models.(类名).objects.filter()    #获取满足条件的所有对象 -> 对象列表
  4. 4. models.(类名).objects.all().order_by('id')    排序　－＞对象列表
  5. 5. pub_obj(既主键对象的类名).pk    ->主键
  6. 6. pub_obj.name
  7. 7. 外键
  8.     book_obj(既设置了外键被的表的获取的对象).publisher    -> 关联的对象
  9.     book_obj.publisher_id    -> 从book表中获取关联对象的ID
  10.     book_obj.publisher.name    -> 关联的对象的属性
  11. 8. 多对多
  12.     author_obj.books    -> 管理对象
  13.     author_obj.books.all()    -> 关联的所有的对象 对象列表
  14.     book_obj.author_set    -> 管理对象

　　　　　　b.增加

  1. 1. models.Publisher.objects.create(name='xx')    -> 对象
  2. 2. 外键
  3.     models.Book.objects.create(name='xxx', publisher=pub_obj)
  4.     models.Book.objexts.create)name='xxx', publisher_id=pub_obj.id)
  5. 3. 多对多
  6.     models.Author.object.create(name='xxxx')    ->author_obj
  7.     author_obj.book.set([多个要关联的对象])
  8.     author_obj.book.set([多个要关联的对象的id])

　　　　　　c.删除

  1. 1. models.Author.objects.get(id=1).delete()
  2. 2. models.Author.objects.filter(id=1).delect()

　　　　　　d.修改

  1. 1. pub_obj.name='new_xxx'
  2. 2. pub_obj.save()
  3. 3. 外键
  4.     book_obj.title = 'xxx'
  5.     book_obj.publisher = pub_obj 或者book_obj.publisher_id=pub_obj.id
  6.     book_obj.save()
  7. 4. 多对多
  8.     author_obj.name='new_name'
  9.     author_obj.save()
  10.     author_obj.book.set([多个要关联对象]) 或 author_obj.book.set([多个要关联对象的id]) 
  1. from django.shortcuts import render,redirect,HttpResponse
  2. from cou_sele import models
  3. # Create your views here.
  4.  
  5. def classes(request):
  6.     all_class = models.Classes.objects.all().order_by('cid')
  7.     return render(request, 'class_list.html', {'all_class':all_class})
  8. def add_classes(request):
  9.     err_msg, obj = '', ''
  10.     if request.method == 'POST':
  11.         new_name = request.POST.get('classes_name')
  12.         if not new_name:
  13.             err_msg = '兄弟,空的啊'
  14.         obj = models.Classes.objects.filter(name='new_name')
  15.         if obj:
  16.             err_msg = '兄弟,重复了'
  17.         if new_name and not obj:
  18.             models.Classes.objects.create(name=new_name)
  19.             return redirect('/class_list')
  20.     return render(request, 'add_classes.html', {'err_msg':err_msg})
  21. def del_classes(request):
  22.     pk = request.GET.get('pk')
  23.     if not models.Classes.objects.filter(pk=pk):
  24.         return HttpResponse('数据不存在')
  25.     models.Classes.objects.get(pk=pk).delete()
  26.     return redirect('/class_list/')
  27. def edit_classes(request):
  28.     err_msg = ''
  29.     pk = request.GET.get('pk')
  30.     obj_list = models.Classes.objects.filter(pk=pk)
  31.     if not obj_list:
  32.         return HttpResponse("数据不存在")
  33.  
  34.     obj = obj_list[0]
  35.     if request.method == 'POST':
  36.         new_name = request.POST.get('classes_name')
  37.         if not new_name:
  38.             err_msg = '不能为空'
  39.         exist = models.Classes.objects.filter(name=new_name)
  40.         if exist:
  41.             err_msg = '已存在'
  42.         if new_name and not exist:
  43.             # 修改出版社的名称
  44.             obj.name = new_name
  45.             obj.save()  # 向数据库提交
  46.             return redirect('/class_list/')
  47.     return render(request, 'edit_classes.html', {'obj': obj, 'err_msg': err_msg})
  48.  
  49. def studet_list(request):
  50.     all_student = models.Student.objects.all()
  51.     return render(request, 'studet_list.html', {'all_student': all_student})
  52. def add_student(request):
  53.     err_msg, obj = '', ''
  54.     if request.method == 'POST':
  55.         new_name = request.POST.get('student_name')
  56.         if not new_name:
  57.             err_msg = '兄弟,空的啊'
  58.         obj = models.Classes.objects.filter(name='new_name')
  59.         if obj:
  60.             err_msg = '兄弟,重复了'
  61.         if new_name and not obj:
  62.             models.Classes.objects.create(name=new_name)
  63.             return redirect('/class_list')
  64.     all_class = models.Classes.objects.all()
  65.     return render(request, 'add_student.html', {'all_class': all_class, 'err_msg': err_msg})
  66. def del_student(request):
  67.     pk = request.GET.get('pk')
  68.     if not models.Classes.objects.filter(pk=pk):
  69.         return HttpResponse('数据不存在')
  70.     models.Classes.objects.get(pk=pk).delete()
  71.     return redirect('/student_list/')
  72. def edit_student(request):
  73.     err_msg = ''
  74.     pk = request.GET.get('pk')
  75.     student_obj = models.Student.objects.get(pk=pk)
  76.     if not student_obj:
  77.         return HttpResponse('数据不存在')
  78.     if request.method == 'POST':
  79.         new_name = request.POST.get('new_name')
  80.  
  81.         classes_id = request.POST.get('classes_id')
  82.         if not new_name:
  83.             err_msg = '不能为空'
  84.         exist = models.Student.objects.filter(name=new_name)
  85.         if exist:
  86.             err_msg = '你瞎啊, 已经有了'
  87.  
  88.         if new_name and not exist:
  89.             student_obj.name = new_name
  90.             student_obj.classes_id = classes_id
  91.             student_obj.save()
  92.             return redirect('/studet_list/')
  93.  
  94.     all_classes = models.Classes.objects.all()
  95.     return render(request, 'edit_student.html', {'err_msg': err_msg, 'student_obj': student_obj, 'all_classes':all_classes})
  96.  
  97. def teacher_list(request):
  98.     all_teacher = models.Teacher.objects.all()
  99.     all_student = models.Student.objects.all()
  100.     return render(request, 'teacher_list.html', {'all_teacher': all_teacher,'all_student':all_student})
  101. def add_teacher(request):
  102.     err_msg = ''
  103.     if request.method == 'POST':
  104.         new_name = request.POST.get('new_name')
  105.         student_ids = request.POST.getlist('stu')
  106.         if not new_name:
  107.             err_msg = '瞎啊,空的'
  108.         obj_new_name = models.Teacher.objects.filter(name=new_name)
  109.         if obj_new_name:
  110.             err_msg = '瞎啊,重复了'
  111.         if new_name and not obj_new_name:
  112.             author_obj = models.Teacher.objects.create(name=new_name)
  113.             author_obj.Student.set(student_ids)
  114.             return redirect('/teacher_list/')
  115.  
  116.     all_student = models.Student.objects.all()
  117.     return render(request, 'add_teacher.html', {'all_student': all_student, 'err_msg': err_msg})
  118. def del_teacher(request):
  119.     del_id = request.GET.get('pk')
  120.     models.Teacher.objects.get(pk = del_id).delete()
  121.     return redirect('/teacher_list/')
  122. def edit_teacher(request):
  123.         err_msg = ''
  124.         pk = request.GET.get('pk')
  125.         teacher_obj = models.Teacher.objects.get(pk=pk)
  126.         if request.method == 'POST':
  127.             name = request.POST.get('new_name')
  128.             student_ids = request.POST.getlist('student_id')
  129.             if not name:
  130.                 err_msg = '空的'
  131.             else:
  132.                 teacher_obj.name = name
  133.                 teacher_obj.save()
  134.                 teacher_obj.Student.set(student_ids)
  135.                 return redirect('/teacher_list/')
  136.  
  137.         all_student = models.Student.objects.all()
  138.  
  139.         return render(request, 'edit_teacher.html', {'err_msg':err_msg,'author_obj': teacher_obj, 'all_student': all_student})

实例

五. request
　　1. request.method　　->请求方式一共有8种 主要的有 GET/POST

　　2. request.GET　　-> url的参数 xxx/?id=1&name=konghui

　　　request.GET.get('id')

  1.  </thead>
  2.                             <tbody>
  3.                             {% for i in all_teacher %}
  4.                                 <tr>
  5.                                     <td>{{ forloop.counter }}</td>
  6.                                     <td>{{ i.pk }}</td>
  7.                                     <td>{{ i.name }}</td>
  8.                                     <td>
  9.                                         {% for book in i.Student.all %}
  10.                                             {{ book.name }}
  11.                                         {% endfor %}
  12.                                     </td>
  13.                                     <td>
  14.                                         <a class="btn btn-success btn-sm" href="/edit_teacher/?pk={{ i.pk }}">编辑</a>
  15.                                         <a class="btn btn-danger btn-sm" href="/del_teacher/?pk={{ i.pk }}">删除</a>
  16.                                     </td>
  17.                                 </tr>
  18.                             {% endfor %}

实例

　　3.request.POST　　-> form表单提交的POST的数据{}

六.函数的返回值

　　1. HttpRequest('字符串')　　-> 返回字符串　　

　　2. render(request, '模板的文件名', {k1:v1})　　-> 返回一个完整的页面

　　3. request.POST(/'跳转的地址'/)　　-> 重定向 响应头 location: '跳转的地址'

　　　　

　　　　

　　

Django - 表与ORM操作的更多相关文章

  1. Python/Django(CBV/FBV/ORM操作)

    Python/Django(CBV/FBV/ORM操作) CBV:url对应的类(模式) ##====================================CBV操作============ ...

  2. 初学Django基础02 ORM操作

    django的ORM操作 之前我们知道了models.py这个文件,这个文件是用来读取数据结构的文件,每次操作数据时都走这个模块 常用字段 AutoField int自增列,必须填入参数 primar ...

  3. Django 模型层 ORM 操作

    运行环境 1. Django:2.1.3 version 2. PyMysql: 0.9.3 version 3. pip :19.0.3 version 4. python : 3.7 versio ...

  4. Django专题之ORM操作2

    Django ORM操作   目录 一般操作 看专业的官网文档,做专业的程序员! 回到顶部 必知必会13条 <1> all(): 查询所有结果 <2> get(**kwargs ...

  5. Django项目的ORM操作之--数据模型类创建

    在django项目中,其自带了ORM(Object Relation Mapping)对象关系映射框架,我们在django项目下app的models模块下对类进行操作,通过ORM会将我们对类的操作转化 ...

  6. Django学习之ORM操作

    一.一般操作 二.必知必会13条 返回QuerySet对象的方法有 特殊的QuerySet 返回具体对象的 返回布尔值的方法有 返回数字的方法 三.单表查询之神奇的双下划线 四.ForeignKey操 ...

  7. Django项目的ORM操作之--模型类数据查询

    1.查询基本格式及理解: 类名.objects.[查询条件] 例如我们要查询数据库中一张表(bookinfo)的所有数据,sql语句为:select * from bookinfo, 对应模型类的操作 ...

  8. Django基础之ORM操作

    ################################################################## # PUBLIC METHODS THAT ALTER ATTRI ...

  9. Django:常见的orm操作

    ArticlePost模型对应的表如下: 1.查询两个日期之间2019.04.20到2019.04.25之间的文章 import datetime from.models import Article ...

随机推荐

  1. HDU2161 Primes

    /* HDU2161 Primes http://acm.hdu.edu.cn/showproblem.php?pid=2161 数论 水题 注意输入截止条件是n<=0 */ #include ...

  2. 【LeetCode-面试算法经典-Java实现】【033-Search in Rotated Sorted Array（在旋转数组中搜索）】

    [033-Search in Rotated Sorted Array(在旋转数组中搜索)] [LeetCode-面试算法经典-Java实现][全部题目文件夹索引] 原题 Suppose a sort ...

  3. SharePoint 2013 开启訪问请求

    1.通常,我们进入SharePoint 2013网站,假设没权限会提示该网站未被共享,而没有切换账号或者申请訪问,实在是非常流氓:事实上,SharePoint为我们提供了訪问请求页面.可是可能须要手动 ...

  4. DOMContentLoaded事件<zz>

    今天查看百度空间源代码,发现多了个util.js文件,打开看看.里面里面定义了addDOMLoadEvent.这是干什么用的? 仔细查看代码,发现在Mozilla添加了DOMContentLoaded ...

  5. EOJ 3018 查找单词

    有一个单词 W,输出它在字符串 S 中从左到右第一次出现的位置 IDX(设 S 中的第 1 个字符的位置为 1).W 只由英文字母组成,S 除英文字母和汉字之外在任何位置(包括头和尾)另有一个或多个连 ...

  6. Java-MyBatis-杂项： MyBatis 中 in 的用法2

    ylbtech-Java-MyBatis-杂项: MyBatis 中 in 的用法2 1.返回顶部 1. 一.简介 在SQL语法中如果我们想使用in的话直接可以像如下一样使用: select * fr ...

  7. 杂项-Java：Spring Cloud

    ylbtech-杂项-Java:Spring Cloud Spring Cloud是一系列框架的有序集合.它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务发现注册. ...

  8. mysql(8.0.*版本 windows10 )忘记密码解决方案

    安装完mysql-8.0.13-winx64后,一些列的安装命令过后再执行mysql -uroot -p之后 报错了 what fuck 什么鬼,就是这个错 ERROR (): Access deni ...

  9. 整理windows相关软件的环境变量

    java: JAVA_HOME    [安装java的home目录] PATH              [在最后添加] ;%JAVA_HOME%\bin; CLASSPATH    [文本框的起始位 ...

  10. 基于Redis实现分布式应用限流--转

    原文地址:https://my.oschina.net/giegie/blog/1525931 摘要: 限流的目的是通过对并发访问/请求进行限速或者一个时间窗口内的的请求进行限速来保护系统,一旦达到限 ...