zoukankan      html  css  js  c++  java
  • Django之Cookie、Session、CSRF、Admin

    Django之Cookie、Session、CSRF、Admin

     

    Cookie

    1、获取Cookie:

    1
    2
    3
    4
    5
    6
    request.COOKIES['key']
    request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
        参数:
            default: 默认值
               salt: 加密盐
            max_age: 后台控制过期时间

    2、设置Cookie:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    rep = HttpResponse(...) 或 rep = render(request, ...)
     
    rep.set_cookie(key,value,...)
    rep.set_signed_cookie(key,value,salt='加密盐',...)
        参数:
            key,              键
            value='',         值
            max_age=None,     超时时间
            expires=None,     超时时间(IE requires expires, so set it if hasn't been already.)
            path='/',         Cookie生效的路径,/ 表示根路径,特殊的:跟路径的cookie可以被任何url的页面访问
            domain=None,      Cookie生效的域名
            secure=False,     https传输
            httponly=False    只能http协议传输,无法被JavaScript获取(不是绝对,底层抓包可以获取到也可以被覆盖)

    由于cookie保存在客户端的电脑上,所以,JavaScript和jquery也可以操作cookie。

    1
    2
    <script src='/static/js/jquery.cookie.js'></script>
    $.cookie("list_pager_num"30,{ path: '/' });

    注:

    1、max_age = None 和 expires = None:

    max_age=秒数,表示多少秒数之后失效。

    expires = 时间,表示失效的时间。支持datetime 和 time.time。

    二选一,只要写一个,Django会自动将另一个写上。

    2、path:默认无论哪个url都可以访问到此cookie。

     
    def cook1(request):
        rep = HttpResponse("cook1")
        rep.set_cookie("k999",123,path="/cook1/")
        rep.set_cookie("k888",123)
        return rep
    
    def cook2(request):
        #request.COOKIES能读到当前url的cookie和全局的cookie
        #能获取到k888,无法获取k999
        print(request.COOKIES)
        return HttpResponse("ok")
     

    3、domain:只在当前域名生效(http://127.0.0.1:8000/)

    4、secure:以安全的方式传输(HTTPS,加证书进行认证 )

    5、httponly:自己写的cookie只能来回传送,别人不能修改和查看。有局限性

    示例:

    普通cookie:

     
    from django.shortcuts import render,HttpResponse
    
    def cook(request):
        #拿到所有的cookie
        print(request.COOKIES)
        rep = HttpResponse("ok")
        # 设置普通cookie
        rep.set_cookie("k1",123)  
        return rep
     

    加密后的cookie:

    默认salt为空

     
    from django.shortcuts import render,HttpResponse
    
    def cook(request):
        #拿到所有的cookie
        print(request.COOKIES)
        #根据加盐的值来获取cookie
        print(request.get_signed_cookie("k2",None,salt="uuu"))
        rep = HttpResponse("ok")
        #设置加密的cookie,根据salt加密
        rep.set_signed_cookie("k2",222,salt="uuu")
        return rep
     

     

    Session

    tornado里面要自定义Session,Django中默认支持Session,其内部提供了5种类型的Session供开发者使用:

    • 数据库(默认)
    • 缓存
    • 文件
    • 缓存+数据库
    • 加密cookie

    1、数据库Session

    首先启动数据库:

    python manage.py makemigrations
    
    python manage.py migrate

    views.py:

     
    def sess(request):
        request.session["k1"] = 123
        return HttpResponse("session")
    def index(request):
        return HttpResponse(request.session["k1"])
    
    def cook(request):
        rep = HttpResponse("cook")
        rep.set_cookie("kk",111)
        return rep
     

    urls.py:

     
    from django.conf.urls import url
    from django.contrib import admin
    from app01 import views
    urlpatterns = [
        url(r'^admin/', admin.site.urls),
        url(r'^session/', views.sess),
        url(r'^index/', views.index),
        url(r'^cook/', views.cook),
    ]
     

    这里为了实现设置session的效果,我们先访问cook的url,先设置成功cookie。然后访问index的url,发现获取不了session,这时我们需要访问session的url,访问的同时,就设置了session,当我们再次访问index的时候,就可以看到获取的session的值了。

    注:

    request.session['k1']:获取session,如果没有会报错

    request.session.get('k1',None):获取session,如果没有会返回None

    request.session['k1'] = 123:设置session,如果k1存在就覆盖

    request.session.setdefault('k1',123):设置session,如果存在则不设置

    del request.session["k1"] :只删除k1,随机字符串和其他session值还存在

    request.session.session_key:当前用户随机字符串

    如图:

    注:随机字符串会在客户端浏览器存在,而默认在数据库也会存在,可查看:django_session表

    request.session.clear_expired():将所有Session失效日期小于当前日期的数据删除,默认失效日期是两周(14天)。如果修改失效日期:通过配置文件中SESSION_COOKIE_AGE修改

    更多配置与操作:

    Django默认支持Session,并且默认是将Session数据存储在数据库中,即:django_session 表中。
     
    a. 配置 settings.py
     
        SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎(默认)
         
        SESSION_COOKIE_NAME = "sessionid"                       # Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串(默认)
        SESSION_COOKIE_PATH = "/"                               # Session的cookie保存的路径(默认)
        SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名(默认)
        SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie(默认)
        SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输(默认)
        SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期(2周)(默认)
        SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期(默认)
        SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session,默认修改之后才保存(默认)
     
     
     
    b. 使用
     
        def index(request):
            # 获取、设置、删除Session中数据
            request.session['k1']
            request.session.get('k1',None)
            request.session['k1'] = 123
            request.session.setdefault('k1',123) # 存在则不设置
            del request.session['k1']
     
            # 所有 键、值、键值对
            request.session.keys()
            request.session.values()
            request.session.items()
            request.session.iterkeys()
            request.session.itervalues()
            request.session.iteritems()
     
     
            # 用户session的随机字符串
            request.session.session_key
     
            # 将所有Session失效日期小于当前日期的数据删除
            request.session.clear_expired()
     
            # 检查 用户session的随机字符串 在数据库中是否
            request.session.exists("session_key")
     
            # 删除当前用户的所有Session数据
            request.session.delete("session_key")
    View Code

    2、缓存Session

    默认情况下Django版本的session存在内存里面,使用缓存session需要修改配置,详见如下:

    a. 配置 settings.py
     
        SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
        SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名(默认内存缓存,也可以是memcache),此处别名依赖缓存的设置
     
     
        SESSION_COOKIE_NAME = "sessionid"                        # Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串
        SESSION_COOKIE_PATH = "/"                                # Session的cookie保存的路径
        SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
        SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
        SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
        SESSION_COOKIE_AGE = 1209600                              # Session的cookie失效日期(2周)
        SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过期
        SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session,默认修改之后才保存
     
     
     
    b. 使用
     
        同上
    View Code

    3、文件Session

    在本地生成一个文件,把session保存到本地文件中

    a. 配置 settings.py
     
        SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
        SESSION_FILE_PATH = None                                    # 缓存文件路径,如果为None,则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如:/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
     
     
        SESSION_COOKIE_NAME = "sessionid"                          # Session的cookie保存在浏览器上时的key,即:sessionid=随机字符串
        SESSION_COOKIE_PATH = "/"                                  # Session的cookie保存的路径
        SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
        SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
        SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
        SESSION_COOKIE_AGE = 1209600                                # Session的cookie失效日期(2周)
        SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过期
        SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session,默认修改之后才保存
     
    b. 使用
     
        同上
    View Code

    4、缓存+数据库Session

    优先在缓存里面获取session,如果没有,就到数据库获取然后放到缓存里

    数据库用于做持久化,缓存用于提高效率
     
    a. 配置 settings.py
     
        SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎
     
    b. 使用
     
        同上
    View Code

    5、加密cookie Session

    这次session就不保存在服务器端了,而是保存在浏览器端,会给session的值加密再发送

    a. 配置 settings.py
         
        SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎
     
    b. 使用
     
        同上
    View Code

    查看源码:from django.contrib.sessions.backends import signed_cookies

    扩展:Session用户验证

    1
    2
    3
    4
    5
    6
    7
    def login(func):
        def wrap(request, *args, **kwargs):
            # 如果未登陆,跳转到指定页面
            if request.path == '/test/':
                return redirect('http://www.baidu.com')
            return func(request, *args, **kwargs)
        return wrap

    Django内置分页: 

    from django.shortcuts import render
    from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
    
    L = []
    for i in range(999):
        L.append(i)
    
    def index(request):
        current_page = request.GET.get('p')
    
        paginator = Paginator(L, 10)
        # per_page: 每页显示条目数量
        # count:    数据总个数
        # num_pages:总页数
        # page_range:总页数的索引范围,如: (1,10),(1,200)
        # page:     page对象
        try:
            posts = paginator.page(current_page)
            # has_next              是否有下一页
            # next_page_number      下一页页码
            # has_previous          是否有上一页
            # previous_page_number  上一页页码
            # object_list           分页之后的数据列表
            # number                当前页
            # paginator             paginator对象
        except PageNotAnInteger:
            posts = paginator.page(1)
        except EmptyPage:
            posts = paginator.page(paginator.num_pages)
        return render(request, 'index.html', {'posts': posts})
    views.py
    <!DOCTYPE html>
    <html>
    <head lang="en">
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
    <ul>
        {% for item in posts %}
            <li>{{ item }}</li>
        {% endfor %}
    </ul>
    
    <div class="pagination">
          <span class="step-links">
            {% if posts.has_previous %}
                <a href="?p={{ posts.previous_page_number }}">Previous</a>
            {% endif %}
              <span class="current">
                Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
              </span>
              {% if posts.has_next %}
                  <a href="?p={{ posts.next_page_number }}">Next</a>
              {% endif %}
          </span>
    
    </div>
    </body>
    </html>
    Html
    from django.shortcuts import render
    from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
    
    
    class CustomPaginator(Paginator):
        def __init__(self, current_page, max_pager_num, *args, **kwargs):
            """
            :param current_page: 当前页
            :param max_pager_num:最多显示的页码个数
            :param args:
            :param kwargs:
            :return:
            """
            self.current_page = int(current_page)
            self.max_pager_num = max_pager_num
            super(CustomPaginator, self).__init__(*args, **kwargs)
    
        def page_num_range(self):
            # 当前页面
            # self.current_page
            # 总页数
            # self.num_pages
            # 最多显示的页码个数
            # self.max_pager_num
            print(1)
            if self.num_pages < self.max_pager_num:
                return range(1, self.num_pages + 1)
            print(2)
            part = int(self.max_pager_num / 2)
            if self.current_page - part < 1:
                return range(1, self.max_pager_num + 1)
            print(3)
            if self.current_page + part > self.num_pages:
                return range(self.num_pages + 1 - self.max_pager_num, self.num_pages + 1)
            print(4)
            return range(self.current_page - part, self.current_page + part + 1)
    
    
    L = []
    for i in range(999):
        L.append(i)
    
    def index(request):
        current_page = request.GET.get('p')
        paginator = CustomPaginator(current_page, 11, L, 10)
        # per_page: 每页显示条目数量
        # count:    数据总个数
        # num_pages:总页数
        # page_range:总页数的索引范围,如: (1,10),(1,200)
        # page:     page对象
        try:
            posts = paginator.page(current_page)
            # has_next              是否有下一页
            # next_page_number      下一页页码
            # has_previous          是否有上一页
            # previous_page_number  上一页页码
            # object_list           分页之后的数据列表
            # number                当前页
            # paginator             paginator对象
        except PageNotAnInteger:
            posts = paginator.page(1)
        except EmptyPage:
            posts = paginator.page(paginator.num_pages)
    
        return render(request, 'index.html', {'posts': posts})
    扩展内置分页:views.py
    <!DOCTYPE html>
    <html>
    <head lang="en">
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
    
    <ul>
        {% for item in posts %}
            <li>{{ item }}</li>
        {% endfor %}
    </ul>
    
    <div class="pagination">
    <span class="step-links">
    {% if posts.has_previous %}
        <a href="?p={{ posts.previous_page_number }}">Previous</a>
    {% endif %}
    
        {% for i in posts.paginator.page_num_range %}
            <a href="?p={{ i }}">{{ i }}</a>
        {% endfor %}
    
        {% if posts.has_next %}
            <a href="?p={{ posts.next_page_number }}">Next</a>
        {% endif %}
    </span>
    
    <span class="current">
    Page {{ posts.number }} of {{ posts.paginator.num_pages }}.
    </span>
    
    </div>
    </body>
    </html>
    扩展内置分页:Html

    自定义分页:

    分页功能在每个网站都是必要的,对于分页来说,其实就是根据用户的输入计算出应该在数据库表中的起始位置。

    1、设定每页显示数据条数

    2、用户输入页码(第一页、第二页...)

    3、根据设定的每页显示条数和当前页码,计算出需要取数据表的起始位置

    4、在数据表中根据起始位置取值,页面上输出数据


    需求又来了,需要在页面上显示分页的页面。如:[上一页][1][2][3][4][5][下一页]

    1、设定每页显示数据条数

    2、用户输入页码(第一页、第二页...)

    3、设定显示多少页号

    4、获取当前数据总条数

    5、根据设定显示多少页号和数据总条数计算出,总页数

    6、根据设定的每页显示条数和当前页码,计算出需要取数据表的起始位置

    7、在数据表中根据起始位置取值,页面上输出数据

    8、输出分页html,如:[上一页][1][2][3][4][5][下一页]

    #!/usr/bin/env python
    # _*_coding:utf-8_*_
    from django.utils.safestring import mark_safe
     
    class PageInfo(object):
        def __init__(self,current,totalItem,peritems=5):
            self.__current=current
            self.__peritems=peritems
            self.__totalItem=totalItem
        def From(self):
            return (self.__current-1)*self.__peritems
        def To(self):
            return self.__current*self.__peritems
        def TotalPage(self):  #总页数
            result=divmod(self.__totalItem,self.__peritems)
            if result[1]==0:
                return result[0]
            else:
                return result[0]+1
     
    def Custompager(baseurl,currentPage,totalpage):  #基础页,当前页,总页数
        perPager=11
        #总页数<11
        #0 -- totalpage
        #总页数>11
            #当前页大于5 currentPage-5 -- currentPage+5
                #currentPage+5是否超过总页数,超过总页数,end就是总页数
            #当前页小于5 0 -- 11
        begin=0
        end=0
        if totalpage <= 11:
            begin=0
            end=totalpage
        else:
            if currentPage>5:
                begin=currentPage-5
                end=currentPage+5
                if end > totalpage:
                    end=totalpage
            else:
                begin=0
                end=11
        pager_list=[]
        if currentPage<=1:
            first="<a href=''>首页</a>"
        else:
            first="<a href='%s%d'>首页</a>" % (baseurl,1)
        pager_list.append(first)
     
        if currentPage<=1:
            prev="<a href=''>上一页</a>"
        else:
            prev="<a href='%s%d'>上一页</a>" % (baseurl,currentPage-1)
        pager_list.append(prev)
     
        for i in range(begin+1,end+1):
            if i == currentPage:
                temp="<a href='%s%d' class='selected'>%d</a>" % (baseurl,i,i)
            else:
                temp="<a href='%s%d'>%d</a>" % (baseurl,i,i)
            pager_list.append(temp)
        if currentPage>=totalpage:
            next="<a href='#'>下一页</a>"
        else:
            next="<a href='%s%d'>下一页</a>" % (baseurl,currentPage+1)
        pager_list.append(next)
        if currentPage>=totalpage:
            last="<a href=''>末页</a>"
        else:
            last="<a href='%s%d'>末页</a>" % (baseurl,totalpage)
        pager_list.append(last)
        result=''.join(pager_list)
        return mark_safe(result)   #把字符串转成html语言
    分页实例

    总结,分页时需要做三件事:

    • 创建处理分页数据的类
    • 根据分页数据获取数据
    • 输出分页HTML,即:[上一页][1][2][3][4][5][下一页]

    跨站请求伪造:CSRF

    一、简介

    django为用户实现防止跨站请求伪造的功能,通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

    全局:

      中间件 django.middleware.csrf.CsrfViewMiddleware

    csrf默认情况下只对post提交有效

    实例:

    默认settings.py中间件里面设置了csrf,只要有post提交就要遵循这个规则,所以要在html页面form里面写上{% csrf_token %},并且views.py返回时要用render方法。

    HTML:

     
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <form action="/csrf/" method="post">
            {% csrf_token %}
            <input name="n1">
            <input type="submit" value="submit" >
        </form>
    </body>
    </html>
     

    views.py:

    def csrf(request):
        return render(request,"csrf.html")

    :settings.py里面去掉django.middleware.csrf.CsrfViewMiddleware时,任何地方都用不上csrf,所有的地方都失效

    局部:

    • @csrf_protect,为当前函数强制设置防跨站请求伪造功能,即便settings中没有设置全局中间件。
    • @csrf_exempt,取消当前函数防跨站请求伪造功能,即便settings中设置了全局中间件。

    注:from django.views.decorators.csrf import csrf_exempt,csrf_protect

    代码:

     
    from django.views.decorators.csrf import csrf_exempt,csrf_protect
    #settings.py里面注销了中间件CSRF,如果想把某一个方法必须遵循CSRF,就要写上该装饰器
    #html写{% csrf_token %}
    #函数里面写render
    @csrf_protect
    def csrf(request):
        return render(request,"csrf.html")
    
    
    #settings.py里面就算设置了中间件CSRF,只要写上该装饰器,html就不用写{% csrf_token %},函数里面也不用写render
    @csrf_exempt
    def csrf(request):
        return HttpResponse("CSRF")
     

    二、应用

    1、普通表单

     
    veiw中设置返回值:
      return render_to_response('Account/Login.html',data,context_instance=RequestContext(request))  
         或者
         return render(request, 'xxx.html', data)
      
    html中设置Token:
      {% csrf_token %}
     

    注:如果返回值使用render_to_response,一定要写上context_instance=RequestContext(request)。原来render_to_response,不具有生成随机字符串的功能,render内部是自动生成该参数。

    2、Ajax

    对于传统的form,可以通过表单的方式将token再次发送到服务端,而对于ajax的话,使用如下方式。

    view.py

     
    from django.template.context import RequestContext
    # Create your views here.
      
      
    def test(request):
      
        if request.method == 'POST':
            print request.POST
            return HttpResponse('ok')
        return  render_to_response('app01/test.html',context_instance=RequestContext(request))
     

    text.html

    <!DOCTYPE html>
    <html>
    <head lang="en">
        <meta charset="UTF-8">
        <title></title>
    </head>
    <body>
        {% csrf_token %}
      
        <input type="button" onclick="Do();"  value="Do it"/>
      
        <script src="/static/plugin/jquery/jquery-1.8.0.js"></script>
        <script src="/static/plugin/jquery/jquery.cookie.js"></script>
        <script type="text/javascript">
            var csrftoken = $.cookie('csrftoken');
      
            function csrfSafeMethod(method) {
                // these HTTP methods do not require CSRF protection
                return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
            }
            $.ajaxSetup({
                beforeSend: function(xhr, settings) {
                    if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                        xhr.setRequestHeader("X-CSRFToken", csrftoken);
                    }
                }
            });
            function Do(){
      
                $.ajax({
                    url:"/app01/test/",
                    data:{id:1},
                    type:'POST',
                    success:function(data){
                        console.log(data);
                    }
                });
      
            }
        </script>
    </body>
    </html>
    View Code

     注:ajaxSetup在所有ajax执行之前都要执行该方法,相当于ajax全局配置

    admin

    django amdin是django提供的一个后台管理页面,改管理页面提供完善的html和css,使得你在通过Model创建完数据库表之后,就可以对数据进行增删改查,而使用django admin 则需要以下步骤:

    • 创建后台管理员
    • 配置url
    • 注册和配置django admin后台管理页面

    1、创建后台管理员

    1
    python manage.py createsuperuser

    输入用户名、密码、邮箱。。。

    2、配置后台管理url

    1
    url(r'^admin/', include(admin.site.urls))

    3、注册和配置django admin 后台管理页面

    a、在admin中执行如下配置

     
    from django.contrib import admin
      
    from app01 import  models
      
    admin.site.register(models.UserType)
    admin.site.register(models.UserInfo)
    admin.site.register(models.UserGroup)
    admin.site.register(models.Asset)
     

    b、设置数据表名称

     
    class UserType(models.Model):
        name = models.CharField(max_length=50)
      
        class Meta:
            verbose_name = '用户类型'  #在admin里面不显示UserType,直接显示中文的:用户类型
            verbose_name_plural = '用户类型'  #用户类型后面加个s
     

    c、打开表之后,设定默认显示,需要在model中作如下配置

    class UserType(models.Model):
        name = models.CharField(max_length=50)
      
        def __unicode__(self):  
            return self.name  #显示name
     
    from django.contrib import admin
      
    from app01 import  models
      
    class UserInfoAdmin(admin.ModelAdmin):
        list_display = ('username', 'password', 'email') #显示多列
      
      
    admin.site.register(models.UserType)
    admin.site.register(models.UserInfo,UserInfoAdmin)  #配置
    admin.site.register(models.UserGroup)
    admin.site.register(models.Asset)
     

    d、为数据表添加搜索功能

     
    from django.contrib import admin
      
    from app01 import  models
      
    class UserInfoAdmin(admin.ModelAdmin):
        list_display = ('username', 'password', 'email')
        search_fields = ('username', 'email')  #输入关键字进行搜索,类似like模糊查询
      
    admin.site.register(models.UserType)
    admin.site.register(models.UserInfo,UserInfoAdmin)
    admin.site.register(models.UserGroup)
    admin.site.register(models.Asset)
     

    e、添加快速过滤

     
    from django.contrib import admin
      
    from app01 import  models
      
    class UserInfoAdmin(admin.ModelAdmin):
        list_display = ('username', 'password', 'email')
        search_fields = ('username', 'email')
        list_filter = ('username', 'email')
          
      
      
    admin.site.register(models.UserType)
    admin.site.register(models.UserInfo,UserInfoAdmin)
    admin.site.register(models.UserGroup)
    admin.site.register(models.Asset)
     
  • 相关阅读:
    回调函数 协程
    网络编程 之线程
    并发编程 之进程相关
    并发编程的理论 python中实现多进程
    基于tcp的粘包处理终极版本
    基于socket的网络编程
    数据分析
    zabbix从入门到放弃
    Linux
    Django
  • 原文地址:https://www.cnblogs.com/zcok168/p/9927474.html
Copyright © 2011-2022 走看看