【亚洲必赢手机入口】Python之Django计算

一.Django

总结django知识点,django知识点

一、视图函数:

    请求对象———–request:

          壹、HttpRequest.body:         请求原数据

          2、HttpRequest.path:           
三个字符串,表示请求的路径组件(不含域名)

          3、HttpRequest.method  

          4、HttpRequest.GET

          5、HttpRequest.POST

          6、HttpRequest.FILES

          7、HttpResquest.user:        一个AUTH_亚洲必赢手机入口 ,USER_MODEL
类型的靶子

   响应对象:

         return   HttpResponse(“”)       再次回到字符串实例

         return   render(request,”template”,{“”:””})   
 重返字符串实例

         return   rredirect(“/index/”)      重定向

贰、  模板语言

       首先在views视图函数里写函数,再次来到1个渲染页面:

      views:

              def foo (request): 

                   name=”li”

                   l=[111,2222,3333]

                  d={“info”:[obj1,obj2…]}

                  return  render(request,”index.html”,locals())

     1、变量:{{name}}

              ——-深度查询  句点符.     如:{{d.info.0.name}}

              ——-过滤器{{name|date:”Y-m-d”}}

    2.标签:

      for循环

          {%for i in l%}

             {{i}}

          {%empty%}

           <p>未有符合的标准化</p>

          {%endfor%}       

     if判断语句

          {%if name=”li”%}

             <p> Yes</p>

          {%elif%}

          {%endif….%}

   3、模板语法

         (一)在母版中base.html:  {%block con%}{%endblock%}**

         (贰)继承母版 index.html:

                                                {%extends
“base.html”%}         继承

                                                {%block con%}

                                             
  
{%endblock%}**

**三、ORM之models模型**

**    一、 映射关系:**

**               sql中表名———–Python的类名**

**               sql中的字段———Python的类属性**

**               sql中的记录———Python的类对象**

**    2、单表操作**

class Article(models.Model):
            nid = models.BigAutoField(primary_key=True)
            title = models.CharField(max_length=50, verbose_name='文章标题')
            read_count = models.IntegerField(default=0)

