文档章节

【学以致用】Django之ORM总结

Asktao
 Asktao
发布于 2017/05/31 15:16
字数 3588
阅读 34
收藏 1

一、创建表

  1. 基本结构

    from django.db import models
       
    class userinfo(models.Model):
        name = models.CharField(max_length=30)
        email = models.EmailField()
        memo = models.TextField()

     

    1. 字段
       AutoField(Field)
              - int自增列,必须填入参数 primary_key=True
      
          BigAutoField(AutoField)
              - bigint自增列,必须填入参数 primary_key=True
      
              注:当model中如果没有自增列,则自动会创建一个列名为id的列
              from django.db import models
      
              class UserInfo(models.Model):
                  # 自动创建一个列名为id的且为自增的整数列
                  username = models.CharField(max_length=32)
      
              class Group(models.Model):
                  # 自定义自增列
                  nid = models.AutoField(primary_key=True)
                  name = models.CharField(max_length=32)
      
          SmallIntegerField(IntegerField):
              - 小整数 -32768 ~ 32767
      
          PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
              - 正小整数 0 ~ 32767
          IntegerField(Field)
              - 整数列(有符号的) -2147483648 ~ 2147483647
      
          PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
              - 正整数 0 ~ 2147483647
      
          BigIntegerField(IntegerField):
              - 长整型(有符号的) -9223372036854775808 ~ 9223372036854775807
      
          自定义无符号整数字段
      
              class UnsignedIntegerField(models.IntegerField):
                  def db_type(self, connection):
                      return 'integer UNSIGNED'
      
              PS: 返回值为字段在数据库中的属性,Django字段默认的值为:
                  'AutoField': 'integer AUTO_INCREMENT',
                  'BigAutoField': 'bigint AUTO_INCREMENT',
                  'BinaryField': 'longblob',
                  'BooleanField': 'bool',
                  'CharField': 'varchar(%(max_length)s)',
                  'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
                  'DateField': 'date',
                  'DateTimeField': 'datetime',
                  'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
                  'DurationField': 'bigint',
                  'FileField': 'varchar(%(max_length)s)',
                  'FilePathField': 'varchar(%(max_length)s)',
                  'FloatField': 'double precision',
                  'IntegerField': 'integer',
                  'BigIntegerField': 'bigint',
                  'IPAddressField': 'char(15)',
                  'GenericIPAddressField': 'char(39)',
                  'NullBooleanField': 'bool',
                  'OneToOneField': 'integer',
                  'PositiveIntegerField': 'integer UNSIGNED',
                  'PositiveSmallIntegerField': 'smallint UNSIGNED',
                  'SlugField': 'varchar(%(max_length)s)',
                  'SmallIntegerField': 'smallint',
                  'TextField': 'longtext',
                  'TimeField': 'time',
                  'UUIDField': 'char(32)',
      
          BooleanField(Field)
              - 布尔值类型
      
          NullBooleanField(Field):
              - 可以为空的布尔值
      
          CharField(Field)
              - 字符类型
              - 必须提供max_length参数, max_length表示字符长度
      
          TextField(Field)
              - 文本类型
      
          EmailField(CharField):
              - 字符串类型,Django Admin以及ModelForm中提供验证机制
      
          IPAddressField(Field)
              - 字符串类型,Django Admin以及ModelForm中提供验证 IPV4 机制
      
          GenericIPAddressField(Field)
              - 字符串类型,Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
              - 参数:
                  protocol,用于指定Ipv4或Ipv6, 'both',"ipv4","ipv6"
                  unpack_ipv4, 如果指定为True,则输入::ffff:192.0.2.1时候,可解析为192.0.2.1,开启刺功能,需要protocol="both"
      
          URLField(CharField)
              - 字符串类型,Django Admin以及ModelForm中提供验证 URL
      
          SlugField(CharField)
              - 字符串类型,Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符(减号)
      
          CommaSeparatedIntegerField(CharField)
              - 字符串类型,格式必须为逗号分割的数字
      
          UUIDField(Field)
              - 字符串类型,Django Admin以及ModelForm中提供对UUID格式的验证
      
          FilePathField(Field)
              - 字符串,Django Admin以及ModelForm中提供读取文件夹下文件的功能
              - 参数:
                      path,                      文件夹路径
                      match=None,                正则匹配
                      recursive=False,           递归下面的文件夹
                      allow_files=True,          允许文件
                      allow_folders=False,       允许文件夹
      
          FileField(Field)
              - 字符串,路径保存在数据库,文件上传到指定目录
              - 参数:
                  upload_to = ""      上传文件的保存路径
                  storage = None      存储组件,默认django.core.files.storage.FileSystemStorage
      
          ImageField(FileField)
              - 字符串,路径保存在数据库,文件上传到指定目录
              - 参数:
                  upload_to = ""      上传文件的保存路径
                  storage = None      存储组件,默认django.core.files.storage.FileSystemStorage
                  width_field=None,   上传图片的高度保存的数据库字段名(字符串)
                  height_field=None   上传图片的宽度保存的数据库字段名(字符串)
      
          DateTimeField(DateField)
              - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
      
          DateField(DateTimeCheckMixin, Field)
              - 日期格式      YYYY-MM-DD
      
          TimeField(DateTimeCheckMixin, Field)
              - 时间格式      HH:MM[:ss[.uuuuuu]]
      
          DurationField(Field)
              - 长整数,时间间隔,数据库中按照bigint存储,ORM中获取的值为datetime.timedelta类型
      
          FloatField(Field)
              - 浮点型
      
          DecimalField(Field)
              - 10进制小数
              - 参数:
                  max_digits,小数总长度
                  decimal_places,小数位长度
      
          BinaryField(Field)
              - 二进制类型

       

    2. 参数
          null                数据库中字段是否可以为空
          db_column           数据库中字段的列名
          db_tablespace
          default             数据库中字段的默认值
          primary_key         数据库中字段是否为主键
          db_index            数据库中字段是否可以建立索引
          unique              数据库中字段是否可以建立唯一索引
          unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
          unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
          unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
      
          verbose_name        Admin中显示的字段名称
          blank               Admin中是否允许用户输入为空
          editable            Admin中是否可以编辑
          help_text           Admin中该字段的提示信息
          choices             Admin中显示选择框的内容,用不变动的数据放在内存中从而避免跨表操作
                              如:gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
      
          error_messages      自定义错误信息(字典类型),从而定制想要显示的错误信息;
                              字典健:null, blank, invalid, invalid_choice, unique, and unique_for_date
                              如:{'null': "不能为空.", 'invalid': '格式错误'}
      
          validators          自定义错误验证(列表类型),从而定制想要的验证规则
                              from django.core.validators import RegexValidator
                              from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
                              MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                              如:
                                  test = models.CharField(
                                      max_length=32,
                                      error_messages={
                                          'c1': '优先错信息1',
                                          'c2': '优先错信息2',
                                          'c3': '优先错信息3',
                                      },
                                      validators=[
                                          RegexValidator(regex='root_\d+', message='错误了', code='c1'),
                                          RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
                                          EmailValidator(message='又错误了', code='c3'), ]
                                  )

       

    3. 元信息
          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/
    4. 拓展知识
         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(其他表)
        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中是否显示关联数据

     

  • 多对多:models.ManyToManyField(其他表)
        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)

     

  • 一对一:models.OneToOneField(其他表)
        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,              # 默认创建第三张表时,数据库中表的名称

     

