django models 数据库操作

创建模型

实例代码如下

from django.db import models

class School(models.Model):

 pass

class Message(models.Model):

 pass

class Teacher(models.Model):

 pass

 class Student(models.Model):

 GENDER_CHOICES = (

  ('male', "男"),

  ('female', "女"),

  ('secret', "保密")

 )

 name = models.CharField(max_length=40, blank=True, verbose_name="姓名")

 gender = models.CharField(max_length=6, choices=GENDER_CHOICES, default="secret", verbose_name="性别")

 age = models.IntegerField(default=0, verbose_name="年龄")

 rank = models.PositiveIntegerField(default=1, verbose_name="排名", unique=True)

 discount = models.DecimalField(max_digits=3, decimal_places=2, verbose_name="折扣", default=1.0)

 school = models.ForeignKey(to=School, verbose_name="学校", on_delete=models.CASCADE)

 message = models.OneToOneField(to=Message, verbose_name="信息", on_delete=models.CASCADE)

 teacher = models.ManyToManyField(verbose_name="老师", to=Teacher, blank=True)

 introduce = models.TextField(blank=True, verbose_name="介绍")

 grade = models.FloatField(default=0.0, verbose_name="成绩")

 url = models.URLField(verbose_name="个人主页", max_length=100)

 email = models.EmailField(verbose_name="邮箱")

 image = models.ImageField(upload_to='img/%Y/%m/%d/', verbose_name='上传图片', null=True)

 file = models.FileField(upload_to="file/%Y/%m/%d/", verbose_name="上传文件", blank=True)

 is_deleted = models.BooleanField(verbose_name="已删除", default=False, blank=True)

 time_added = models.DateTimeField(verbose_name="添加时间", auto_now_add=True, blank=True)

 def delete(self, using=None, keep_parents=False):

  self.is_deleted = True

  # some actions

  self.save()

 def save(self, force_insert=False, force_update=False, using=None,

    update_fields=None):

  # some actions

  self.name = self.name.capitalize() # 首字母大写

  return super().save(force_insert=force_insert, force_update=force_update, using=using,

       update_fields=update_fields)

 def __repr__(self):

  return "UserProfile:{}".format(self.name)

 def __str__(self):

  return self.name

 class Meta:

  ordering = ['-time_added']

# 对象的默认排序字段，获取对象列表时使用，升序ordering['time_added']，降序ordering['-time_added']

  verbose_name = "用户信息"

  verbose_name_plural = verbose_name

  db_table = "student_info"

字段类型

一般数据库中字段类型大概5种(字符串/数字/浮点型/时间类型/布尔类型)，但Django为了在后台admin中可以操作数据库，同时为了限制在admin中对数据库的无效操作，Model中设置了很多种数据类型。

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 文件

CharField（max_length） 字符串

    max_length:长度

BooleanField：布尔类型

DateField: 年月日，日期

DateTimeField：年月日 时分秒

    auto_now_add： 第一次创建的时候赋值

    auto_now：每次修改的时候赋值

AutoField：自动增长

IntegerField 整数

FloatField 浮点数

FileField() 文件

ImageField(upload_to=)  upload_to='' 指定上传图片的路径

models.TextField 存文本信息

models.DecimalField(max_digits=3, decimal_places=1) 固定精度

max_digits 总位数 decimal_places 小数后几位

模型参数

default: 默认

null ：设置是否为空，针对数据库中该字段是否可以为空

blank ：设置是否为空，针对表单提交该字段是否可以为空

primary_key：创建主键

unique：唯一

blank:

当blank=True时，说明此处的数据可以不填，默认情况下为False,也就意味着默认情况下，所输入的数据不得空，blank是和页面表单有关，在页面需要输入参数的时候，如果在models里面定义了blank=True时，那么这个参数是可以不填写的，如果是默认的话，如果没有填写，则会提示错误。

null:

当null=True时，也就是说如果没有填写数据，此处用NULL来储存空值，默认的是null=False。

总结：

blank主要是用在CharField, TextField,这两个字符型字段可以用空字符穿来储存空值。

null主要是用在IntegerField，DateField, DateTimeField,这几个字段不接受空字符串，所以在使用时，必须将blank和null同时赋值为True。

