精华内容
下载资源
问答
  • Django数据库一对多数据关系

    千次阅读 2017-10-10 19:24:08
    本文主要描述Django数据中一对一的数据关系,创建app等配置不再赘述。 Django操作数据库,使用ORM ORM:关系映射对象,把传统的...一对多关系是通过‘子表’中设置‘父表’的外键约束来完成关联 父表的一个数据对应

    本文主要描述Django数据中一对一的数据关系,创建app等配置不再赘述。

    Django操作数据库,使用ORM

    ORM:关系映射对象,把传统的SQL语句封装成了类和对象的形式,在操作表中的记录时,就像在操作类和对象一样。

    使用默认数据库:sqlite

    操作在models.py文件中完成。

    一对多数据关系:

    一对多关系是通过‘子表’中设置‘父表’的外键约束来完成关联

    父表的一个数据对应子表中的多个数据

    举例:班级和学生

    class Classes(models.Model):
        id = models.AutoField(primary_key=True)
        name = models.CharField(max_length=10, null=True)  # 班级名称
        num = models.IntegerField(null=True)  # 班级人数
    
        class Meta:
            db_table = 'Classes'
    
        def __unicode__(self):
            return 'classname:%s | classnum:%s' % (self.name, self.num)
    
    
    class Student(models.Model):
        id = models.AutoField(primary_key=True)
        # 关联‘父表’,设置外键
        classes = models.ForeignKey(Classes, on_delete=models.CASCADE)
        name = models.CharField(max_length=20, null=True)
        age = models.IntegerField(null=True)
    
        class Meta:
            db_table = 'Student'
    
        def __unicode__(self):
            return 'studentname:%s | studentage:%s' % (self.name, self.age)

    创建完数据库模型之后,我们要创建数据库变更文件以及应用表更文件等操作,具体操作步骤,参考上篇文章《Django数据库一对一数据关系》


    对数据表中数据的查询操作

    1)从子表中查询父表的数据

    print  s1.classes.num 学生在所在班级的总人数

    print s1.classes 学生所在班级的所有信息


    2)从父表中查询子表的相关数据

    1. 查询一个班级的所有学生,通过student_set属性查询

    print c1.student_set.all()

    2.filter:根据条件,去结果集中进行匹配查询

    print c1.student_set.filter(name='lisi')

    3. get :根据条件,去结果集中进行匹配查询

    print  c1.student_set.get(name='lisi')


    get()和filter()方法的区别

    get():只能查询出一个结果,如果查询的结果不止一个,name使用get()方法会报错

    filter():可以根据条件,匹配一组结果,得到一个结果集


    XXX.set :Django提供的用于通过主模型(父表)对象访问子模型(子表)对象集合的属性名。

    展开全文
  • 一对多的,多的那个类(Student)的对象(stu )中的,属性就是一的对象(class_room = ClassRoom.objects.get(id=6))这个属性就是在model中设置外间的那个属性】 stu.name = 'ssss' stu.phone = '1110' stu....

    one2one:model数据字段,最重要的就是设置外键 这个
    # 联系人作为主表
    class PersonModel(models.Model):

        name = models.CharField(max_length=20, verbose_name='姓名')
        phone = models.CharField(max_length=15, verbose_name='手机号')

        class Meta:
            db_table = 'person'

    class AccountModel(models.Model):

        # 一个账户对应一个联系人
        # models.CASCADE,当主表中的数据被删除时,从表数据一块删除
    ~~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        person = models.OneToOneField(PersonModel, on_delete=models.CASCADE)【在这列设置的外键,外间的关键词OneToOneField】
    ~~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        username = models.CharField(max_length=20, verbose_name='用户名')
        address = models.CharField(max_length=50, verbose_name='地址')

        class Meta:
            db_table = 'account'    

    one2one:添加!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    创建models中的数据类的对象
    主表:
    person = PersonModel()
    person.name = ‘赋予的值’
    person.phone = ‘赋予的值’
    person.save()
    从表:
    account = AccountModel()
    account.person = person[这里的’acount.person‘(这里的person就是model从表中设置的外键)属性对应的就是主表的一个对象]
    account.username = 'www'
        account.address = 'wwwww'
        account.save()
    one2one:查询!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    person = PersonModel.objects.get(id=3)
    account = person.accountmodel(是根据person在AccountModel中对应的一条数据)
    以上写法等同于这个:account = AccountModel.objects.get(person=person)
    某个属性的值就是   account.username   account.address

     account = AccountModel.objects.get(id=2)   找到account对象
    某个属性的值就是   account.username   account.address

     知道某张表中的某个条件,查询另外一张表中的所有数据
        # person = PersonModel.objects.get(name='www')
        # print(person.accountmodel.username)
        # print(person.accountmodel.address)

    person__name利用person表中name字段,查询account表中的数据
      account = AccountModel.objects.get(person__phone='110')
    print(account.username)

    {person = PersonModel.objects.get(accountmodel__username='qq')
        print(person.phone)
    }这个accountmodel是大写还是小写
    one2one:删除
    主表中的数据被删除后,从表数据一并删除
    PersonModel.objects.get(id=2).delete()
    account = AccountModel.objects.get(id=4)
    修改从中的person属性值,person值必须是person表中的一条没有被关联的数据
     # account.person =


    one2many
    # 一对多
    # 一个老师 对应多个学生
    # 一个班级 对应多个学生
    # 一个用户 对应多个收货地址
    class ClassRoom(models.Model):

        class_name = models.CharField(max_length=20, verbose_name='教室名称')
        class_addr = models.CharField(max_length=20, verbose_name='教室地址')

    class Teacher(models.Model):
        name = models.CharField(max_length=20, verbose_name='教师名称')

    class Student(models.Model):

       #### ######## ForeignKey 设置外键
        class_room = models.ForeignKey(ClassRoom, on_delete=models.CASCADE)
        # ############可以设置多个外键
        teacther = models.ForeignKey(Teacher, on_delete=models.CASCADE)

        name = models.CharField(max_length=10, verbose_name='学生姓名')
        phone = models.CharField(max_length=20, verbose_name='学生电话')

    添加还是创建对象,对象点属性等于一个值,然后就是对象点save()
    class_room = ClassRoom()
    class_room.class_name = 'python12'
    class_room.class_addr = '315'
    class_room.save()
    找到ClassRoom表格id=6的对象
    class_room = ClassRoom.objects.get(id=6)
    stu = Student()
    stu.class_room = class_room【这个class_room 就是 ClassRoom.objects.get(id=6),也就是ClassRoom的一个对象,stu.class_room这个是 Student()的一个属性 stu是Student()对象   】
    【一对多的,多的那个类(Student)的对象(stu )中的,属性就是一的对象(class_room = ClassRoom.objects.get(id=6))这个属性就是在model中设置外间的那个属性】
    stu.name = 'ssss'
    stu.phone = '1110'
    stu.save()

    one2many  查询
    class_room = ClassRoom.objects.get(id=6)
    class_room.class_name,     class_room.class_addr

    2.根据主表数据查询从表数据
    student_set从表中的数据集合{这个从表中的数据集合是什么意思 ????????????????}
    stus = class_room.student_set.all()
    stus = Student.objects.filter(class_room = class_room)

    # 3.根据从表数据查询主表数据
        # stu = Student.objects.get(name='lisi')
    ####    ##### class_room ,就是主表中对应的数据模型对象
        # print(stu.class_room.class_name)
    class_room = ClassRoom.objects.get(student__name__contains='lisi')
      print(class_room.class_name)


       # 删除主表中的数据,从表中关联的数据一并删除
        # ClassRoom.objects.get(id=6).delete()

        # 删除从表中的数据
        # Student.objects.get(id=1).delete()

        return HttpResponse('delete ok')

     


    # 学徒
    # 新闻出版社  文章
    # 一个出版社对应多篇文章
    # 一篇文章对应多个出版社

    class Publication(models.Model):

        name = models.CharField(max_length=20, verbose_name='出版社')
        addr = models.CharField(max_length=20, verbose_name='地址')

        class Meta:
            db_table = 'publication'


    class Article(models.Model):

        title = models.CharField(max_length=50, verbose_name='标题')
        author = models.CharField(max_length=50, verbose_name='作者')
        content = models.CharField(max_length=50, verbose_name='内容')
        # ManyToManyField 多对多
        pub = models.ManyToManyField(Publication ,verbose_name='出版社')

        class Meta:
            db_table = 'article'

    # pub = Publication()
        #     # pub.name = 'qqqqqq'
        #     # pub.addr = '北京'
        #     # pub.save()
        #
        # article = Article()
        # article.title = '3寻找!'
        # article.author = '凤凰'
        # article.content = '寻找!'
        # article.save()
    {


    pub = Publication.objects.get(id=1)
    # pub2 = Publication.objects.get(id=2)
        # article2 = Article.objects.get(id=2)
        # article3 = Article.objects.get(id=3)
    不管是一对一还是一对多,从表对象.关系字段 = 主表数据对象
    多对多关系
        # article.pub 是一个数据集合
     article.pub.all()
     article2.pub = {pub}
      # article2.save()

    # article3.pub = {pub}
        # article3.save()
        # print(article.pub.all())

     article = Article.objects.get(id=1)
        pub = Publication.objects.get(id=2)
        # article.pub.add(pub)
        article.pub = {1, 2, 3}
        # article.pub.add(3)
        article.save()
    {这里的没有了理解  # article.pub 是一个数据集合 }
    }
    # 1.删除表数据之间的关联
        # 2.删除表中的数据
        # Publication.objects.get(id=1).delete()

        # 1.删除表数据之间的关联
        # 2.删除表中的数据
        Article.objects.get(id=1).delete()

     pub = Publication.objects.get(id=1)
        # 获取主表对应的所有从表数据
        # article_set数据集合
        # print(pub.article_set.all())

        article = Article.objects.get(id=1)
        # 获取从表对应主表信息
        # article.pub 数据集合
        print(article.pub.all())

    url中的参数   第一个 正则表达式 路由   第二个就是

    视图函数   第三个name 就是反向解析名前台{% url ‘name’%}

    展开全文
  • Django数据库对多数据关系

    千次阅读 2017-10-10 19:39:35
    本文主要描述Django数据中一对一的数据关系,创建app等配置不再赘述。 Django操作数据库,使用ORM ORM:关系映射对象,把传统的SQL语句封装成了类和对象的形式,在操作表中的记录时,就像在操作类和对象一样。 ...

    本文主要描述Django数据中一对一的数据关系,创建app等配置不再赘述。

    Django操作数据库,使用ORM

    ORM:关系映射对象,把传统的SQL语句封装成了类和对象的形式,在操作表中的记录时,就像在操作类和对象一样。

    使用默认数据库:sqlite

    操作在models.py文件中完成。

    多对多关系

    举例:一个出版社发表多个文章,一篇文章也可以对多个出版社发表

    ManyToManyFiled():关联两个表的函数,但是函数的设置位置,在模型中任选一个即可,不能在两个模型中都设置此函数。

    class Publication(models.Model):
        id = models.AutoField(primary_key=True)
        title = models.CharField(max_length=30, null=True)  # 出版社名称
    
        class Meta:
            db_table = 'Publication'
    
        def __unicode__(self):
            return 'Publication-Name: %s' % self.title
    
    
    class Article(models.Model):
        id = models.AutoField(primary_key=True)
        headline = models.CharField(max_length=100, null=True)
    
        # 让文章关联出版社
        publication = models.ManyToManyField(Publication)
    
        class Meta:
            db_table = 'Article'
    
        def __unicode__(self):
            return 'Article-Name: %s' % self.headline
    
    
    创建完数据库模型之后,就需要创建数据库变更文件,应用数据库变更文件创建表的操作。
    创建数据库变更文件:python manage.py makemigrations
    应用数据库变更文件:python manage.py migrate
    可以使用SQLite可视化工具查看已经建立成功的数据库表
    
    由于未进行其他配置,所以只能在shell环境下,对数据库进行操作。
    进入shell环境的命令:python manage.py shell

    注意点:

    1)注意ManyToManyField()的设置位置;该实例中设置了Article模型中,在绑定两张表的时候,利用Article的对象a1进行绑定的,a1.publication.add()。但是不能使用Publication的对象p1进行绑定(p1.article.add())。

    两张表之间的相互查询关系

    查询a1这篇文章所属的出版社有哪些

    print a1.publication.all()

    查询某一出版社,所包含的所有文章有哪些

    print p1.article_set.all()


    展开全文
  • 文章目录一对多模型路由函数一对一模型路由函数 一对多 这里注意class Meta:managed = False表示不会在数据库中做改动,没有表也不会创建表 模型 class Book(BaseMode): id = models.AutoField(primary_key=True) ...

    一对多

    这里注意class Meta:managed = False表示不会在数据库中做改动,没有表也不会创建表

    模型

    class Book(BaseMode):
        id = models.AutoField(primary_key=True)
        bname = models.CharField(max_length=200, blank=True, null=True)
        # ForeignKey第一个参数:参照的模型名
        # on_delete CASCADE级联删除
        # db_column  属性对应表中字段名
        # related_name 从出版社查询图书引用的名字
        pub = models.ForeignKey('Publisher', on_delete=models.CASCADE, related_name="books", db_column='pid', blank=True, null=True)
    
        class Meta:
            managed = False
            db_table = 'book'
    
    
    class Publisher(models.Model):
        pname = models.CharField(max_length=100, blank=True, null=True)
    
        class Meta:
            managed = False
            db_table = 'publisher'
    

    路由函数

    def index(request):
        #创建一个出版社
        pub = Publisher(pname="first出版社")
        pub.save()
        # 创建图书
        book = Book(bname="三体")
        book.save()
    
        # 把图书所属的出版社赋值
        book = Book.objects.get(pk=3)
        pub = Publisher.objects.get(pk=2)
        book.pub = pub  # pub必须是出版社对象
        book.save()
    
        # 通过出版社管理图书
        pub = Publisher.objects.get(pk=3)
        #增加图书
        pub.books.create(bname='放风筝的人')
    
        # 级联删除
        pub = Publisher.objects.get(pk=3)
        pub.delete()
    
        # 更新
        pub = Publisher.objects.get(pk=2)
        pub.books.update(bname="读者")
    
        book = Book.objects.get(pk=3)
        book.pub.pname = 'second出版社'
        book.pub.save()
        print(book.pub)
    
        # 查询
        pub = Publisher.objects.get(pk=2)
        # pub.books是一个查询管理器对象 = objects
        print(pub.books.all())
        # 由图书查出版社
        book = Book.objects.get(pk=3)
        print(book.pub.pname)
    
        # 复杂查询
        pub = Publisher.objects.filter(books__bname='读者')
        pub = Publisher.objects.filter(books__id=3)
        print(pub[0].pname)
    
        return HttpResponse("ok")
    
    

    一对一

    模型

    class Student(models.Model):
        sno = models.CharField(primary_key=True, max_length=6)
        sname = models.CharField(max_length=100)
        ssex = models.CharField(max_length=2, blank=True, null=True)
        sage = models.IntegerField(blank=True, null=True)
        sclass = models.CharField(max_length=10, blank=True, null=True)
    
        class Meta:
            managed = False
            db_table = 'student'
            # abstract = True  # 父类不生成表
    
    class Archives(models.Model):
        idcard = models.CharField(unique=True, max_length=18)
        address = models.CharField(max_length=200, blank=True, null=True)
        student = models.OneToOneField('Student', models.CASCADE, unique=True, related_name='archive')
    
        class Meta:
            managed = False
            db_table = 'archives'
    

    路由函数

    def one2one(request):
    	# 获取
        student = Student.objects.get(pk='002')
        print(student.sname)
        # 查档案
        print(student.archive)
        # 看学生信息
        arc = Archives.objects.get(pk=1)
        print(arc.student.sno)
        return HttpResponse("one2one")
    
    展开全文
  • 一对多 是一行记录的对象,然后点外键,就可以点到多的那张表的属性了。 转载于:https://www.cnblogs.com/seanliang/p/9183518.html
  • 、新建工程和应用 二、修改settings.py添加数据库配置和相关应用 三、在应用blog下修改models.py ...五、使用python解析器对数据库blog_book、blog_author、blog_book_authos进行数据操作 ...
  • django数据库排序聚合的影响问题场景问题解决结语 问题场景 最近在公司实习需要做个django的系统,初次学习还是遇到了很坑。django的数据库操作和别的框架下的数据库操作有不同,提供了特有的操作方式。在个...
  • django数据库数据关系一对一,一对多,多对多,超详解(添加,查询) 查询了网上很多这方面的资料,看过很多介绍,但感觉都不是很全面,自己总结了一下,而且大部分介绍中字段名是采用某个关联模型类名的小写形式...
  • django数据库操作-增删改查-多对多关系以及一对多(外键)关系 原创2012年08月29日 14:56:33 标签: django/ 数据库/ class/ email/ 出版 28343 一、一对多(外键) 例子:一个作者对应...
  • from django.db import models class UserInfo(models.Model): name = models.CharField(max_length=64,unique=True) ut = models.ForeignKey(to='UserType') class UserType(models.Model):...
  • 1、先创建项目  django-admin.py startproject cst04  cd cst04  django-admin.py startapp blog 2、修改F:\cst04\cst04\setting.py...INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth',...
  • 1、一对一关系 比如某班级学生表和学生详细信息表 两张表结构如下 class Student(models.Model): stu_id = models.AutoField(primary_key=True) stu_name = models.CharField(max_length=32) class ...
  • 前面已经学习了在Django里面如何对单表的操作,同时也学习了1对多(单个外键)的表的操作。接下来,我们看看多对多(多个外键)的关系如何创建和管理。 比如说,我们有个主机表,也有个应用程序表,个主机...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 839
精华内容 335
关键字:

django数据库一对多