应用场景:

  • 一对多:当一张表中创建一行数据时,有一个单选的下拉框(可以被重复选择)
    例如:创建用户信息时候,需要选择一个用户类型【普通用户】【金牌用户】【铂金用户】等。
  • 多对多:在某表中创建一行数据是,有一个可以多选的下拉框
    例如:创建用户信息,需要为用户指定多个爱好
  • 一对一:在某表中创建一行数据时,有一个单选的下拉框(下拉框中的内容被用过一次就消失了
    例如:原有含10列数据的一张表保存相关信息,经过一段时间之后,10列无法满足需求,需要为原来的表再添加5列数据

二、操作表

  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()                                                 # 修改单条数据
  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等于11、22、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. 其他操作
        # 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()
  4. 连表操作(了不起的双下划线)
    利用双下划线和 _set 将表之间的操作连接起来

    1. 表结构实例

      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
    2. 一对一操作

      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()

       

    3. 一对多

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

       

    4. 多对多操作

      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')
    5. 扩展

      1. 自定义上传

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

         

      2. Form上传文件实例

        1. Form

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

           

        2. Model

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

           

        3. View

          def UploadFile(request):
              uf = AssetForm.FileForm(request.POST,request.FILES)
              if uf.is_valid():
                      upload = models.UploadFile()
                      upload.userid = 1
                      upload.file = uf.cleaned_data['ExcelFile']
                      upload.save()
                      
                      print upload.file

           

 

 

 

 

 

 

© 著作权归作者所有

共有 人打赏支持
Asktao
粉丝 27
博文 92
码字总数 111183
作品 0
丰台
程序员
私信 提问
【精华】【学以致用】Django精华总结

简单入门和梳理 1、WEB框架 MVC Model View Controller 数据库 模板文件 业务处理 MTV Model Template View 数据库 模板文件 业务处理 ############## WEB:MVC、MTV 2、Django #安装 pip3 i...

Asktao
2017/10/31
0
0
『Django ORM』完整总结

由于官方文档一般讲究『平均发力,面面俱到』,虽然内容是详细,但是对于初学者往往是『不知轻重,找不着北』。本文试图总结一些 Django ORM 中比较常用的东西,力求覆盖全面,实现『花20%的...

浮生若梦的编程
10/30
0
0
Django基于ORM操作数据库的方法详解

本文实例讲述了Django基于ORM操作数据库的方法。分享给大家供大家参考,具体如下: 1、配置数据库 vim settings #HelloWorld/HelloWorld目录下 DATABASES = {'default': { },'article': { }...

萌萌小白
04/25
0
0
Django ORM模型:想说爱你不容易

使用Python的Django模型的话,一般都会用它自带的ORM(Object-relational mapping)模型。这个ORM模型的设计比较简单,学起来不会特别花时间。不过,Django的ORM模型有自己的一套语法,有时候...

余凯力
2017/06/19
0
0
Django数据管理和配置后台系统 - DjangoX

DjangoX 强大灵活的Django数据管理和配置后台系统 依托于实际项目和生产环境互联网产品的总结积累,继承和扩展Xadmin,DjangoX 努力做 Django 框架的优秀实践项目。 特性 经过生产环境大数据...

Jone.x
2016/06/03
0
7

没有更多内容

加载失败,请刷新页面

加载更多

《资治通鉴》读书笔记及阅读感悟2200字

《资治通鉴》读书笔记及阅读感悟2200字: 1.用夏桀,商纣暴虐昏君和商汤,周武王仁德明君做比较,因为人民归心,上天赐名要不然就永远要恪守臣节至死不渝。 又用商朝的微子取代纣王,商朝可以...

原创小博客
7分钟前
0
0
十万个为什么之为什么大家都说dubbo

Dubbo是什么? 使用背景 dubbo为什么这么流行, 为什么大家都这么喜欢用dubbo; 通过了解分布式开发了解到, 为适应访问量暴增,业务拆分后, 子应用部署在多台服务器上,而多台服务器通过可以通过d...

尾生
46分钟前
2
0
Docker搭建代码质量检测平台-SonarQube(中文版)

Sonar是一个用于代码质量管理的开源平台,用于管理源代码的质量,可以从七个维度检测代码质量。通过插件形式,可以支持包括java,C#,C/C++,PL/SQL,Cobol,JavaScrip,Groovy等等二十几种编程语言...

Jacktanger
52分钟前
2
0
Windows / Linux / MacOS 设置代理上网的方法汇总

本文汇总了 Windows / Linux / MacOS 设置代理上网的各种方法,总结如下: 1、设置系统代理(Windows、Linux、MacOS) 2、设置代理插件(Chrome、Chromium、Firefox、Opera、QQ等浏览器) 3、...

sunboy2050
昨天
4
0
自定义 Maven 的 repositories

有时,应用中需要一些比较新的依赖,而这些依赖并没有正式发布,还是处于milestone或者是snapshot阶段,并不能从中央仓库或者镜像站上下载到。此时,就需要 自定义Maven的<repositories>。 ...

waylau
昨天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部