无名有名分组反向解析

    1. 无名分组反向解析
    2. re_path(r'^home/(\d+)/',views.home,name='xx')
    3. #前端
    4. <a href="{% url 'xx' 123 %}">a</a>
    5. #后端
    6. def home(request,*args):
    7.     reverse('xx', args=(1,))
    8. '''
    9. 因为无名分组是匹配数字，所有前后端也需要一起加数字
    10. 数字怎么放，一般来说放的是数据的主键值  --->用于数据的编辑和删除
    11.     url(r'^edit/(\d+)/',views.edit,name='xxx')
    13.     def edit(request,edit_id):
    14.         reverse('xxx',args=(edit_id,))
    16.     {%for user_obj in user_queryset%}
    17.         <a href="{% url 'xxx' user_obj.id %}">编辑</a>
    18.     {%endfor%}
    19. '''
    22. 有名分组反向解析-->两种方法二选一
    23. path('index/<int>',views.index,name='index')
    24. #前端
    25. <a href="{% url 'index' int=123 %}">a</a>
    26. or
    27. <a href="{% url 'index' 123 %}">a</a>
    28. #后端
    29. def index(request,**kwargs):
    30.     print(reverse('index',kwargs={'int':1}))
    31.     or
    32. def index(request,**kwargs):
    33.     print(reverse('index',args=(1,)))
    35. 总结:记得一定要拿参数接收

    路由分发

    1. '''
    2. django的每一个应用都可以有自己的templates文件夹 urls.py static文件夹
    3. 正是基于上述特点 django能够非常好的做到分组开发(每个人只写自己的app)
    4. 作为组长 只需要将手下书写的app全部拷贝到一个新的django项目中 然后在配置文件里面注册所有的app再利用路由分发的特点将所有的app整合起来
    6. 当一个django项目中的url非常多的时候，总路由就会显得非常冗余不太好进行维护
    7. 这个时候就可以利用路由分发来减轻总路由的压力
    9. 利用方式以及优点：利用路由分发之后 总路由不再做路由与视图函数的直接关系
    10. 而是利用一个分发处理
    11.     识别当前的url是属于哪个应用下的 直接分发给相应的应用去处理
    12. '''
    14. 总路由：
    15. from app01 import app01_urls
    16. from app02 import app02_urls
    18. urlpatterns = [
    19.     path('admin/', admin.site.urls),
    20.     path('app01/',include(app01_urls)),#只要url前缀是app01开头 全部交给app01处理
    21.     path('app02/',include(app02_urls)),#只要url前缀是app01开头 全部交给app02处理
    22. ]
    23. 举个栗子-->http://127.0.0.1:8000/app01/index/-->这就是交给app01处理
    25. 终极写法:无需导入
    26.     path('app01/',include('app01.app01_urls')),-->直接在include内导入
    27.     path('app02/',include('app02.app02_urls')),
    29. 子路由
    31. app01:
    32. from django.urls import path,re_path
    33. from app01 import views
    34.     urlpatterns = [
    35.     re_path(r'^index/',views.index)
    36. ]
    38. app02:
    39. from django.urls import path,re_path
    40. from app02 import views
    41.     urlpatterns = [
    42.         path('index/',views.index)
    43. ]

    名称空间（了解）

    1. # 当多个应用出现了相同的别名 我们研究反向解析会不会自动识别应用前缀
    2. """
    3. 正常情况下的反向解析是没有办法自动识别前缀的
    4. """
    5. app01：
    6. path('reg/', views.reg, name='reg')
    7. def reg(request):
    8.     print(reverse('reg'))
    9.     return HttpResponse('app01:reg')
    10. app02：
    11. path('reg/',views.reg,name='reg')
    12. def reg(request):
    13.     print(reverse('reg'))
    14.     return HttpResponse('app02:reg')
    15. 后端就会识别不了前缀 返回的是/app02/reg/
    17. # 名称空间
    18.     # 总路由
    19.     url(r'^app01/',include('app01.urls',namespace='app01')),
    20.     url(r'^app02/',include('app02.urls',namespace='app02'))
    21.   # 解析的时候
    22.       # app01
    23.       urlpatterns = [
    24.     url(r'^reg/',views.reg,name='reg')
    25.         ]
    26.     # app02
    27.     urlpatterns = [
    28.     url(r'^reg/',views.reg,name='reg')
    29.         ]
    31.       reverse('app01:reg')
    32.     reverse('app02:reg')
    34.     {% url 'app01:reg' %}
    35.     {% url 'app02:reg' %}
    36. # 其实只要保证名字不冲突 就没有必要使用名称空间
    37. """
    38. 一般情况下 有多个app的时候我们在起别名的时候会加上app的前缀
    39. 这样的话就能够确保多个app之间名字不冲突的问题
    40. """
    41. urlpatterns = [
    42.     url(r'^reg/',views.reg,name='app01_reg')
    43. ]
    44. urlpatterns = [
    45.     url(r'^reg/',views.reg,name='app02_reg')
    46. ]
    47. 反正这东西不加为好，加了就是一堆乱七八糟的错误

    伪静态（了解）

    1. """
    2. 静态网页
    3.     数据是写死的 万年不变
    5. 伪静态
    6.     将一个动态网页伪装成静态网页
    8.     为什么要伪装呢？
    9.         https://www.cnblogs.com/Dominic-Ji/p/9234099.html
    10.         伪装的目的在于增大本网站的seo查询力度
    11.         并且增加搜索引擎收藏本网上的概率
    13.     搜索引擎本质上就是一个巨大的爬虫程序
    15.     总结:
    16.         无论你怎么优化 怎么处理
    17.         始终还是干不过RMB玩家
    18. """
    19. urlpatterns = [
    20.     url(r'^reg.html',views.reg,name='app02_reg')
    21. ]

    反向解析（了解）

    1. # 通过一些方法得到一个结果 该结果可以直接访问对应的url触发视图函数
    2. path('dddsadasd/',views.ddd,name='ooo')
    3. 前端获取
    4. <a href="{% url 'ooo'%}">1</a>
    5. 后端获取的是views的url名
    6. from django.shortcuts import reverse
    7. print(reverse('ooo'))

    虚拟环境（了解）

    1. """
    2. 在正常开发中 我们会给每一个项目配备一个该项目独有的解释器环境
    3. 该环境内只有该项目用到的模块 用不到一概不装
    5. linux:缺什么才装什么
    7. 虚拟环境
    8.     你每创建一个虚拟环境就类似于重新下载了一个纯净的python解释器
    9.     但是虚拟环境不要创建太多，是需要消耗硬盘空间的
    11. 扩展:
    12.     每一个项目都需要用到很多模块 并且每个模块版本可能还不一样
    13.     那我该如何安装呢？ 一个个看一个个装？？？
    15.     开发当中我们会给每一个项目配备一个requirements.txt文件
    16.     里面书写了该项目所有的模块即版本
    17.     你只需要直接输入一条命令即可一键安装所有模块即版本
    18. """

    django版本区别

    1. """
    2. 1.django1.X路由层使用的是url方法
    3.     而在django2.Xhe3.X版本中路由层使用的是path方法
    4.     url()第一个参数支持正则
    5.     path()第一个参数是不支持正则的 写什么就匹配什么
    8.     如果你习惯使用path那么也给你提供了另外一个方法
    9.         from django.urls import path, re_path
    10.         from django.conf.urls import url
    12.         re_path(r'^index/',index),
    13.     url(r'^login/',login)
    14.   2.X和3.X里面的re_path就等价于1.X里面的url
    17. 2.虽然path不支持正则 但是它的内部支持五种转换器
    18.     path('index/<int:id>/',index)
    19.     # 将第二个路由里面的内容先转成整型然后以关键字的形式传递给后面的视图函数
    21.     def index(request,id):
    22.     print(id,type(id))
    23.     return HttpResponse('index')
    27.   str,匹配除了路径分隔符（/）之外的非空字符串，这是默认的形式
    28.     int,匹配正整数，包含0。
    29.     slug,匹配字母、数字以及横杠、下划线组成的字符串。
    30.     uuid,匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
    31.     path,匹配任何非空字符串，包含了路径分隔符（/）（不能用？）
    33. 3.除了有默认的五个转换器之外 还支持自定义转换器(了解)
    34.     class MonthConverter:
    35.     regex='\d{2}' # 属性名必须为regex
    37.     def to_python(self, value):
    38.         return int(value)
    40.     def to_url(self, value):
    41.         return value # 匹配的regex是两个数字，返回的结果也必须是两个数字
    44.     from django.urls import path,register_converter
    45.     from app01.path_converts import MonthConverter
    47.     # 先注册转换器
    48.     register_converter(MonthConverter,'mon')
    50.     from app01 import views
    53.     urlpatterns = [
    54.     path('articles/<int:year>/<mon:month>/<slug:other>/',     views.article_detail, name='aaa'),
    56. ]
    59. 4.模型层里面1.X外键默认都是级联更新删除的
    60. 但是到了2.X和3.X中需要你自己手动配置参数
    61.     models.ForeignKey(to='Publish')
    63.     models.ForeignKey(to='Publish',on_delete=models.CASCADE...)
    64. """

    视图层
    三板斧

    1. '''
    2. HTTPResponse
    3.     返回字符串类型
    4. render
    5.     返回html页面 并且返回给浏览器之前还可以给html文件传值
    6. redirect
    7.     重定向
    9. '''
    11. #验证视图函数必须返回一个HTTPResponse对象 正确   研究三者的源码即可得处结论
    12. The view app01.views.index didn't return an HttpResponse object. It returned None instead.
    14. # render简单内部原理
    15.     from django.template import Template,Context
    16.     res = Template('<h1>{{ user }}</h1>')
    17.     con = Context({'user':{'username':'jason','password':123}})
    18.     ret = res.render(con)
    19.     print(ret)
    20.     return HttpResponse(ret)

    JsonResponse对象

    1. '''
    2. json格式数据的作用
    3.     前后端数据交互需要使用到json作为过渡 实现跨语言传输数据
    4. '''
    5. 前端序列化
    6.     JavaScript                            Python
    7.     JSON.stringify()                    json.dumps()
    8.     JSON.parse()                        json.loads()
    10. python语法返回
    11. def obj_json(request):
    12.     user_dict = {'username':'yo','age':'20','hobby':'钱'}
    13.     # json_str = json.dumps(user_dict,ensure_ascii=True)
    14.     # return HttpResponse(json_str)
    16. Django语法返回
    17. from django.http import JsonResponse
    18. def obj_json(request):
    19.      user_dict = {'username':'yo','age':'20','hobby':'钱'}
    20.         return JsonResponse(l,json_dumps_params={'ensure_ascii':True})
    22. def obj_json(request):
    23.     l = [1,2,3,4,5]
    24.     return JsonResponse(l,safe=False)
    25.     JsonResponse默认只能格式化字典，若是需要格式化其他则要将safa=False
    27. 解析
    28. JsonResponse源码：
    29.     def __init__(self, data, encoder=DjangoJSONEncoder, safe=True,
    30.                  json_dumps_params=None, **kwargs):
    31.         通过读取源码即可知道用法

    from表单上传文件及后端如何操作

    2. """
    3. form表单上传文件类型的数据
    4.     1.method必须指定成post
    5.     2.enctype必须换成formdata
    7. """
    8. def file(request):
    9.     if request.method == 'POST':
    10.         # print(request.POST)--->只能获得普通数据
    11.         # print(request.FILES)--->能够获得文件数据
    12.         file_obj = request.FILES.get('files')
    13.         with open(file_obj.name,'wb')as f :
    14.             for line in file_obj.chunks() :-->加不加chunks都一样，不过官方推荐加
    15.                 f.write(line)
    17.     return render(request,'file.html')

    request对象方法

    1. """
    2. request.method
    3. request.POST
    4. request.GET
    5. request.FILES
    6. request.body  # 原生的浏览器发过来的二进制数据  后面详细的讲
    7. request.path 
    8. request.path_info
    9. request.get_full_path()  能过获取完整的url及问号后面的参数 
    10. """
    11.     # print(request.path)#/file/
    12.     # print(request.path_info)#/file/
    13.     # print(request.get_full_path())#/file/?username=egon&files=django%E7%94%9F%E5%91%BD%E6%B5%81%E7%A8%8B%E5%9B%BE.jpg&%E6%8F%90%E4%BA%A4=%E6%8F%90%E4%BA%A

    FBV与CBV

    1. FBV（function base views） 基于函数的视图，就是在视图里使用函数处理请求。
    3. CBV（class base views） 基于类的视图，就是在视图里使用类处理请求。
    5. FBV就是我们经常使用的
    6. def index(request):
    7.     return HttpResponse('index')
    9. CBV可以自动判断请求的类型，从而来使用不同方法来处理数据
    10. path('ddd/',views.ddd.as_view())
    11. 使用前需要导入库
    12. from django.views import View
    13. class ddd(View):
    14.     def get(self,request):
    15.         return HttpResponse('get请求')
    16.     def post(self,request):
    17.         return HttpResponse('post请求')
    19. 执行对应请求的方法前会优先执行 dispatch 方法(在get/post/put...方法前执行)，dispatch() 方法会根据请求的不同调用相应的方法来处理。
    21. 其实，在我们前面学到的知识都知道 Django 的 url 是将一个请求分配给可调用的函数的，而不是一个类，那是如何实现基于类的视图的呢？ 主要还是通过父类 View 提供的一个静态方法 as_view() ，as_view 方法是基于类的外部接口， 他返回一个视图函数，调用后请求会传递给 dispatch 方法，dispatch 方法再根据不同请求来处理不同的方法

    CBV内部源码剖析

    1. # 你自己不要修改源码 除了bug很难找
    3. # 突破口在urls.py
    4. url(r'^login/',views.MyLogin.as_view())
    5. # url(r'^login/',views.view)  FBV一模一样
    6. # CBV与FBV在路由匹配上本质是一样的 都是路由 对应 函数内存地址
    7. """
    8. 函数名/方法名 加括号执行优先级最高
    9. 猜测
    10.     as_view()
    11.         要么是被@staicmethod修饰的静态方法
    12.         要么是被@classmethod修饰的类方法  正确
    14.     @classonlymethod
    15.     def as_view(cls, **initkwargs):
    16.         pass
    17. """
    19.     @classonlymethod
    20.     def as_view(cls, **initkwargs):
    21.         """
    22.         cls就是我们自己写的类   MyCBV
    23.         Main entry point for a request-response process.
    24.         """
    25.         def view(request, *args, **kwargs):
    26.             self = cls(**initkwargs)  # cls是我们自己写的类
    27.             # self = MyLogin(**initkwargs)  产生一个我们自己写的类的对象
    28.             return self.dispatch(request, *args, **kwargs)
    29.             """
    30.             以后你们会经常需要看源码 但是在看python源码的时候 一定要时刻提醒自己面向对象属性方法查找顺序
    31.                 先从对象自己找
    32.                 再去产生对象的类里面找
    33.                 之后再去父类找
    34.                 ...
    35.             总结:看源码只要看到了self点一个东西 一定要问你自己当前这个self到底是谁
    36.             """
    37.         return view
    39.         # CBV的精髓
    40.     def dispatch(self, request, *args, **kwargs):
    41.         # 获取当前请求的小写格式 然后比对当前请求方式是否合法
    42.         # get请求为例
    43.         # post请求
    44.         if request.method.lower() in self.http_method_names:
    45.             handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    46.             """
    47.             反射:通过字符串来操作对象的属性或者方法
    48.                 handler = getattr(自己写的类产生的对象,'get',当找不到get属性或者方法的时候就会用第三个参数)
    49.                 handler = 我们自己写的类里面的get方法
    50.             """
    51.         else:
    52.             handler = self.http_method_not_allowed
    53.         return handler(request, *args, **kwargs)
    54.         """
    55.         自动调用get方法
    56.         """
    58. # 要求掌握到不看源码也能够描述出CBV的内部执行流程(******)

    今日考题

    1. 1.列举你知道的orm数据的增删改查方法
    2. 数据的增
    3. res = models.User.objects.create(username=username,...)
    4. or
    5. user_obj = models.User(username=username,...)
    6. user_obj.save()
    7. 删
    8. models.User.objects.filter(id=delect_id).delect()
    9. or
    10. delect_id = request.GET.get('user_id')
    11. models.User.objects.filter(id=delect_id).delect()
    12. 改
    13. models.User.onjects.filter(id=edit_id).update(username=username,password=password)
    14. or
    15. edit_obj = models.User.objects.filter(id=edit_id).first()
    16. edit_obj.username = username
    17. edit_obj.password = password
    18. edit_obj.save()
    19. 查
    20. res = models.User.objects.filter(username=username)
    21. #查询用户表中所有的数据
    22. #方式一：
    23. data = models.User.objects.filter()
    24. 方式二：
    25. user_queryset = models.User.objects.all()
    27. 2.表关系如何判定，django orm中如何建立表关系，有什么特点和注意事项
    28. 表关系的判定：换位思考
    29. 表关系有 一对一，一对多，多对多
    31. 一对多建立方法
    32. xx = models.ForeignKey(to='xxx',on_delect=models.CASCADE,)
    33. 特点：外键一般建立在查询频率较高的一方
    35. 一对一建立方法
    36. xx = models.OneToOneField(to='xxx',on_delect=models.CASCADE,)
    37. 特点：外键一般建立在查询频率较高的一方
    39. 多对多建立方法
    40. authors = models.ManyToManyField(to='xxx')
    41. 特点:不需要建立关系表，会自动帮你创建好关系表，创建这个需要在表下面写，建议先创建表再写关系
    43. 3.请画出完整的django请求生命周期流程图
    45. 4.无名、有名分组各是什么意思
    46. 无名分组就是将括号内正则表达式匹配到的内容当作位置参数传递给后面的视图函数
    47. 有名分组就是将括号内正则表达式匹配到的内容当作关键字参数传递给后面的视图函数
    49. 5.反向解析是什么，如何使用
    50. 当路由层 url 发生改变，在视图层和模板层动态反向解析出更改后的 url，免去修改的操作。
    51. 反向解析一般用在模板中的超链接及视图中的重定向
    52. 普通路径
    53. 在 urls.py 中给路由起别名，name="路由别名"。
    54. 在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名") 反向解析:
    55. 无名分组
    56. 在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名"，args=(符合正则匹配的参数,)) 反向解析。
    57. 正则路径（有名分组）
    58. 在 views.py 中，从 django.urls 中引入 reverse，利用 reverse("路由别名"，kwargs={"分组名":符合正则匹配的参数}) 反向解析。
    59. 具体参考笔记