Django周总结一

Django周复习总结：

 1，web基础知识
 2，django生命周期
 3，django下载，安装，django中文件解析，wsgiref模块
 4，路由层：路由与视图函数对应关系(urls.py)
 5，视图层
 6，模板层
 7，模型层
 8，事务，字段，数据库连接，数据库查询优化，
 9，静态文件配置，settins源码，request方法，form表单提交数据
 10，伪静态，虚拟环境，django版本区别，名称空间
 11，新增测试脚本，配置文件中增加配置查看sql语句
 
 
 
 
 1，web基础知识：
  1，什么是web框架
   所有的Web应用本质上就是一个socket服务端，而用户的浏览器就是一个socket客户端。
   这样我们就可以自己实现Web框架了
   也就是说是bs架构
    软件开发架构
     c/s架构
      客户端
      服务端
     b/s架构
      浏览器
      服务器
     本质:b/s架构其实也是c/s架构
   2，http协议：******
    1，为什么要有http协议：
     有了客户端和服务端，那么用户在浏览器输入网址，会给服务端发送数据，那浏览器会发送什么数据？
     怎么发？这个谁来定？ 你这个网站是这个规定，他那个网站按照他那个规定，这互联网还能玩么？
     所以，必须有一个统一的规则，让大家发送消息、接收消息的时候有个格式依据，不能随便写。
     这个规则就是HTTP协议，以后浏览器发送请求信息也好，服务器回复响应信息也罢，都要按照这个规则来。
    2，http协议是什么？
     超文本传输协议:规定了客户端与服务端消息传输的格式
      四大特性:
       1.基于TCP/IP协议作用于应用层的协议
       2.基于请求响应
       3.无状态
       4.无连接
      
      数据格式之请求:
       请求首行
       请求头(一堆k,v键值对)
       
       请求体(post请求携带的数据)
      数据格式之响应:
       响应首行
       响应头(一堆k,v键值对)
       
       响应体(post请求携带的数据)
      
      
      响应状态码
       1XX 服务器已经成功接受到你的数据正在处理，你可以继续提交其他数据
       2XX 请求成功 服务器已经将你请求的数据发送给你了
       3XX 重定向
       4XX 请求资源不存在
       5XX 服务器错误
   3,动静态网页：
     静态网页:
      页面上的数据都是写死的，万年不变
     动态网页:
      页面上的数据是从后端动态获取的
      比如后端获取当前时间
      后端获取数据库数据然后传递给前端页面
  
  2，python三大主流web框架*****
   1，Django
   2，Flask
   3，Tornado
   
   Django:大而全，自带了很多功能模块，类似于航空母舰 (缺点:有点笨重)
   Flask:短小精悍,自带的功能模块特别少，大部分都是依赖于第三方模块(小而轻)
   Tornado:异步非阻塞 主要用在处理高io 多路复用的情况 可以写游戏后端
   
 2，Django生命周期：******
  
   浏览器-->uwsgi(wsgiref模块文件）-->???(?)-->urls.py(路由层）
    -->views.py(视图层）
       -->templates文件夹（模板层）--视图层
       -->models.py(orm模型层）-->数据库
    
   图解：
   
 3，django下载，安装，django中文件作用解析，wsgiref模块
   1注意事项(*******************):
    1.计算机的名称不能有中文
    2.一个pycharm窗口就是一个项目，不要多个项目放在一个窗口里面
    3.项目名不能起中文
   2， 版本问题
    djang下载（在pycharm中直接搜索即可）
     推荐下载1.11.11版本
    命令行直接下载：
     pip3 install django==1.11.11
    验证是否下载成功
     django-admin
     
   3，创建django项目的方式：******
    方式1：在命令行创建
     创建django项目：
      django-admin startproject 项目名
     创建app应用：
      python manage.py startapp app01
     启动django项目
      python manage.py runserver
      
     ps:用命令行创建django默认不会自动创建templates文件夹
     需要你手动自己创建(注意改文件夹路径是否被添加配置文件中)
   
    方式2(pycharm创建)
     FILE >>> new project 选择第二个django 需要注意名字不能有中文，选择本地的解释器，勾选后台管理
     创建app
      pycharm命令行创建
       python3 manage.py startapp app01
      Tools下面run manage task功能栏
     启动点小绿色箭头
     
    强调:
     1.用django一定要保证只有一个在运行状态  切记切记！！！！！！！
     2.一定记得清浏览器的缓存
   
   4，app(应用)的概念
    一个django项目就是一所大学
    app就是大学里面的学院
    
    
    注意新创建的app需要在配置文件中注册才能生效(*****)
    在settings.py  文件中找到INSTALLED_APPS中添加：
     INSTALLED_APPS = ['app01.apps.App01Config'  # 可以用全称
         'app01'      # 也可以简写]
 
   5，django中各个文件作用解析
    应用名
     migrations  数据库迁移记录相关数据
     admin.py    django后台管理相关
     models.py   模型表相关
     views.py    视图函数相关
   
    项目名
     settings.py  配置文件
     urls.py  路由与视图函数的映射关系
    templates
     项目用到的所有的html文件
    manage.py
     django入口文件
  6，wsgi（wsgiref模块文件）
   它对html和socket进行了封装，把数据整理成了一个大字典

  7，django小白必会三板斧******
   from django.shortcuts import render,HttpResponse,redirect
   
   HttpResponse  返回字符串
   render        返回一个html页面
    两种给前端页面传值的方式
     def reg(request):
      user_dict = {'name':'jason','password':'123'}
      return render(request,'reg.html',{'user_dict':user_dict})
     
     def reg(request):
      user_dict = {'name':'jason','password':'123'}
      return render(request,'reg.html',locals())
      
   redirect   重定向
   
 4，路由层：路由与视图函数对应关系（urls.py)
  1，url：
   统一资源定位符
  2，URL的配置
   在1.x版本中
    1,url 中的参数
     第一个参数是正则表达式，第二参数是视图函数
     基本格式：
    
      from django.conf.urls import url

      urlpatterns = [
        url(正则表达式, views视图函数，参数，别名),
      ]
      第一个参数是正则表达式的字符串，
      第二参数是views视图函数：一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串  
      参数：可选的要传递给视图函数的默认参数（字典形式）   
      别名：一个可选的name参数
      
      网站首页路由
      url(r'^$',views.home)
      网站不存在页面
      url(r'',views.error)
      
       案例：from app01 import views

        urlpatterns = [
         url(r'^admin/', admin.site.urls),
         url(r'^$', views.home)，# 主页
         url(r'^delete_book/(?P<delete_id>d+)/',views.delete_book,name='delete'),
      
     ps：在url中的正则表达式匹配注意事项：
       1，urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则不再继续。
       2，若要从URL中捕获一个值，只需要在它周围放置一对圆括号（分组匹配）。
       3，不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
       4，每个正则表达式前面的'r' 是可选的但是建议加上。
      补充：
       Django settings.py配置文件中默认没有 APPEND_SLASH 这个参数，
        但 Django 默认这个参数为 APPEND_SLASH = True。
        其作用就是自动在网址结尾加'/'。
       取消自动加/
       在 settings配置文件中加以下代码：
        APPEND_SLASH=False  该参数默认是True
        # 是否开启URL访问地址后面不为/跳转至带有/的路径的配置项
   
    2，分组命名匹配
     使用简单的正则表达式分组匹配（通过圆括号）来捕获URL中的值并以位置参数形式传递给视图。
     在更高级的用法中，可以使用分组命名匹配的正则表达式组来捕获URL中的值并以关键字参数形式传递给视图。
     在Python的正则表达式中，分组命名正则表达式组的语法是(?P<name>pattern)，其中name是组的名称，pattern是要匹配的模式。
     
     url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
     传递到视图函数views.year_archive() 中的year 参数永远是一个字符串类型
     
     1，无名分组 ******
      url(r'^test/([0-9]{4})/', views.test)
      路由匹配的时候 会将括号内正则表达式匹配到的内容 当做位置参数传递给视图函数
      test(request,2019)
     2，有名分组 ******
       url(r'^test/(?P<year>d+)/', views.test)
       路由匹配的时候 会将括号内正则表达式匹配到的内容 当做关键字参数传递给视图函数
       test(request,year=2019)
      
     3，视图函数中指定默认值
      # urls.py中
      from django.conf.urls import url

      from . import views

      urlpatterns = [
       url(r'^blog/$', views.page),
       url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
      ]

      # views.py中，可以为num指定默认值
      def page(request, num="1"):
       pass
      在上面的例子中，两个URL模式指向相同的view - views.page - 但是第一个模式并没有从URL中捕获任何东西。
      如果第一个模式匹配上了，page()函数将使用其默认参数num=“1”,
      如果第二个模式匹配，page()将使用正则表达式捕获到的num值。
      
     4.反向解析，reverse
       本质:其实就是给你返回一个能够返回对应url的地址
       三步骤：
        1，先给url和视图函数起别名
        2,反向解析,关键字reverse
         后端反向解析
          后端可以在任意位置通过reverse反向解析出对应的url   ********
          from django.shortcuts import render,HttpResponse,redirect,reverse
          reverse('kkk')
          
         前端反向解析
          {% url 'kkk' %}
       无名分组反向解析

        url(r'^index/(d+)/$',views.index,name='kkk')
        
        后端反向解析
         reverse('kkk',args=(1,))  # 后面的数字通常都是数据的id值
        前端反向解析
         {% url 'kkk' 1%}   # 后面的数字通常都是数据的id值 
     
       有名分组反向解析
        同无名分组反向解析意义的用法
         url(r'^index/(?P<year>d+)/$',views.index,name='kkk')
 
         后端方向解析
          print(reverse('kkk',args=(1,)))  # 推荐你使用上面这种  减少你的脑容量消耗
          print(reverse('kkk',kwargs={'year':1}))
         前端反向解析 
          <a href="{% url 'kkk' 1 %}">1</a>  # 推荐你使用上面这种  减少你的脑容量消耗
          <a href="{% url 'kkk' year=1 %}">1</a>

       注意:在同一个应用下 别名千万不能重复!!!
     
     5，路由分发： include（）
      当你的django项目比较庞大时，就需要路由分发，路由与视图对应关系特别多的时候
       那么你的总路由urls.py代码太过冗长  不易维护
       
       正是基于上述条件 可以实现多人分组开发 等多人开发完成之后  我们只需要创建一个空的django项目
       然后将多人开发的app全部注册进来 在总路由实现一个路由分发 而不再做路由匹配(来了之后 我只给你分发到对应的app中)
       
      ps：每一个应用都可以有自己的urls.py,static文件夹,templates文件夹(******)
       当你的应用下的视图函数特别特别多的时候  你可以建一个views文件夹 里面根据功能的细分再建不同的py文件(******)
       
      案列：
        urlpatterns = [
         url(r'^admin/', admin.site.urls),
         url(r'^app01/',include('app01.urls')),
         url(r'^app02/',include('app02.urls')),

        ]
     
     
     
     ps：# 无名分组有名分组不能混合使用 !!!
      url(r'^test/(d+)/(?P<year>d+)/', views.test),

      但是用一种分组下 可以使用多个
       # 无名分组支持多个
       # url(r'^test/(d+)/(d+)/', views.test),
       # 有名分组支持多个
       # url(r'^test/(?P<year>d+)/(?P<xx>d+)/', views.test),  
 5,视图层（views.py)
  1,三板斧：
   HttpResponse：返回一个字符串  return HttpResponse('hjfkljdsfj')
   render：返回一个html页面         return render(request,'edit_book.html',locals())
   redircet：重定向    return redirect(reverse('list'))
   
   from django.shortcuts import render,HttpResponse,redirect
   
   前后端分离
    前端一个人干(前端转成自定义对象)
     JSON.stringify()        json.dumps()
     JSON.parse()   json.loads()
    后端另一个干(python后端用字典)
    只要涉及到数据交互,一般情况下都是用的json格式
    后端只负责产生接口,前端调用该接口能拿到一个大字典
    后端只需要写一个接口文档 里面描述字典的详细信息以及参数的传递
  2.JsonReponse
   from django.http import JsonResponse
   def index(request):
    data = {'name':'jason好帅哦 我好喜欢','password':123}
    l = [1,2,3,4,5,6,7,8]
    # res = json.dumps(data,ensure_ascii=False)
    # return HttpResponse(res)
    # return JsonResponse(data,json_dumps_params={'ensure_ascii':False})
    return JsonResponse(l,safe=False)  # 如果返回的不是字典 只需要修改safe参数为false即可
    
    
    
    
  3.上传文件
   form表单上传文件需要注意的事项
    1.enctype需要由默认的urlencoded变成formdata
    2.method需要由默认的get变成post
    (目前还需要考虑的是 提交post请求需要将配置文件中的csrf中间件注释)

    如果form表单上传文件 后端需要在request.FILES获取文件数据 而不再是POST里面
    file_obj = request.FILES.get('my_file')
    print(file_obj.name)
    with open(file_obj.name,'wb') as f:
     for line in file_obj.chunks():
      f.write(line)
      
      
     request.method
     request.GET
     request.POST
     request.FILES
     request.path  # 只回去url后缀 不获取?后面的参数
     request.get_full_path()  # 后缀和参数全部获取
    
    简单的文件上传
     前端:
      1.method由默认的get改为post
      2.enctype由默认的urlencoded改为formdata
     后端:
      1.暂时先去settings.py中将csrfmiddleware中间件注释掉
      2.从request.FILES中获取文件数据

  4，FBV与CBV
   视图函数并不只是指函数，也可以是类
    FBV(基于函数的视图）面向函数式编程
    CBV（基于类的视图） 面向对象式编程
   
   
   1,Fbv
   2,CBV（基于类的视图）
    as_view（）
    from django.views import View
     
     urls.py中
     url(r'^login/',views.MyLogin.as_view())
     
     views.py中
     CBV：
     url(r'^mycls/',views.MyCls.as_view())

     class MyCls(View):
      def get(self,request):
       return render(request,'index.html')
      def post(self,request):
       return HttpResponse('post')

     无论是FBV还是CBV路由层都是路由对应视图函数内存地址
     urlpatterns = [
      # url(r'^mycls/',views.view)
      url(r'^mycls/',views.MyCls.as_view())
     ]

     class MyCls(View):
      def get(self,request):
       return render(request,'index.html')
      def post(self,request):
       return HttpResponse('post')
       
 6.模板层：
  1.模板语法
   {{}}   变量相关
   {%%}   逻辑相关
   
   1，传值及取值
    为模板传值：
     方式1，字典形式
      return render(request,'reg.html',{'n':n,'f':f})
     方式2，locals()
      return render(request, 'reg.html',locals())
    前端取值：
      {{变量名}}
   2，那些数据 可以被传到前端
    1，python的所有数据类型都可以
    2，函数，只支持无参函数
     传函数名，会自动加括号调用该函数，前端展示的是函数调用之后的返回值，
     若函数没有返回值，就会展示None，你返回什么就展示什么
     注意：如果函数需要参数的话，模板语法不支持，即用不了模板语法，用直接报错
    3，类
    总结：django的模板语法，不支持给函数传参
    案列：
     class Demo(object):
      def get_self(self):
       return '绑定给对象的方法'
      @classmethod
      def get_cls(cls):
       # 类绑定方法，不管是对象还是类来调，都会把类当做第一个参数传入
       return '绑定给类方法'
      @staticmethod
      def get_static():
       return '我是静态方法 其实就是函数自身'
     obj = Demo()
     return render(request, 'reg.html',locals())
    
     <p>{{ obj }}</p>   #结果为对象的内存地址：<app02.views.reg.<locals>.Demo object at 0x0000015E7D9B7B70>
     <p>{{ obj.get_cls }}</p> #结果：绑定给类方法
     <p>{{ obj.get_self}}</p> #结果：绑定给对象的方法
     <p>{{ obj.get_static }}</p>  # 结果：我是静态方法 其实就是函数自身
   
   3，过滤器  |
    模板语法之过滤器：内部原理(会将|前面的当做第一个参数传入|后面的方法中
    1，统计长度：length     如果是字典 统计的是键值对的个数
     {{ n|length }}
    2，default：''   必须要有两个参数 （如果default后面没有设默认值就返回None）
     <p>{{ n|default:'当|左边的变量为空就会返回|右边的值' }}</p>
     
     |add                       增加
     |default     默认值
     |filesizeformat    计算文件大小 按多少MB划分
     |truncatewords    截断文字，就是按空格截取内容  三个点不
     |truncatechars              截断文字，就是按字符截取内容  三个点也算
     |safe      前端取消转义
     |slice      切片
     |date {{ value|date:"Y-m-d H:i:s"}}   时间  年月日 时分秒
     
     再views.py中  后端取消转义： mark_safe
        from django.utils.safestring import mark_safe
        zzz = mark_safe('<h1>阿萨德搜啊第三款垃圾袋</h1>')
       前端：<p>{{ zzz }}</p>
       
   4，模板语法之标签（逻辑相关）
     1，for循环
     {% for foo in d %}
      {{ foo }}     此时哪里出来就是一个个键 ，如果是列表，就是列表中的值
     {% endfor %}
     
     {% for foo in d %}
      <p>{{ forloop }}</p>
      #通过此forloop可以知道第一次最后一次循环是谁
     {% endfor %}
     2，if
      {% if n %}
       <p>n有值条件为true</p>
        {% else %}
        <p>n无值条件为false</p>
      {% endif %}
     3，for循环if嵌套
      {% for foo in l %}
      {#    {% for foo in '' %}#此时为空就会走empty}
       {% if forloop.first %}
        <p>这是第一次</p>
        
        {% elif forloop.last %}
        <p>这是最后一次</p>
        
        {% else %}
        <p>来啊来啊！！！</p>
       {% endif %}
       {% empty %}
       <p>当for循环的对象为空的时候 会走empty</p>
      {% endfor %}
      
    注意：django的模板语法在取值的时候统一使用句点符 ，（大白话就是 点号   .）
   
     l = [1,2,3,4,5,6,[1,2,4{'name':'haha'}]]
     {{ l.6.3.name }} 此时就取到为haha     按索引取值
     
     <p>
      {% with l.6.3.name as yyy  %}    #起别名
       {{ yyy }}           取到为haha        
       {{ l.6.3.name }}   取到为haha
      {% endwith %}
     </p>
   
   5，字典获取不同的数据
     {% for foo in d.keys %}
      <p>{{ foo }}</p>
     {% endfor %}
     {% for foo in d.values %}
      <p>{{ foo }}</p>
     {% endfor %}
     {% for foo in d.items %}   获取到的结果是以元祖的形式
      <p>{{ foo }}</p>
     {% endfor %}
     
     和python中的字典三个意思一样，获取所有key，所有值，所有键值对（元祖形式）
   6，自定义标签，自定义过滤器
     自定义标签 过滤器 inclusion_tag
     自定义固定的三步走战略:
      1.必须在你的应用下新建一个名为templatetags文件夹
      2.在该文件夹内新建一个任意名称的py文件
      3.在该py文件中固定先写下面两句代码
       from  django import template
       
       register = template.Library()
       
       案列：
       from django import template
       register = template.Library()
      # 自定义过滤器
       @register.filter(name='ttt')
       def index(a,b):
        #该过滤器只做加法运算
        return a+b
       
       在reg.html文件中：
       <h1>自定义过滤器的使用</h1>
       {% load mystg %}   #表示导入mystg.py文件 （下面如果引用，导入一次后无需再次导入，和导入模块的作用类似）
       {{ 234|ttt:1 }}
   7，模板继承*****
    {% extends 'home.html' %}   继承home.html母版
    在html文件中：
    1，在head头部内
     {% block css %}
      子页面自己的css代码
     {% endblock %}
    2，在body内：
     {% block content %}
      子页面自己的html代码
     {% endblock %}
    3，在body体下面：
     {% block js %}
      子页面自己的js代码
     {% endblock %}
    ps:那个html文件想要继承母版，就直接在自己的html文件中用 
     {% extends 'home.html' %}
     假如home.html是母版文件
     2，进行更改：
      {% block content %}
       子页面自己的html代码
      {% endblock %}
      css， js 都可以
   8，模板导入：
    {% include 'beautiful.html' %}
   
    当你写了一个特别好看的form表单/列表标签等
    可以将它当成一个模块 哪个地方需要 就直接导入使用即可
 7，模型层：
  周复习二 
  
 8，事务，字段，数据库连接，数据库查询优化，
  周复习二
   
 9，静态文件配置，settins源码，request方法，form表单提交数据
  1，静态文件配置
   大前提:浏览器之所以能够输入网址访问到对应的资源,是因为后端开设了资源的访问接口(url),
    django在何处可以开设接口???   urls.py路由与视图函数对应关系
    
    网址所用到的html文件通常都是放在templates文件夹下
    网站所用到的静态资源通常都是放在static文件夹下
   django 配置文件中指定静态文件暴露的接口
    在settings.py文件中：
     STATIC_URL = '/static/'  # 仅仅是访问静态资源的接口前缀
     STATICFILES_DIRS = [
      os.path.join(BASE_DIR,'static'),  # 一旦你是以接口前缀开头的 那么就会自动拿着接口前缀后面的文件路径去列表中一个个的文件夹中查找文件
      os.path.join(BASE_DIR,'static1'),
      os.path.join(BASE_DIR,'static2'),
     
     ]
    在html文件中： 
     静态文件路径动态解析
     {% load  static %}
     {% static '文件路径' %} 
  
  2，form表单提交数据 ******
   action
    1.不写默认朝当前url(http://127.0.0.1:8080/index/?id=1)提交
    2.只写后缀/index/或者/index/?id=1
    3.写全路径(你这个form要往其他网站的url提交数据)
   method
    默认是get请求
    
   get请求和post请求携带参数的特点
    get请求是直接在url后面?开头以&连接多个条件
    /index/?id=1&username=jason(get请求携带的参数大小是有限制的)
    
    而post请求数据是放在请求体中的
  3，request方法：*******
    request.methon  获取请求方式（get/post),全大写 的字符串
    request.GET     获取get请求携带的所有数据，类似是一个大字典
    request.POST    获取post请求携带的所有数据，类似是一个 大字典
    
     取值方式：
     request.POST.get('hobby') 默认获取列表的最后一个元素
     request.POST.getlist('hobby')  直接将列表原封不动的取出
    
    
    
  4，settings源码：
    django settings源码
   前提:
    1.django除了暴露给用户一个settings.py配置文件之外  自己内部还有一个全局的配置文件
    2.我们在使用配置文件的时候 可以直接直接导入暴露给用户的settings.py也可以使用django全局的配置文件 并且后者居多
     from django.conf import settings
    3.django的启动入口是manage.py
    
   import os
   import sys

   if __name__ == "__main__":
    # django在启动的时候 就会往全局的大字典中设置一个键值对  值是暴露给用户的配置文件的路径字符串
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day54.settings")
   
   class Settings(object):
    def __init__(self, settings_module):  # settings_module = 'day54.settings'
     # update this dict from global settings (but only for ALL_CAPS settings)
     for setting in dir(global_settings):  # django全局配置文件
      # dir获取django全局配置文件中所有的变量名
      if setting.isupper():  # 判断文件中的变量名是否是大写 如果是大写才会执行/生效
       setattr(self, setting, getattr(global_settings, setting))  # 给settings对象设置键值对
       # 给settings对象设置键值对  settings[配置文件中大写的变量名] = 配置文件中大写的变量名所对应的值

     # store the settings module in case someone later cares
     self.SETTINGS_MODULE = settings_module  # 'day54.settings'

     mod = importlib.import_module(self.SETTINGS_MODULE)  # mod = 模块settings(暴露给用户的配置文件)
     for setting in dir(mod):  # for循环获取暴露给用户的配置文件中所有的变量名
      if setting.isupper():  # 判断变量名是否是大写
       setting_value = getattr(mod, setting)  # 获取大写的变量名所对应的值
       setattr(self, setting, setting_value)  # 给settings对象设置键值对
       """
       d = {}
       d['username'] = 'jason'
       d['username'] = 'egon'
       用户如果配置了就用用户的
       用户如果没有配置就用系统默认的
       其实本质就是利用字典的键存在就是替换的原理 实现了用户配置就用用户的用户没配置就用默认的
       """
    
   class LazySettings(LazyObject):
     def _setup(self, name=None):
      # os.environ你可以把它看成是一个全局的大字典
      settings_module = os.environ.get(ENVIRONMENT_VARIABLE)  # 从大字典中取值键为DJANGO_SETTINGS_MODULE所对应的值:day54.settings
      # settings_module = 'day54.settings'
      self._wrapped = Settings(settings_module)  # Settings('day54.settings')

 

 10，伪静态，虚拟环境，django版本区别，名称空间
    
  1，伪静态，（了解）
   在url的第一参数正则表达式后加.html
   搜索优化seo
   url(r'^index.html',views.index,name='app01_index')
   
    静态网页:数据是写死的 万年不变
 
    伪静态网页的设计是为了增加百度等搜索引擎seo查询力度
    
    所有的搜索引擎其实都是一个巨大的爬虫程序
    
    网站优化相关  通过伪静态确实可以提高你的网站被查询出来的概率
    但是再怎么优化也抵不过RMB玩家
  2,django虚拟环境（了解）  
    
    一般情况下 我们会给每一个项目 配备该项目所需要的模块 不需要的一概不装
    虚拟环境 就类似于为每个项目量身定做的解释器环境
    
    
    如何创建虚拟环境
    每创建一个虚拟环境 就类似于你又下载了一个全新的python解释器
    
    ps:虚拟环境不易开多个，因为也要占用资源
  3，django的版本区别（了解）
    django1.X跟django2.X版本区别
    路由层1.X用的是url
    而2.X用的是path
    
    2.X中的path第一个参数不再是正则表达式,而是写什么就匹配什么 是精准匹配
    
    当你使用2.X不习惯的时候  2.X还有一个叫re_path
    2.x中的re_path就是你1.X的url
    
    虽然2.X中path不支持正则表达式  但是它提供了五种默认的转换器
 
    1.0版本的url和2.0版本的re_path分组出来的数据都是字符串类型
    默认有五个转换器，感兴趣的自己可以课下去试一下
    str,匹配除了路径分隔符（/）之外的非空字符串，这是默认的形式
    int,匹配正整数，包含0。
    slug,匹配字母、数字以及横杠、下划线组成的字符串。
    uuid,匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
    path,匹配任何非空字符串，包含了路径分隔符（/）（不能用？）
    
    path('index/<int:id>/',index)  # 会将id匹配到的内容自动转换成整型
    
   还支持自定义转换器
    class FourDigitYearConverter: 
    regex = '[0-9]{4}' 
    def to_python(self, value): 
     return int(value) 
    def to_url(self, value): 
     return '%04d' % value  占四位，不够用0填满，超了则就按超了的位数来！
    register_converter(FourDigitYearConverter, 'yyyy') 
    
    urlpatterns = [ 
      path('articles/2003/', views.special_case_2003), 
      path('articles/<yyyy:year>/', views.year_archive), 
      ... 
     ]
  4，名称空间
    名称空间(了解)
    多个app起了相同的别名 这个时候用反向解析 并不会自动识别应用前缀
    如果想避免这种问题的发生
    方式1:
    
     总路由
      url(r'^app01/',include('app01.urls',namespace='app01'))
      url(r'^app02/',include('app02.urls',namespace='app02'))

     后端解析的时候
      reverse('app01:index')
      reverse('app02:index')
     前端解析的时候
      {% url 'app01:index' %}
      {% url 'app02:index' %}
    
    方式2:
     起别名的时候不要冲突即可  一般情况下在起别名的时候通常建议以应用名作为前缀
      name = 'app01_index'
      name = 'app02_index'
 11，新增测试脚本，配置文件中增加配置查看sql语句
 
  1，在djang中新增测试脚本
   1，可以在根目录下新建一个py文件。列如test.py文件
   2，在文件中写入以下代码即可
   
   #!/usr/bin/env python
   import os
   import sys

   if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day55.settings")
    import django
    django.setup()
  
  2，配置文件中增加配置查看sql语句
   LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
     'console':{
      'level':'DEBUG',
      'class':'logging.StreamHandler',
     },
    },
    'loggers': {
     'django.db.backends': {
      'handlers': ['console'],
      'propagate': True,
      'level':'DEBUG',
     },
    }
   }