顺便一提，在设置BooleanField为空时，可以使用NullBooleanField型字段。


使用实例

null=True,blank=True,unique=True,primary_key=True

# id = models.AutoField(primary_key=True)  (id 不用写，django会自动生成一个id属性)

字段中的参数详解：

    null                数据库中字段是否可以为空（null=True）

    db_column           数据库中字段的列名(db_column="test")

    db_tablespace

    default             数据库中字段的默认值

    primary_key         数据库中字段是否为主键(primary_key=True)

    db_index            数据库中字段是否可以建立索引(db_index=True)

    unique              数据库中字段是否可以建立唯一索引(unique=True)

    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引

    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引

    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

    auto_now            更新时自动更新当前时间
    auto_now_add        创建时自动更新当前时间

    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'), ]

                            )

message = models.OneToOneField(to=Message, verbose_name="信息", on_delete=models.CASCADE)

OneToOneField的第一个参数是被关联的模型的名称，第二个参数表示级联删除，这个已经在之前的博客里面讲过了，当Message数据表里面的数据被删除后Student里面的数据也随着被删除

模型操作

模型成员objects

Django默认通过模型的object对象实现模型数据查询

1. 模型查询

过滤器

查询集表示从数据库获取的对象集合

查询集可以有多个过滤器

过滤器就是一个函数，基于所给的参数限制查询的结果

从SQL角度来说，查询集合和select语句等价，过滤器就像where条件

Django有两种过滤器用于筛选记录 filter : 返回符合筛选条件的数据集 exclude : 返回不符合筛选条件的数据集

多个filter和exclude可以连接在一起查询

当然还有如下这些过滤器: all() 返回所有数据 filter() 返回符合条件的数据 exclude() 过滤掉符合条件的数据 order_by() 排序 values() 一条数据就是一个字典，返回一个列表

1. 查询单个数据

get()：返回一个满足条件的对象。如果没有返回符合条件的对象，会应该模型类DoesNotExist异常，如果找到多个，会引发模型类MultiObjectsReturned异常

entry = Entry.objects.get(pk=1)

cheese_blog = Blog.objects.get(name="Cheddar Talk")

first()：返回查询集中的第一个对象

obj = models.User.objects.filter(username='yang', password='').first()

print(obj.username)

print(obj.password)

last()：返回查询集中的最后一个对象

count()：返回当前查询集中的对象个数

exists()：判断查询集中是否有数据，如果有数据返回True，没有返回False

2. 限制查询集

限制查询集，可以使用下表的方法进行限制，等同于sql中的limit

模型名.objects.all()[0:5] 小标不能为负数

3. 字段查询

对sql中的where实现，作为方法，filter(),exclude()，get()的参数

语法：属性名称__比较运算符 = 值

外键：属性名_id

注意：like语句中使用%表示通配符。比如sql语句查询 where name like '%xxx%'，等同于filter(name_contains='xxx')

4. 比较运算符

contains：是否包含，大小写敏感 startswith，endswith：以values开头或者结尾，大小写敏感以上的运算符前加上i(ignore)就不区分大小写了

isnull，isnotnull：是否为空。filter(name__isnull=True)

in：是否包含在范围内。filter(id__in=[1,2,3])

gt，gte，lt，lte：大于，大于等于，小于，小于等于。filter(age__gt=10)

pk：代表主键，也就是id。filter(pk=1)

5. 聚合函数

ggregate()函数返回聚合函数的值

Avg：平均值

Count：数量

Max：最大

Min：最小

Sum：求和

例如: Student.objects.aggregate(Max('age'))

6. F对象/Q对象

F对象:可以使用模型的A属性与B属性进行比较背景:在模型中有两个字段，分别表示学生成绩A与成绩B，要对成绩AB进行比较计算，就需要使用到F对象。例如有如下例子，班级中有女生个数字段以及男生个数字段，统计女生数大于男生数的班级可以如下操作: grades = Grade.objects.filter(girlnum__gt=F('boynum'))

F对象支持算数运算

grades = Grade.objects.filter(girlnum__gt=F('boynum') + 10)

Q对象: Q()对象就是为了将过滤条件组合起来

当我们在查询的条件中需要组合条件时(例如两个条件“且”或者“或”)时。我们可以使用Q()查询对象