【亚洲必赢手机入口】Python之Django计算。    (1)添加操作

      views:

 

 #方法1:
      article_obj=models.Article.objects.create(nid=1,title="yuan",read_count=12) # create方法返回的是当前创建的文章对象
 #方法2:
      article_obj=models.Article(nid=1,title="yuan",read_count=12)
      article_obj.save()

  删除:
      models.Article.objects.filter(title="python").delete()  #  默认级联删除

  修改:
      models.Article.objects.filter(title="python").update(read_count=F("read_count")+10)

 查询API:
          <1> all():                            查询所有结果   #QuerySet

                    <2> filter(**kwargs):        它包含了与所给筛选条件相匹配的对象  #QuerySet

                    <3> get(**kwargs):     返回与所给筛选条件相匹配的对象,返回结果有且只有一个,
                                               如果符合筛选条件的对象超过一个或者没有都会抛出错误。# model对象

                    <5> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象  #QuerySet 

                    <4> values(*field):     返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列
                                               model的实例化对象,而是一个可迭代的字典序列   #QuerySet

                    <9> values_list(*field):        它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列 #QuerySet

                    <6> order_by(*field):         对查询结果排序 #QuerySet

                    <7> reverse():                  对查询结果反向排序 #QuerySet

                    <8> distinct():                从返回结果中剔除重复纪录 #QuerySet

                    <10> count():                返回数据库中匹配查询(QuerySet)的对象数量。 # int

                    <11> first():                  返回第一条记录       # model对象

                    <12> last():                  返回最后一条记录     # model对象

                    <13> exists():   如果QuerySet包含数据,就返回True,否则返回False

                    querySet支持链式操作:
                           models.Article.objects.all().filter().values().distinct().count()

                    QuerySet数据类型:
                        1、可切片,可迭代      [obj,....]  
                        2、惰性查询:
                                 articles_list=models.Article.objects.all()
                                 使用articles_list,比如if articles_list,这时转换sql语句                 

                        3、缓存机制
                                 articles_list=models.Article.objects.all()
                                 for i in articles_list:
                                        print(i.title)     # hit the database

                                 for i in articles_list:
                                        print(i.title)     # not hit the database    

                                 ==============================================
                                 for i in models.Article.objects.all():
                                        print(i.title)     # hit the database

                                 for i in models.Article.objects.all():
                                        print(i.title)     #  hit the database    
                        4、优化查询
                                 articles_list=models.Article.objects.all().iterator()
                                 for i in articles_list:
                                        print(i.title)     # hit the database

                                                                 for i in articles_list:
                                        print(i.title)     # 无结果            

        连表操作:

                表关系:

                       class UserInfo(AbstractUser):  # settings:   AUTH_USER_MODEL = "blog.UserInfo"
                            """
                            用户信息
                            """
                            nid = models.BigAutoField(primary_key=True)
                            nickname = models.CharField(verbose_name='昵称', max_length=32,null=True)
                            telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手机号码')
                            avatar = models.FileField(verbose_name='头像', upload_to='avatar', default="avatar/default.png")
                            create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)

                        class Blog(models.Model):
                            """
                            站点信息
                            """
                            nid = models.BigAutoField(primary_key=True)
                            title = models.CharField(verbose_name='个人博客标题', max_length=64)
                            site = models.CharField(verbose_name='个人博客后缀', max_length=32, unique=True)
                            theme = models.CharField(verbose_name='博客主题', max_length=32)

                            user = models.OneToOneField(to='UserInfo', to_field='nid')    

                        class Category(models.Model):

                            nid = models.AutoField(primary_key=True)
                            title = models.CharField(verbose_name='分类标题', max_length=32)
                            blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')

                        class Article(models.Model):
                            nid = models.BigAutoField(primary_key=True)
                            title = models.CharField(max_length=50, verbose_name='文章标题')
                            desc = models.CharField(max_length=255, verbose_name='文章描述')

                            # category字段: 与Article对象关联的category对象
                            category = models.ForeignKey(verbose_name='文章类型', to='Category', to_field='nid', null=True)

                            # user字段:与Article对象关联的user字段
                            user = models.ForeignKey(verbose_name='所属用户', to='UserInfo', to_field='nid')

                            tags = models.ManyToManyField(
                                to="Tag",
                                through='Article2Tag',
                                through_fields=('article', 'tag'),
                            )


                        class ArticleDetail(models.Model):

                            nid = models.AutoField(primary_key=True)
                            content = models.TextField(verbose_name='文章内容', )

                            article = models.OneToOneField(verbose_name='所属文章', to='Article', to_field='nid')

                        class Article2Tag(models.Model):
                            nid = models.AutoField(primary_key=True)
                            article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
                            tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid')


                        class Tag(models.Model):
                            nid = models.AutoField(primary_key=True)
                            title = models.CharField(verbose_name='标签名称', max_length=32)
                            blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid'


                关联表的添加记录操作:
                        1、创建一篇文章对象:
                           user_obj=models.UserInfo.objects.get(nid=1)
                           category_obj=models.Category.objects.get(nid=2)


                           #################一对多关系绑定#########################
                           # 方式1:
                           article_obj=models.Article.objects.create(nid=5,title="朝花夕拾"....,user=user_obj,category=category_obj)

                           # 方式2:
                            article_obj=models.Article.objects.create(nid=5,title="朝花夕拾"....,user_id=1,category_id=2)
                           '''
                               Article:
                                         nid         title        user_id     category_id
                                          5         朝花夕拾        1              2

                           '''

 

 

 

  

1、视图函数:
请求对象———–request: 一、HttpRequest.body: 请求原数据
二、HttpRequest.path: 一个字符串,表示…

1、视图函数:

一、视图函数:

总结django知识点

   
请求对象———–request:

   
请求对象———–request:

 

          一、HttpRequest.body:       
 请求原数据

          一、HttpRequest.body:       
 请求原数据

1、视图函数:

          二、HttpRequest.path:           
2个字符串,表示请求的不二等秘书诀组件(不含域名)

          贰、HttpRequest.path:           
3个字符串,表示请求的门路组件(不含域名)

   
请求对象———–request:

         
3、HttpRequest.method  

         
3、HttpRequest.method  

          1、HttpRequest.body:       
 请求原数据

          4、HttpRequest.GET

          4、HttpRequest.GET

          二、HttpRequest.path:           
1个字符串,表示请求的门道组件(不含域名)

          5、HttpRequest.POST

          5、HttpRequest.POST

         
3、HttpRequest.method  

          6、HttpRequest.FILES

          6、HttpRequest.FILES

          4、HttpRequest.GET

          7、HttpResquest.user:       
一个AUTH_USER_MODEL 类型的靶子

          7、HttpResquest.user:       
一个AUTH_USER_MODEL 类型的目的

          5、HttpRequest.POST

   响应对象:

   响应对象:

          6、HttpRequest.FILES

         return   HttpResponse(“”)     
 重临字符串实例

         return   HttpResponse(“”)     
 重回字符串实例

          7、HttpResquest.user:       
