1 # 无名分组反向解析
 2     url(r‘^index/(\d+)/‘,views.index,name=‘xxx‘)
 3 
 4 # 前端
 5     {% url ‘xxx‘ 123 %}
 6 # 后端
 7     reverse(‘xxx‘, args=(1,))
 8 
 9 """
10 这个数字写代码的时候应该放什么
11     数字一般情况下放的是数据的主键值  数据的编辑和删除
12     url(r‘^edit/(\d+)/‘,views.edit,name=‘xxx‘)
13     
14     def edit(request,edit_id):
15         reverse(‘xxx‘,args=(edit_id,))
16         
17     {%for user_obj in user_queryset%}
18         <a href="{% url ‘xxx‘ user_obj.id %}">编辑</a>
19     {%endfor%}
20 
21 今天每个人都必须完成的作业(*******)
22     利用无名有名 反向解析 完成数据的增删改查
23 """
24 
25 
26 
27 # 有名分组反向解析
28    url(r‘^func/(?P<year>\d+)/‘,views.func,name=‘ooo‘)
29 # 前端
30     <a href="{% url ‘ooo‘ year=123 %}">111</a>  了解
31     <a href="{% url ‘ooo‘ 123 %}">222</a>              记忆
32 
33 # 后端    
34      # 有名分组反向解析 写法1  了解
35    print(reverse(‘ooo‘,kwargs={‘year‘:123}))
36    # 简便的写法  减少你的脑容量消耗 记跟无名一样的操作即可
37    print(reverse(‘ooo‘,args=(111,)))

 1 """
 2 django的每一个应用都可以有自己的templates文件夹 urls.py static文件夹
 3 正是基于上述的特点 django能够非常好的做到分组开发(每个人只写自己的app)
 4 作为组长 只需要将手下书写的app全部拷贝到一个新的django项目中 然后在配置文件里面注册所有的app再利用路由分发的特点将所有的app整合起来
 5 
 6 当一个django项目中的url特别多的时候 总路由urls.py代码非常冗余不好维护
 7 这个时候也可以利用路由分发来减轻总路由的压力
 8 
 9 利用路由分发之后 总路由不再干路由与视图函数的直接对应关系
10 而是做一个分发处理
11     识别当前url是属于哪个应用下的 直接分发给对应的应用去处理
12     
13 """
14 
15 
16 # 总路由
17 from app01 import urls as app01_urls
18 from app02 import urls as app02_urls
19 urlpatterns = [
20     url(r‘^admin/‘, admin.site.urls),
21     # 1.路由分发
22     url(r‘^app01/‘,include(app01_urls)),  # 只要url前缀是app01开头 全部交给app01处理
23     url(r‘^app02/‘,include(app02_urls))   # 只要url前缀是app02开头 全部交给app02处理
24   
25     # 2.终极写法  推荐使用
26     url(r‘^app01/‘,include(‘app01.urls‘)),
27     url(r‘^app02/‘,include(‘app02.urls‘))
28     # 注意事项:总路由里面的url千万不能加$结尾
29 ]
30 
31 # 子路由
32     # app01 urls.py
33   from django.conf.urls import url
34   from app01 import views
35 
36   urlpatterns = [
37       url(r‘^reg/‘,views.reg)
38   ]
39   # app02 urls.py
40   from django.conf.urls import url
41   from app02 import views
42 
43   urlpatterns = [
44       url(r‘^reg/‘,views.reg)
45   ]

 1 # 当多个应用出现了相同的别名 我们研究反向解析会不会自动识别应用前缀
 2 """
 3 正常情况下的反向解析是没有办法自动识别前缀的
 4 """
 5 
 6 # 名称空间
 7     # 总路由
 8     url(r‘^app01/‘,include(‘app01.urls‘,namespace=‘app01‘)),
 9     url(r‘^app02/‘,include(‘app02.urls‘,namespace=‘app02‘))