使用符号&或者|将多个Q()对象组合起来传递给filter()，exclude()，get()等函数

Q()对象的前面使用字符“~”来代表意义“非”

例如查询，学生中不是12岁的或者姓名叫张三的学生，可以如下操作: student = Student.objects.filter(~Q(age=12) | Q(name='张三')) django 模型（model）

模型的对应关系

1：1 一对一 OneToOneField 1：N 一对多 ForeignKey M：N 多对多 ManyToManyField 常见的几种数据关系，django都提供了很好的支持

1. 一对一

1.1 模型

创建学生的模型：

    class Student(models.Model):

        stu_name = models.CharField(max_length=6, unique=True)

        stu_sex = models.BooleanField(default=0)

        stu_birth = models.DateField()

        stu_delete = models.BooleanField(default=0)

        stu_create_time = models.DateField(auto_now_add=True)

        stu_operate_time = models.DateField(auto_now=True)

        stu_tel = models.CharField(max_length=11)

        stu_yuwen = models.DecimalField(max_digits=3, decimal_places=1, default=0)

        stu_shuxue = models.DecimalField(max_digits=3, decimal_places=1, default=0)

        class Meta:

            db_table = 'stu'

    创建学生拓展的模型：

    class StuInfo(models.Model):

        stu_addr = models.CharField(max_length=30)

        stu_age = models.IntegerField()

        stu = models.OneToOneField(Student)

        class Meta:

            db_table = 'stu_info'

使用models.OneToOneField()进行关联

class StuInfo(models.Model):下是通过班级获取学生信

    stu = models.OneToOneField(Student)

注意：在数据中关联字段名称叫stu_id

1.2 通过学生拓展表去获取学生信息

...

    stuinfo = StuInfo.objects.all().first()

    student = stuinfo.stu

...

注意：通过拓展表去获取学生的信息的话，语法如下；

    学生拓展表的单条对象.关联字段，即可获取到学生表的数据

1.3 通过学生获取人信息1

...

    stu = Student.objects.all().first()

    stuInfo = stu.stuInfo

...

注意：通过学生获取关联表的数据的话，语法如下：

    学生对象.关联的表名，即可获取到关联表的数据

1.3.1 通过学生获取人信息2

在关联字段OneToOneField中加入参数related_name='xxx'

stu = models.OneToOneField(Student，related_name='xxx')

...

    在

    stu = Student.objects.all().first()

    stuInfo = stu.xxx

...

注意：通过学生获取关联表的数据的话，语法如下：

    学生对象.关联的字段中定义的related_name参数，即可获取到关联表的数据

1.4 设置对应关系的字段为保护模式 :

models.CASCADE                      默认值

models.PROTECT                  保护模式

models.SET_NULL                 置空模式

models.SET_DETAULT          置默认值

models.SET()     删除的时候吃重新动态指向一个实体访问对象元素

on_delete = models.PROTECT

...

修改on_delete参数

models.OneToOneField('Student', on_delete=models.SET_NULL, null=True)

...

在删除student对象的时候，stuinfo的关联字段会设置为空null=True，如下命令去删除student的数据：

...

Student.objects.filter(id=1).delete()

...

1.5 定义on_delete=models.PROTECT

p =  Student.objects.all().first()

p.delete()

注意：这个时候去执行该业务逻辑的方法的时候会报错

2. 一对多

2.1 模型

...

    定义一个班级类还有学生类，实现一对多的关系：

    先定义班级类

    Class Grade(models.Model):

        g_name = models.CharField(max_length=16)

    定义student

        class Student:

            s_name = models.CharField(max_length=10)

            s_age = models.IntegerField(default=1)

            s_grade = models.ForeignKey(Grade, on_delete=PROTECT)

...

注意：使用models.ForeignKey关联 获取对象元素 grade.student_set

2.2 获取数据

语法：通过一获取多的数据

公式：一的对象.多的模型_set

然后在获取数据all(), get(), filter() 等等

如下先通过学生去获取班级信息：

 stu = Student.objects.first()

    stu.s_grade

如下是通过班级获取学生信息：

 g = Grade.objects.all().first()

    g.student_set.all()   ---> 其中stugrade是定义的related_name参数