一个AUTH_USER_MODEL 类型的靶子

         return 
 render(request,”template”,{“”:””})     重回字符串实例

         return 
 render(request,”template”,{“”:””})     重返字符串实例

   响应对象:

         return   rredirect(“/index/”)     
重定向

         return   rredirect(“/index/”)     
重定向

         return   HttpResponse(“”)     
 再次回到字符串实例

二、  模板语言

二、  模板语言

         return 
 render(request,”template”,{“”:””})     再次回到字符串实例

     
 首先在views视图函数里写函数,重返一个渲染页面:

     
 首先在views视图函数里写函数,再次来到一个渲染页面:

         return   rredirect(“/index/”)     
重定向

      views:

      views:

2、  模板语言

              def foo
(request): 

              def foo
(request): 

     
 首先在views视图函数里写函数,再次回到三个渲染页面:

                   name=”li”

                   name=”li”

      views:

                 
 l=[111,2222,3333]

                 
 l=[111,2222,3333]

              def foo
(request): 

                 
d={“info”:[obj1,obj2…]}

                 
d={“info”:[obj1,obj2…]}

                   name=”li”

                  return 
render(request,”index.html”,locals())

                  return 
render(request,”index.html”,locals())

                 
 l=[111,2222,3333]

     1、变量:{{name}}

     1、变量:{{name}}

                 
d={“info”:[obj1,obj2…]}

              ——-深度查询  句点符.   
 如:{{d.info.0.name}}

              ——-深度查询  句点符.   
 如:{{d.info.0.name}}

                  return 
render(request,”index.html”,locals())

             
——-过滤器{{name|date:”Y-m-d”}}

             
——-过滤器{{name|date:”Y-m-d”}}

     1、变量:{{name}}

    2.标签:

    2.标签:

              ——-深度查询  句点符.   
 如:{{d.info.0.name}}

      for循环

      for循环

             
——-过滤器{{name|date:”Y-m-d”}}

          {%for i in l%}

          {%for i in l%}

    2.标签:

             {{i}}

             {{i}}

      for循环

          {%empty%}

          {%empty%}

          {%for i in l%}

         
 <p>未有适合的基准</p>

         
 <p>没有符合的条件</p>

             {{i}}

          {%endfor%}       

          {%endfor%}       

          {%empty%}

     if判断语句

     if判断语句

         
 <p>没有适合的口径</p>

          {%if name=”li”%}

          {%if name=”li”%}

          {%endfor%}       

             <p>
Yes</p>

             <p>
Yes</p>

     if判断语句

          {%elif%}

          {%elif%}

          {%if name=”li”%}

          {%endif….%}

          {%endif….%}

             <p>
Yes</p>

   三、模板语法

   3、模板语法

          {%elif%}

         (一)在母版中base.html:  {%block
con%}
{%endblock%}**

         (一)在母版中base.html:  {%block
con%}
{%endblock%}**

          {%endif….%}

         (2)继承母版
index.html:

         (贰)继承母版
index.html:

   三、模板语法

                                             
  {%extends “base.html”%}         继承

                                             
  {%extends “base.html”%}         继承

         (一)在母版中base.html:  {%block
con%}
{%endblock%}**

                                             
  {%block con%}

                                             
  {%block con%}

         (二)继承母版
index.html:

                                             
  
{%endblock%}**

                                             
  
{%endblock%}**

                                             
  {%extends “base.html”%}         继承

**三、ORM之models模型**

**三、ORM之models模型**

                                             
  {%block con%}

**    一、 映射关系:**

**    一、 映射关系:**

                                             
  
{%endblock%}**

**             
 sql中表名———–Python的类名**

**             
 sql中表名———–Python的类名**

**三、ORM之models模型**

**             
 sql中的字段———Python的类属性**

**             
 sql中的字段———Python的类属性**

**    一、 映射关系:**

**             
 sql中的记录———Python的类对象**

**             
 sql中的记录———Python的类对象**

**             
 sql中表名———–Python的类名**

**    二、单表操作**

**    2、单表操作**

**             
 sql中的字段———Python的类属性**

class Article(models.Model):
            nid = models.BigAutoField(primary_key=True)
            title = models.CharField(max_length=50, verbose_name='文章标题')
            read_count = models.IntegerField(default=0)
class Article(models.Model):
            nid = models.BigAutoField(primary_key=True)
            title = models.CharField(max_length=50, verbose_name='文章标题')
            read_count = models.IntegerField(default=0)

