zoukankan      html  css  js  c++  java
  • django知识点回顾

    1.web应用

      本质是基于socket实现的应用程序

      浏览器-----------服务器

    2.http协议:应用层协议

      1.基于TCP协议

      2.基于请求响应

      3.短连接

      4.无状态保存(引入了cookie,session技术)效率快,服务器记录不下来客户端的状态

          请求协议

      浏览器--------------------->服务器

         <--------------------        发送的都是一堆字符串

          响应协议

      请求协议:

        请求首行  GET  path?get数据  HTTP/11

        请求头       userAgent:用户信息    contentType:json,application/x-www-form-urlencoded

         

        请求体(post请求才有请求体)  a=1&b=2   {"a":1,"b":2}

        如何给服务器发送json数据

          给服务器发送请求的方式:

            1.地址栏  get请求

            2.form表单  get  post请求 (无法发送json数据)

            3.a标签链接请求  get请求

            4.Ajax请求   get(查) post(提交数据添加记录) put(更新)delete(删除)        

                                                  $.ajax({
                                 url:"/index/",
                                 type:"post",
                                 data:{
                                    a:1,
                                    b:2
                                 },  # 默认urlencoded编码
                                 success:function(res){
                                 
                                 
                                 }
                            
                            })
                            
                            
                            发送json数据
                            
                            $.ajax({
                                 url:"/index/",
                                 type:"post",
                                 contentType:"json"
                                 data:JSON.stringfy({
                                    a:1,
                                    b:2
                                 }), 
                                 success:function(res){
                                     
                                 
                                 }
                            
                            })
                            
                            
                            
                            注意:Django解析不了json数据,只能自己利用request.body解析                
    View Code

        响应协议

          响应首行  HTTP/1.1 200 OK

          响应头   contentType:"json"

          

          响应体

        响应状态码

          1开头:请求中

          200:请求成功

          3开头:重定向

          4开头:文件路径找不到‘

          5开头:服务器错误

    django

      MTV+url路由分发:

        M:model.py

        T:template:存放模板文件

        V:视图,逻辑

    url路由分发:

      反向解析:

           url(r'^role/add/$', views.role, name='role_add'),

          url(r'^role/edit/(d+)/$', views.role, name='role_edit'),

        视图:

          path=reverse("role_add")  # "role/add/"

           path=reverse("role_edit",args=(1,2))  # "role/edit/1/"

        模板:

            {% url 'role_add' %}

            {% url 'role_edit' 2 %}

      名称空间:

           re_path(r'^app01/', include(("app01.urls","app01"),namespace="app01",)),

      视图函数:

        request对象:储存这次请求的所有请求信息

        属性:

          HttpRequest.GET

          HttpRequest.POST              

                      ---- urlencoded编码
                       ---- 注意:键值对的值是多个的时候,比如checkbox类型的input标签,select标签,需要用:request.POST.getlist("hobby")

          HttpRequest.body   一个字节串,代表请求报文的主体

          HttpRequest.path

          HtpRequest.method

          HttpRequest.META  请求头

          HttpRequest.FILES

          HttpRequest.COOKIES

          HttpRequest.session  session中间件

          HttpRequest.user    认证中间件

        方法:

          HttpRequest.get_full_path()

          HttpRequest.is_ajax()

        HttpResponse对象:

          obj=HttpResponse("hello")

          obj=render(request,"index.html")

          obj=redircet("/index/")

         FBV与CBV

          views:

              from django.views import View

               class BookView(View):

                def get(self,request):

                  pass

                def post(self,request):

                  pass

          urls.py:

             url("books",BookView.as_view()

    模板层

      含有模板语法的html文件成为模板文件

      render方法渲染引擎

      模板语法:

        {{}}:渲染变量 :-----深度查询,句点符 .无参方法

                -----过滤器:date,safe,add,slice

        {%%}:渲染标签:            

              {%for i in [111,222,333]%}
                {%if i!= 222%}
                  <p>i</p>
                {%endif%}
              {%endfor%}

        自定义标签和过滤器

          1、在settings中的INSTALLED_APPS配置当前app,不然django无法找到自定义的simple_tag.

          2、 在app中创建templatetags模块(模块名只能是templatetags)

          3、 创建任意 .py 文件,如:my_tags.py

              from django import template

              register = template.Library()   #register的名字是固定的,不可改变

              @register.filter

              def filter_multi(v1,v2):

                return  v1 * v2

              @register.simple_tag

              def simple_tag_multi(v1,v2):

                return  v1 * v2

           4、模板中使用:

               {% load my_tags %}  

               # num=12

              {{ num|filter_multi:2 }} #24

              {{ num|filter_multi:"[22,333,4444]" }}

      继承 extend:

        创建base.html

          构建钩子

            {%block css%}

            {%endblock css%}

            {%block content%}

              <p>123</p>

            {%endblock%}

            {%block js%}

            {%endblock js%}

       子模板继承:

             {%extends 'base.html' %}

              {%block content%}

                <p>111</p>

              {%endblock%}

    ORM:

       class  Book(model.Model):

         title=models.CharFiled(max_length=32)

        类-----------------表 # Book------- app01_book
        属性变量-----------字段 # title------ title
        属性对象-----------约束 # models.CharFiled(max_length=32)
        类实例对象---------表记录

      单表操作:

          model的元类信息:
              Book._meta.verbose_name
                '书籍'
                Book
                <class 'app01.models.Book'>
                Book._meta.model_name
                'book'
                Book._meta.app_label
                'app01'
        class Book(models.Model):
          title=models.CharField(max_length=32,verbose_name="书籍名称")


          def __str__(self):
            return self.title
          class Meta:
            app_label="APP01"
            db_table="app01book"
            unique_together=["title","price"]
            verbose_name="书籍"
            ordering=["price"]


        class Book(models.Model):
          id=models.AutoField(primary_key=True)
          title=models.CharField(max_length=32)
          state=models.BooleanField()
          pub_date=models.DateField()
          price=models.DecimalField(max_digits=8,decimal_places=2)
          publish=models.CharField(max_length=32)


        更多参数:
          (1)null

            如果为True,Django 将用NULL 来在数据库中存储空值。 默认值是 False.

          blank

            如果为True,该字段允许不填。默认为False。
            要注意,这与 null 不同。null纯粹是数据库范畴的,而 blank 是数据验证范畴的。
            如果一个字段的blank=True,表单的验证将允许该字段是空值。如果字段的blank=False,该字段就是必填的。

          (2)default

            字段的默认值。可以是一个值或者可调用对象。如果可调用 ,每有新对象被创建它都会被调用。

          (3)primary_key

            如果为True,那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True,
            Django 就会自动添加一个IntegerField字段做为主键,所以除非你想覆盖默认的主键行为,
            否则没必要设置任何一个字段的primary_key=True。

          (4)unique

            如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的

          (5)choices
            由二元组组成的一个可迭代对象(例如,列表或元组),用来给字段提供选择项。 如果设置了choices ,默认的表单将是一个选择框而不是标准的文本框,<br>而且这个选择框的选项就是choices 中的选项。

       数据库配置:
          DATABASES = {
            'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME':'bms',      # 要连接的数据库,连接前需要创建好
            'USER':'root',       # 连接数据库的用户名
            'PASSWORD':'',       # 连接数据库的密码
            'HOST':'127.0.0.1', # 连接主机,默认本级
            'PORT':3306     # 端口 默认3306
              },

            'app01': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME':'bms',      # 要连接的数据库,连接前需要创建好
            'USER':'root',       # 连接数据库的用户名
            'PASSWORD':'',       # 连接数据库的密码
            'HOST':'127.0.0.1', # 连接主机,默认本级
            'PORT':3306     # 端口 默认3306
              },

            }

           针对每一个注册的app下的models.py创建对应的表结构

            python manage.py makemigrations

            python manage.py migrate

          添加记录:         

              book_obj=Book.objects.create(title="python葵花宝典",state=True,price=100,publish="苹果出版社",pub_date="2012-12-12")       
              

              book_obj=Book(title="python葵花宝典",state=True,price=100,publish="苹果出版社",pub_date="2012-12-12")      
              book_obj.save()  

          查询表记录:

    <1> all():                  查询所有结果
    
    <2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象
      
    <3> get(**kwargs):          返回与所给筛选条件相匹配的对象,返回结果有且只有一个,
                                如果符合筛选条件的对象超过一个或者没有都会抛出错误。
      
    <4> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象
     
    <5> order_by(*field):       对查询结果排序
      
    <6> reverse():              对查询结果反向排序
      
    <8> count():                返回数据库中匹配查询(QuerySet)的对象数量。
      
    <9> first():                返回第一条记录
      
    <10> last():                返回最后一条记录
      
    <11> exists():              如果QuerySet包含数据,就返回True,否则返回False
     
    <12> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列
                                model的实例化对象,而是一个可迭代的字典序列
                                
                                
                                Book.objects.filter(price__gt=100).values("title","price")
                                '''
                                queryset=[]
                                for obj in Book.objects.filter(price__gt=100):
                                    queryset.append({
                                        "title":obj.title,
                                        "price":obj.price
                                    
                                    })
                                
                                '''
                                
    <13> values_list(*field):   它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列
                                
                                    Book.objects.filter(price__gt=100).values("title","price")
                                '''
                                queryset=[]
                                for obj in Book.objects.filter(price__gt=100):
                                    queryset.append((
                                        obj.title,
                                        obj.price
                                    
                                    ))
                                
                                '''
                                
                                
                                
    <14> distinct():            从返回结果中剔除重复纪录
    View Code

          基于双下划线的模糊查询

    Book.objects.filter(price__in=[100,200,300])
    Book.objects.filter(price__gt=100)
    Book.objects.filter(price__lt=100)
    Book.objects.filter(price__range=[100,200])
    Book.objects.filter(title__contains="python")
    Book.objects.filter(title__icontains="python")
    Book.objects.filter(title__startswith="py")
    Book.objects.filter(pub_date__year=2012)
    Book.objects.filter(pub_date__year__gt=2012)
    View Code

          删除表记录

    Book.objects.filter(price__in=[100,200,300]).delete()
    Book.objects.get(pk=1).delete()

          修改表记录

    1 # 方式1
    2 Book.objects.filter(title__startswith="py").update(price=120)
    3 # 方式2
    4 book=Book.objects.filter(title__startswith="py").first()
    5 book.price=1000
    6 book.save()

      多表操作

    from django.db import models
    
    # Create your models here.
    
    
    class Author(models.Model):
        nid = models.AutoField(primary_key=True)
        name=models.CharField( max_length=32)
        age=models.IntegerField()
    
        # 与AuthorDetail建立一对一的关系
        authorDetail=models.OneToOneField(to="AuthorDetail",on_delete=models.CASCADE)
    
    class AuthorDetail(models.Model):
    
        nid = models.AutoField(primary_key=True)
        birthday=models.DateField()
        telephone=models.BigIntegerField()
        addr=models.CharField( max_length=64)
    
    class Publish(models.Model):
        nid = models.AutoField(primary_key=True)
        name=models.CharField( max_length=32)
        city=models.CharField( max_length=32)
        email=models.EmailField()
        '''
            create table app01_publish(
               nid   INT auto_increment primary key
               name  varchar(32)
               city  varchar(32)
               email varchar(32)
            
            )
        
        '''
    
    
    class Book(models.Model):
    
        nid = models.AutoField(primary_key=True)
        title = models.CharField( max_length=32)
        publishDate=models.DateField()
        price=models.DecimalField(max_digits=5,decimal_places=2)
    
        # 与Publish建立一对多的关系,外键字段建立在多的一方
        publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE)
        # 与Author表建立多对多的关系,ManyToManyField可以建在两个模型中的任意一个,自动创建第三张表
        authors=models.ManyToManyField(to='Author',)
        '''
            create table app01_book(
                   nid   INT auto_increment primary key
                   title  varchar(32)
                   publishDate  date
                   price decimal(5,2)
                   publish_id  INT
                   ForeignKey publish_id references Publish(nid)
            )
            
            
            create book_authors(
                 id   INT auto_increment primary key
                 book_id INT
                 ForeignKey book_id references app01_book(nid)
    
                 author_id INT
                 ForeignKey author_id references app01_author(nid)                             
            )
        
        '''
    表关系

        1.添加记录

          针对一对多

    1 book_obj=Book.objects.create(title="python葵花宝典",price=100,publishDate="2012-12-12",publish_id=1)
    2 
    3 pub_obj=Publish.objects.get(pk=1)
    4 book_obj=Book.objects.create(title="python葵花宝典",price=100,publishDate="2012-12-12",publish=pub_obj)

          针对多对多

    book_authors
    
      id  book_id    author_id
      
       4    2           3
       5    1           4
     book=Book.objects.get(pk=1)
     book.authors.add(1,2,3)
     
     book=Book.objects.get(pk=2)
     book.authors.add(3)
     
     book=Book.objects.get(pk=1)
     book.authors.remove(2,3)
    
     book=Book.objects.get(pk=1)
     book.authors.clear()
    
     book=Book.objects.get(pk=1)
     book.authors.set([4,5]) # 列表不打散

          补充中介模型

    class Student(models.Model):
        name = models.CharField( max_length=32)
        courses=models.ManyToManyField("Courses",through="Score")    #*****
    
    class Course(models.Model):
        name = models.CharField( max_length=32)
    
    class Score(models.Model):
         student=models.ForeignKey("Student")
         course=models.ForeignKey("Course")
         score=models.IntegerField()

          跨表查询

          基于对象(子查询):正向查询按字段,反向查询relate_name,如果没有设置,按表名小写_set

    book=Book.objects.get(pk=1)
    book.publish
    book.authors.all()
    
    pub=Publish.objects.get(pk=1)
    pub.xxx.all()
    
    author=Author.objects.get(pk=1)
    author.book_set.all()
    
    author.authordetail
    authordetail.author

          基于双下划线(join查询)

    查询python出版社的名字

    Book.objects.filter(title="python").values("publish__name")    
    Publish.objects.filter(book__title="python").values("name")        

    查询以“a”开头的作者出版过的书籍名称

    Author.objects.filter(name__startswith="a").values("book__title")
    Book.objects.filter(authors__name__startswith="a")

          分组查询(基于双下划线(join查询))

            聚合:计算所有图书的平均价格

    Book.objects.all().aggregate(AVG("price"))

            分组

    id  name age   salary    dep
    1   alex  12   2000     销售部
    2   egon  22   3000     人事部
    3   wen   22   5000     人事部
                                                    
    sql:select dep,AVG(salary)  from  emp  group by  dep
    
    orm:Emp.objects.values("dep").annotate(avg=AVG("salary")) # [{"dep":"销售","avg":5000},{}]                         
    View Code

            跨表分组查询

    查询每一个出版社的名称以及出版书籍的个数
    
    id   title     pub_id      id   name
     1   python       1        1    沙河
     2   linux        1        1    沙河
     3   go           2        2    北京
     
     
    Publish.objects.values(pk).annotate(c=Count("book")) # [{pk:1,c:2},{pk:2,c:1}]
    Publish.objects.all.annotate(c=Count("book")).values("c","name") # [publish_obj,publish_obj]
    
    
    # 查询每一个作者的名字以及出版书籍的最高价格
    Author.objects.annotate(max_price=Max("book__price")).values("name","max_price")
    
    # 查询96年以后出生的每一个作者的名字以及出版书籍的最高价格
    Author.objects.filter(birthday__year__gt=1996).annotate(max_price=Max("book__price")).values("name","max_price")
    
    # 查询不止一个作者的书籍名称以及关联的作者个数
    Book.objects.all().annotate(c=Count("authors"))# [book1,book2,.....]
    Book.objects.all().annotate(c=Count("authors")).filter(c__gt=1).values("title","c")
    View Code

            F与Q

     1  Book.objects.filter(commnetNum__lt=F('keepNum'))
     2  Book.objects.filter(commnetNum__lt=F('keepNum')*2)               
     3  Book.objects.all().update(price=F("price")+30)             
     4  
     5  Book.objects.filter(Q(title__startswith="py")|Q(price__gt=100))
     6  
     7  q=Q()
     8  q.conector="or"
     9  q.children.append(("title__startswith","py"))
    10  q.children.append(("price__gt",100))

    Django组件:

      1.文件上传

        form表单

    <form action="/file_put/" method="post" enctype="multipart/form-data">
        姓名<input type="text" name="user">
        文件<input type="file" name="file_obj">
        <input type="submit">
    </form>

        ajax形式

    <div>
        姓名<input type="text" id="user">
        文件<input type="file" name="file_obj" id="file">
        <input type="button" class="filebtn" value="提交">
        <p class="msg"></p>
    </div>
    
    // 发送文件
      $(".filebtn").click(function () {
    
    
          var formdata=new FormData();
          formdata.append("file_obj",$("#file")[0].files[0]);
          formdata.append("user",$("#user").val());
    
          $.ajax({
              url:"/file_put/",
              type:"post",
    
              // Ajax上传文件必备参数
              processData: false ,    // 不处理数据
              contentType: false,    // 不设置内容类型
    
              data:formdata,
              success:function (response) {
                  console.log(response);
                  if (response=="OK"){
                      $(".msg").html("提交成功!")
                  }
              }
          })
          
      })
    View Code

        视图:

    def file_put(request):
    
        print(request.POST)
        print(request.FILES)
        file_obj=request.FILES.get("file_obj")
        # 文件对象有一个name属性,获取文件名称字符串
        print(file_obj.name)
        path=file_obj.name
    
        path=os.path.join(settings.BASE_DIR,"media","img",path)
        with open(path,"wb") as f:
            for line in file_obj:
                f.write(line)
    
        return HttpResponse("OK")

      2.cookie,session,auth

        cookie概念:

            针对每一个服务器,保存在客户端(浏览器)的一个key-value结构数据,可以理解成一个字典结构

        cookie语法:

    obj=HttpResponse()
    obj=render()
    obj=redirect()
    # 设置cookie
    obj.set_cookie("key","value",3600*24)
    # 获取cookie
    request.COOKIES
    # 删除cookie
    obj.delete_cookie("key","value")

        应用:登录认证,验证码,保存上次访问时间,浏览过的商品

        session语法:

    # 设置session
    
    request.session["key"]="value"
       '''
        if request.cookie("session_id"):
            1 获取随机字符串session_id:21342saidf92349
            2 去django-seeson表中过滤session-key=21342saidf92349的记录
                session-key         session-data
                21342saidf92349    {"key":"value"}
            3 更新:
        else:                            
       
       
            1 生成一个随机字符串:21342saidf92349
            2 去django-seeson表中创建一条记录
                session-key         session-data
                21342saidf92349    {"key":"value"}
            3 响应setcookie("session_id",21342saidf92349)
       '''
    # 获取session
       request.seesion["key"]
       '''
         1 获取cookie中key为session_id的对应值:21342saidf92349
         2 去django-session表中过滤session-key=21342saidf92349的记录对象obj
         3 obj.session-data.get("key"")
       
       '''
    View Code
  • 相关阅读:
    【问题】解决python3不支持mysqldb
    《Craking the Coding interview》python实现---02
    《Craking the Coding interview》python实现---01
    python标准库--functools.partial
    Multimodal Machine LearningA Survey and Taxonomy
    概率热图的绘制--gradcam
    Pytorch 技巧总结(持续更新)
    linux教训
    Destruction and Construction Learning for Fine-grained Image Recognition----论文
    Ubuntu16.04+3090+cuda11.0+cudnnV8+pytorch-nightly
  • 原文地址:https://www.cnblogs.com/qq849784670/p/10003855.html
Copyright © 2011-2022 走看看