重点：定义了related_name字段以后，只能通过related_name去反向获取数据，在也不能通过_set方法去获取数据了

2.3 性能对比

获取班级的学生(通过一获取多)

...

    1\. 低性能方法：

    g = Grade.objects.all().first()

    s = Student.objects.filter(s_grade=g)

    2\. 高性能方法：

    g = Grate.objects.all().first()

    s = g.student_set.all()

...

2.4 练习题

2.5 获取python班下的所有学生的信息

    gs = Grade.objects.filter(g_name='python')[0]

    allstu = gs.student_set.all()

2.6 获取python班下语文成绩大于80分的女学生

 gs = Grade.objects.filter(g_name='python')[0]

    allstu = gs.student_set.filter(stu_yuwen__gte=80)

2.7 获取python班下语文成绩超过数学成绩10分的男学生

gs = Grade.objects.filter(g_name='python')[0]

    allstu = gs.student_set.filter(stu_yuwen__gte=F('stu_shuxue') + 10)

2.8 获取出生在80后的男学生，查看他们的班级

 gs = Grade.objects.filter(g_name='python')[0]

    allstu = gs.student_set.filter(stu_birth__gte='1980-01-01', stu_birth__lte='1990-01-01')

3. 多对多

3.1 M:N 模型

定义购物车，用户的例子实现多对多：

...

1\. 创建用户模型: class GoodsUser(models.Model): u_name = models.CharField(max_length=32)

...

2\. 创建商品模型:

    class Goods(models.Model):

    g_name = models.CharField(max_length=32)

    g_user = models.ManyToManyField(User)

3.2 多对多表结构

多对多关系：

1\. 生成表的时候会多生成一张表（实际会有三张表）

2\. 生成的表是专门用来维护关系的

3\. 生成的表是使用两个外键来维护多对多的关系

4\. 两个一对多的关系来实现多对多的实现　　　

5\. 删除一个表的数据的话，中间关联表也要删除相关的信息

3.3 练习题

3.3.1 获取第一个用户购买了那些商品

...

    gu = GoodsUser.objects.all().first()

    allstu = gu.goods_set.all()

...

3.3.2 获取指定商品的购买用户信息

...

    g = Goods.objects.filter(id=1)[0]

    g.g_user.all()

...

1.增(create , save)：

    from app01.models import *

    #create方式一:   Author.objects.create(name='Alvin')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")

                    author.save()

    #save方式二:     author=Author()

                    author.name="alvin"

                    author.save()

update_or_create(defaults=None, **kwargs)

defaults 的值不同则创建，相同则更新

例

Member.objects.update_or_create(defaults={'user':1}, others={'field1':1,'field2':1})

#当存在user=1时，则更新，不存在则创建

# django get_or_create()如果有就取这个数据，如果没有就创建数据

2.删（delete）：

#正向    book = models.Book.objects.filter(id=1)

    #删除第三张表中和女孩1关联的所有关联信息

        book.author.clear()        #清空与book中id=1 关联的所有数据

        book.author.remove(2)  #可以为id

        book.author.remove(*[1,2,3,4])     #可以为列表,前面加*

    #反向

        author = models.Author.objects.filter(id=1)

        author.book_set.clear() #清空与boy中id=1 关联的所有数据

3.改（update和save）：

update方法直接设定对应属性

# models.Tb1.objects.filter(name='seven').update(gender='0')  # 将指定条件的数据更新，均支持 **kwargs

save方法会将所有属性重新设定一遍,效率低

  　　　　# obj = models.Tb1.objects.get(id=1)

        # obj.c1 = '111'

        # obj.save()                                                 # 修改单条数据

查询

# 获取个数

        #

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

class User(models.Model):

    username = models.CharField(max_length=32,unique=True)

    password = models.CharField(max_length=32)

    age = models.CharField(max_length=32)

    e_mail = models.EmailField()

    create_time = models.DateTimeField(auto_now_add=True)

    update_time = models.DateTimeField(auto_now=True)

    def __str__(self):

        return self.username

    class Meta:

        db_table = 'user'

        verbose_name = verbose_name_plural = '用户信息表'

# 保存

      user = models.User(username=usr, password=pas, age=age,e_mail= e_mail)

                user.save()

如图时间会自动存储

记得修改配置，要不然时间不是正确时间