**             
 sql中的记录———Python的类对象**

    (1)添加操作

    (壹)添加操作

** 连表操作(基于对象查询):**

   
  views:

   
  views:

一对多的查询:

                                实例1:查询主键为4的文章的分类名称(正向查询,按字段)

                                       article_obj=models.Article.objects.get(nid=4)
                                       print(article_obj.category.title)

                                       SELECT * FROM "blog_article" WHERE "blog_article"."nid" = 4;  // category_id=2
                                       SELECT * FROM "blog_category" WHERE "blog_category"."nid" = 2; 

                                实例2:查询用户yuan发表过的所有的文章(反向查询,表名_set)
                                       yuan=models.UserInfo.objects.get(username="yuan")
                                       book_list=yuan.article_set.all()  # QuerySet 



                            多对多的查询:

                                 实例3:查询主键为4的文章的标签名称(正向查询,按字段)     
                                     article_obj=models.Article.objects.get(nid=4)                                
                                     tag_list=article_obj.tags.all()   #  是通过Article2Tag找到tag表中关联的tag记录
                                     for i in tag_list:
                                          print(i.title)

                                 实例4:查询web开发的这个标签对应的所有的文章(反向查询,按表名_set)
                                    tag_obj=models.Tag.objects.get(title="web开发")
                                    article_list=tag_obj.article_set.all()
                                    for i in article_list:
                                        print(i.title)                            

                                 实例5:查询web开发的这个标签对应的所有的文章对应的作者名字
                                      tag_obj=models.Tag.objects.get(title="web开发")
                                      article_list=tag_obj.article_set.all()    
                                      for article in article_list:
                                           print(article.user.username)
基于QuerySet跨表查询 ( 正向查询,按字段 ;反向查询,按表名)


一对多的查询:

 实例1:查询主键为4的文章的分类名称

models.Article.objects.filter(nid=4).values("category__title") 
 models.Category.objects.filter(article__nid=4).values("title")

实例2:查询用户yuan发表过的所有的文章
models.UserInfo.objects.filter(username="yuan").values(article__title)
 models.Article.objects.filter(user__username="yuan").values("title")


多对多的查询:

 实例3:查询主键为4的文章的标签名称(正向查询,按字段) 
models.Article.objects.filter(nid=4).values("tags__title")
 models.Tag.objects.filter(article__nid=4).values("title") 

实例4:查询web开发的这个标签对应的所有的文章(反向查询,按表名_set)
models.Article.objects.filter(tags__title="web开发").values("title")
 models.Tag.objects.filter(title="web开发").values("article__title") 