10   # 解析的时候
11       # app01
12       urlpatterns = [
13     url(r‘^reg/‘,views.reg,name=‘reg‘)
14         ]
15     # app02
16     urlpatterns = [
17     url(r‘^reg/‘,views.reg,name=‘reg‘)
18         ]
19     
20       reverse(‘app01:reg‘)
21     reverse(‘app02:reg‘)
22     
23     {% url ‘app01:reg‘ %}
24     {% url ‘app02:reg‘ %}
25 # 其实只要保证名字不冲突 就没有必要使用名称空间
26 """
27 一般情况下 有多个app的时候我们在起别名的时候会加上app的前缀
28 这样的话就能够确保多个app之间名字不冲突的问题
29 """
30 urlpatterns = [
31     url(r‘^reg/‘,views.reg,name=‘app01_reg‘)
32 ]
33 urlpatterns = [
34     url(r‘^reg/‘,views.reg,name=‘app02_reg‘)
35 ]

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

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

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

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

 1 """
 2 json格式的数据有什么用？
 3     前后端数据交互需要使用到json作为过渡 实现跨语言传输数据
 4 
 5 前端序列化
 6     JSON.stringify()                    json.dumps()
 7     JSON.parse()                            json.loads()
 8 """
 9 import json
10 from django.http import JsonResponse
11 def ab_json(request):
12     user_dict = {‘username‘:‘jason好帅哦,我好喜欢!‘,‘password‘:‘123‘,‘hobby‘:‘girl‘}
13 
14     l = [111,222,333,444,555]
15     # 先转成json格式字符串
16     # json_str = json.dumps(user_dict,ensure_ascii=False)
17     # 将该字符串返回
18     # return HttpResponse(json_str)
19     # 读源码掌握用法
20     # return JsonResponse(user_dict,json_dumps_params={‘ensure_ascii‘:False})
21     # In order to allow non-dict objects to be serialized set the safe parameter to False.
22     # return JsonResponse(l,safe=False)  
23     # 默认只能序列化字典 序列化其他需要加safe参数

 1 """
 2 form表单上传文件类型的数据
 3     1.method必须指定成post
 4     2.enctype必须换成formdata
 5 
 6 """
 7 def ab_file(request):
 8     if request.method == ‘POST‘:
 9         # print(request.POST)  # 只能获取普通的简直对数据 文件不行
10         print(request.FILES)  # 获取文件数据
11         # <MultiValueDict: {‘file‘: [<InMemoryUploadedFile: u=1288812541,1979816195&fm=26&gp=0.jpg (image/jpeg)>]}>
12         file_obj = request.FILES.get(‘file‘)  # 文件对象
13         print(file_obj.name)
14         with open(file_obj.name,‘wb‘) as f:
15             for line in file_obj.chunks():  # 推荐加上chunks方法 其实跟不加是一样的都是一行行的读取
16                 f.write(line)
17 
18     return render(request,‘form.html‘)

 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()  获取的路径包含参数
10 """
11     print(request.path)  # /app01/ab_file/
12     print(request.path_info)  # /app01/ab_file/
13     print(request.get_full_path())  # /app01/ab_file/?username=jason
14             

 1 # 视图函数既可以是函数也可以是类
 2 def index(request):
 3   return HttpResponse(‘index‘)
 4 
 5 # CBV
 6     # CBV路由
 7     url(r‘^login/‘,views.MyLogin.as_view())
 8 
 9 
10         from django.views import View
11 
12 
13         class MyLogin(View):
14         def get(self,request):
15         return render(request,‘form.html‘)
16 
17         def post(self,request):
18         return HttpResponse(‘post方法‘)
19       
20 """
21 FBV和CBV各有千秋
22 CBV特点
23     能够直接根据请求方式的不同直接匹配到对应的方法执行
24     
25     内部到底是怎么实现的？
26         CBV内部源码(******)
27 """

1 """
2 今日考题
3 1.反向解析的本质是什么，无名和有名反向解析如何操作？
4 2..路由分发能够实现的前提是什么，需要注意什么，名称空间什么时候使用
5 3..什么是虚拟环境，django1.X与django2.X/3.X的区别有哪些
6 4.诠释为何跨语言传输数据以json格式为主，django返回json格式数据方式有哪些，又有哪些注意事项和配置参数
7 """

1 ‘‘‘
2 1.整理今日内容到博客
3 2.利用无名有名 反向解析 完成数据的增删改查
4 选做:    
5   研究FBV内部原理
6 ‘‘‘