django知識點有哪些

小編給大家分享一下django知識點有哪些，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

一、視圖函數：

請求對象-----------request：

1、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視圖函數里寫函數，返回一個渲染頁面：

      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、模板語法

         (1)在母版中base.html：  {%block con%}{%endblock%}

         (2)繼承母版 index.html：

                                                {%extends "base.html"%}         繼承

                                                {%block con%}

                                                {%endblock%}

三、ORM之models模型

    1、 映射關系：

               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)

    （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

                           '''

############################多對多關系綁定#########################

                           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的文章的分類名稱

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

以上是“django知識點有哪些”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！