实例5:查询web开发的这个标签对应的所有的文章对应的作者名字
models.Tag.objects.filter(title="web开发").values("article__user__username")
 models.UserInfo.objects.filter(article__tags__title="web开发").values("username")

 

 

 

 #方法1:
      article_obj=models.Article.objects.create(nid=1,title="yuan",read_count=12) # create方法返回的是当前创建的文章对象
 #方法2:
      article_obj=models.Article(nid=1,title="yuan",read_count=12)
      article_obj.save()

  删除:
      models.Article.objects.filter(title="python").delete()  #  默认级联删除

  修改:
      models.Article.objects.filter(title="python").update(read_count=F("read_count")+10)

 查询API:
          <1> all():                            查询所有结果   #QuerySet

                    <2> filter(**kwargs):        它包含了与所给筛选条件相匹配的对象  #QuerySet

                    <3> get(**kwargs):     返回与所给筛选条件相匹配的对象,返回结果有且只有一个,
                                               如果符合筛选条件的对象超过一个或者没有都会抛出错误。# model对象

                    <5> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象  #QuerySet 

                    <4> values(*field):     返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列
                                               model的实例化对象,而是一个可迭代的字典序列   #QuerySet

                    <9> values_list(*field):        它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列 #QuerySet

                    <6> order_by(*field):         对查询结果排序 #QuerySet

                    <7> reverse():                  对查询结果反向排序 #QuerySet

                    <8> distinct():                从返回结果中剔除重复纪录 #QuerySet

                    <10> count():                返回数据库中匹配查询(QuerySet)的对象数量。 # int

                    <11> first():                  返回第一条记录       # model对象

                    <12> last():                  返回最后一条记录     # model对象

                    <13> exists():   如果QuerySet包含数据,就返回True,否则返回False

                    querySet支持链式操作:
                           models.Article.objects.all().filter().values().distinct().count()

                    QuerySet数据类型:
                        1、可切片,可迭代      [obj,....]  
                        2、惰性查询:
                                 articles_list=models.Article.objects.all()
                                 使用articles_list,比如if articles_list,这时转换sql语句                 

                        3、缓存机制
                                 articles_list=models.Article.objects.all()
                                 for i in articles_list:
                                        print(i.title)     # hit the database

                                 for i in articles_list:
                                        print(i.title)     # not hit the database    

                                 ==============================================
                                 for i in models.Article.objects.all():
                                        print(i.title)     # hit the database

                                 for i in models.Article.objects.all():
                                        print(i.title)     #  hit the database    
                        4、优化查询
                                 articles_list=models.Article.objects.all().iterator()
                                 for i in articles_list:
                                        print(i.title)     # hit the database

                                                                 for i in articles_list:
                                        print(i.title)     # 无结果            

        连表操作:

                表关系:

                       class UserInfo(AbstractUser):  # settings:   AUTH_USER_MODEL = "blog.UserInfo"
                            """
                            用户信息
                            """
                            nid = models.BigAutoField(primary_key=True)
                            nickname = models.CharField(verbose_name='昵称', max_length=32,null=True)
                            telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手机号码')
                            avatar = models.FileField(verbose_name='头像', upload_to='avatar', default="avatar/default.png")
                            create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)

                        class Blog(models.Model):
                            """
                            站点信息
                            """
                            nid = models.BigAutoField(primary_key=True)
                            title = models.CharField(verbose_name='个人博客标题', max_length=64)
                            site = models.CharField(verbose_name='个人博客后缀', max_length=32, unique=True)
                            theme = models.CharField(verbose_name='博客主题', max_length=32)

                            user = models.OneToOneField(to='UserInfo', to_field='nid')    

                        class Category(models.Model):

                            nid = models.AutoField(primary_key=True)
                            title = models.CharField(verbose_name='分类标题', max_length=32)
                            blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')

                        class Article(models.Model):
                            nid = models.BigAutoField(primary_key=True)
                            title = models.CharField(max_length=50, verbose_name='文章标题')
                            desc = models.CharField(max_length=255, verbose_name='文章描述')

                            # category字段: 与Article对象关联的category对象
                            category = models.ForeignKey(verbose_name='文章类型', to='Category', to_field='nid', null=True)

                            # user字段:与Article对象关联的user字段
                            user = models.ForeignKey(verbose_name='所属用户', to='UserInfo', to_field='nid')

                            tags = models.ManyToManyField(
                                to="Tag",
                                through='Article2Tag',
                                through_fields=('article', 'tag'),
                            )


                        class ArticleDetail(models.Model):

                            nid = models.AutoField(primary_key=True)
                            content = models.TextField(verbose_name='文章内容', )

                            article = models.OneToOneField(verbose_name='所属文章', to='Article', to_field='nid')

                        class Article2Tag(models.Model):
                            nid = models.AutoField(primary_key=True)
                            article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
                            tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid')


                        class Tag(models.Model):
                            nid = models.AutoField(primary_key=True)
                            title = models.CharField(verbose_name='标签名称', max_length=32)
                            blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid'


                关联表的添加记录操作:
                        1、创建一篇文章对象:
                           user_obj=models.UserInfo.objects.get(nid=1)
                           category_obj=models.Category.objects.get(nid=2)


                           #################一对多关系绑定#########################
                           # 方式1:
                           article_obj=models.Article.objects.create(nid=5,title="朝花夕拾"....,user=user_obj,category=category_obj)

                           # 方式2:
                            article_obj=models.Article.objects.create(nid=5,title="朝花夕拾"....,user_id=1,category_id=2)
                           '''
                               Article:
                                         nid         title        user_id     category_id
                                          5         朝花夕拾        1              2

                           '''