遇到一个 def __str__(self): 是什么作用的问题，

如代码这样写

class User(models.Model):

    USER_TYPE = (

        (1, '普通用户'),

        (2, 'VIP'),

        (3, 'SVIP')

    )

    username = models.CharField(max_length=32,unique=True)

    password = models.CharField(max_length=32)

    age = models.CharField(max_length=32)

    e_mail = models.EmailField()

    user_type = models.IntegerField(choices=USER_TYPE)

    create_time = models.DateTimeField(auto_now_add=True)

    update_time = models.DateTimeField(auto_now=True)

    def __str__(self):

        return 'username: %s,password: %s' %(self.username,self.password)

        # return 'username: {},password: {}'.format(self.username, self.password)

    class Meta:

        db_table = 'user'

        verbose_name = verbose_name_plural = '用户信息表'

# 在终端中执行  python manage.py shell

# from api.models import User

# User.objects.get(id=1)

# 即可返回如下 信息，

# <User: username: wang,password: 123456>

如

class userToken(models.Model):

    user = models.OneToOneField(to='User',on_delete=models.DO_NOTHING)

    # 注意：在数据中关联字段名称叫user_id

    token = models.CharField(max_length=60)

    """定义每个数据对象的显示信息"""

    def __unicode__(self):      # return self.user   使用 def __str__(self):报错 ， 使用 __unicode__ 就 OK了。

        return  self.user

    """定义每个数据对象的显示信息"""

    # def __str__(self):

    #     return self.token     # 这个返回值是干什么的？ 这里 不能写 user 因为user 对应的是 user_id 是int 类型，服务端会报错。

    class Meta:

        db_table =  'userToken'

        verbose_name = verbose_name_plural = '用户token表'

# 在终端中执行  python manage.py shell

# from api.models import userToken

# userToken.objects.get(id=1)

# 即可返回如下 信息，

# <userToken: userToken object (1)>

如这样写

class userToken(models.Model):

    user = models.OneToOneField(to='User',on_delete=models.DO_NOTHING)

    # 注意：在数据中关联字段名称叫user_id

    token = models.CharField(max_length=60)

    """定义每个数据对象的显示信息"""

    def __unicode__(self):      # return self.user   使用 def __str__(self):报错 ， 使用 __unicode__ 就 OK了。

        return  self.user

    """定义每个数据对象的显示信息"""

    def __str__(self):

        return self.token     # 这个返回值是干什么的？ 这里 不能写 user 因为user 对应的是 user_id 是int 类型，服务端会报错。

    class Meta:

        db_table =  'userToken'

        verbose_name = verbose_name_plural = '用户token表'

# 在终端中执行  python manage.py shell

# from api.models import userToken

# userToken.objects.get(id=1)

# 即可返回如下 信息，

# <userToken: ffc992a78efd6a95c4dc93921a9fc128>

注意：django model中def __str__不能是int ，使用后会报错，如上代码注释。 def __unicode__(self): 则可以。

参考资料：https://code.ziqiangxuetang.com/django/django-queryset-api.html

巴特西

django models 数据库操作

django models 数据库操作

创建模型

模型参数

模型操作

模型成员objects

1. 模型查询

过滤器

1. 查询单个数据

2. 限制查询集

3. 字段查询

4. 比较运算符

5. 聚合函数

6. F对象/Q对象

模型的对应关系

1. 一对一

1.1 模型

1.2 通过学生拓展表去获取学生信息

1.3 通过学生获取人信息1

1.3.1 通过学生获取人信息2

1.4 设置对应关系的字段为保护模式 :

1.5 定义on_delete=models.PROTECT

2. 一对多

2.1 模型

2.2 获取数据

2.3 性能对比

2.4 练习题

2.5 获取python班下的所有学生的信息

2.6 获取python班下语文成绩大于80分的女学生

2.7 获取python班下语文成绩超过数学成绩10分的男学生

2.8 获取出生在80后的男学生，查看他们的班级

3. 多对多

3.1 M:N 模型

3.2 多对多表结构

3.3 练习题

3.3.1 获取第一个用户购买了那些商品

3.3.2 获取指定商品的购买用户信息

1.增(create , save)：

2.删（delete）：

3.改（update和save）：

最新文章

热门文章