• 路由与视图


    数据的查,改,删

    # 先讲数据库中的数据全部展示到前端 然后给每一个数据两个按钮 一个编辑一个删除
    
    # 查看
    def userlist(request):
        # 查询出用户表里面所有的数据
        # 方式1
        # data = models.User.objects.filter()
        # print(data)
        # 方式2
        user_queryset = models.User.objects.all()
        # return render(request,'userlist.html',{'user_queryset':user_queryset})
        return render(request,'userlist.html',locals())
    
    # 编辑功能
    	# 点击编辑按钮朝后端发送编辑数据的请求
      """
      如何告诉后端用户想要编辑哪条数据?
      	将编辑按钮所在的那一行数据的主键值发送给后端
      	利用url问号后面携带参数的方式
      	
      	{% for user_obj in user_queryset %}
                            <tr>
                                <td>{{ user_obj.id }}</td>
                                <td>{{ user_obj.username }}</td>
                                <td>{{ user_obj.password }}</td>
                                <td>
                                    <a href="/edit_user/?user_id={{ user_obj.id }}" class="btn btn-primary btn-xs">编辑</a>
                                    <a href="" class="btn btn-danger btn-xs">删除</a>
                                </td>
                            </tr>
                        {% endfor %}
      """
      # 后端查询出用户想要编辑的数据对象 展示到前端页面供用户查看和编辑
      def edit_user(request):
        # 获取url问号后面的参数
        edit_id = request.GET.get('user_id')
        # 查询当前用户想要编辑的数据对象
        edit_obj = models.User.objects.filter(id=edit_id).first()
    
        if request.method == "POST":
            username = request.POST.get('username')
            password = request.POST.get('password')
            # 去数据库中修改对应的数据内容
            # 修改数据方式1
            # models.User.objects.filter(id=edit_id).update(username=username,password=password)
            """
                将filter查询出来的列表中所有的对象全部更新            批量更新操作
                只修改被修改的字段
            """
    
            # 修改数据方式2
            edit_obj.username = username
            edit_obj.password= password
            edit_obj.save()
            """
                上述方法当字段特别多的时候效率会非常的低
                从头到尾将数据的所有字段全部更新一边 无论该字段是否被修改
            """
            
            # 跳转到数据的展示页面
            return redirect('/userlist/')
    
    
    
        # 将数据对象展示到页面上
        return render(request,'edit_user.html',locals())
    
    # 删除功能
    	"""
    	跟编辑功能逻辑类似
    	def delete_user(request):
        # 获取用户想要删除的数据id值
        delete_id = request.GET.get('user_id')
        # 直接去数据库中找到对应的数据删除即可
        models.User.objects.filter(id=delete_id).delete()
        """
            批量删除
        """
        # 跳转到展示页面
    
        return redirect('/userlist/')	
    	
    	"""
    # 真正的删除功能应该需要二次确认 我们这里先不做后面会讲
    # 删除数据内部其实并不是真正的删除 我们会给数据添加一个标识字段用来表示当前数据是否被删除了,如果数据被删了仅仅只是讲字段修改一个状态
    	username password	is_delete
      jason			123				0
      egon			123				1
    

    django orm中如何创建表关系

    """
    表与表之间的关系
    	一对多
    	
    	多对多
    	
    	一对一
    	
    	没有关系
    
    判断表关系的方法:换位思考
    """
    图书表
    
    出版社表
    
    作者表
    
    作者详情表
    
    
    """
    图书和出版社是一对多的关系 外键字段建在多的那一方 book
    	
    图书和作者是多对多的关系 需要创建第三张表来专门存储
    
    作者与作者详情表是一对一
    """
    from django.db import models
    
    # Create your models here.
    
    
    # 创建表关系  先将基表创建出来 然后再添加外键字段
    class Book(models.Model):
        title = models.CharField(max_length=32)
        price = models.DecimalField(max_digits=8,decimal_places=2)
        # 总共八位 小数点后面占两位
        """
        图书和出版社是一对多 并且书是多的一方 所以外键字段放在书表里面
        """
        publish = models.ForeignKey(to='Publish')  # 默认就是与出版社表的主键字段做外键关联
        """
        如果字段对应的是ForeignKey 那么会orm会自动在字段的后面加_id
        如果你自作聪明的加了_id那么orm还是会在后面继续加_id
        
        后面在定义ForeignKey的时候就不要自己加_id
        """
    
    
        """
        图书和作者是多对多的关系 外键字段建在任意一方均可 但是推荐你建在查询频率较高的一方
        """
        authors = models.ManyToManyField(to='Author')
        """
        authors是一个虚拟字段 主要是用来告诉orm 书籍表和作者表是多对多关系
        让orm自动帮你创建第三张关系表
        """
    
    
    class Publish(models.Model):
        name = models.CharField(max_length=32)
        addr = models.CharField(max_length=32)
    
    
    class Author(models.Model):
        name = models.CharField(max_length=32)
        age = models.IntegerField()
        """
        作者与作者详情是一对一的关系 外键字段建在任意一方都可以 但是推荐你建在查询频率较高的表中
        """
        author_detail = models.OneToOneField(to='AuthorDetail')
        """
        OneToOneField也会自动给字段加_id后缀
        所以你也不要自作聪明的自己加_id
        """
    
    class AuthorDetail(models.Model):
        phone = models.BigIntegerField()  # 或者直接字符类型
        addr = models.CharField(max_length=32)
    
    
    """
    	orm中如何定义三种关系
    		publish = models.ForeignKey(to='Publish')  # 默认就是与出版社表的主键字段做外键关联
    		
    		authors = models.ManyToManyField(to='Author')
    		
    		author_detail = models.OneToOneField(to='AuthorDetail')
    		
    		
    		ForeignKey
    		OneToOneField
    			会自动在字段后面加_id后缀
    """
    
    # 在django1.X版本中外键默认都是级联更新删除的
    # 多对多的表关系可以有好几种创建方式 这里暂且先介绍一种
    # 针对外键字段里面的其他参数 暂时不要考虑 如果感兴趣自己可以百度试试看
    

    django请求生命周期流程图(必会)

    # 每个人都要会画 这个图是你们后期复习django最好的一个梳理方式
    
    
    # 扩展知识点
    	"""
    	缓存数据库
    		提前已经将你想要的数据准备好了 你来直接拿就可以
    		提高效率和响应时间
    		
    	当你在修改你的数据的时候 你会发现数据并不是立刻修改完成的
    	而是需要经过一段时间才会修改
    		博客园
    	
    	了解即可
    	"""
    

    路由层

    路由匹配

    # 路由匹配
    url(r'test',views.test),
    url(r'testadd',views.testadd)
    """
    url方法第一个参数是正则表达式
    	只要第一个参数正则表达式能够匹配到内容 那么就会立刻停止往下匹配
    	直接执行对应的视图函数
    
    你在输入url的时候会默认加斜杠
    	django内部帮你做到重定向
    		一次匹配不行
    		url后面加斜杠再来一次
    """
    # 取消自动加斜杠
    APPEND_SLASH = False/True	# 默认是自动加斜杠的
    
    
    urlpatterns = [
        url(r'^admin/', admin.site.urls),
        # 首页
        url(r'^$',views.home),
        # 路由匹配
        url(r'^test/$',views.test),
        url(r'^testadd/$',views.testadd),
        # 尾页(了解)
        url(r'',views.error),
    ]
    

    无名分组

    """
    分组:就是给某一段正则表达式用小括号扩起来
    """
    url(r'^test/(d+)/',views.test)
    
    def test(request,xx):
        print(xx)
        return HttpResponse('test')
      
    # 无名分组就是将括号内正则表达式匹配到的内容当作位置参数传递给后面的视图函数
    

    有名分组

    """
    可以给正则表达式起一个别名
    """
    url(r'^testadd/(?P<year>d+)',views.testadd)
    
    def testadd(request,year):
        print(year)
        return HttpResponse('testadd')
    
    # 有名分组就是将括号内正则表达式匹配到的内容当作关键字参数传递给后面的视图函数
    

    无名有名是否可以混合使用

    """
    嘻嘻 不能混用
    但是同一个分组可以使用N多次
    """
    
    # 单个的分组可以使用多次
    url(r'^index/(d+)/(d+)/(d+)/',views.index),
    url(r'^index/(?P<year>d+)/(?P<age>d+)/(?P<month>d+)/',views.index),
    

    反向解析

    # 通过一些方法得到一个结果 该结果可以直接访问对应的url触发视图函数
    
    # 先给路由与视图函数起一个别名
    	url(r'^func_kkk/',views.func,name='ooo')
    # 反向解析
    	# 后端反向解析
      	from django.shortcuts import render,HttpResponse,redirect,reverse
      	reverse('ooo')
      # 前端反向解析
      	<a href="{% url 'ooo' %}">111</a>
    

    无名有名分组反向解析

    # 无名分组反向解析
    	url(r'^index/(d+)/',views.index,name='xxx')
    
    # 前端
    	{% url 'xxx' 123 %}
    # 后端
    	reverse('xxx', args=(1,))
    
    """
    这个数字写代码的时候应该放什么
    	数字一般情况下放的是数据的主键值  数据的编辑和删除
    	url(r'^edit/(d+)/',views.edit,name='xxx')
    	
    	def edit(request,edit_id):
    		reverse('xxx',args=(edit_id,))
    		
    	{%for user_obj in user_queryset%}
    		<a href="{% url 'xxx' user_obj.id %}">编辑</a>
    	{%endfor%}
    
    今天每个人都必须完成的作业(*******)
    	利用无名有名 反向解析 完成数据的增删改查
    """
    
    
    
    # 有名分组反向解析
       url(r'^func/(?P<year>d+)/',views.func,name='ooo')
    # 前端
    	<a href="{% url 'ooo' year=123 %}">111</a>  了解
    	<a href="{% url 'ooo' 123 %}">222</a>  			记忆
    
    # 后端	
    	 # 有名分组反向解析 写法1  了解
       print(reverse('ooo',kwargs={'year':123}))
       # 简便的写法  减少你的脑容量消耗 记跟无名一样的操作即可
       print(reverse('ooo',args=(111,)))
    

    路由分发

    """
    django的每一个应用都可以有自己的templates文件夹 urls.py static文件夹
    正是基于上述的特点 django能够非常好的做到分组开发(每个人只写自己的app)
    作为组长 只需要将手下书写的app全部拷贝到一个新的django项目中 然后在配置文件里面注册所有的app再利用路由分发的特点将所有的app整合起来
    
    当一个django项目中的url特别多的时候 总路由urls.py代码非常冗余不好维护
    这个时候也可以利用路由分发来减轻总路由的压力
    
    利用路由分发之后 总路由不再干路由与视图函数的直接对应关系
    而是做一个分发处理
    	识别当前url是属于哪个应用下的 直接分发给对应的应用去处理
    	
    """
    
    
    # 总路由
    from app01 import urls as app01_urls
    from app02 import urls as app02_urls
    urlpatterns = [
        url(r'^admin/', admin.site.urls),
        # 1.路由分发
        url(r'^app01/',include(app01_urls)),  # 只要url前缀是app01开头 全部交给app01处理
        url(r'^app02/',include(app02_urls))   # 只要url前缀是app02开头 全部交给app02处理
      
        # 2.终极写法  推荐使用
        url(r'^app01/',include('app01.urls')),
        url(r'^app02/',include('app02.urls'))
        # 注意事项:总路由里面的url千万不能加$结尾
    ]
    
    # 子路由
    	# app01 urls.py
      from django.conf.urls import url
      from app01 import views
    
      urlpatterns = [
          url(r'^reg/',views.reg)
      ]
      # app02 urls.py
      from django.conf.urls import url
      from app02 import views
    
      urlpatterns = [
          url(r'^reg/',views.reg)
      ]
    

    名称空间(了解)

    # 当多个应用出现了相同的别名 我们研究反向解析会不会自动识别应用前缀
    """
    正常情况下的反向解析是没有办法自动识别前缀的
    """
    
    # 名称空间
    	# 总路由
        url(r'^app01/',include('app01.urls',namespace='app01')),
        url(r'^app02/',include('app02.urls',namespace='app02'))
      # 解析的时候
      	# app01
      	urlpatterns = [
        url(r'^reg/',views.reg,name='reg')
    		]
        # app02
        urlpatterns = [
        url(r'^reg/',views.reg,name='reg')
    		]
        
      	reverse('app01:reg')
        reverse('app02:reg')
        
        {% url 'app01:reg' %}
        {% url 'app02:reg' %}
    # 其实只要保证名字不冲突 就没有必要使用名称空间
    """
    一般情况下 有多个app的时候我们在起别名的时候会加上app的前缀
    这样的话就能够确保多个app之间名字不冲突的问题
    """
    urlpatterns = [
        url(r'^reg/',views.reg,name='app01_reg')
    ]
    urlpatterns = [
        url(r'^reg/',views.reg,name='app02_reg')
    ]
    

    伪静态(了解)

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

    虚拟环境(了解)

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

    django版本区别

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

    三板斧

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

    JsonResponse对象

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

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

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

    request对象方法

    def index(request):
        '''
        request:django封装的对象,它的类是WSGIRequest,它里面包含了所有http请求的东西
        '''
        print(request)
        print(type(request))
        # from django.core.handlers.wsgi import WSGIRequest
        #######################1 讲过的
        print(request.method)
        print(request.GET)
        print(request.POST)
    
        ########################2 新讲的path,get_full_path,META,FIELS,body
        # 自定制请求头
        # 上传文件使用的编码方式是form-data,默认编码方式urlencoded
        print(request.is_ajax()) # 是不是ajax请求
        print(request.path)      # 请求路径
        print(request.get_full_path()) # 请求全路径,带数据
    
        # print(request.body)      # 请求体,二进制,如果传文件,这个报错
        '''
        使用form表单,默认情况下数据被转成name=lqz&password=123放到请求体中
        request.POST其实是从body中取出bytes格式的,转成了字典
        requet.GET其实是把路径中?后面的部分拆出来,转成了字典
        '''
        print(request.encoding) # 客户端向服务端传递时,使用的编码方法
    
        print(request.META)    # 重点,字典,一堆东西,请求用户的ip地址,请求头中数据,用户自定制请求头的数据
        '''
        把请求头的key值部分统一加HTTP_  并且全部转成大写
        '''
        print(request.META['REMOTE_ADDR'])  # 客户端的ip地址
        print(request.FILES)  # 客户端上传的文件
    
    
    
        ########################3 暂时不用关注(后面会讲)
        print(request.COOKIES) # 空字典
        print(request.session) # session对象
        print(request.user)    # 匿名用户
        return HttpResponse('ok')
    

    FBV与CBV

    # 视图函数既可以是函数也可以是类
    def index(request):
      return HttpResponse('index')
    
    # CBV
        # CBV配置路由
    url(r'^login/',views.MyLogin.as_view())
    
    
    from django.views import View
    
    
    	class MyLogin(View):
        	def get(self,request):
            	return render(request,'form.html')
    
        	def post(self,request):
           		return HttpResponse('post方法')
          
    """
    FBV和CBV各有千秋
    CBV特点
    	能够直接根据请求方式的不同直接匹配到对应的方法执行
    	
    	内部到底是怎么实现的?
    		CBV内部源码(******)
    """
    

    Pycharm的自动提示

    from django.core.handlers.wsgi import WSGIRequest
    # pycharm的自动提示
    request=request  # type: WSGIRequest
    
  • 相关阅读:
    kyeremal-bzoj2038-[2009国家集训队]-小z的袜子(hose)-莫队算法
    移位操作之旋转移位
    leetcode 二分查找 Search in Rotated Sorted Array
    背包算法练习--求小于某数字的数组最大和:
    Splunk 会议回想: 大数据的关键是机器学习
    CSDN个人空间、问答频道停站维护公告
    HDFS主要节点解说(一)节点功能
    24点
    【Nginx】事件驱动框架和异步处理
    OC中字符串的提取与替换-四种不同方法实现
  • 原文地址:https://www.cnblogs.com/lgh8023/p/13788058.html
走看看 - 开发者的网上家园