############################多对多关系绑定#########################
                           if 没有中介模型:
                                   tags = models.ManyToManyField("Tag")
                                   '''
                                      ORM创建的第三张表:
                                      Article2tags:
                                         nid    article_id    tag_id   
                                          1         5            1
                                          2         5            2                                          
                                   '''

                                   实例:给article_obj绑定kw1,kw2的标签
                                       tag1=Tag.objects.filter(title=kw1).first()
                                       tag2=Tag.objects.filter(title=kw2).first()

                                       article_obj.tags.add(tag1,tag2)   #      
                                       article_obj.tags.add(*[tag1,tag2])    
                                       article_obj.tags.add(1,2)    
                                       article_obj.tags.add(*[1,2])  

                                    解除关系:
                                        article_obj.tags.remove(tag1,tag2)
                                        article_obj.tags.clear()

                                    重置关系:
                                         article_obj.tags.clear()
                                         article_obj.tags.add(tag1,tag2)  
                                         =====
                                         article_obj.tags.set(tag1,tag2)    

                        if 有中介模型:                
                                tags = models.ManyToManyField(
                                            to="Tag",
                                            through='Article2Tag',
                                            through_fields=('article', 'tag'),
                                        )
                                class Article2Tag(models.Model):  #  中介模型
                                    nid = models.AutoField(primary_key=True)
                                    article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
                                    tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid') 

                             绑定多对多的关系,有中介模型,不能再使用article_obj.tags.add(),remove()等方法;
                             只能用Article2Tag表进行实例对象。

                             实例:给article_obj绑定kw1,kw2的标签:

                                 models.Article2Tag.objects.create(tag_id=1,article_id=5)
                                 models.Article2Tag.objects.create(tag_id=2,article_id=5)
 #方法1:
      article_obj=models.Article.objects.create(nid=1,title="yuan",read_count=12) # create方法返回的是当前创建的文章对象
 #方法2:
      article_obj=models.Article(nid=1,title="yuan",read_count=12)
      article_obj.save()

  删除:
      models.Article.objects.filter(title="python").delete()  #  默认级联删除

  修改:
      models.Article.objects.filter(title="python").update(read_count=F("read_count")+10)

 查询API:
          <1> all():                            查询所有结果   #QuerySet

                    <2> filter(**kwargs):        它包含了与所给筛选条件相匹配的对象  #QuerySet

                    <3> get(**kwargs):     返回与所给筛选条件相匹配的对象,返回结果有且只有一个,
                                               如果符合筛选条件的对象超过一个或者没有都会抛出错误。# model对象

                    <5> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象  #QuerySet 

                    <4> values(*field):     返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列
                                               model的实例化对象,而是一个可迭代的字典序列   #QuerySet

                    <9> values_list(*field):        它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列 #QuerySet

                    <6> order_by(*field):         对查询结果排序 #QuerySet

                    <7> reverse():                  对查询结果反向排序 #QuerySet

                    <8> distinct():                从返回结果中剔除重复纪录 #QuerySet

                    <10> count():                返回数据库中匹配查询(QuerySet)的对象数量。 # int

                    <11> first():                  返回第一条记录       # model对象

                    <12> last():                  返回最后一条记录     # model对象

                    <13> exists():   如果QuerySet包含数据,就返回True,否则返回False

                    querySet支持链式操作:
                           models.Article.objects.all().filter().values().distinct().count()

                    QuerySet数据类型:
                        1、可切片,可迭代      [obj,....]  
                        2、惰性查询:
                                 articles_list=models.Article.objects.all()
                                 使用articles_list,比如if articles_list,这时转换sql语句                 

                        3、缓存机制
                                 articles_list=models.Article.objects.all()
                                 for i in articles_list:
                                        print(i.title)     # hit the database

                                 for i in articles_list:
                                        print(i.title)     # not hit the database    

                                 ==============================================
                                 for i in models.Article.objects.all():
                                        print(i.title)     # hit the database

                                 for i in models.Article.objects.all():
                                        print(i.title)     #  hit the database    
                        4、优化查询
                                 articles_list=models.Article.objects.all().iterator()
                                 for i in articles_list:
                                        print(i.title)     # hit the database

                                                                 for i in articles_list:
                                        print(i.title)     # 无结果            

        连表操作:

                表关系:

                       class UserInfo(AbstractUser):  # settings:   AUTH_USER_MODEL = "blog.UserInfo"
                            """
                            用户信息
                            """
                            nid = models.BigAutoField(primary_key=True)
                            nickname = models.CharField(verbose_name='昵称', max_length=32,null=True)
                            telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手机号码')
                            avatar = models.FileField(verbose_name='头像', upload_to='avatar', default="avatar/default.png")
                            create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)

                        class Blog(models.Model):
                            """
                            站点信息
                            """
                            nid = models.BigAutoField(primary_key=True)
                            title = models.CharField(verbose_name='个人博客标题', max_length=64)
                            site = models.CharField(verbose_name='个人博客后缀', max_length=32, unique=True)
                            theme = models.CharField(verbose_name='博客主题', max_length=32)

                            user = models.OneToOneField(to='UserInfo', to_field='nid')    

                        class Category(models.Model):

                            nid = models.AutoField(primary_key=True)
                            title = models.CharField(verbose_name='分类标题', max_length=32)
                            blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')

                        class Article(models.Model):
                            nid = models.BigAutoField(primary_key=True)
                            title = models.CharField(max_length=50, verbose_name='文章标题')
                            desc = models.CharField(max_length=255, verbose_name='文章描述')

                            # category字段: 与Article对象关联的category对象
                            category = models.ForeignKey(verbose_name='文章类型', to='Category', to_field='nid', null=True)

                            # user字段:与Article对象关联的user字段
                            user = models.ForeignKey(verbose_name='所属用户', to='UserInfo', to_field='nid')

                            tags = models.ManyToManyField(
                                to="Tag",
                                through='Article2Tag',
                                through_fields=('article', 'tag'),
                            )


                        class ArticleDetail(models.Model):

                            nid = models.AutoField(primary_key=True)
                            content = models.TextField(verbose_name='文章内容', )

                            article = models.OneToOneField(verbose_name='所属文章', to='Article', to_field='nid')

                        class Article2Tag(models.Model):
                            nid = models.AutoField(primary_key=True)
                            article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
                            tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid')


                        class Tag(models.Model):
                            nid = models.AutoField(primary_key=True)
                            title = models.CharField(verbose_name='标签名称', max_length=32)
                            blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid'


                关联表的添加记录操作:
                        1、创建一篇文章对象:
                           user_obj=models.UserInfo.objects.get(nid=1)
                           category_obj=models.Category.objects.get(nid=2)


                           #################一对多关系绑定#########################
                           # 方式1:
                           article_obj=models.Article.objects.create(nid=5,title="朝花夕拾"....,user=user_obj,category=category_obj)

                           # 方式2:
                            article_obj=models.Article.objects.create(nid=5,title="朝花夕拾"....,user_id=1,category_id=2)
                           '''
                               Article:
                                         nid         title        user_id     category_id
                                          5         朝花夕拾        1              2

                           '''

############################多对多关系绑定#########################
                           if 没有中介模型:
                                   tags = models.ManyToManyField("Tag")
                                   '''
                                      ORM创建的第三张表:
                                      Article2tags:
                                         nid    article_id    tag_id   
                                          1         5            1
                                          2         5            2                                          
                                   '''

                                   实例:给article_obj绑定kw1,kw2的标签
                                       tag1=Tag.objects.filter(title=kw1).first()
                                       tag2=Tag.objects.filter(title=kw2).first()

                                       article_obj.tags.add(tag1,tag2)   #      
                                       article_obj.tags.add(*[tag1,tag2])    
                                       article_obj.tags.add(1,2)    
                                       article_obj.tags.add(*[1,2])  

                                    解除关系:
                                        article_obj.tags.remove(tag1,tag2)
                                        article_obj.tags.clear()

                                    重置关系:
                                         article_obj.tags.clear()
                                         article_obj.tags.add(tag1,tag2)  
                                         =====
                                         article_obj.tags.set(tag1,tag2)    

                        if 有中介模型:                
                                tags = models.ManyToManyField(
                                            to="Tag",
                                            through='Article2Tag',
                                            through_fields=('article', 'tag'),
                                        )
                                class Article2Tag(models.Model):  #  中介模型
                                    nid = models.AutoField(primary_key=True)
                                    article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
                                    tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid') 

                             绑定多对多的关系,有中介模型,不能再使用article_obj.tags.add(),remove()等方法;
                             只能用Article2Tag表进行实例对象。

                             实例:给article_obj绑定kw1,kw2的标签:

                                 models.Article2Tag.objects.create(tag_id=1,article_id=5)
                                 models.Article2Tag.objects.create(tag_id=2,article_id=5)

 

 连表操作(基于对象查询):

 连表操作(基于对象查询):

         

一对多的查询:

                                实例1:查询主键为4的文章的分类名称(正向查询,按字段)

                                       article_obj=models.Article.objects.get(nid=4)
                                       print(article_obj.category.title)

                                       SELECT * FROM "blog_article" WHERE "blog_article"."nid" = 4;  // category_id=2
                                       SELECT * FROM "blog_category" WHERE "blog_category"."nid" = 2; 

                                实例2:查询用户yuan发表过的所有的文章(反向查询,表名_set)
                                       yuan=models.UserInfo.objects.get(username="yuan")
                                       book_list=yuan.article_set.all()  # QuerySet 



                            多对多的查询:

                                 实例3:查询主键为4的文章的标签名称(正向查询,按字段)     
                                     article_obj=models.Article.objects.get(nid=4)                                
                                     tag_list=article_obj.tags.all()   #  是通过Article2Tag找到tag表中关联的tag记录
                                     for i in tag_list:
                                          print(i.title)

                                 实例4:查询web开发的这个标签对应的所有的文章(反向查询,按表名_set)
                                    tag_obj=models.Tag.objects.get(title="web开发")
                                    article_list=tag_obj.article_set.all()
                                    for i in article_list:
                                        print(i.title)                            

                                 实例5:查询web开发的这个标签对应的所有的文章对应的作者名字
                                      tag_obj=models.Tag.objects.get(title="web开发")
                                      article_list=tag_obj.article_set.all()    
                                      for article in article_list:
                                           print(article.user.username)
基于QuerySet跨表查询 ( 正向查询,按字段 ;反向查询,按表名)
一对多的查询:

                                实例1:查询主键为4的文章的分类名称(正向查询,按字段)

                                       article_obj=models.Article.objects.get(nid=4)
                                       print(article_obj.category.title)

                                       SELECT * FROM "blog_article" WHERE "blog_article"."nid" = 4;  // category_id=2
                                       SELECT * FROM "blog_category" WHERE "blog_category"."nid" = 2; 

                                实例2:查询用户yuan发表过的所有的文章(反向查询,表名_set)
                                       yuan=models.UserInfo.objects.get(username="yuan")
                                       book_list=yuan.article_set.all()  # QuerySet 



                            多对多的查询:

                                 实例3:查询主键为4的文章的标签名称(正向查询,按字段)     
                                     article_obj=models.Article.objects.get(nid=4)                                
                                     tag_list=article_obj.tags.all()   #  是通过Article2Tag找到tag表中关联的tag记录
                                     for i in tag_list:
                                          print(i.title)

                                 实例4:查询web开发的这个标签对应的所有的文章(反向查询,按表名_set)
                                    tag_obj=models.Tag.objects.get(title="web开发")
                                    article_list=tag_obj.article_set.all()
                                    for i in article_list:
                                        print(i.title)                            

                                 实例5:查询web开发的这个标签对应的所有的文章对应的作者名字
                                      tag_obj=models.Tag.objects.get(title="web开发")
                                      article_list=tag_obj.article_set.all()    
                                      for article in article_list:
                                           print(article.user.username)
基于QuerySet跨表查询 ( 正向查询,按字段 ;反向查询,按表名)

一对多的查询:

1对多的查询:

实例1:查询主键为4的小说的归类名称

实例一:查询主键为四的小说的归类名称

models.Article.objects.filter(nid=4).values(“category__title”)

models.Article.objects.filter(nid=4).values(“category__title”)

models.Category.objects.filter(article__nid=4).values(“title”)

models.Category.objects.filter(article__nid=4).values(“title”)

实例二:查询用户yuan发布过的拥有的文章

实例2:查询用户yuan发布过的具有的小说

models.UserInfo.objects.filter(username=”yuan”).values(article__title)

models.UserInfo.objects.filter(username=”yuan”).values(article__title)

models.Article.objects.filter(user__username=”yuan”).values(“title”)

models.Article.objects.filter(user__username=”yuan”).values(“title”)

多对多的询问:

多对多的询问:

实例三:查询主键为四的文章的价签名称(正向查询,按字段)

实例三:查询主键为4的篇章的价签名称(正向查询,按字段)

models.Article.objects.filter(nid=4).values(“tags__title”)

models.Article.objects.filter(nid=4).values(“tags__title”)

models.Tag.objects.filter(article__nid=4).values(“title”)

models.Tag.objects.filter(article__nid=4).values(“title”)

实例四:查询web开发的这么些标签对应的富有的稿子(反向查询,按表名_set)

实例四:查询web开发的这一个标签对应的有着的文章(反向查询,按表名_set)

models.Article.objects.filter(tags__title=”web开发”).values(“title”)

models.Article.objects.filter(tags__title=”web开发”).values(“title”)

models.Tag.objects.filter(title=”web开发”).values(“article__title”)

models.Tag.objects.filter(title=”web开发”).values(“article__title”)

实例5:查询web开发的这么些标签对应的保有的篇章对应的笔者名字

实例伍:查询web开发的那一个标签对应的富有的稿子对应的我名字

models.Tag.objects.filter(title=”web开发”).values(“article__user__username”)

models.Tag.objects.filter(title=”web开发”).values(“article__user__username”)

models.UserInfo.objects.filter(article__tags__title=”web开发”).values(“username”)

models.UserInfo.objects.filter(article__tags__title=”web开发”).values(“username”)

 

 

 

 

 

 

 

 

  

  

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图